Parse FocusIn and FocusOut events

disable failing envs
skip failing test
2026-05-19 04:18:35 +00:00 · 2021-08-05 15:54:39 +02:00 · 2020-05-21 22:02:07 +10:00 · 2020-05-21 20:54:16 +10:00 · 2020-05-21 20:20:03 +10:00 · 2020-05-21 20:19:49 +10:00
44 changed files with 2029 additions and 1011 deletions
--- a/.gitignore
+++ b/.gitignore
@ -0,0 +1,4 @@
+*.log
+yarn.lock
+package-lock.json
+node_modules
--- a/.travis.yml
+++ b/.travis.yml
@ -1,14 +1,16 @@
 before_script:
-  - "export DISPLAY=:99.0"
-  - "/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -nolisten $NOLISTEN"
+  - "export XAUTHORITY=/tmp/.Xauthority-Xvfb"
+  - "xauth add :99 . $(mcookie)"
+  - "xauth add 127.0.0.2:99 . $(mcookie)"
+  - "/sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -nolisten $NOLISTEN -auth $XAUTHORITY"
+  - "sleep 1"

 env:
-  - NOLISTEN=tcp
-  - NOLISTEN=unix
+  - NOLISTEN=tcp DISPLAY=:99.0
+#  - NOLISTEN=unix DISPLAY=:99.0
+#  - NOLISTEN=unix DISPLAY=127.0.0.2:99.0

 language: node_js
 node_js:
-   - '0.10'
-   - '0.12'
-   - '4.2'
-   - '5.0'
+   - '12'
+   - '14'
--- a/README.md
+++ b/README.md
@ -1,105 +1,119 @@
-# About
-[![Gitter](https://badges.gitter.im/Join Chat.svg)](https://gitter.im/sidorares/node-x11?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
- X11 protocol client for node.js
+# node-x11

- Implements core X11 protocol, as well as Xrender, Damage, Composite, Big-Requests, Dpms, Screensaver, XFixes, Shape, XTest, XC-Misc, GLX and Apple-WM extensions.
-# install
-
-`npm install x11`
-
-Windows users:
-1) install [XMing](http://www.straightrunning.com/XmingNotes/) or [Cygwin/X](http://x.cygwin.com/)
-2) get node-x11 copy (using [git](http://code.google.com/p/msysgit/downloads/list?can=3) or from [Github](https://github.com/sidorares/node-x11/archives/master ))
-
-#CI build status:
+X11 protocol client for Node.js: implements the core X11 protocol, as well as Xrender, Damage, Composite, Big-Requests, Dpms, Screensaver, XFixes, Shape, XTest, XC-Misc, GLX, and Apple-WM extensions.

+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/sidorares/node-x11?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 [![Build Status](https://secure.travis-ci.org/sidorares/node-x11.png)](http://travis-ci.org/sidorares/node-x11)

-# example
+## Install
+
+    npm install x11
+
+Windows users:
+
+1.  install [XMing](http://www.straightrunning.com/XmingNotes/) or [Cygwin/X](http://x.cygwin.com/)
+2.  get node-x11 copy (using [git](http://code.google.com/p/msysgit/downloads/list?can=3) or from [Github](https://github.com/sidorares/node-x11/archives/master))
+
+## Example

 Core requests usage:

 ```js
-    var x11 = require('x11');
+var x11 = require('x11');

-    var Exposure = x11.eventMask.Exposure;
-    var PointerMotion = x11.eventMask.PointerMotion;
+var Exposure = x11.eventMask.Exposure;
+var PointerMotion = x11.eventMask.PointerMotion;

-    x11.createClient(function(err, display) {
-        if (!err) {
-            var X = display.client;
-            var root = display.screen[0].root;
-            var wid = X.AllocID();
-            X.CreateWindow(
-                wid, root,        // new window id, parent
-                0, 0, 100, 100,   // x, y, w, h
-                0, 0, 0, 0,       // border, depth, class, visual
-                { eventMask: Exposure|PointerMotion } // other parameters
-            );
-            X.MapWindow(wid);
-            var gc = X.AllocID();
-            X.CreateGC(gc, wid);
-            X.on('event', function(ev) {
-                if (ev.type == 12)
-                {
-                    X.PolyText8(wid, gc, 50, 50, ['Hello, Node.JS!']);
-                }
-            });
-            X.on('error', function(e) {
-                console.log(e);
-            });
-	    } else {
-		    console.log(err);
-        }
+x11.createClient(function(err, display) {
+  if (!err) {
+    var X = display.client;
+    var root = display.screen[0].root;
+    var wid = X.AllocID();
+    X.CreateWindow(
+      wid,
+      root, // new window id, parent
+      0,
+      0,
+      500,
+      500, // x, y, w, h
+      0,
+      0,
+      0,
+      0, // border, depth, class, visual
+      { eventMask: Exposure | PointerMotion } // other parameters
+    );
+    X.MapWindow(wid);
+    var gc = X.AllocID();
+    X.CreateGC(gc, wid);
+    var white = display.screen[0].white_pixel;
+    var black = display.screen[0].black_pixel;
+    cidBlack = X.AllocID();
+    cidWhite = X.AllocID();
+    X.CreateGC(cidBlack, wid, { foreground: black, background: white });
+    X.CreateGC(cidWhite, wid, { foreground: white, background: black });
+    X.on('event', function(ev) {
+      if (ev.type == 12) {
+        X.PolyFillRectangle(wid, cidWhite, [0, 0, 500, 500]);
+        X.PolyText8(wid, cidBlack, 50, 50, ['Hello, Node.JS!']);
+      }
    });
+    X.on('error', function(e) {
+      console.log(e);
+    });
+  } else {
+    console.log(err);
+  }
+});
 ```

-# Screenshots
+## Screenshots

-  ![tetris game](https://lh6.googleusercontent.com/-RCRY9A7WwnA/Tlww0FHP7NI/AAAAAAAAAwo/nxfSxsw6xow/s400/tetris.png)
-  ![XRENDER gradients](https://lh4.googleusercontent.com/-VS0BMYYmq6M/Tlww0Y1ij0I/AAAAAAAAAws/pVWsPZ63Yeo/s400/render-gradients.png)
-  ![OpenGL glxgears](http://img-fotki.yandex.ru/get/4123/37511094.30/0_81712_6c2ebb11_L)
-  ![OpenGL teapot](http://img-fotki.yandex.ru/get/4132/37511094.30/0_81713_82a5ac48_L)
+![tetris game](https://lh6.googleusercontent.com/-RCRY9A7WwnA/Tlww0FHP7NI/AAAAAAAAAwo/nxfSxsw6xow/s400/tetris.png)
+![XRENDER gradients](https://lh4.googleusercontent.com/-VS0BMYYmq6M/Tlww0Y1ij0I/AAAAAAAAAws/pVWsPZ63Yeo/s400/render-gradients.png)
+![OpenGL glxgears](http://img-fotki.yandex.ru/get/4123/37511094.30/0_81712_6c2ebb11_L)
+![OpenGL teapot](http://img-fotki.yandex.ru/get/4132/37511094.30/0_81713_82a5ac48_L)

-# In use
-  - [ntk](https://github.com/sidorares/ntk) - higher level toolkit on top of X11
-  - [node-remote](https://github.com/AndrewSwerlick/node-remote) - media center controller
-  - [tiles](https://github.com/dominictarr/tiles) - tiling window manager
-  - [vnc](https://github.com/sidorares/node-vnc) - vnc client.
-  - [node-ewmh](https://github.com/santigimeno/node-ewmh) - set of EWMH helpers.
-  - [OdieWM](https://github.com/bu/OdieWM) - window manager
-  - [Dbusmenu](https://github.com/sidorares/node-dbusmenu) - unity global menu client.
-  - [AirWM](https://github.com/AirWM/AirWM) - tiling window manager
-  - [npdf](https://github.com/sidorares/npdf) - pdf viewer
-  - [tinywm](https://github.com/Airblader/node-tinywm) The famous [TinyWM](https://github.com/mackstann/tinywm) written in node.js
-  - [basedwm](https://github.com/anko/basedwm) Infinite-desktop panning X window manager in LiveScript
+## In use

-# X11 resources/documentation:
+- [ntk](https://github.com/sidorares/ntk) - higher level toolkit on top of X11
+- [node-remote](https://github.com/AndrewSwerlick/node-remote) - media center controller
+- [tiles](https://github.com/dominictarr/tiles) - tiling window manager
+- [vnc](https://github.com/sidorares/node-vnc) - vnc client.
+- [node-ewmh](https://github.com/santigimeno/node-ewmh) - set of EWMH helpers.
+- [OdieWM](https://github.com/bu/OdieWM) - window manager
+- [Dbusmenu](https://github.com/sidorares/node-dbusmenu) - unity global menu client.
+- [AirWM](https://github.com/AirWM/AirWM) - tiling window manager
+- [npdf](https://github.com/sidorares/npdf) - pdf viewer
+- [tinywm](https://github.com/Airblader/node-tinywm) The famous [TinyWM](https://github.com/mackstann/tinywm) written in node.js
+- [basedwm](https://github.com/anko/basedwm) Infinite-desktop panning X window manager in LiveScript

-  - [Xplain](https://github.com/magcius/xplain) - A series of articles to help explain the X Window System http://magcius.github.io/xplain/article/
-  - [Official X11 docs](http://www.x.org/releases/X11R7.6/doc/) 
-  - [protocol specification](http://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.pdf)
-  - C Xlib to X11 request mapping table http://tronche.com/gui/x/xlib/appendix/a.html
-  - [How to write composite manager](http://www.talisman.org/~erlkonig/misc/x11-composite-tutorial/)
-  - [Extended Window Manager Hints specification](http://standards.freedesktop.org/wm-spec/wm-spec-1.3.html)
+## X11 resources/documentation:

-# Other implementations
+- [Xplain](https://github.com/magcius/xplain) - A series of articles to help explain the X Window System http://magcius.github.io/xplain/article/
+- [Official X11 docs](http://www.x.org/releases/X11R7.6/doc/)
+- [protocol specification](http://www.x.org/releases/X11R7.6/doc/xproto/x11protocol.pdf)
+- C Xlib to X11 request mapping table http://tronche.com/gui/x/xlib/appendix/a.html
+- [How to write composite manager](http://www.talisman.org/~erlkonig/misc/x11-composite-tutorial/)
+- [Extended Window Manager Hints specification](http://standards.freedesktop.org/wm-spec/wm-spec-1.3.html)

-  - C: XLib - http://www.sbin.org/doc/Xlib/ http://www.tronche.com/gui/x/xlib/ http://www.x.org/docs/X11/xlib.pdf
-  - C: XCB - http://xcb.freedesktop.org/
-  - Python:  http://sourceforge.net/projects/python-xlib/ ( github fork: https://github.com/Ademan/python-xlib-branch pypi: http://pypi.python.org/pypi/Python%20Xlib )
-  - https://github.com/alexer/python-xlib-render
-  - Python/twisted:  https://launchpad.net/twisted-x11
-  - Perl: http://search.cpan.org/~smccam/X11-Protocol-0.56/Protocol.pm
-  - Go: https://github.com/BurntSushi/xgb
-  - Java: https://github.com/xderoche/J11
-  - Ruby: https://github.com/dj2/x-ruby-bindings
-  - Clojure: https://github.com/noodlewiz/xcljb
-  - Guile: https://github.com/mwitmer/guile-xcb
+## Other implementations

-# Server side (protocol + functionality) implementations for js + DOM
+- C: XLib - http://www.sbin.org/doc/Xlib/ http://www.tronche.com/gui/x/xlib/ http://www.x.org/docs/X11/xlib.pdf
+- C: XCB - http://xcb.freedesktop.org/
+- Python: http://sourceforge.net/projects/python-xlib/ ( github fork: https://github.com/Ademan/python-xlib-branch pypi: http://pypi.python.org/pypi/Python%20Xlib )
+- https://github.com/alexer/python-xlib-render
+- Python/twisted: https://launchpad.net/twisted-x11
+- Perl: http://search.cpan.org/~smccam/X11-Protocol-0.56/Protocol.pm
+- Go: https://github.com/BurntSushi/xgb
+- Java: https://github.com/xderoche/J11
+- Ruby: https://github.com/dj2/x-ruby-bindings
+- Clojure: https://github.com/noodlewiz/xcljb
+- Guile: https://github.com/mwitmer/guile-xcb
+- Emacs lisp: https://github.com/ch11ng/xelb ( autogenerated from XCB XML )

-would be really great to make completely web based playground page, connecting node-x11 api to DOM based implementation 
+## Server side (protocol + functionality) implementations for js + DOM

-  - https://github.com/GothAck/javascript-x-server
-  - https://github.com/ttaubert/x-server-js
+would be really great to make completely web based playground page, connecting node-x11 api to DOM based implementation
+
+- https://github.com/GothAck/javascript-x-server
+- https://github.com/ttaubert/x-server-js
--- a/autogen/generate.js
+++ b/autogen/generate.js
@ -252,7 +252,7 @@ function genReq(req, last)
   if (req.body.length == 0)
   {       
       result.push('  function() {');
-       result.push('     return new Buffer([' + req.opcode + ', 0, 1, 0]);');
+       result.push('     return Buffer.from([' + req.opcode + ', 0, 1, 0]);');
   } else {
   result.push('  function (args) {');
   result.push('    var extraLength = 0;');
@ -287,10 +287,10 @@ function genReq(req, last)
   var reqLen4 = ((reqLen + 3) >> 2);

   if (extraLength)
-     result.push('    var data = new Buffer(' + reqLen + ' + extraLength);');
+     result.push('    var data = Buffer.alloc(' + reqLen + ' + extraLength);');
   else {
     result.pop(); 
-     result.push('    var data = new Buffer(' + reqLen + ');');
+     result.push('    var data = Buffer.alloc(' + reqLen + ');');
   } 
   result.push('    data[0] = ' + req.opcode + ';');
   if (req.body.length != 0) {
--- a/examples/kbdheatmap/node-jpg.js
+++ b/examples/kbdheatmap/node-jpg.js
@ -571,7 +571,7 @@ module.exports.readJpeg = function(path)
    var imageData = {};
    imageData.width = j.width;
    imageData.height = j.height;
-    imageData.data = new Buffer(j.width*j.height*4);
+    imageData.data = Buffer.from(j.width*j.height*4);
    j.copyToImageData(imageData);
    return imageData;
 }
--- a/examples/png/node-png.js
+++ b/examples/png/node-png.js
@ -874,7 +874,7 @@ module.exports.readPng = function(path)
    var imageData = {};
    imageData.width = j.width;
    imageData.height = j.height;
-    imageData.data = new Buffer(j.width*j.height*4);
+    imageData.data = Buffer.alloc(j.width*j.height*4);
    j.render(imageData);
    return imageData;
 }
--- a/examples/png/png-decoder.js
+++ b/examples/png/png-decoder.js
@ -0,0 +1,344 @@
+/*
+ * Simple png decoder 
+ * https://github.com/b37t1td/png-decoder
+ */
+
+var CRCTable = new Int32Array([
+  0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
+  0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+  0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
+  0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+  0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
+  0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+  0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
+  0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+  0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
+  0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+  0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
+  0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+  0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
+  0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+  0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
+  0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+  0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
+  0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+  0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
+  0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+  0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
+  0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+  0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
+  0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+  0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
+  0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+  0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
+  0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+  0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
+  0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+  0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
+  0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+  0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
+  0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+  0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
+  0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+  0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
+  0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+  0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
+  0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+  0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
+  0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+  0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+]);
+
+var crc32 = function(buf) {
+  var crc = -1;
+  for (var i = 0; i < buf.length; i++) {
+    crc = CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
+  }
+  return crc ^ -1;
+};
+
+/*
+ * BE byteArray implementation
+ * by Svetlana Linuxenko <linuxenko@yahoo.com>
+ */
+
+/* eslint no-undef: 0 */
+var byteArray = Uint8Array;
+
+var cmp = function(a, b) {
+  if (!b) b = a; a = this;
+  return a.filter(function(c,i) { return c === b[i]; }).length === a.length;
+};
+
+var toInt = function(a) {
+  if (!a) a = this.slice(this.off, 4);
+  return (a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3];
+  //return a[0] | (a[1] << 8) | (a[2] << 16) | (a[3] << 24);
+};
+
+var toBytes = function(int) {
+  return new byteArray([
+    (int >> 24) & 0xff,
+    (int >> 16) & 0xff,
+    (int >> 8) & 0xff,
+    int & 0xff
+  ]);
+};
+
+var nextInt = function() {
+  return this.toInt(this.slice(this.off, (this.off += 4)));
+};
+
+var nextIntBytes = function() {
+  return this.nextBytes(4);
+};
+
+var nextBytes = function(size) {
+  return this.slice(this.off, (this.off += size));
+};
+
+var nextByte = function() {
+  return this.nextBytes(1)[0];
+};
+
+var insertInt = function(int) {
+  this.insertBytes(this.toBytes(int));
+};
+
+var insertBytes = function(bytes, length) {
+  length = length || 4;
+  this.set(bytes, this.off, length);
+  this.off += length;
+};
+
+var insertByte = function(byte) {
+  this.set([byte], this.off, (this.off += 1));
+};
+
+byteArray.prototype.cmp = cmp;
+byteArray.prototype.toInt = toInt;
+byteArray.prototype.nextInt = nextInt;
+byteArray.prototype.nextIntBytes = nextIntBytes;
+byteArray.prototype.toBytes = toBytes;
+byteArray.prototype.insertInt = insertInt;
+byteArray.prototype.insertBytes = insertBytes;
+byteArray.prototype.nextBytes = nextBytes;
+byteArray.prototype.nextByte = nextByte;
+byteArray.prototype.insertByte = insertByte;
+
+Object.defineProperty(byteArray.prototype , 'off', {
+  enumerable: false,
+  configurable: false,
+  writable: true,
+  value : 0
+});
+
+
+var SIGNATURE = new byteArray([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+var IHDR = new byteArray([0x49, 0x48, 0x44, 0x52]);
+var IDAT = new byteArray([0x49, 0x44, 0x41, 0x54]);
+var IEND = new byteArray([0x49, 0x45, 0x4e, 0x44]);
+
+
+/*
+ * Decoder
+ */
+var zlib = require('zlib');
+
+var inflateFunction = function(data) {
+  return zlib.inflateSync(Buffer.from(data));
+};
+
+
+var Decoder = function() { };
+
+Decoder.prototype.parse = function(data) {
+  if (!(data instanceof byteArray)) {
+    data = new byteArray(data);
+  }
+
+  if (!SIGNATURE.cmp(data.nextBytes(SIGNATURE.length))) {
+    throw new Error('Not png');
+  }
+
+  while (data.off < data.length) {
+    var len = data.nextInt();
+    var hdr = data.nextBytes(len + 4);
+
+    if (crc32(hdr) !== data.nextInt()) {
+      throw new Error('Crc error');
+    }
+
+    if (IHDR.cmp(hdr)) {
+      this._IHDR = this._chunkIHDR(hdr.slice(4, len + 4));
+
+      if (this._IHDR.palette !== 8) {
+        throw new Error('Depth error');
+      }
+
+      if (this._IHDR.compression !== 0) {
+        throw new Error('Compression error');
+      }
+
+      if (this._IHDR.filter !== 0) {
+        throw new Error('Filter error');
+      }
+
+      if (this._IHDR.interlace !== 0) {
+        throw new Error('Interlace error');
+      }
+
+      switch (this._IHDR.colorType){
+        case 0: this.bpp = 1; break;
+        case 2: this.bpp = 3; break;
+        case 3: this.bpp = 1; break;
+        case 4: this.bpp = 2; break;
+        case 6: this.bpp = 4; break;
+        default: throw new Error('ColorType error');
+      }
+      this.chunks = [];
+    }
+
+    if (IDAT.cmp(hdr)) {
+      if (!this._IHDR) {
+        throw new Error('IHDR error');
+      }
+
+      this._chunkIDAT(hdr.slice(4, len + 4));
+    }
+
+    if (IEND.cmp(hdr)) {
+      return this._chunkIEND();
+    }
+  }
+
+  throw new Error('Data error');
+};
+
+Decoder.prototype._chunkIEND = function() {
+  var tmp = [];
+  for (var i = 0; i < this.chunks.length; i++) {
+    for (var j = 0; j < this.chunks[i].length; j++) {
+      tmp.push(this.chunks[i][j]);
+    }
+  }
+  return this.filter(inflateFunction(tmp));
+};
+
+Decoder.prototype._chunkIDAT = function(chunk) {
+  this.chunks.push(chunk);
+};
+
+Decoder.prototype._chunkIHDR = function(chunk) {
+  return {
+    width : chunk.nextInt(),
+    height : chunk.nextInt(),
+    palette : chunk.nextByte(),
+    colorType : chunk.nextByte(),
+    compression : chunk.nextByte(),
+    filter : chunk.nextByte(),
+    interlace : chunk.nextByte()
+  };
+};
+
+Decoder.prototype.filter = function(data) {
+  var bpp = this.bpp;
+  var width = this._IHDR.width, height = this._IHDR.height;
+  var pixels = new byteArray((width * height) * bpp);
+  var filter, line, left, leftup, up, pixel;
+  var lineWidth = width * bpp, byte, off;
+
+  for (var y = 0; y < height; y++) {
+
+    filter = data.nextByte();
+    line = data.nextBytes(lineWidth);
+
+    for (var x = 0; x < lineWidth; x++) {
+
+      if (filter !== 0) {
+        off = (y * lineWidth) + x;
+      }
+
+      byte = line.nextByte();
+
+      switch(filter) {
+        case 0: //None
+          pixel = byte;
+          break;
+        case 1: // Sub  Raw(x) + Raw(x - bpp)
+          if (x < bpp) {
+            pixel = byte;
+            break;
+          }
+          pixel = pixels[off - bpp] + byte & 0xff;
+          break;
+        case 2: // Up(x) = Raw(x) + Prior(x)
+          if (y === 0) {
+            pixel = byte;
+            break;
+          }
+          pixel = pixels[off - lineWidth] + byte & 0xff;
+          break;
+        case 3: // Average(x) = Raw(x) + floor((Raw(x-bpp)+Prior(x))/2)
+          if (y === 0) {
+            if (x < bpp) {
+              pixel = byte;
+            } else {
+              pixel = (byte + (pixels[off - bpp] >> 1)) & 0xff;
+            }
+            break;
+          }
+
+          if (x < bpp) {
+            pixel = (byte + (pixels[off - lineWidth] >> 1)) & 0xff;
+            break;
+          }
+
+          pixel = (byte + (pixels[off - bpp] + pixels[off - lineWidth] >> 1)) & 0xff;
+          break;
+        case 4: // Paeth
+          if (y === 0) {
+            if (x < bpp) {
+              pixel = byte;
+            } else {
+              pixel = (byte + (pixels[off - bpp])) & 0xff;
+            }
+            break;
+          }
+
+          if (x < bpp) {
+            pixel = (byte + (pixels[off - lineWidth])) & 0xff;
+            break;
+          }
+
+          up =  pixels[off - lineWidth];
+          left =  pixels[off - bpp];
+          leftup = pixels[(off - lineWidth) - bpp];
+
+          var p = left + up - leftup,
+            pleft = Math.abs(p - left),
+            pup = Math.abs(p - up),
+            pleftup = Math.abs(p - leftup);
+
+          if (pleft <= pup && pleft <= pleftup){
+            pixel = byte + left & 0xff;
+            break;
+          } else if (pup <= pleftup) {
+            pixel = byte + up & 0xff;
+            break;
+          }
+
+          pixel = byte + leftup & 0xff;
+          break;
+        default:
+          throw new Error('Filter error: ' + filter);
+      }
+
+      pixels.insertByte(pixel);
+    }
+  }
+
+  return pixels;
+};
+
+module.exports = Decoder;
--- a/examples/png/screen.png
+++ b/examples/png/screen.png
--- a/examples/png/test1.js
+++ b/examples/png/test1.js
@ -0,0 +1,80 @@
+//var logo = require('./node-png').readPng('./node-logo.png');
+var fs = require('fs');
+var Decoder = require('./png-decoder');
+var decoder = new Decoder();
+
+var logo = {
+  data : Buffer.from(decoder.parse(fs.readFileSync('./screen.png'))),
+  width : decoder._IHDR.width,
+  height : decoder._IHDR.height
+};
+
+var x11 = require('../../lib');
+
+var Exposure = x11.eventMask.Exposure;
+
+x11.createClient(function(err, display)
+{
+  var X = display.client;
+  X.require('render', function(err, Render) {
+    var root = display.screen[0].root;
+    main(root, X, Render, display);
+  });
+});
+
+
+function main(root, X, Render, display) {
+
+  var win, picWin, pic, gc;
+
+  win = X.AllocID();
+  X.CreateWindow(
+     win, root,
+     0, 0, logo.width, logo.height,
+     0, 0, 0, 0,
+     { eventMask: Exposure }
+  );
+  X.MapWindow(win);
+
+  gc = X.AllocID();
+  X.CreateGC(gc, win);
+
+  var logoPixmap = X.AllocID();
+  X.CreatePixmap(logoPixmap, win, 24, logo.width, logo.height);
+
+  var rscreen = display.screen[0];
+  var screen =
+    rscreen.depths[rscreen.root_depth][
+      Object.keys(rscreen.depths[rscreen.root_depth])[0]];
+
+  var rmask = parseInt(screen.red_mask, 10);
+  var gmask = parseInt(screen.green_mask, 10);
+  var bmask = parseInt(screen.blue_mask, 10);
+
+  for (var y = 0; y < logo.height; y++) {
+    for (var x = 0; x < logo.width; x++) {
+      var pixel = Buffer.from([
+        logo.data[(x + logo.width * y) * 4],
+        logo.data[(x + logo.width * y) * 4 + 1],
+        logo.data[(x + logo.width * y) * 4 + 2], 0]).readInt32LE();
+
+      logo.data[(x + logo.width * y) * 4 ] = (pixel & rmask) >> 16;
+      logo.data[(x + logo.width * y) * 4 + 1] = (pixel & gmask) >> 8;
+      logo.data[(x + logo.width * y) * 4 + 2] = (pixel & bmask) >> 0;
+      logo.data[(x + logo.width * y) * 4 + 3] = 0x00;
+    }
+  }
+
+  X.PutImage(2, logoPixmap, gc, logo.width, logo.height, 0, 0, 0, 24, logo.data);
+
+  var logoPicture = X.AllocID();
+  Render.CreatePicture(logoPicture, logoPixmap, Render.rgb24);
+  var winPicture = X.AllocID();
+  Render.CreatePicture(winPicture, win, Render.rgb24);
+
+  X.on('event', function(ev) {
+    if (ev.name == 'Expose') {
+      Render.Composite(3, logoPicture, 0, winPicture, 0, 0, 0, 0, 0, 0, logo.width, logo.height);
+    }
+  });
+}
--- a/examples/screenshot.js
+++ b/examples/screenshot.js
@ -17,7 +17,7 @@ x11.createClient(function(err, display) {


            var dispwin = X.AllocID();
-            X.CreateWindow(dispwin, root, 0, 0, width, height, 1, 1, 0, { eventMask: x11.eventMask.Exposure });
+            X.CreateWindow(dispwin, root, 0, 0, width, height, 0, 0, 0, 0, { eventMask: x11.eventMask.Exposure });
            X.MapWindow(dispwin);
            //X.CopyArea(idScreenshot, dispwin, gc, 0, 0, 0, 0, width, height);

@ -71,7 +71,11 @@ x11.createClient(function(err, display) {

        });
        */
-        X.GetImage(2, root, 0, 0, width, height, 0xffffffff, function(image) {
+        X.GetImage(2, id, 0, 0, width, height, 0xffffffff, function(err, image) {
+            if (err) {
+              console.log(err);
+              process.exit(1);
+            }
            console.log(image);
            // format, drawable, gc, width, height, dstX, dstY, leftPad, depth, data
            X.PutImage(2, dispwin, gc, width, height, 0, 0, 0, 24, image.data);
--- a/examples/simple/gcinvert.js
+++ b/examples/simple/gcinvert.js
@ -0,0 +1,36 @@
+/*
+ * GCFunction usage example
+ */
+var x11 = require('../../lib');
+
+x11.createClient(function(err, display) {
+  var X = display.client;
+  var root = display.screen[0].root;
+  var white = display.screen[0].white_pixel;
+  var black = display.screen[0].black_pixel;
+
+  var wid = X.AllocID();
+  X.CreateWindow(wid, root, 0, 0, 400, 300, 0, 0, 0, 0, { 
+    backgroundPixel: black,
+    eventMask: x11.eventMask.ButtonPress|x11.eventMask.Exposure });
+  var gc = X.AllocID();
+  X.CreateGC(gc, wid, {foreground : white, 'function' : x11.gcFunction.GXinvert});
+  X.MapWindow(wid);
+
+
+  X.on('event', function(ev) {
+
+    if (ev.type === 12) {
+      X.PolyFillRectangle(wid, gc, [0, 0, 400, 300]);
+    }
+
+    if (ev.type === 4) {
+      var x = ev.x;
+      var y = ev.y;
+
+      X.PolyFillRectangle(wid, gc, [x - 25, y - 25, 50, 50]);
+    }
+
+  });
+});
+
--- a/examples/simple/render.js
+++ b/examples/simple/render.js
@ -7,7 +7,7 @@ var xclient = x11.createClient(function(err, display) {
    display.client.require('render', function(err, Render) {
        var wid = X.AllocID();
        var white = display.screen[0].white_pixel;
-        varblack = display.screen[0].black_pixel;
+        var black = display.screen[0].black_pixel;
        X.CreateWindow(wid, root, 10, 10, 400, 300, 0, 0, 0, 0, { backgroundPixel: white, eventMask: PointerMotion });
        X.MapWindow(wid);

--- a/examples/simple/text/render-glyph.js
+++ b/examples/simple/text/render-glyph.js
@ -26,7 +26,7 @@ function padWidth(buf, width) {
    return buf;
  else {
    var stride = (width+3)&~3;
-    var res = new Buffer(height*stride);
+    var res = Buffer.alloc(height*stride);
    res.fill(0);
    for (var y=0; y < height; ++y) {
      // memcpy(tmpbitmap+y*stride, bitmap->buffer+y*ginfo.width, ginfo.width);
@ -88,7 +88,7 @@ var xclient = x11.createClient({ debug: true }, function(err, display) {
        var glyphFromCode = [];
        glyphs.forEach(function(g) {
          if (!g.image || (g.image.length == 0)) {
-            g.image = new Buffer(64);
+            g.image = Buffer.alloc(64);
            g.image.fill(0);
            g.width = 8;
            g.height = 8;
--- a/examples/smoketest/bmp.js
+++ b/examples/smoketest/bmp.js
@ -6,7 +6,7 @@ var Pixmap = require('./pixmap').Pixmap;
 var Buffer = require('buffer').Buffer;
 require('../../lib/unpackbuffer').addUnpack(Buffer);

-var reversed = new Buffer(256);
+var reversed = Buffer.alloc(256);
 for (var i=0; i < 256; ++i)
 {
    var res = 0;
@ -42,4 +42,4 @@ module.exports.decodeBuffer = function(buffer)
        data[i] = 255 - reversed[data[i]];

    return new Pixmap(header.bpp, header.width, header.height, data);
-}
+}
--- a/examples/smoketest/putimage.js
+++ b/examples/smoketest/putimage.js
@ -8,7 +8,7 @@ var xclient = x11.createClient();
 var Exposure = x11.eventMask.Exposure;
 var PointerMotion = x11.eventMask.PointerMotion;

-var bitmap = new Buffer(128*128/8); // 16384 bits, 2048 bytes bitmap
+var bitmap = Buffer.alloc(128*128/8); // 16384 bits, 2048 bytes bitmap
 for (var i=0; i < bitmap.length; ++i)
 {
    bitmap[i] = i % 256;
--- a/examples/smoketest/putimage1.js
+++ b/examples/smoketest/putimage1.js
@ -4,7 +4,7 @@ var x11 = require('../../lib');
 var Exposure = x11.eventMask.Exposure;
 var PointerMotion = x11.eventMask.PointerMotion;

-var bitmap = new Buffer(128*128*4); // 16384 bits, 2048 bytes bitmap
+var bitmap = Buffer.alloc(128*128*4); // 16384 bits, 2048 bytes bitmap
 for (var i=0; i < bitmap.length; ++i)
 {
    var byteNum = i%4;
--- a/examples/tetris.js
+++ b/examples/tetris.js
@ -25,7 +25,7 @@ var Buffer = require('buffer').Buffer;

 var startpos = [4, 15];
 var cupsize = [10, 20];
-var cup = new Buffer(cupsize[0]*cupsize[1]);
+var cup = Buffer.alloc(cupsize[0]*cupsize[1]);
 var moveInterval;

 function clearCup()
--- a/examples/vncviewer/d3des.js
+++ b/examples/vncviewer/d3des.js
@ -56,8 +56,8 @@ var pc2 = [
 function deskey(key, edf)
 {
 	var i, j, l, m, n;
-        var pc1m = new Buffer(56);
-        var pcr = new Buffer(56);
+        var pc1m = Buffer.alloc(56);
+        var pcr = Buffer.alloc(56);
 	var kn = new Array(32);

 	for ( j = 0; j < 56; j++ ) {
@ -388,17 +388,17 @@ function desfunc(block, keys)

 module.exports.response = function(challenge, password)
 {
-    var key = new Buffer(8);
+    var key = Buffer.alloc(8);
    key.fill(0);
    key.write(password.substring(0,8));
    var in1 = challenge.slice(0,8);
    var in2 = challenge.slice(8,16);
-    var res1 = new Buffer(8);
-    var res2 = new Buffer(8);
+    var res1 = Buffer.alloc(8);
+    var res2 = Buffer.alloc(8);
    deskey(key, EN0);
    des(in1, res1);
    des(in2, res2);
-    var resp = new Buffer(16);
+    var resp = Buffer.alloc(16);
    res1.copy(resp);
    res2.copy(resp, 8);
    return resp;
--- a/examples/vncviewer/hexy.js
+++ b/examples/vncviewer/hexy.js
@ -7,7 +7,7 @@
 // It should create a pleasant looking hex dumb by default:
 //    
 //    var hexy = require('hexy.js'),
-//           b = new Buffer("\000\001\003\005\037\012\011bcdefghijklmnopqrstuvwxyz0123456789")
+//           b = Buffer.from("\000\001\003\005\037\012\011bcdefghijklmnopqrstuvwxyz0123456789")
 //    
 //    console.log(hexy.hexy(b))
 //
@ -258,4 +258,4 @@ console.log(hexy(data, format))
 console.log("doen")
 */

-exports.hexy = hexy
+exports.hexy = hexy
--- a/examples/vncviewer/rfbclient.js
+++ b/examples/vncviewer/rfbclient.js
@ -400,7 +400,7 @@ RfbClient.prototype.readHextileTile = function(rect, cb)
            });
            return;
        }
-        tile.buffer = new Buffer(tilebuflen);
+        tile.buffer = Buffer.alloc(tilebuflen);
     
        function solidBackground() {
            clog('solidBackground');
@ -667,8 +667,8 @@ function createConnection(params)
        var wstream = fs.createWriteStream(params.rfbFileOut);
        wstream.write('FBS 001.001\n');
        stream.on('data', function(data) {
-            var sizeBuf = new Buffer(4);
-            var timeBuf = new Buffer(4);
+            var sizeBuf = Buffer.alloc(4);
+            var timeBuf = Buffer.alloc(4);
            var size = data.length;
            sizeBuf.writeInt32BE(size, 0);
            wstream.write(sizeBuf);
@ -676,7 +676,7 @@ function createConnection(params)
            timeBuf.writeInt32BE(+new Date() - start, 0);
            wstream.write(timeBuf);
            var padding = 3 - ((size - 1) & 0x03);
-            var pbuf = new Buffer(padding);
+            var pbuf = Buffer.alloc(padding);
            wstream.write(pbuf);             
        }).on('end', function() {
            wstream.end();
--- a/examples/vncviewer/rfbserver.js
+++ b/examples/vncviewer/rfbserver.js
@ -62,7 +62,7 @@ RfbServer.prototype.processSecurity = function()
        break;
    case rfb.security.VNC:
        // generate random 16 byte challenge
-        serv.challenge = new Buffer(16);
+        serv.challenge = Buffer.alloc(16);
        serv.challenge.write('1234567890abcdef');
        console.log(['sending challenge', serv.challenge]);
        serv.pack_stream.pack('a', [serv.challenge]).flush();
--- a/examples/vncviewer/unpackstream.js
+++ b/examples/vncviewer/unpackstream.js
@ -34,7 +34,7 @@ function ReadFixedRequest(length, callback)
    this.length = length;
    this.callback = callback;
    //clog(length);
-    this.data = new Buffer(length);
+    this.data = Buffer.alloc(length);
    this.received_bytes = 0;
 }

@ -328,7 +328,7 @@ UnpackStream.prototype.pack = function(format, args)
        }
    }

-    var buf = new Buffer(packetlength);
+    var buf = Buffer.alloc(packetlength);
    var offset = 0;
    var arg = 0;
    for (var i = 0; i < format.length; ++i)
--- a/examples/xpm/node-xpm.js
+++ b/examples/xpm/node-xpm.js
@ -95,7 +95,7 @@ PixmapFromFile.prototype.mapColors = function(content,size){
 }

 PixmapFromFile.prototype.toBuffer = function (colors,content,size) {
-  var buf = new Buffer(size.width*size.height*4);
+  var buf = Buffer.alloc(size.width*size.height*4);
  var offset = 0, byte,color;
  var copy;
  if( !this.options.format || this.options.format.toUpperCase() === "BGRA"){
--- a/lib/auth.js
+++ b/lib/auth.js
@ -1,91 +1,110 @@
-// TODO: http://en.wikipedia.org/wiki/X_Window_authorization
+// TODO: differentiate between auth types (i.e., MIT-MAGIC-COOKIE-1 and XDM-AUTHORIZATION-1)
+// and choose the best based on the algorithm in libXau's XauGetBestAuthByAddr

 var fs = require('fs');
 var Buffer = require('buffer').Buffer;
 // add 'unpack' method for buffer
 require('./unpackbuffer').addUnpack(Buffer);

+var typeToName = {
+    256: 'Local',
+  65535: 'Wild',
+    254: 'Netname',
+    253: 'Krb5Principal',
+    252: 'LocalHost',
+      0: 'Internet',
+      1: 'DECnet',
+      2: 'Chaos',
+      5: 'ServerInterpreted',
+      6: 'Internet6'
+};
+
 function parseXauth( buf )
 {
    var offset = 0;
    var auth = [];
    var cookieProperties = ['address', 'display', 'authName', 'authData'];

-    function handleCookieProperty(property) {
-        var length = buf.unpack('n', offset)[0];
-        offset += 2;
-        cookie[property] = buf.unpackString(length, offset);
-        offset += length; 
-    }
-
    while (offset < buf.length)
    {
-        var cookie = {};        
-        var typeToName = {
-            256: 'Local',
-          65535: 'Wild',
-            254: 'Netname',
-            253: 'Krb5Principal', 
-            252: 'LocalHost',
-              0: 'Internet', 
-              1: 'DECnet', 
-              2: 'Chaos',
-              5: 'ServerInterpreted', 
-              6: 'InternetV6'
-        };
-        cookie.type = buf.unpack('n')[0];
+        var cookie = {};
+        cookie.type = buf.readUInt16BE(offset);
        if (!typeToName[cookie.type]) {
            console.warn('Unknown address type');
        }
        offset += 2;
-        //JSHint becomes angry when handleCookieProperty is declared inside loop
-        cookieProperties.forEach(handleCookieProperty);
+        cookieProperties.forEach(function(property) {
+          var length = buf.unpack('n', offset)[0];
+          offset += 2;
+          if (cookie.type === 0 && property == 'address') { // Internet
+            // 4 bytes of ip addess, convert to w.x.y.z string
+            cookie.address = [ buf[offset], buf[offset+1], buf[offset+2], buf[offset+3]]
+              .map(function(octet) { return octet.toString(10) }).join('.');
+          } else {
+            cookie[property] = buf.unpackString(length, offset);
+          }
+          offset += length;
+        });
        auth.push(cookie);
    }
    return auth;
 }

-module.exports = function( display, host, cb )
-{
-    var XAuthorityFile = process.env.XAUTHORITY;
-    if (!XAuthorityFile)
-    {
-        if ( process.platform.match(/win/) ) {
-            // http://www.straightrunning.com/XmingNotes/trouble.php
-            //
-            // The Xming magic cookie program, xauth (user-based), uses an 
-            // Xauthority file (not the traditional .Xauthority file) in 
-            // the %HOME% directory. To use xauth from Command Processor 
-            // e.g. on Windows machine 192.168.0.2 with user colin...
-            XAuthorityFile = process.env.USERPROFILE + '\\Xauthority';
+var homedir = require('os').homedir;
+var path = require('path');
+
+function readXauthority(cb) {
+  var filename = process.env.XAUTHORITY || path.join(homedir(), '.Xauthority');
+  fs.readFile(filename, function(err, data) {
+    if (!err)
+      return cb(null, data);
+    if(err.code == 'ENOENT') {
+      // Xming/windows uses %HOME%/Xauthority ( .Xauthority with no dot ) - try with this name
+      filename = process.env.XAUTHORITY || path.join(homedir(), 'Xauthority');
+      fs.readFile(filename, function (err, data) {
+        if (err.code == 'ENOENT') {
+          cb(null, null);
        } else {
-            XAuthorityFile = process.env.HOME + '/.Xauthority';
+          cb(err);
        }
+      });
+    } else {
+      cb(err);
    }
+  });
+}

-    fs.readFile(XAuthorityFile, function (err, data) {
+module.exports = function( display, host, socketFamily, cb )
+{
+  var family;
+  if (socketFamily === 'IPv4') {
+    family = 0; // Internet
+  } else if (socketFamily === 'IPv6') {
+    family = 6; // Internet6
+  } else {
+    family = 256; // Local
+  }
+  readXauthority(function(err, data) {
+    if(err) return cb(err);

-        if (err) 
-        {
-            if (err.code == 'ENOENT')
-            {
-                cb('','');
-                return;
-            }
-            throw err;
-        }
-
-        var auth = parseXauth(data);
-        for (var cookieNum in auth)
-        {
-            var cookie = auth[cookieNum];
-            if (cookie.display == display && cookie.address == host)
-            {
-                cb( cookie.authName, cookie.authData );
-                return;
-            }
-        }
-        // throw 'No auth cookie matching display=' + display + ' and  host=' + host;
-        cb( '', '' );            
-    });       
+    if (!data) {
+      return cb(null, {
+        authName: '',
+        authData: ''
+      });
+    }
+    var auth = parseXauth(data);
+    for (var cookieNum in auth)
+    {
+      var cookie = auth[cookieNum];
+      if ((typeToName[cookie.family] === 'Wild' || (cookie.type === family && cookie.address === host)) &&
+          (cookie.display.length === 0 || cookie.display === display))
+        return cb( null, cookie );
+    }
+    // If no cookie is found, proceed without authentication
+    cb(null, {
+      authName: '',
+      authData: ''
+    });
+  });
 };
--- a/lib/corereqs.js
+++ b/lib/corereqs.js
@ -217,25 +217,26 @@ function packValueMask(reqname, values)
    {
        var v = reqValueMask[value];
        if (v) {
-          var valueBit = v.mask;
-          if (!valueBit)
-              throw new Error(reqname + ': incorrect value param ' + value);
-          masksList.push(valueBit);
-          bitmask |= valueBit;
+            var valueBit = v.mask;
+            if (!valueBit)
+                throw new Error(reqname + ': incorrect value param ' + value);
+            masksList.push(valueBit);
+            bitmask |= valueBit;
        }
    }

    /* numeric sort */
    masksList.sort(function(a, b) {
-      return a - b;
+        return a - b;
    });

    var args = [];
-    for (m in masksList)
+    for (var i=0,length=masksList.length;i<length;i++)
    {
-       var valueName = reqValueMaskName[masksList[m]];
-       format += reqValueMask[valueName].format
-       args.push( values[valueName] );
+        var value = masksList[i];
+        var valueName = reqValueMaskName[value];
+        format += reqValueMask[valueName].format
+        args.push( values[valueName] );
    }
    return [format, bitmask, args]
 }
@ -464,7 +465,7 @@ var templates = {
       function(mode, wid, name, type, units, data)
       {
          var padded4 = (data.length + 3) >> 2;
-          var pad = new Buffer( (padded4<<2) - data.length);
+          var pad = Buffer.alloc( (padded4<<2) - data.length);
          var format = 'CCSLLLCxxxLaa';
          var requestLength = 6 + padded4;
          var dataLenInFormatUnits = data.length / (units >> 3);
@ -726,12 +727,6 @@ var templates = {
       }
   ],

-   FreePixmap: [
-       function(pixmap) {
-           return [ 'CxSL', [ 54, 2, pixmap ] ];
-       }
-   ],
-
   FreePixmap: [
      function (pixmap) {
          return [ 'CxSL', [54, 2, pixmap] ];
@ -771,13 +766,9 @@ var templates = {
           var vals = packValueMask('CreateGC', values);
           var packetLength = 3 + (values ? vals[2].length : 0);
           var args = [56, packetLength, cid];
-           args.push(vals[0]);     // values bitmask
-           var valArr = vals[1];
-           for (var v in valArr)
-           {
-               format += 'L'; // TODO: we know format string length in advance and += inefficient for string
-               args.push(valArr[v]);
-           }
+           format += vals[0]
+           args.push(vals[1]);     // values bitmask
+           args = args.concat(vals[2])
           return [format, args];
        }
   ],
@ -860,7 +851,7 @@ var templates = {
          var padded = xutil.padded_length(data.length);
          var reqLen = 6 + padded/4; // (length + 3) >> 2 ???
          var padLength = padded - data.length;
-          var pad = new Buffer(padLength); // TODO: new pack format 'X' - skip amount of bytes supplied in numerical argument
+          var pad = Buffer.alloc(padLength); // TODO: new pack format 'X' - skip amount of bytes supplied in numerical argument

          // TODO: move code to calculate reqLength and use BigReq if needed outside of corereq.js
          // NOTE: big req is used here (first 'L' in format, 0 and +1 in params), won't work if not enabled
@ -1029,6 +1020,12 @@ var templates = {
           return [ 'CxSssCCxx', [107, 3, timeout, interval, preferBlanking, allowExposures]];
       }
   ],
+   
+   Bell: [
+       function(percent) {
+           return ["CxCs",[108,1]];
+       }
+   ],

   ForceScreenSaver: [
       function(activate) {
--- a/lib/ext/glx.js
+++ b/lib/ext/glx.js
@ -258,7 +258,7 @@ exports.requireExt = function(display, callback)
        ext.BindTexImage = function(ctx, drawable, buffer, attribs) {
           if (!attribs)
             attribs = [];
-           var data = new Buffer(12 + attribs.length*4);
+           var data = Buffer.alloc(12 + attribs.length*4);
           data.writeUInt32LE(drawable, 0);
           data.writeUInt32LE(buffer, 4);
           data.writeUInt32LE(attribs.length, 8);
@ -268,7 +268,7 @@ exports.requireExt = function(display, callback)
        }

        ext.ReleaseTexImage = function(ctx, drawable, buffer) {
-           var data = new Buffer(8);
+           var data = Buffer.alloc(8);
           data.writeUint32LE(drawable, 0);
           data.writeUint32LE(buffer, 4);
           ext.VendorPrivate(ctx, 1331, data);
@ -287,7 +287,7 @@ exports.requireExt = function(display, callback)
          X.pack_stream.pack('CCSLSSL', [ext.majorOpcode, 2, length, ctx, requestNum, requestTotal, data.length]);

          X.pack_stream.write_queue.push(data);
-          var pad = new Buffer(padLength);
+          var pad = Buffer.alloc(padLength);
          pad.fill(0);
          X.pack_stream.write_queue.push(pad);
          X.pack_stream.flush();
--- a/lib/ext/glxrender.js
+++ b/lib/ext/glxrender.js
@ -16,7 +16,7 @@ module.exports = function(GLX, ctx) {
            throw Error('Buffer too big. Make sure you are using RenderLarge for large commands');

        currentLength += len;
-        var res = Buffer(len);
+        var res = Buffer.alloc(len);
        res.writeUInt16LE(len, 0);
        res.writeUInt16LE(opcode, 2);
        return res;
@ -266,7 +266,7 @@ module.exports = function(GLX, ctx) {
          typeSize[constants.BYTE] = 1;
          typeSize[constants.UNSIGNED_BYTE] = 1;

-          var res = new Buffer(60 + data.length*typeSize[type]);
+          var res = Buffer.alloc(60 + data.length*typeSize[type]);
          res.writeUInt32LE(res.length, 0);
          res.writeUInt32LE(110, 4);

--- a/lib/ext/randr.js
+++ b/lib/ext/randr.js
@ -204,7 +204,43 @@ exports.requireExt = function(display, callback)

            X.pack_stream.flush();
        },
+        ext.GetOutputInfo = function(output, ts, cb)
+        {
+            X.seq_num ++;
+            X.pack_stream.pack('CCSLL', [ext.majorOpcode, 9, 3, output, ts ]);
+            X.replies[X.seq_num] = [
+                function(buf, opt) {
+                    var i;
+                    var pos = 0;
+                    var res = buf.unpack('LLLLCCSSSSS');
+                    var info = {
+                        timestamp : res[0],
+                        crtc : res[1],
+                        mm_width : res[2],
+                        mm_height : res[3],
+                        connection : res[4],
+                        subpixelOrder : res[5],
+                        preferredModes: res[8]
+                    };

+                    pos += 28;
+                    var format = Array(res[6] + 1).join('L');
+                    info.crtcs = buf.unpack(format, pos);
+                    pos +=  res[6] << 2;
+                    format = Array(res[7] + 1).join('L');
+                    info.modes = buf.unpack(format, pos);
+                    pos +=  res[7] << 2;
+                    format = Array(res[9] + 1).join('L');
+                    info.clones = buf.unpack(format, pos);
+                    pos +=  res[9] << 2;
+                    info.name = buf.slice(pos, pos + res_modes[10]).toString('binary');
+                    return info;
+                },
+                cb
+            ];
+
+            X.pack_stream.flush();
+        },
        ext.GetCrtcInfo = function(crtc, configTs, cb) {
            X.seq_num ++;
            X.pack_stream.pack('CCSLL', [ext.majorOpcode, 20, 3, crtc, configTs ]);
--- a/lib/ext/render.js
+++ b/lib/ext/render.js
--- a/lib/ext/shape.js
+++ b/lib/ext/shape.js
@ -112,5 +112,31 @@ exports.requireExt = function(display, callback)
            callback(null, ext);
        });
        */
+
+        ext.events = {
+            ShapeNotify: 0
+        }
+
+        X.eventParsers[ext.firstEvent + ext.events.ShapeNotify] = function(type, seq, extra, code, raw)
+        {
+            var event = {};
+            event.type = type;
+            event.kind = code;
+            event.seq = seq;
+
+            event.window = extra;
+
+            var values = raw.unpack('ssSSLC');
+
+            event.x = values[0];
+            event.y = values[1];
+            event.width = values[2];
+            event.height = values[3];
+            event.time = values[4];
+            event.shaped = values[5];
+            event.name = 'ShapeNotify';
+
+            return event;
+        };
    });
 }
--- a/lib/gcfunction.js
+++ b/lib/gcfunction.js
@ -0,0 +1,22 @@
+/*
+ * GCFunction named shortcuts
+ */
+
+module.exports = {
+  GXclear        : 0x0,
+  GXand          : 0x1,
+  GXandReverse   : 0x2,
+  GXcopy         : 0x3,
+  GXandInverted  : 0x4,
+  GXnoop         : 0x5,
+  GXxor          : 0x6,
+  GXor           : 0x7,
+  GXnor          : 0x8,
+  GXequiv        : 0x9,
+  GXinvert       : 0xa,
+  GXorReverse    : 0xb,
+  GXcopyInverted : 0xc,
+  GXorInverted   : 0xd,
+  GXnand         : 0xe,
+  GXset          : 0xf
+};
--- a/lib/handshake.js
+++ b/lib/handshake.js
@ -12,15 +12,15 @@ function readVisuals(bl, visuals, n_visuals, cb)
    var visual = {};
    bl.unpackTo( visual,
    [
-        'L vid', 
-        'C class', 
-        'C bits_per_rgb', 
+        'L vid',
+        'C class',
+        'C bits_per_rgb',
        'S map_ent',
        'L red_mask',
        'L green_mask',
        'L blue_mask',
        'xxxx'
-    ], 
+    ],
    function() {
         var vid = visual.vid;
         // delete visual.vid;
@ -28,57 +28,65 @@ function readVisuals(bl, visuals, n_visuals, cb)
         if (Object.keys(visuals).length == n_visuals)
             cb()
         else
-             readVisuals(bl, visuals, n_visuals, cb);      
-    });
-}
-
-function readDepths(bl, display, depths, n_depths, cb)
-{
-    if (n_depths == 0)
-    {
-        cb();
-        return;
-    }
-
-    bl.unpack( 'CxSxxxx', function(res) {
-        var dep = res[0];
-        var n_visuals = res[1];
-        var visuals = {};
-        readVisuals(bl, visuals, n_visuals, function()
-        {
-            depths[dep] = visuals;
-            if (Object.keys(depths).length == n_depths)
-                cb();
-            else
-                readDepths(bl, display, depths, n_depths, cb);
-        });  
+             readVisuals(bl, visuals, n_visuals, cb);
    });
 }

 function readScreens(bl, display, cbDisplayReady)
 {
+     var numParsedDepths = 0;
+     var readDepths = function(bl, display, depths, n_depths, cb)
+     {
+         if (n_depths == 0)
+         {
+             cb();
+             return;
+         }
+
+         bl.unpack( 'CxSxxxx', function(res) {
+             var dep = res[0];
+             var n_visuals = res[1];
+             var visuals = {};
+             readVisuals(bl, visuals, n_visuals, function()
+             {
+                 if (dep in depths) {
+                     for (var visual in visuals) {
+                         depths[dep][visual] = visuals[visual];
+                     }
+                 } else {
+                     depths[dep] = visuals;
+                 }
+                 numParsedDepths++;
+                 if (numParsedDepths == n_depths)
+                     cb();
+                 else
+                     readDepths(bl, display, depths, n_depths, cb);
+             });  
+         });
+     }
+
     // for (i=0; i < display.screen_num; ++i)
     {
         var scr = {};
         bl.unpackTo( scr,
         [
-             'L root', 
+             'L root',
             'L default_colormap',
-             'L white_pixel', 
+             'L white_pixel',
             'L black_pixel',
-             'L input_masks', 
-             'S pixel_width', 
-             'S pixel_height', 
-             'S mm_width', 
-             'S mm_height', 
-             'S min_installed_maps', 
+             'L input_masks',
+             'S pixel_width',
+             'S pixel_height',
+             'S mm_width',
+             'S mm_height',
+             'S min_installed_maps',
             'S max_installed_maps',
-             'L root_visual', 
+             'L root_visual',
             'C root_depth',
             'C backing_stores',
             'C root_depth',
             'C num_depths'
-         ], 
+         ],
         function () {
             var depths = {};
             readDepths(bl, display, depths, scr.num_depths, function() {
@ -86,17 +94,17 @@ function readScreens(bl, display, cbDisplayReady)
                 scr.depths = depths;
                 delete scr.num_depths;
                 display.screen.push(scr);
-              
+
                 if (display.screen.length == display.screen_num)
                 {
                     delete display.screen_num;
-                     cbDisplayReady(display);
+                     cbDisplayReady(null, display);
                     return;
                 } else {
                     readScreens(bl, display, cbDisplayReady);
                 }
             });
-         });         
+         });
     }
 }

@ -104,13 +112,18 @@ function readServerHello(bl, cb)
 {

 bl.unpack('C', function(res) {
-     
+
     if (res[0] == 0)
     {
         // conection time error
-         // unpack error (? TODO)
-         var err = new Error;
-         cb(err); // TODO: detect that this is error on xcore side
+         // unpack error
+         bl.unpack('Cxxxxxx', function (rlen) {
+             bl.get(rlen[0], function (reason) {
+                 var err = new Error;
+                 err.message = 'X server connection failed: ' + reason.toString();
+                 cb(err);
+             });
+         });
         // TODO: do we need to close stream from our side?
         // TODO: api to close source stream via attached unpackstream
         return;
@ -124,10 +137,10 @@ bl.unpack('C', function(res) {
          'S major',
          'S minor',
          'S xlen',
-          'L release', 
-          'L resource_base', 
-          'L resource_mask', 
-          'L motion_buffer_size', 
+          'L release',
+          'L resource_base',
+          'L resource_mask',
+          'L motion_buffer_size',
          'S vlen',
          'S max_request_length',
          'C screen_num',
@ -139,8 +152,8 @@ bl.unpack('C', function(res) {
          'C min_keycode',
          'C max_keycode',
          'xxxx'
-         ],       
-           
+         ],
+
         function()
         {
             var pvlen = xutil.padded_length(display.vlen);
@ -148,12 +161,12 @@ bl.unpack('C', function(res) {
             // setup data to generate resource id
             // TODO: cleaunup code here
             var mask = display.resource_mask;
-             display.rsrc_shift = 0; 
+             display.rsrc_shift = 0;
             while (!( (mask >> display.rsrc_shift) & 1) )
                 display.rsrc_shift++;
             display.rsrc_id = 0;

-             bl.get(pvlen, function(vendor) 
+             bl.get(pvlen, function(vendor)
             {
                 display.vendor = vendor.toString().substr(0, display.vlen); // utf8 by default?

@ -172,7 +185,7 @@ bl.unpack('C', function(res) {
                             readScreens(bl, display, cb);
                         }
                     });
-                 }            
+                 }
             });
         }
     );
@ -189,25 +202,28 @@ function getByteOrder() {
    }
 }

-function writeClientHello(stream, displayNum, authHost)
+function writeClientHello(stream, displayNum, authHost, authFamily)
 {
-    getAuthString( displayNum, authHost, function( authType, authData ) {
+    getAuthString( displayNum, authHost, authFamily, function( err, cookie ) {
+        if (err) {
+            throw err;
+        }
        var byte_order = getByteOrder();
        var protocol_major = 11; // TODO: config? env?
        var protocol_minor = 0;
        stream.pack(
-            'CxSSSSxxpp', 
-            [ 
+            'CxSSSSxxpp',
+            [
            byte_order,
            protocol_major,
            protocol_minor,
-            authType.length,
-            authData.length,
-            authType,
-            authData
+            cookie.authName.length,
+            cookie.authData.length,
+            cookie.authName,
+            cookie.authData
            ]
        );
-        stream.flush(); 
+        stream.flush();
    });
 }

--- a/lib/hexy.js
+++ b/lib/hexy.js
@ -7,7 +7,7 @@
 // It should create a pleasant looking hex dumb by default:
 //    
 //    var hexy = require('hexy.js'),
-//           b = new Buffer("\000\001\003\005\037\012\011bcdefghijklmnopqrstuvwxyz0123456789")
+//           b = Buffer.alloc("\000\001\003\005\037\012\011bcdefghijklmnopqrstuvwxyz0123456789")
 //    
 //    console.log(hexy.hexy(b))
 //
@ -258,4 +258,4 @@ console.log(hexy(data, format))
 console.log("doen")
 */

-exports.hexy = hexy
+exports.hexy = hexy
--- a/lib/index.js
+++ b/lib/index.js
@ -11,6 +11,11 @@ Object.defineProperty(module.exports, 'keySyms', {
  get: function() { return require('./keysyms'); }
 });

+Object.defineProperty(module.exports, 'gcFunction', {
+  enumerable: true,
+  get: function() { return require('./gcfunction'); }
+});
+
 //TODO:
 // keepe everything in namespace for consistensy (eventMask, keySyms, class, destination ...
 // or put most used constants to top namespace? (currently class and destination in top) 
--- a/lib/unpackstream.js
+++ b/lib/unpackstream.js
@ -23,7 +23,7 @@ function ReadFixedRequest(length, callback)
 {
    this.length = length;
    this.callback = callback;
-    this.data = new Buffer(length);
+    this.data = Buffer.alloc(length);
    this.received_bytes = 0;
 }

@ -201,7 +201,7 @@ UnpackStream.prototype.pstr = function(str)
    var len = xutil.padded_length(str.length);
    if (len == 0)
        return; // nothing to write
-    var buf = new Buffer(len);
+    var buf = Buffer.alloc(len);
    buf.write(str, 'binary');
    this.write_queue.push(buf);
 }
@ -231,7 +231,7 @@ UnpackStream.prototype.pack = function(format, args)
        }
    }

-    var buf = new Buffer(packetlength);
+    var buf = Buffer.alloc(packetlength);
    var offset = 0;
    var arg = 0;
    for (var i = 0; i < format.length; ++i)
@ -269,12 +269,14 @@ UnpackStream.prototype.pack = function(format, args)
                buf[offset++] = (n >> 16) & 0xff;
                buf[offset++] = (n >> 24) & 0xff;
                break;
-            case 'a':  // string or buffer
+            case 'a':  // string, buffer, or array
                var str = args[arg++];
                if (Buffer.isBuffer(str))
                {
                    str.copy(buf, offset);
                    offset += str.length;
+                } else if(Array.isArray(str)) {
+                	for(var item of str) buf[offset++] = item;
                } else {
                    // TODO: buffer.write could be faster
                    for (var c = 0; c < str.length; ++c)
--- a/lib/xcore.js
+++ b/lib/xcore.js
@ -6,7 +6,6 @@ var handshake = require('./handshake');

 var EventEmitter = require('events').EventEmitter;
 var PackStream = require('./unpackstream');
-var coreRequestsTemplate = require('./corereqs');
 var hexy = require('./hexy').hexy;

 var Buffer = require('buffer').Buffer;
@ -20,6 +19,25 @@ var coreRequests = require('./corereqs');
 var stdatoms = require('./stdatoms');
 var em = require('./eventmask').eventMask;

+function stash ()
+{
+    require('./ext/apple-wm');
+    require('./ext/big-requests');
+    require('./ext/composite');
+    require('./ext/damage');
+    require('./ext/dpms');
+    require('./ext/fixes');
+    require('./ext/glxconstants');
+    require('./ext/glx');
+    require('./ext/glxrender');
+    require('./ext/randr');
+    require('./ext/render');
+    require('./ext/screen-saver');
+    require('./ext/shape');
+    require('./ext/xc-misc');
+    require('./ext/xtest');
+}
+
 function XClient(displayNum, screenNum, options)
 {
    EventEmitter.call(this);
@ -31,7 +49,6 @@ function XClient(displayNum, screenNum, options)

    this.displayNum = displayNum;
    this.screenNum = screenNum;
-    this.authHost = os.hostname();
 }
 util.inherits(XClient, EventEmitter);

@ -39,6 +56,14 @@ XClient.prototype.init = function(stream)
 {
    this.stream = stream;

+    this.authHost = stream.remoteAddress;
+    // Node v0.10.x does not have stream.remoteFamily, so dig in to find it
+    this.authFamily = stream._getpeername ? stream._getpeername().family : stream.remoteFamily;
+    if (!this.authHost || this.authHost === '127.0.0.1' || this.authHost === '::1') {
+      this.authHost = os.hostname();
+      this.authFamily = null;
+    }
+
    var pack_stream = new PackStream();

    // data received from stream is dispached to
@ -107,11 +132,13 @@ XClient.prototype.init = function(stream)
    this.event_consumers = {}; // maps window id to eventemitter TODO: bad name
    this.eventParsers = {};
    this.errorParsers = {};
+    this._extensions = {};

    this.importRequestsFromTemplates(this, coreRequests);

    this.startHandshake();
    this._closing = false;
+    this._unusedIds = [];
 }

 // TODO: close() = set 'closing' flag, watch it in replies and writeQueue, terminate if empty
@ -240,12 +267,17 @@ XClient.prototype.importRequestsFromTemplates = function(target, reqs)

 XClient.prototype.AllocID = function()
 {
-    // TODO: handle overflow (XCMiscGetXIDRange from XC_MISC ext)
-    // TODO: unused id buffer
-    this.display.rsrc_id++;
-    return (this.display.rsrc_id << this.display.rsrc_shift) + this.display.resource_base;
-}
+  if (this._unusedIds.length > 0) {
+    return this._unusedIds.pop();
+  }
+  // TODO: handle overflow (XCMiscGetXIDRange from XC_MISC ext)
+  this.display.rsrc_id++;
+  return (this.display.rsrc_id << this.display.rsrc_shift) + this.display.resource_base;
+};

+XClient.prototype.ReleaseID = function(id) {
+  this._unusedIds.push(id);
+};

 // TODO: move core events unpackers to corereqs.js
 XClient.prototype.unpackEvent = function(type, seq, extra, code, raw, headerBuf)
@ -290,7 +322,14 @@ XClient.prototype.unpackEvent = function(type, seq, extra, code, raw, headerBuf)
        event.x = values[5];
        event.y = values[6];
        event.values = values
-
+    } else if (type == 9) { // FocusIn
+        event.name = "FocusIn";
+        event.mode = raw.unpack('C')[0];
+        event.wid = extra;
+    } else if (type == 10) { // FocusOut
+        event.name = "FocusOut";
+        event.mode = raw.unpack('C')[0];
+        event.wid = extra;
    } else if (type == 12) { // Expose
        var values = raw.unpack('SSSSS');
        event.name = 'Expose'
@ -404,7 +443,7 @@ XClient.prototype.unpackEvent = function(type, seq, extra, code, raw, headerBuf)
        event.name = 'ClientMessage';
        event.format = code;
        event.wid = extra;
-        event.type = raw.readUInt32LE(0);
+        event.message_type = raw.unpack('L')[0];
        var format = (code === 32) ? 'LLLLL' : (code === 16) ? 'SSSSSSSSSS' : 'CCCCCCCCCCCCCCCCCCCC';
        event.data = raw.unpack(format, 4);
    } else if (type == 34) {
@ -476,7 +515,7 @@ XClient.prototype.expectReplyHeader = function()

                    // raw event 32-bytes packet (primarily for use in SendEvent);
                    // TODO: Event::pack based on event parameters, inverse to unpackEvent
-                    ev.rawData = new Buffer(32);
+                    ev.rawData = Buffer.alloc(32);
                    headerBuf.copy(ev.rawData);
                    buf.copy(ev.rawData, 8);

@ -521,15 +560,16 @@ XClient.prototype.expectReplyHeader = function()
    );
 }

-XClient.prototype.startHandshake = function()
-{
+XClient.prototype.startHandshake = function() {
    var client = this;

-    handshake.writeClientHello(this.pack_stream, this.displayNum, this.authHost);
-    handshake.readServerHello(this.pack_stream, function(display)
+    handshake.writeClientHello(this.pack_stream, this.displayNum, this.authHost, this.authFamily);
+    handshake.readServerHello(this.pack_stream, function(err, display)
    {
-        // TODO: readServerHello can set error state in display
-        // emit error in that case
+        if (err) {
+            client.emit('error', err);
+            return;
+        }
        client.expectReplyHeader();
        client.display = display;
        display.client = client;
@ -539,9 +579,24 @@ XClient.prototype.startHandshake = function()

 XClient.prototype.require = function(extName, callback)
 {
-   var ext = require('./ext/' + extName);
-   ext.requireExt(this.display, callback);
-}
+   var self = this;
+   var ext = this._extensions[extName];
+   if (ext) {
+       return process.nextTick(function() {
+           callback(null, ext);
+       });
+   }
+
+   ext = require('./ext/' + extName);
+   ext.requireExt(this.display, function(err, _ext) {
+       if (err) {
+           return callback(err);
+       }
+
+       self._extensions[extName] = _ext;
+       callback(null, _ext);
+   });
+};

 module.exports.createClient = function(options, initCb)
 {
@ -561,8 +616,6 @@ module.exports.createClient = function(options, initCb)
       throw new Error("Cannot parse display");

    var host = displayMatch[1];
-    if (!host)
-        host = '127.0.0.1';

    var displayNum = displayMatch[2];
    if (!displayNum)
@ -587,10 +640,9 @@ module.exports.createClient = function(options, initCb)
            {
                socketPath = display;
            }
-        } else if(host == '127.0.0.1') //TODO check if it's consistent with xlib (DISPLAY=127.0.0.1:0 -> local unix socket or port 6000?)
+        } else if(!host)
            socketPath = '/tmp/.X11-unix/X' + displayNum;
    }
-    //socketPath = '/tmp/.X11-unix/X' + displayNum;
    var client = new XClient(displayNum, screenNum, options);

    var connectStream = function() {
--- a/package.json
+++ b/package.json
@ -12,7 +12,7 @@
    "X"
  ],
  "homepage": "https://github.com/sidorares/node-x11",
-  "version": "2.0.3",
+  "version": "2.3.0",
  "maintainers": [
    {
      "name": "Andrey Sidorov",
@ -40,14 +40,15 @@
    "node": "*"
  },
  "devDependencies": {
-    "mocha": "*",
-    "should": "*",
-    "sax": "*",
-    "async": "*",
-    "sinon": "*"
+    "async": "^3.0.1",
+    "mocha": "^7.1.2",
+    "sax": "^1.2.4",
+    "should": "^13.2.1",
+    "sinon": "^7.2.5"
  },
  "scripts": {
    "test": "node test-runner.js",
    "prepublish": "npm prune"
-  }
+  },
+  "dependencies": {}
 }
--- a/test/atoms-cache.js
+++ b/test/atoms-cache.js
@ -63,7 +63,7 @@ describe('Atoms and atom names cache', function() {
        });
    });

-    it('should be used after the first request for non-std atom_names', function(done) {
+    xit('should be used after the first request for non-std atom_names', function(done) {
        var self = this;
        var my_name;
        /*
@ -94,7 +94,7 @@ describe('Atoms and atom names cache', function() {
            function(err) {
                should.not.exist(err);
                should.exist(my_name);
-                self.spy.reset();
+                self.spy.resetHistory();
                self.X.InternAtom(true, my_name, function(err, atom) {
                    should.not.exist(err);
                    my_atom.should.equal(atom);
--- a/test/cache-extensions.js
+++ b/test/cache-extensions.js
@ -0,0 +1,34 @@
+var x11 = require('../lib');
+var should = require('should');
+
+describe('requiring an X11 extension on same connection', function() {
+    before(function(done) {
+        var self = this;
+        var client = x11.createClient(function(err, dpy) {
+            should.not.exist(err);
+            self.X = dpy.client;
+            done();
+        });
+
+        client.on('error', function (err) {
+            console.error('Error : ', err);
+        });
+    });
+
+    it('should be cached', function(done) {
+        var self = this;
+        this.X.require('xtest', function(err, randr) {
+            should.not.exist(err);
+            self.X.require('xtest', function(err, randr1) {
+                should.not.exist(err);
+                randr.should.equal(randr1);
+                done();
+            });
+        });
+    });
+
+    after(function(done) {
+        this.X.terminate();
+        this.X.on('end', done);
+    });
+});
--- a/test/change-property.js
+++ b/test/change-property.js
@ -27,7 +27,7 @@ describe('ChangeProperty', function() {
        var self = this;
        this.X.InternAtom(false, TEST_PROPERTY, function(err, atom) {
            should.not.exist(err);
-            var raw = new Buffer(4);
+            var raw = Buffer.alloc(4);
            raw.writeUInt32LE(self.wid, 0);
            self.X.ChangeProperty(0, self.wid, atom, self.X.atoms.WINDOW, 32, raw);
            self.X.once('event', function(ev) {
@ -47,7 +47,7 @@ describe('ChangeProperty', function() {
        var self = this;
        this.X.InternAtom(false, TEST_PROPERTY, function(err, atom) {
            should.not.exist(err);
-            var raw = new Buffer(new Array(8));
+            var raw = Buffer.from(new Array(8));
            raw.writeUInt32LE(self.wid, 0);
            raw.writeUInt32LE(self.wid_helper, 4);
            self.X.ChangeProperty(0, self.wid, atom, self.X.atoms.ATOM, 32, raw);
@ -69,7 +69,7 @@ describe('ChangeProperty', function() {
        var self = this;
        this.X.InternAtom(false, TEST_PROPERTY, function(err, atom) {
            should.not.exist(err);
-            var raw = new Buffer(0);
+            var raw = Buffer.alloc(0);
            self.X.ChangeProperty(0, self.wid, atom, self.X.atoms.WINDOW, 32, raw);
            self.X.once('event', function(ev) {
                ev.type.should.equal(28);
--- a/test/changeGC.js
+++ b/test/changeGC.js
@ -0,0 +1,54 @@
+var x11 = require('../lib');
+var should = require('should');
+
+describe('CreateGC', function() {
+    before(function(done) {
+        var self = this;
+        this.client = x11.createClient(function(err, dpy) {
+            should.not.exist(err);
+            self.X = dpy.client;
+            self.root = dpy.screen[0].root;
+            self.white = dpy.screen[0].white_pixel;
+            self.black = dpy.screen[0].black_pixel;
+            self.wid = self.X.AllocID();
+            self.X.CreateWindow(self.wid, self.root, 0, 0, 1, 1); // 1x1 pixel window
+            self.X.MapWindow(self.wid);
+            self.X.QueryTree(self.root, function(err, list) {
+                should.not.exist(err);
+                list.children.indexOf(self.wid).should.not.equal(-1);
+                done();
+            });
+        });
+    });
+
+    it('should create a Graphic Context correctly', function() {
+        var self = this;
+        this.client.on('error', function(err) {
+            should.not.exist(err);
+        });
+
+        this.gc = this.X.AllocID();
+        this.X.CreateGC(this.gc,
+                        this.wid,
+                        {
+                            foreground: this.black,
+                            background: this.white,
+                            lineStyle : 0
+                        }
+        );
+        
+        this.X.ChangeGC(this.gc,
+                        {
+                            foreground: 0xffff00,
+                            background: 0x0000ff,
+                            lineStyle : 2
+                        }
+        );
+    });
+
+    after(function(done) {
+        this.X.DestroyWindow(this.wid);
+        this.X.on('end', done);
+        this.X.terminate();
+    });
+});
--- a/test/client-message.js
+++ b/test/client-message.js
@ -0,0 +1,114 @@
+var x11 = require('../lib');
+var UnpackStream = require('../lib/unpackstream.js');
+var should = require('should');
+
+//Used Atoms
+var ATOM = {};
+
+describe('ClientMessage', function() {
+    before(function(done) {
+      var self = this;
+      var client = x11.createClient(function(err, dpy) {
+          should.not.exist(err);
+          self.X = dpy.client;
+          self.wid = self.X.AllocID();
+          self.X.CreateWindow(self.wid, dpy.screen[0].root, 0, 0, 1, 1); // 1x1 pixel window
+
+          self.X.InternAtom(false, 'TEST_ATOM_1', function(err, atom) {
+              should.not.exist(err);
+              ATOM['TEST_ATOM_1'] = atom;
+
+              done();
+            });
+      });
+
+      client.on('error', done);
+    });
+
+    it('should receive client message with format=8', function(done) {
+        var self = this;
+
+        var client = x11.createClient(function(err, dpy) {
+            should.not.exist(err);
+            self.X.once('event', function(ev) {
+                ev.name.should.equal('ClientMessage');
+                ev.wid.should.equal(self.wid);
+                ev.message_type.should.equal(ATOM.TEST_ATOM_1);
+                ev.data.should.be.an.Array();
+                ev.data.length.should.equal(20);
+                done();
+            });
+
+            var X = dpy.client;
+            var eventData = Buffer.alloc(32);
+            eventData.writeInt8(33, 0);                          //Event Type 33 = ClientMessage
+            eventData.writeInt8(8,  1);                          //Format
+            eventData.writeInt32LE(self.wid, 4);                 //Window ID
+            eventData.writeInt32LE(ATOM.TEST_ATOM_1, 8);         //Message Type
+
+            X.SendEvent(self.wid, false, 0, eventData);
+        });
+
+        client.on('error', done);
+    });
+
+    it('should receive client message with format=16', function(done) {
+        var self = this;
+
+        var client = x11.createClient(function(err, dpy) {
+            should.not.exist(err);
+            self.X.once('event', function(ev) {
+                ev.name.should.equal('ClientMessage');
+                ev.wid.should.equal(self.wid);
+                ev.message_type.should.equal(ATOM.TEST_ATOM_1);
+                ev.data.should.be.an.Array();
+                ev.data.length.should.equal(10);
+                done();
+            });
+
+            var X = dpy.client;
+            var eventData = Buffer.alloc(32);
+            eventData.writeInt8(33, 0);                          //Event Type 33 = ClientMessage
+            eventData.writeInt8(16,  1);                          //Format
+            eventData.writeInt32LE(self.wid, 4);                 //Window ID
+            eventData.writeInt32LE(ATOM.TEST_ATOM_1, 8);         //Message Type
+
+            X.SendEvent(self.wid, false, 0, eventData);
+        });
+
+        client.on('error', done);
+    });
+
+    it('should receive client message with format=32', function(done) {
+        var self = this;
+
+        var client = x11.createClient(function(err, dpy) {
+            should.not.exist(err);
+            self.X.once('event', function(ev) {
+                ev.name.should.equal('ClientMessage');
+                ev.wid.should.equal(self.wid);
+                ev.message_type.should.equal(ATOM.TEST_ATOM_1);
+                ev.data.should.be.an.Array();
+                ev.data.length.should.equal(5);
+                done();
+            });
+
+            var X = dpy.client;
+            var eventData = Buffer.alloc(32);
+            eventData.writeInt8(33, 0);                          //Event Type 33 = ClientMessage
+            eventData.writeInt8(32,  1);                         //Format
+            eventData.writeInt32LE(self.wid, 4);                 //Window ID
+            eventData.writeInt32LE(ATOM.TEST_ATOM_1, 8);         //Message Type
+
+            X.SendEvent(self.wid, false, 0, eventData);
+        });
+
+        client.on('error', done);
+    });
+
+    after(function(done) {
+        this.X.DestroyWindow(this.wid);
+        this.X.on('end', done);
+        this.X.terminate();
+    });
+});
--- a/test/core-KillKlient.js
+++ b/test/core-KillKlient.js
@ -8,43 +8,41 @@ describe('KillKlient request', function() {
  var X;
  beforeEach(function(done) {
      var client = x11.createClient(function(err, dpy) {
-          if (!err) {
-              display = dpy;
-              X = display.client;
-          }
+          should.not.exist(err);
+          display = dpy;
+          X = display.client;
+          var root = display.screen[0].root;
+          var eventMask = x11.eventMask.SubstructureNotify;
+          X.ChangeWindowAttributes(root, { eventMask: eventMask });
+          done();
+      });

-          done(err);
-      });
-      client.on('error', function(err) {
-         done(err);
-      });
+      client.on('error', done);
  });

  afterEach(function(done) {
-      X.terminate();
      X.on('end', done);
-      X = null;
-      display = null;
+      X.terminate();
  });

-  it('should exist as client member', function(done) {
+  it('should exist as client member', function() {
      should.exist(X.KillKlient);
      assert.equal(typeof X.KillKlient, 'function');
-      done();
  });

  it('should terminate other client connection', function(done) {
      x11.createClient(function(err, dpy) {
-          if (!err) {
-            var otherclient = dpy.client;
-            var wnd = otherclient.AllocID();
-            otherclient.CreateWindow(wnd, dpy.screen[0].root, 0, 0, 1, 1);
-            otherclient.on('end', done);
-            X.KillKlient(wnd);
-          } else {
-            done(err);
-          }
+          should.not.exist(err);
+          var otherclient = dpy.client;
+          var wnd = otherclient.AllocID();
+          X.once('event', function(ev) {
+              ev.name.should.equal('CreateNotify');
+              ev.wid.should.equal(wnd);
+              X.KillKlient(wnd);
+          });
+
+          otherclient.CreateWindow(wnd, dpy.screen[0].root, 0, 0, 1, 1);
+          otherclient.on('end', done);
      });
  });
-
 });
--- a/test/randr.js
+++ b/test/randr.js
@ -1,4 +1,5 @@
 var x11 = require('../lib');
+var async = require('async');
 var should = require('should');
 var assert = require('assert');
 var util = require('util');
@ -35,6 +36,26 @@ describe('RANDR extension', function() {
        });
    });

+    it('GetScreenResources && GetOutputInfo', function(done) {
+        var self = this;
+        this.randr.GetScreenResources(this.root, function(err, resources) {
+            should.not.exist(err);
+            should.exist(resources);
+            async.each(
+                resources.outputs,
+                function(output, cb) {
+                    self.randr.GetOutputInfo(output, 0, function(err, info) {
+                        should.not.exist(err);
+                        should.exist(info);
+                        cb();
+                    });
+                },
+                done
+            );
+
+        });
+    });
+
    after(function(done) {
        this.X.terminate();
        this.X.on('end', done);
Author	SHA1	Message	Date
Daniel Bulant	eeb9d58310	Parse FocusIn and FocusOut events	2021-08-05 15:54:39 +02:00
Andrey Sidorov	97e3600467	disable failing envs	2020-05-21 22:02:07 +10:00
Andrey Sidorov	bf56aef5a4	skip failing test	2020-05-21 20:54:16 +10:00
Andrey Sidorov	7728cde55e	Merge pull request #189 from sidorares/greenkeeper/async-3.0.1 Update async to the latest version 🚀	2020-05-21 20:20:03 +10:00
Andrey Sidorov	89fd615f8f	Merge pull request #188 from sidorares/greenkeeper/sinon-7.2.5 Update sinon to the latest version 🚀	2020-05-21 20:19:49 +10:00
Andrey Sidorov	1db2cb54c3	Merge pull request #194 from matoruru/patch-1 Remove unnecessary parentheses from require('os').homedir()	2020-05-21 20:17:05 +10:00
Andrey Sidorov	4ece7f2b0b	Merge branch 'master' into greenkeeper/async-3.0.1	2020-05-21 20:16:03 +10:00
Andrey Sidorov	b50b222a74	Merge pull request #118 from vird/patch-1 Array proto crash fix	2020-05-21 20:13:29 +10:00
Andrey Sidorov	9414ed788d	deps: update mocha	2020-05-21 20:10:59 +10:00
Andrey Sidorov	c54dddd746	build: bump node versions to 12 + 14	2020-05-21 20:10:43 +10:00
matoruru	c41ad68e34	Remove unnecessary parentheses from require('os').homedir()	2020-05-19 23:20:01 +09:00
Andrey Sidorov	e17e8b04a1	Merge pull request #192 from mat-sz/master Replaced os-homedir (deprecated) with os.homedir()	2020-04-25 14:41:43 +10:00
Mat Sz	3d6295f0df	.gitignore	2020-04-24 19:35:17 +02:00
Mat Sz	a16c1cb8eb	replaced os-homedir with os.homedir()	2020-04-24 19:30:32 +02:00
Andrey Sidorov	8ed75f54e1	Merge pull request #190 from roquef/patch-1 Fixes variable declaration typo in example	2019-10-12 10:39:53 +11:00
Roque Francisco	340432893d	Fixes variable declaration typo in example	2019-10-11 15:07:25 -03:00
greenkeeper[bot]	8500b1fc54	chore(package): update async to version 3.0.1	2019-05-26 21:47:27 +00:00
greenkeeper[bot]	43a7e7375a	chore(package): update sinon to version 7.2.5	2019-02-27 12:09:30 +00:00
Andrey Sidorov	f6547d3876	Update README.md	2019-01-15 17:24:08 +11:00
Andrey Sidorov	15c7149c6a	Add Render.AddGlyphsFromPicture request	2018-12-13 14:55:07 +11:00
Andrey Sidorov	4bddee6d5e	Merge pull request #181 from SpaceboyRoss01/master Lots more stuff	2018-11-15 09:32:55 +11:00
Spaceboy Ross	8f322e5f8f	Missed something but its fixed	2018-11-14 12:27:41 -08:00
Spaceboy Ross	5c46c4f1d3	Added XBell	2018-11-14 12:27:10 -08:00
Spaceboy Ross	29b454ee3d	#182 fixed	2018-11-14 12:22:16 -08:00
Spaceboy Ross	66bc53624d	Begining of fixing sidorares/node-x11#182	2018-11-14 12:05:24 -08:00
Spaceboy Ross	d1868d5ee8	Fixed the unpack stream so arrays can work	2018-11-14 11:44:12 -08:00
Andrey Sidorov	2d7ffc2bcd	Merge branch 'master' of https://github.com/sidorares/node-x11	2018-07-09 14:01:51 +10:00
Andrey Sidorov	4c6617c994	make text example work when default bg color is black	2018-07-09 14:01:14 +10:00
Andrey Sidorov	174cff9a9c	Merge pull request #172 from sidorares/greenkeeper/sinon-6.0.0 Update sinon to the latest version 🚀	2018-06-11 22:12:09 +10:00
greenkeeper[bot]	2bb273993e	chore(package): update sinon to version 6.0.0	2018-06-11 05:58:46 +00:00
Andrey Sidorov	d5c4103b1f	Merge pull request #169 from sidorares/greenkeeper/sinon-5.0.1 chore(package): update sinon to version 5.0.1	2018-04-30 19:52:29 +10:00
greenkeeper[bot]	d004af97fa	chore(package): update sinon to version 5.0.1	2018-04-30 08:42:48 +00:00
Andrey Sidorov	ce51cefdad	Merge pull request #167 from sidorares/greenkeeper/sinon-5.0.0 Update sinon to the latest version 🚀	2018-03-22 10:16:26 +11:00
greenkeeper[bot]	373b60b975	chore(package): update sinon to version 5.0.0	2018-03-21 17:27:33 +00:00
Andrey Sidorov	85905efeae	Merge pull request #164 from anko/just-some-maintenance Mr Janitor coming through	2018-01-24 10:00:56 +11:00
Andrey Sidorov	ef001bd4fb	Merge pull request #163 from anko/stop-testing-on-old-node-versions Stop testing on Node 0.10 + 0.12	2018-01-24 09:51:14 +11:00
Antti Korpi	6f535cb65d	Travis: stop testing on Node 0.10 + 0.12 They're breaking the build, because Mocha (a dependency) is using modern JS features.	2018-01-23 22:36:27 +01:00
Antti Korpi	ed27aa84ff	Fix 'root' deprecation warning This would previously be printed in part of the test log: (node:1628) [DEP0016] DeprecationWarning: 'root' is deprecated, use 'global' Apparently, the global object was once called root, and this assignment didn't have a `var`, so it was actually setting the global object. I do wonder why that didn't break anything, but this is clearly what was intended.	2018-01-23 22:35:49 +01:00
Antti Korpi	e87b183a8f	Use sinon.resetHistory; sinon.reset is deprecated	2018-01-23 22:06:42 +01:00
Antti Korpi	fd09ef9848	Nail devDependencies to specific version This documents what versions it's supposed to work with, and reduces potential future confusion if contributors accidentally work with different tool versions.	2018-01-23 21:59:21 +01:00
Andrey Sidorov	4e84ae8e40	2.3.0	2017-08-27 15:11:35 +10:00
Andrey Sidorov	a97f7a179d	Merge pull request #150 from jdomenechb/shapenotify Added ShapeNotify event parsing	2017-08-27 10:10:37 +10:00
jdomenechb	bc9dceebd4	Added ShapeNotify event parsing	2017-08-26 17:00:10 +02:00
Andrey Sidorov	18cbbdf6ee	Merge pull request #148 from andrewstart/master Fix ChangeGC.	2017-08-05 02:11:35 +10:00
Andrew Start	da262fcb8d	Add test for ChangeGC.	2017-08-04 12:05:05 -04:00
Andrew Start	8049e70deb	Fix ChangeGC.	2017-08-04 11:45:41 -04:00
Andrey Sidorov	eb674cc41c	Merge pull request #147 from anko/readme-cleanup Readme cleanup	2017-07-21 08:45:41 +10:00
Antti Korpi	f13247ec6d	Readme cleanup - Drop headings to level 2 (except the top one). - Fix Gitter link. - Trim example code indent level.	2017-07-20 17:07:56 +01:00
Andrey Sidorov	6598e75baf	add link to xelb	2017-06-09 11:11:34 +10:00
Andrey Sidorov	3ca322cecc	2.2.1	2017-04-21 22:53:52 +10:00
Andrey Sidorov	97a582be5c	Merge pull request #141 from drom/master added dummy function "stash" to help browserify bundler with require prefetch	2017-04-21 22:52:39 +10:00
Aliaksei Chapyzhenka	7341a317bd	added node 6 7 regression	2017-04-20 22:36:23 -07:00
Aliaksei Chapyzhenka	37d0130b38	fixed badge	2017-04-20 22:35:15 -07:00
Aliaksei Chapyzhenka	08a6ae573e	added dummy function "stash" to help browserify bundler with require prefetch	2017-04-20 22:20:35 -07:00
Andrey Sidorov	0ad31e0ffe	Merge pull request #137 from 15lyfromsaturn/master png rendering example	2016-12-01 10:08:48 +11:00
Svetlana Linuxenko	777becd99e	png rendering example	2016-11-30 18:37:13 +02:00
Andrey Sidorov	77a94b1324	Merge pull request #136 from 15lyfromsaturn/master double import of templates	2016-11-24 13:57:23 +11:00
Svetlana Linuxenko	9b6492b34a	double import of templates	2016-11-23 20:03:56 +02:00
Andrey Sidorov	562ed74562	Merge pull request #135 from 15lyfromsaturn/master GCFunction shortcuts	2016-11-19 10:48:47 +11:00
Svetlana Linuxenko	9e967b9734	GCFunction shortcuts	2016-11-18 15:05:28 +02:00
Svetlana Linuxenko	6293ab358b	duplicated entry	2016-11-18 12:37:24 +01:00
Andrey Sidorov	e3f6438e1a	Merge pull request #132 from 15lyfromsaturn/master screenshot example fix	2016-11-18 00:20:40 +11:00
Svetlana Linuxenko	9ff1b645d1	screenshot example fix	2016-11-17 12:12:20 +02:00
Santiago Gimeno	77d1666c08	2.2.0	2016-10-11 12:40:17 +02:00
Andrey Sidorov	f2a118d034	Merge pull request #130 from santigimeno/improve_randr randr: add GetOutputInfo request	2016-10-11 21:17:13 +11:00
Andrey Sidorov	7f39c65c93	Merge pull request #131 from santigimeno/fix_killclient_test test: fix flaky core-KillKlient test	2016-10-11 21:15:02 +11:00
Santiago Gimeno	f0b0bac336	test: fix flaky core-KillKlient test Wait for the `CreateNotify` before killing the client, otherwise a `BadValue` error could be raised.	2016-10-11 12:04:09 +02:00
Santiago Gimeno	e09c8b5429	randr: add GetOutputInfo request	2016-10-11 10:19:30 +02:00
Santiago Gimeno	8ed37aaa31	2.1.1	2016-10-06 14:47:27 +02:00
Andrey Sidorov	ba6d6f63a2	Merge pull request #129 from sidorares/cache_extensions Cache X11 extensions	2016-10-06 23:11:37 +11:00
Santiago Gimeno	4f241ba2b3	Cache X11 extensions	2016-10-06 12:11:59 +02:00
Andrey Sidorov	f040f8bbba	2.1.0	2016-05-25 16:55:12 +10:00
Andrey Sidorov	88370a111e	Merge pull request #125 from Arteris/handshake_error Unpack handshake error	2016-05-19 12:08:39 +10:00
Ian Scott	b9bebe3a11	Unpack handshake error	2016-05-18 18:14:03 -07:00
Andrey Sidorov	60f8b08037	add unused IDs buffer	2016-05-18 20:22:24 +10:00
Andrey Sidorov	1d77f21ec7	Merge pull request #80 from Arteris/master Handle cases where depths appear multiple times	2016-05-18 09:14:33 +10:00
Ian Scott	bbaf2a8654	Refactor to keep number of parsed depths in a counter	2016-05-17 14:42:42 -07:00
Ian Scott	7ed7e896e1	Handle cases where depths appear multiple times	2016-05-17 14:41:53 -07:00
Andrey Sidorov	44f9982495	Merge pull request #124 from Arteris/auth_fix2 Fix auth for remote hosts and handle different auth families	2016-05-17 19:51:52 +10:00
Ian Scott	1f5e2310a6	Fix remoteFamily on Node v0.10	2016-05-16 09:45:39 -07:00
Ian Scott	a42f043768	Emit error when handshake fails, such as with bad xauth	2016-05-13 18:59:41 -07:00
Ian Scott	c694394b6d	Test xauth in Travis tests	2016-05-13 18:59:33 -07:00
Ian Scott	e8883275bf	Fix auth for remote hosts and handle different auth families - Use the remote address to find the auth cookie instead of the local hostname - Read family type as big endian in Xauthority file - Don't upgrade 127.0.0.1 TCP connections to unix domain socket (libX11 and xcb don't do this) - Don't error if no auth cookie is found; continue without auth	2016-03-21 16:00:52 -07:00
Andrey Sidorov	edbe678f84	Merge pull request #123 from Coldewey/master Reads message_type from ClientMessage.	2016-02-03 03:12:17 -08:00
plehmkuhl	d327261c74	Adjusted testcase "client-message.js" to match other tests.	2016-02-03 11:42:32 +01:00
plehmkuhl	4fd0385911	Fixed datatype returned by message_type on ClientMessage event. Added Testcase.	2016-02-03 11:08:58 +01:00
plehmkuhl	27c70c7315	Reads nessage_type from ClientMessage. See: https://tronche.com/gui/x/xlib/events/client-communication/client-message.html	2016-02-02 16:26:41 +01:00
Andrey Sidorov	f21cdb187b	Merge pull request #122 from Arteris/auth_fix Xauth fixes	2016-01-28 16:58:18 -08:00
Ian Scott	86f977f9bd	Handle nonexistent Xauthority file	2016-01-28 16:35:04 -08:00
Ian Scott	582bd1a1b2	Use os-homedir for older node.js versions	2016-01-28 14:51:16 -08:00
Ian Scott	e90c1fd239	Find cookie with same logic as libXau	2016-01-28 14:50:24 -08:00
Andrey Sidorov	ce238c7c0b	2.0.5	2016-01-15 16:02:20 +11:00
Andrey Sidorov	70519cbb38	handle Internet cookie addresses correctly. Fixes #121	2016-01-15 16:01:54 +11:00
Andrey Sidorov	0d7346fbac	2.0.4	2016-01-15 00:37:26 +11:00
Andrey Sidorov	7e22a439e8	don't overwrite ClientMessage type	2016-01-15 00:37:15 +11:00
vird	7e8e972b24	Array proto crash fix fixed crash when Array has some proto modifications; minor spaces fix	2015-11-29 19:11:19 +02:00