diff --git a/examples/asteroids/asteroids.js b/examples/asteroids/asteroids.js
new file mode 100644
index 0000000..0c7b36e
--- /dev/null
+++ b/examples/asteroids/asteroids.js
@@ -0,0 +1,103 @@
+var x11 = require('../../lib/x11');
+var watchMobile = require('./staticserver');
+var PointerMotion = x11.eventMask.PointerMotion;
+
+var X, Render;
+var rocketX = 400;
+var rocketY = 300;
+var speedX = 0;
+var speedY = 0;
+var angle = 0;
+var acc = 0;
+
+
+var xclient = x11.createClient(function(display) {
+ X = display.client;
+ var root = display.screen[0].root;
+ X.require('render', function(rendExt) {
+
+
+ Render = rendExt;
+ var wid = X.AllocID();
+
+ var white = display.screen[0].white_pixel;
+ var black = display.screen[0].black_pixel;
+ X.CreateWindow(wid, root, 10, 10, 900, 600, 1, 1, 0, { backgroundPixel: white, eventMask: PointerMotion });
+ X.MapWindow(wid);
+
+ var gc = X.AllocID();
+ X.CreateGC(gc, wid, { foreground: white, background: black } );
+
+ var pict = X.AllocID();
+ Render.CreatePicture(pict, wid, Render.rgb24);
+ var pictGrad = X.AllocID();
+ Render.RadialGradient(pictGrad, [50,56], [50,50], 0, 50,
+ [
+ [0, [0,0,0xffff,0xffff ] ],
+ [0.95, [0,0,0,0x00ff00 ] ],
+ [0.997, [0xffff, 0xf, 0, 0x1] ],
+ [1, [0xffff, 0xffff, 0, 0x0] ]
+ ]);
+
+ var solid = Render.SolidFill
+ var dark_grad = X.AllocID();
+ Render.LinearGradient(dark_grad, [0,0], [1000,100],
+ [
+ [0, [0,0,0,0x0 ] ],
+ [0.1, [0xfff, 0, 0xffff, 0] ] ,
+ [0.25, [0xfff, 0, 0xfff, 0] ] ,
+ [0.5, [0xfff, 0, 0xffff, 0] ] ,
+ [1, [0xfff, 0xffff, 0, 0] ]
+ ]);
+
+ function draw(x, y) {
+
+ X.PolyFillRectangle(wid, gc, [0, 0, 1000, 1000]);
+ Render.Composite(3, pictGrad, 0, pict, 0, 0, 0, 0, rocketX - 50, rocketY - 50, 100, 100);
+ // draw directed triangle
+
+ //
+ //
+ //
+ var pts = [
+ rocketX + Math.cos(angle)*50, rocketY + Math.sin(angle)*50,
+ rocketX + Math.cos(angle + 1)*50, rocketY + Math.sin(angle+1)*50,
+ rocketX + Math.cos(angle + 2)*50, rocketY + Math.sin(angle+2)*50,
+
+ ];
+ //Render.Triangles(3, dark_grad, 0, 0, dark_grad, 0, pts);
+ X.PolyLine(0, wid, gc, pts);
+ }
+
+ X.on('event', function(ev) {
+ //draw(ev.x, ev.y);
+ });
+
+ watchMobile(function(x, y, z) {
+ //console.log([x, y, z]);
+ //console.log(x);
+ angle = 2*Math.PI*(y/360);
+ acc = 90 - z;
+ draw();
+ });
+
+function updateScene()
+{
+ rocketX += speedX;
+ rocketY += speedY;
+ speedX += Math.cos(angle + 1)*acc/500;
+ speedY += Math.sin(angle + 1)*acc/500;
+ console.log(acc);
+ if (rocketX+100 > 900)
+ speedX = -speedX;
+ if (rocketX-100 < 0)
+ speedX = -speedX;
+ if (rocketY+100 > 600)
+ speedY = -speedY;
+ if (rocketY-100 < 0)
+ speedY = -speedY;
+}
+ setInterval(updateScene, 50);
+ });
+});
+
diff --git a/examples/asteroids/orientation b/examples/asteroids/orientation
new file mode 160000
index 0000000..aa529ee
--- /dev/null
+++ b/examples/asteroids/orientation
@@ -0,0 +1 @@
+Subproject commit aa529ee711d3c0704c9721710f164acedc5b2fc7
diff --git a/examples/asteroids/orientation.html b/examples/asteroids/orientation.html
new file mode 100644
index 0000000..789bad0
--- /dev/null
+++ b/examples/asteroids/orientation.html
@@ -0,0 +1,30 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/examples/asteroids/staticserver.js b/examples/asteroids/staticserver.js
new file mode 100644
index 0000000..bafe401
--- /dev/null
+++ b/examples/asteroids/staticserver.js
@@ -0,0 +1,45 @@
+var http = require("http"),
+ url = require("url"),
+ path = require("path"),
+ fs = require("fs")
+ port = process.argv[2] || 8888;
+
+module.exports = function(cb)
+{
+console.log('here');
+http.createServer(function(request, response) {
+
+ var uri = url.parse(request.url).pathname
+ , filename = path.join(process.cwd(), uri);
+
+ path.exists(filename, function(exists) {
+ if(!exists) {
+ var params = filename.split('_');
+ console.log(params);
+ if (params.length == 4)
+ cb(params[1], params[2], params[3]);
+ response.writeHead(404, {"Content-Type": "text/plain"});
+ response.write("404 Not Found\n");
+ response.end();
+ return;
+ }
+
+ if (fs.statSync(filename).isDirectory()) filename += '/index.html';
+
+ fs.readFile(filename, "binary", function(err, file) {
+ if(err) {
+ response.writeHead(500, {"Content-Type": "text/plain"});
+ response.write(err + "\n");
+ response.end();
+ return;
+ }
+
+ response.writeHead(200);
+ response.write(file, "binary");
+ response.end();
+ });
+ });
+}).listen(parseInt(port, 10));
+
+console.log("Static file server running at\n => http://localhost:" + port + "/\nCTRL + C to shutdown");
+}
diff --git a/examples/png/node-logo.png b/examples/png/node-logo.png
new file mode 100644
index 0000000..ef3494e
Binary files /dev/null and b/examples/png/node-logo.png differ
diff --git a/examples/png/node-png.js b/examples/png/node-png.js
new file mode 100644
index 0000000..f293baa
--- /dev/null
+++ b/examples/png/node-png.js
@@ -0,0 +1,868 @@
+/* Extracted from https://github.com/devongovett/png.js/ */
+/*
+ # MIT LICENSE
+ # Copyright (c) 2011 Devon Govett
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ # software and associated documentation files (the "Software"), to deal in the Software
+ # without restriction, including without limitation the rights to use, copy, modify, merge,
+ # publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+ # to whom the Software is furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included in all copies or
+ # substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ # BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+/*
+ * Extracted from pdf.js
+ * https://github.com/andreasgal/pdf.js
+ *
+ * Copyright (c) 2011 Mozilla Foundation
+ *
+ * Contributors: Andreas Gal
+ * Chris G Jones
+ * Shaon Barman
+ * Vivien Nicolas <21@vingtetun.org>
+ * Justin D'Arcangelo
+ * Yury Delendik
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+var DecodeStream = (function() {
+ function constructor() {
+ this.pos = 0;
+ this.bufferLength = 0;
+ this.eof = false;
+ this.buffer = null;
+ }
+
+ constructor.prototype = {
+ ensureBuffer: function decodestream_ensureBuffer(requested) {
+ var buffer = this.buffer;
+ var current = buffer ? buffer.byteLength : 0;
+ if (requested < current)
+ return buffer;
+ var size = 512;
+ while (size < requested)
+ size <<= 1;
+ var buffer2 = new Uint8Array(size);
+ for (var i = 0; i < current; ++i)
+ buffer2[i] = buffer[i];
+ return this.buffer = buffer2;
+ },
+ getByte: function decodestream_getByte() {
+ var pos = this.pos;
+ while (this.bufferLength <= pos) {
+ if (this.eof)
+ return null;
+ this.readBlock();
+ }
+ return this.buffer[this.pos++];
+ },
+ getBytes: function decodestream_getBytes(length) {
+ var pos = this.pos;
+
+ if (length) {
+ this.ensureBuffer(pos + length);
+ var end = pos + length;
+
+ while (!this.eof && this.bufferLength < end)
+ this.readBlock();
+
+ var bufEnd = this.bufferLength;
+ if (end > bufEnd)
+ end = bufEnd;
+ } else {
+ while (!this.eof)
+ this.readBlock();
+
+ var end = this.bufferLength;
+ }
+
+ this.pos = end;
+ return this.buffer.subarray(pos, end);
+ },
+ lookChar: function decodestream_lookChar() {
+ var pos = this.pos;
+ while (this.bufferLength <= pos) {
+ if (this.eof)
+ return null;
+ this.readBlock();
+ }
+ return String.fromCharCode(this.buffer[this.pos]);
+ },
+ getChar: function decodestream_getChar() {
+ var pos = this.pos;
+ while (this.bufferLength <= pos) {
+ if (this.eof)
+ return null;
+ this.readBlock();
+ }
+ return String.fromCharCode(this.buffer[this.pos++]);
+ },
+ makeSubStream: function decodestream_makeSubstream(start, length, dict) {
+ var end = start + length;
+ while (this.bufferLength <= end && !this.eof)
+ this.readBlock();
+ return new Stream(this.buffer, start, length, dict);
+ },
+ skip: function decodestream_skip(n) {
+ if (!n)
+ n = 1;
+ this.pos += n;
+ },
+ reset: function decodestream_reset() {
+ this.pos = 0;
+ }
+ };
+
+ return constructor;
+})();
+
+var FlateStream = (function() {
+ var codeLenCodeMap = new Uint32Array([
+ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+ ]);
+
+ var lengthDecode = new Uint32Array([
+ 0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a,
+ 0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f,
+ 0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073,
+ 0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102
+ ]);
+
+ var distDecode = new Uint32Array([
+ 0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d,
+ 0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1,
+ 0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01,
+ 0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001
+ ]);
+
+ var fixedLitCodeTab = [new Uint32Array([
+ 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0,
+ 0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0,
+ 0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0,
+ 0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0,
+ 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8,
+ 0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8,
+ 0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8,
+ 0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8,
+ 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4,
+ 0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4,
+ 0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4,
+ 0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4,
+ 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc,
+ 0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec,
+ 0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc,
+ 0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc,
+ 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2,
+ 0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2,
+ 0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2,
+ 0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2,
+ 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca,
+ 0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea,
+ 0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da,
+ 0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa,
+ 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6,
+ 0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6,
+ 0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6,
+ 0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6,
+ 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce,
+ 0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee,
+ 0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de,
+ 0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe,
+ 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1,
+ 0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1,
+ 0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1,
+ 0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1,
+ 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9,
+ 0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9,
+ 0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9,
+ 0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9,
+ 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5,
+ 0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5,
+ 0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5,
+ 0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5,
+ 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd,
+ 0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed,
+ 0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd,
+ 0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd,
+ 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3,
+ 0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3,
+ 0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3,
+ 0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3,
+ 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb,
+ 0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb,
+ 0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db,
+ 0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb,
+ 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7,
+ 0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7,
+ 0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7,
+ 0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7,
+ 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf,
+ 0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef,
+ 0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df,
+ 0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff
+ ]), 9];
+
+ var fixedDistCodeTab = [new Uint32Array([
+ 0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c,
+ 0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000,
+ 0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d,
+ 0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000
+ ]), 5];
+
+ function error(e) {
+ throw new Error(e)
+ }
+
+ function constructor(bytes) {
+ //var bytes = stream.getBytes();
+ var bytesPos = 0;
+
+ var cmf = bytes[bytesPos++];
+ var flg = bytes[bytesPos++];
+ if (cmf == -1 || flg == -1)
+ error('Invalid header in flate stream');
+ if ((cmf & 0x0f) != 0x08)
+ error('Unknown compression method in flate stream');
+ if ((((cmf << 8) + flg) % 31) != 0)
+ error('Bad FCHECK in flate stream');
+ if (flg & 0x20)
+ error('FDICT bit set in flate stream');
+
+ this.bytes = bytes;
+ this.bytesPos = bytesPos;
+
+ this.codeSize = 0;
+ this.codeBuf = 0;
+
+ DecodeStream.call(this);
+ }
+
+ constructor.prototype = Object.create(DecodeStream.prototype);
+
+ constructor.prototype.getBits = function(bits) {
+ var codeSize = this.codeSize;
+ var codeBuf = this.codeBuf;
+ var bytes = this.bytes;
+ var bytesPos = this.bytesPos;
+
+ var b;
+ while (codeSize < bits) {
+ if (typeof (b = bytes[bytesPos++]) == 'undefined')
+ error('Bad encoding in flate stream');
+ codeBuf |= b << codeSize;
+ codeSize += 8;
+ }
+ b = codeBuf & ((1 << bits) - 1);
+ this.codeBuf = codeBuf >> bits;
+ this.codeSize = codeSize -= bits;
+ this.bytesPos = bytesPos;
+ return b;
+ };
+
+ constructor.prototype.getCode = function(table) {
+ var codes = table[0];
+ var maxLen = table[1];
+ var codeSize = this.codeSize;
+ var codeBuf = this.codeBuf;
+ var bytes = this.bytes;
+ var bytesPos = this.bytesPos;
+
+ while (codeSize < maxLen) {
+ var b;
+ if (typeof (b = bytes[bytesPos++]) == 'undefined')
+ error('Bad encoding in flate stream');
+ codeBuf |= (b << codeSize);
+ codeSize += 8;
+ }
+ var code = codes[codeBuf & ((1 << maxLen) - 1)];
+ var codeLen = code >> 16;
+ var codeVal = code & 0xffff;
+ if (codeSize == 0 || codeSize < codeLen || codeLen == 0)
+ error('Bad encoding in flate stream');
+ this.codeBuf = (codeBuf >> codeLen);
+ this.codeSize = (codeSize - codeLen);
+ this.bytesPos = bytesPos;
+ return codeVal;
+ };
+
+ constructor.prototype.generateHuffmanTable = function(lengths) {
+ var n = lengths.length;
+
+ // find max code length
+ var maxLen = 0;
+ for (var i = 0; i < n; ++i) {
+ if (lengths[i] > maxLen)
+ maxLen = lengths[i];
+ }
+
+ // build the table
+ var size = 1 << maxLen;
+ var codes = new Uint32Array(size);
+ for (var len = 1, code = 0, skip = 2;
+ len <= maxLen;
+ ++len, code <<= 1, skip <<= 1) {
+ for (var val = 0; val < n; ++val) {
+ if (lengths[val] == len) {
+ // bit-reverse the code
+ var code2 = 0;
+ var t = code;
+ for (var i = 0; i < len; ++i) {
+ code2 = (code2 << 1) | (t & 1);
+ t >>= 1;
+ }
+
+ // fill the table entries
+ for (var i = code2; i < size; i += skip)
+ codes[i] = (len << 16) | val;
+
+ ++code;
+ }
+ }
+ }
+
+ return [codes, maxLen];
+ };
+
+ constructor.prototype.readBlock = function() {
+ function repeat(stream, array, len, offset, what) {
+ var repeat = stream.getBits(len) + offset;
+ while (repeat-- > 0)
+ array[i++] = what;
+ }
+
+ // read block header
+ var hdr = this.getBits(3);
+ if (hdr & 1)
+ this.eof = true;
+ hdr >>= 1;
+
+ if (hdr == 0) { // uncompressed block
+ var bytes = this.bytes;
+ var bytesPos = this.bytesPos;
+ var b;
+
+ if (typeof (b = bytes[bytesPos++]) == 'undefined')
+ error('Bad block header in flate stream');
+ var blockLen = b;
+ if (typeof (b = bytes[bytesPos++]) == 'undefined')
+ error('Bad block header in flate stream');
+ blockLen |= (b << 8);
+ if (typeof (b = bytes[bytesPos++]) == 'undefined')
+ error('Bad block header in flate stream');
+ var check = b;
+ if (typeof (b = bytes[bytesPos++]) == 'undefined')
+ error('Bad block header in flate stream');
+ check |= (b << 8);
+ if (check != (~blockLen & 0xffff))
+ error('Bad uncompressed block length in flate stream');
+
+ this.codeBuf = 0;
+ this.codeSize = 0;
+
+ var bufferLength = this.bufferLength;
+ var buffer = this.ensureBuffer(bufferLength + blockLen);
+ var end = bufferLength + blockLen;
+ this.bufferLength = end;
+ for (var n = bufferLength; n < end; ++n) {
+ if (typeof (b = bytes[bytesPos++]) == 'undefined') {
+ this.eof = true;
+ break;
+ }
+ buffer[n] = b;
+ }
+ this.bytesPos = bytesPos;
+ return;
+ }
+
+ var litCodeTable;
+ var distCodeTable;
+ if (hdr == 1) { // compressed block, fixed codes
+ litCodeTable = fixedLitCodeTab;
+ distCodeTable = fixedDistCodeTab;
+ } else if (hdr == 2) { // compressed block, dynamic codes
+ var numLitCodes = this.getBits(5) + 257;
+ var numDistCodes = this.getBits(5) + 1;
+ var numCodeLenCodes = this.getBits(4) + 4;
+
+ // build the code lengths code table
+ var codeLenCodeLengths = Array(codeLenCodeMap.length);
+ var i = 0;
+ while (i < numCodeLenCodes)
+ codeLenCodeLengths[codeLenCodeMap[i++]] = this.getBits(3);
+ var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
+
+ // build the literal and distance code tables
+ var len = 0;
+ var i = 0;
+ var codes = numLitCodes + numDistCodes;
+ var codeLengths = new Array(codes);
+ while (i < codes) {
+ var code = this.getCode(codeLenCodeTab);
+ if (code == 16) {
+ repeat(this, codeLengths, 2, 3, len);
+ } else if (code == 17) {
+ repeat(this, codeLengths, 3, 3, len = 0);
+ } else if (code == 18) {
+ repeat(this, codeLengths, 7, 11, len = 0);
+ } else {
+ codeLengths[i++] = len = code;
+ }
+ }
+
+ litCodeTable =
+ this.generateHuffmanTable(codeLengths.slice(0, numLitCodes));
+ distCodeTable =
+ this.generateHuffmanTable(codeLengths.slice(numLitCodes, codes));
+ } else {
+ error('Unknown block type in flate stream');
+ }
+
+ var buffer = this.buffer;
+ var limit = buffer ? buffer.length : 0;
+ var pos = this.bufferLength;
+ while (true) {
+ var code1 = this.getCode(litCodeTable);
+ if (code1 < 256) {
+ if (pos + 1 >= limit) {
+ buffer = this.ensureBuffer(pos + 1);
+ limit = buffer.length;
+ }
+ buffer[pos++] = code1;
+ continue;
+ }
+ if (code1 == 256) {
+ this.bufferLength = pos;
+ return;
+ }
+ code1 -= 257;
+ code1 = lengthDecode[code1];
+ var code2 = code1 >> 16;
+ if (code2 > 0)
+ code2 = this.getBits(code2);
+ var len = (code1 & 0xffff) + code2;
+ code1 = this.getCode(distCodeTable);
+ code1 = distDecode[code1];
+ code2 = code1 >> 16;
+ if (code2 > 0)
+ code2 = this.getBits(code2);
+ var dist = (code1 & 0xffff) + code2;
+ if (pos + len >= limit) {
+ buffer = this.ensureBuffer(pos + len);
+ limit = buffer.length;
+ }
+ for (var k = 0; k < len; ++k, ++pos)
+ buffer[pos] = buffer[pos - dist];
+ }
+ };
+
+ return constructor;
+})();
+
+
+ /*
+ # MIT LICENSE
+ # Copyright (c) 2011 Devon Govett
+ #
+ # Permission is hereby granted, free of charge, to any person obtaining a copy of this
+ # software and associated documentation files (the "Software"), to deal in the Software
+ # without restriction, including without limitation the rights to use, copy, modify, merge,
+ # publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+ # to whom the Software is furnished to do so, subject to the following conditions:
+ #
+ # The above copyright notice and this permission notice shall be included in all copies or
+ # substantial portions of the Software.
+ #
+ # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ # BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ # DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+ var __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+ var APNG_BLEND_OP_OVER, APNG_BLEND_OP_SOURCE, APNG_DISPOSE_OP_BACKGROUND, APNG_DISPOSE_OP_NONE, APNG_DISPOSE_OP_PREVIOUS, makeImage, scratchCanvas, scratchCtx;
+ APNG_DISPOSE_OP_NONE = 0;
+ APNG_DISPOSE_OP_BACKGROUND = 1;
+ APNG_DISPOSE_OP_PREVIOUS = 2;
+ APNG_BLEND_OP_SOURCE = 0;
+ APNG_BLEND_OP_OVER = 1;
+ function PNG(data) {
+ var chunkSize, colors, delayDen, delayNum, frame, i, section, short, _ref;
+ this.data = data;
+ this.pos = 8;
+ this.palette = [];
+ this.imgData = [];
+ this.transparency = {};
+ this.animation = null;
+ frame = null;
+ while (true) {
+ chunkSize = this.readUInt32();
+ section = ((function() {
+ var _results;
+ _results = [];
+ for (i = 0; i < 4; i++) {
+ _results.push(String.fromCharCode(this.data[this.pos++]));
+ }
+ return _results;
+ }).call(this)).join('');
+ switch (section) {
+ case 'IHDR':
+ this.width = this.readUInt32();
+ this.height = this.readUInt32();
+ this.bits = this.data[this.pos++];
+ this.colorType = this.data[this.pos++];
+ this.compressionMethod = this.data[this.pos++];
+ this.filterMethod = this.data[this.pos++];
+ this.interlaceMethod = this.data[this.pos++];
+ break;
+ case 'acTL':
+ this.animation = {
+ numFrames: this.readUInt32(),
+ numPlays: this.readUInt32() || Infinity,
+ frames: []
+ };
+ break;
+ case 'PLTE':
+ this.palette = this.read(chunkSize);
+ break;
+ case 'fcTL':
+ if (frame) {
+ this.animation.frames.push(frame);
+ }
+ this.pos += 4;
+ frame = {
+ width: this.readUInt32(),
+ height: this.readUInt32(),
+ xOffset: this.readUInt32(),
+ yOffset: this.readUInt32()
+ };
+ delayNum = this.readUInt16();
+ delayDen = this.readUInt16() || 100;
+ frame.delay = 1000 * delayNum / delayDen;
+ frame.disposeOp = this.data[this.pos++];
+ frame.blendOp = this.data[this.pos++];
+ frame.data = [];
+ break;
+ case 'IDAT':
+ case 'fdAT':
+ if (section === 'fdAT') {
+ this.pos += 4;
+ chunkSize -= 4;
+ }
+ data = (frame != null ? frame.data : void 0) || this.imgData;
+ for (i = 0; 0 <= chunkSize ? i < chunkSize : i > chunkSize; 0 <= chunkSize ? i++ : i--) {
+ data.push(this.data[this.pos++]);
+ }
+ break;
+ case 'tRNS':
+ this.transparency = {};
+ switch (this.colorType) {
+ case 3:
+ this.transparency.indexed = this.read(chunkSize);
+ short = 255 - this.transparency.indexed.length;
+ if (short > 0) {
+ for (i = 0; 0 <= short ? i < short : i > short; 0 <= short ? i++ : i--) {
+ this.transparency.indexed.push(255);
+ }
+ }
+ break;
+ case 0:
+ this.transparency.grayscale = this.read(chunkSize)[0];
+ break;
+ case 2:
+ this.transparency.rgb = this.read(chunkSize);
+ }
+ break;
+ case 'IEND':
+ if (frame) {
+ this.animation.frames.push(frame);
+ }
+ this.colors = (function() {
+ switch (this.colorType) {
+ case 0:
+ case 3:
+ case 4:
+ return 1;
+ case 2:
+ case 6:
+ return 3;
+ }
+ }).call(this);
+ this.hasAlphaChannel = (_ref = this.colorType) === 4 || _ref === 6;
+ colors = this.colors + (this.hasAlphaChannel ? 1 : 0);
+ this.pixelBitlength = this.bits * colors;
+ this.colorSpace = (function() {
+ switch (this.colors) {
+ case 1:
+ return 'DeviceGray';
+ case 3:
+ return 'DeviceRGB';
+ }
+ }).call(this);
+ this.imgData = new Uint8Array(this.imgData);
+ return;
+ default:
+ this.pos += chunkSize;
+ }
+ this.pos += 4;
+ }
+ return;
+ }
+ PNG.prototype.read = function(bytes) {
+ var i, _results;
+ _results = [];
+ for (i = 0; 0 <= bytes ? i < bytes : i > bytes; 0 <= bytes ? i++ : i--) {
+ _results.push(this.data[this.pos++]);
+ }
+ return _results;
+ };
+ PNG.prototype.readUInt32 = function() {
+ var b1, b2, b3, b4;
+ b1 = this.data[this.pos++] << 24;
+ b2 = this.data[this.pos++] << 16;
+ b3 = this.data[this.pos++] << 8;
+ b4 = this.data[this.pos++];
+ return b1 | b2 | b3 | b4;
+ };
+ PNG.prototype.readUInt16 = function() {
+ var b1, b2;
+ b1 = this.data[this.pos++] << 8;
+ b2 = this.data[this.pos++];
+ return b1 | b2;
+ };
+ PNG.prototype.decodePixels = function(data) {
+ var byte, col, filter, i, left, length, p, pa, paeth, pb, pc, pixelBytes, pixels, pos, row, rowData, s, scanlineLength, upper, upperLeft, _ref, _step;
+ if (data == null) {
+ data = this.imgData;
+ }
+ if (data.length === 0) {
+ return [];
+ }
+ data = new FlateStream(data);
+ data = data.getBytes();
+ pixelBytes = this.pixelBitlength / 8;
+ scanlineLength = pixelBytes * this.width;
+ row = 0;
+ pixels = [];
+ length = data.length;
+ pos = 0;
+ while (pos < length) {
+ filter = data[pos++];
+ i = 0;
+ rowData = [];
+ switch (filter) {
+ case 0:
+ while (i < scanlineLength) {
+ rowData[i++] = data[pos++];
+ }
+ break;
+ case 1:
+ while (i < scanlineLength) {
+ byte = data[pos++];
+ left = i < pixelBytes ? 0 : rowData[i - pixelBytes];
+ rowData[i++] = (byte + left) % 256;
+ }
+ break;
+ case 2:
+ while (i < scanlineLength) {
+ byte = data[pos++];
+ col = (i - (i % pixelBytes)) / pixelBytes;
+ upper = row === 0 ? 0 : pixels[row - 1][col][i % pixelBytes];
+ rowData[i++] = (upper + byte) % 256;
+ }
+ break;
+ case 3:
+ while (i < scanlineLength) {
+ byte = data[pos++];
+ col = (i - (i % pixelBytes)) / pixelBytes;
+ left = i < pixelBytes ? 0 : rowData[i - pixelBytes];
+ upper = row === 0 ? 0 : pixels[row - 1][col][i % pixelBytes];
+ rowData[i++] = (byte + Math.floor((left + upper) / 2)) % 256;
+ }
+ break;
+ case 4:
+ while (i < scanlineLength) {
+ byte = data[pos++];
+ col = (i - (i % pixelBytes)) / pixelBytes;
+ left = i < pixelBytes ? 0 : rowData[i - pixelBytes];
+ if (row === 0) {
+ upper = upperLeft = 0;
+ } else {
+ upper = pixels[row - 1][col][i % pixelBytes];
+ upperLeft = col === 0 ? 0 : pixels[row - 1][col - 1][i % pixelBytes];
+ }
+ p = left + upper - upperLeft;
+ pa = Math.abs(p - left);
+ pb = Math.abs(p - upper);
+ pc = Math.abs(p - upperLeft);
+ if (pa <= pb && pa <= pc) {
+ paeth = left;
+ } else if (pb <= pc) {
+ paeth = upper;
+ } else {
+ paeth = upperLeft;
+ }
+ rowData[i++] = (byte + paeth) % 256;
+ }
+ break;
+ default:
+ throw new Error("Invalid filter algorithm: " + filter);
+ }
+ s = [];
+ for (i = 0, _ref = rowData.length, _step = pixelBytes; 0 <= _ref ? i < _ref : i > _ref; i += _step) {
+ s.push(rowData.slice(i, i + pixelBytes));
+ }
+ pixels.push(s);
+ row += 1;
+ }
+ return pixels;
+ };
+ PNG.prototype.decodePalette = function() {
+ var alpha, decodingMap, i, index, palette, pixel, transparency, _ref, _ref2, _ref3, _step;
+ palette = this.palette;
+ transparency = (_ref = this.transparency.indexed) != null ? _ref : [];
+ decodingMap = [];
+ index = 0;
+ for (i = 0, _ref2 = palette.length, _step = 3; 0 <= _ref2 ? i < _ref2 : i > _ref2; i += _step) {
+ alpha = (_ref3 = transparency[index++]) != null ? _ref3 : 255;
+ pixel = palette.slice(i, i + 3).concat(alpha);
+ decodingMap.push(pixel);
+ }
+ return decodingMap;
+ };
+ PNG.prototype.copyToImageData = function(imageData, pixels) {
+ var alpha, byte, colors, data, i, palette, pixel, row, v, _i, _j, _k, _len, _len2, _len3, _ref;
+ colors = this.colors;
+ palette = null;
+ alpha = this.hasAlphaChannel;
+ if (this.palette.length) {
+ palette = (_ref = this._decodedPalette) != null ? _ref : this._decodedPalette = this.decodePalette();
+ colors = 4;
+ alpha = true;
+ }
+ data = imageData.data;
+ i = 0;
+ for (_i = 0, _len = pixels.length; _i < _len; _i++) {
+ row = pixels[_i];
+ for (_j = 0, _len2 = row.length; _j < _len2; _j++) {
+ pixel = row[_j];
+ if (palette) {
+ pixel = palette[pixel];
+ }
+ if (colors === 1) {
+ v = pixel[0];
+ data[i++] = v;
+ data[i++] = v;
+ data[i++] = v;
+ data[i++] = pixel[1] || 255;
+ } else {
+ for (_k = 0, _len3 = pixel.length; _k < _len3; _k++) {
+ byte = pixel[_k];
+ data[i++] = byte;
+ }
+ if (!alpha) {
+ data[i++] = 255;
+ }
+ }
+ }
+ }
+ };
+ PNG.prototype.decodeFrames = function(ctx) {
+ var frame, i, imageData, pixels, _len, _ref, _results;
+ if (!this.animation) {
+ return;
+ }
+ _ref = this.animation.frames;
+ _results = [];
+ for (i = 0, _len = _ref.length; i < _len; i++) {
+ frame = _ref[i];
+ imageData = ctx.createImageData(frame.width, frame.height);
+ pixels = this.decodePixels(new Uint8Array(frame.data));
+ this.copyToImageData(imageData, pixels);
+ frame.imageData = imageData;
+ _results.push(frame.image = makeImage(imageData));
+ }
+ return _results;
+ };
+ PNG.prototype.renderFrame = function(ctx, number) {
+ var frame, frames, prev;
+ frames = this.animation.frames;
+ frame = frames[number];
+ prev = frames[number - 1];
+ if (number === 0) {
+ ctx.clearRect(0, 0, this.width, this.height);
+ }
+ if ((prev != null ? prev.disposeOp : void 0) === APNG_DISPOSE_OP_BACKGROUND) {
+ ctx.clearRect(prev.xOffset, prev.yOffset, prev.width, prev.height);
+ } else if ((prev != null ? prev.disposeOp : void 0) === APNG_DISPOSE_OP_PREVIOUS) {
+ ctx.putImageData(prev.imageData, prev.xOffset, prev.yOffset);
+ }
+ if (frame.blendOp === APNG_BLEND_OP_SOURCE) {
+ ctx.clearRect(frame.xOffset, frame.yOffset, frame.width, frame.height);
+ }
+ return ctx.drawImage(frame.image, frame.xOffset, frame.yOffset);
+ };
+ PNG.prototype.animate = function(ctx) {
+ var doFrame, frameNumber, frames, numFrames, numPlays, _ref;
+ frameNumber = 0;
+ _ref = this.animation, numFrames = _ref.numFrames, frames = _ref.frames, numPlays = _ref.numPlays;
+ return (doFrame = __bind(function() {
+ var f, frame;
+ f = frameNumber++ % numFrames;
+ frame = frames[f];
+ this.renderFrame(ctx, f);
+ if (numFrames > 1 && frameNumber / numFrames < numPlays) {
+ return this.animation._timeout = setTimeout(doFrame, frame.delay);
+ }
+ }, this))();
+ };
+ PNG.prototype.stopAnimation = function() {
+ var _ref;
+ return clearTimeout((_ref = this.animation) != null ? _ref._timeout : void 0);
+ };
+ PNG.prototype.render = function(data) {
+ this.copyToImageData(data, this.decodePixels());
+ };
+
+
+var Buffer = require('buffer').Buffer;
+var fs = require('fs');
+
+module.exports.readPng = function(path)
+{
+ var pngData = fs.readFileSync(path);
+ var j = new PNG(pngData);
+ var imageData = {};
+ imageData.width = j.width;
+ imageData.height = j.height;
+ imageData.data = new Buffer(j.width*j.height*4);
+ j.render(imageData);
+ return imageData;
+}
diff --git a/examples/png/test.js b/examples/png/test.js
new file mode 100644
index 0000000..6615d7f
--- /dev/null
+++ b/examples/png/test.js
@@ -0,0 +1,58 @@
+var logo = require('./node-png').readPng('./node-logo.png');
+var x11 = require('../../lib/x11');
+
+var Exposure = x11.eventMask.Exposure;
+var KeyPress = x11.eventMask.KeyPress;
+var KeyRelease = x11.eventMask.KeyRelease;
+var ButtonPress = x11.eventMask.ButtonPress;
+var ButtonRelease = x11.eventMask.ButtonRelease;
+
+x11.createClient(function(display)
+{
+ var X = display.client;
+ X.require('big-requests', function(BigReq)
+ {
+ X.require('render', function(Render) {
+ X.Render = Render;
+ BigReq.Enable(function(maxLen)
+ {
+
+ var root = display.screen[0].root;
+ var white = display.screen[0].white_pixel;
+ var black = display.screen[0].black_pixel;
+
+ var win = X.AllocID();
+ X.CreateWindow(
+ win, root,
+ 0, 0, logo.width, logo.height,
+ 1, 1, 0,
+ {
+ backgroundPixel: white, eventMask: Exposure|KeyPress|ButtonPress
+ }
+ );
+ X.MapWindow(win);
+
+ var gc = X.AllocID();
+ X.CreateGC(gc, win);
+
+ var pixmaplogo = X.AllocID();
+ X.CreatePixmap(pixmaplogo, win, 24, logo.width, logo.height);
+ var piclogo = X.AllocID();
+ X.PutImage(2, pixmaplogo, gc, logo.width, logo.height, 0, 0, 0, 24, logo.data);
+ Render.CreatePicture(piclogo, pixmaplogo, Render.rgb24);
+
+X.on('event', function(ev) {
+ if (ev.type == 12) // expose
+ {
+ Render.Composite(3, piclogo, 0, win, 0, 0, 0, 0, 0, 0, logo.width, logo.height);
+ }
+});
+
+X.on('error', function(err) {
+ console.log(err.stack);
+});
+
+ });
+ });
+ });
+});