ntk 2.2.0 → 3.0.0

package/lib/picture.js

@@ -1,41 +1,84 @@
-var weak = require('weak-napi');
-
-function Picture(app, args) {
-  var X = app.X;
-  this.X = X;
-  this.Render = app.display.Render;
-  var display = app.display;
-  this.display = display;
-  if (typeof args.id == 'undefined') {
-    this.id = X.AllocID();
-    var format = args.format || this.Render.rgb24;
-    this.format = format;
-    this.Render.CreatePicture(this.id, args.drawable.id, format, args);
-  } else {
-    this.id = args.id;
-  }
-  var id = this.id;
-  var ref = weak(this, function() {
-    app.display.Render.FreePicture(id);
-    X.ReleaseID(id);
-  });
-}
-
-Picture.prototype.setFilter = function(name, params) {
-  this.Render.SetPictureFilter(this.id, name, params);
-};
-
-Picture.prototype.setBlurFilter = function(radius, sigma) {
-  if (radius === 0) {
-    return this.setFilter('convolution', [1, 1, 1]);
-  }
-
-  if (!sigma) sigma = radius / 2;
-  var dim = parseInt(radius);
-  if (radius % 2 == 0) radius++;
-  var generateGaussianKernel = require('gaussian-convolution-kernel');
-  var params = [radius, radius].concat(generateGaussianKernel(radius, sigma));
-  this.setFilter('convolution', params);
-};
-
-module.exports = Picture;
+import { safeRelease } from './cleanup.js';
+
+const registry = new FinalizationRegistry(({ Render, X, id }) => {
+  safeRelease(X, () => {
+    Render.FreePicture(id);
+    X.ReleaseID(id);
+  });
+});
+
+export default class Picture {
+  constructor(app, args = {}) {
+    const X = app.X;
+    this.X = X;
+    this.Render = app.display.Render;
+    this.display = app.display;
+
+    if (typeof args.id === 'undefined') {
+      this.id = X.AllocID();
+      this.format = args.format || this.Render.rgb24;
+      this.Render.CreatePicture(this.id, args.drawable.id, this.format, args);
+    } else {
+      this.id = args.id;
+    }
+    this._owned = true;
+    registry.register(this, { Render: this.Render, X, id: this.id }, this);
+  }
+
+  setFilter(name, params) {
+    this.Render.SetPictureFilter(this.id, name, params);
+  }
+
+  setBlurFilter(radius, sigma) {
+    if (radius === 0) {
+      return this.setFilter('convolution', [1, 1, 1]);
+    }
+    if (!sigma) sigma = radius / 2;
+    if (radius % 2 === 0) radius++;
+    const params = [radius, radius, ...gaussianKernel(radius, sigma)];
+    this.setFilter('convolution', params);
+  }
+
+  destroy() {
+    if (!this._owned) return;
+    this._owned = false;
+    registry.unregister(this);
+    safeRelease(this.X, () => {
+      this.Render.FreePicture(this.id);
+      this.X.ReleaseID(this.id);
+    });
+  }
+
+  /**
+   * Stop tracking without sending FreePicture. Used when the server already
+   * destroyed the picture implicitly — pictures on a *window* are freed by
+   * the server when the window is destroyed (RENDER spec); a later explicit
+   * FreePicture would raise BadPicture. Pixmap-backed pictures don't need
+   * this (pixmap storage is refcounted).
+   */
+  forget() {
+    if (!this._owned) return;
+    this._owned = false;
+    registry.unregister(this);
+    safeRelease(this.X, () => this.X.ReleaseID(this.id));
+  }
+
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}
+
+// normalized 2d gaussian, row-major size x size
+function gaussianKernel(size, sigma) {
+  const kernel = new Array(size * size);
+  const center = (size - 1) / 2;
+  let sum = 0;
+  for (let y = 0; y < size; ++y) {
+    for (let x = 0; x < size; ++x) {
+      const v = Math.exp(-((x - center) ** 2 + (y - center) ** 2) / (2 * sigma * sigma));
+      kernel[y * size + x] = v;
+      sum += v;
+    }
+  }
+  return kernel.map((v) => v / sum);
+}

package/lib/pixmap.js

@@ -1,39 +1,50 @@
-var util = require('util');
-var weak = require('weak-napi');
-
-var Drawable = require('./drawable.js');
-
-module.exports = Pixmap;
-
-function Pixmap(app, args) {
-  this.app = app;
-  Drawable.call(this);
-  var X = app.X;
-
-  var parentId;
-  if (!args.parent) parentId = app.display.screen[0].root;
-  else {
-    parentId = args.parent.id;
-  }
-
-  this.depth = args.depth || 24;
-
-  if (!args.id) {
-    this.id = X.AllocID();
-    X.CreatePixmap(this.id, parentId, this.depth, args.width, args.height);
-    var id = this.id;
-    var ref = weak(this, function(obj) {
-      X.FreePixmap(id);
-      X.ReleaseID(id);
-    });
-    this.width = args.width;
-    this.height = args.height;
-  } else {
-    this.id = args.id;
-  }
-
-  this.X = X;
-  var display = app.display;
-  this.display = display;
-}
-util.inherits(Pixmap, Drawable);
+import { safeRelease } from './cleanup.js';
+import Drawable from './drawable.js';
+
+// GC fallback: free the server-side pixmap when the wrapper is collected
+// without an explicit destroy()
+const registry = new FinalizationRegistry(({ X, id }) => {
+  safeRelease(X, () => {
+    X.FreePixmap(id);
+    X.ReleaseID(id);
+  });
+});
+
+export default class Pixmap extends Drawable {
+  constructor(app, args = {}) {
+    super();
+    this.app = app;
+    const X = app.X;
+    this.X = X;
+    this.display = app.display;
+
+    const parentId = args.parent ? args.parent.id : app.display.screen[0].root;
+    this.depth = args.depth || 24;
+
+    if (!args.id) {
+      this.id = X.AllocID();
+      X.CreatePixmap(this.id, parentId, this.depth, args.width, args.height);
+      this.width = args.width;
+      this.height = args.height;
+      this._owned = true;
+      registry.register(this, { X, id: this.id }, this);
+    } else {
+      this.id = args.id;
+      this._owned = false;
+    }
+  }
+
+  destroy() {
+    if (!this._owned) return;
+    this._owned = false;
+    registry.unregister(this);
+    safeRelease(this.X, () => {
+      this.X.FreePixmap(this.id);
+      this.X.ReleaseID(this.id);
+    });
+  }
+
+  [Symbol.dispose]() {
+    this.destroy();
+  }
+}

package/lib/rasterize.js

@@ -0,0 +1,178 @@
+// Minimal pure-JS scanline rasterizer for glyph outlines.
+//
+// Takes path commands in y-down pixel coordinates with the origin at the
+// glyph baseline (produced by Font.rasterize from fontkit outlines) and
+// produces an antialiased 8-bit alpha bitmap suitable for XRender
+// AddGlyphs. Non-zero winding rule, 4x4 supersampling.
+
+const DEFAULT_SS = 4; // supersampling factor per axis
+
+/**
+ * @param {Array} commands path commands ({type: M|L|Q|C|Z, x, y, x1, y1, x2, y2})
+ * @param {number} [ss] supersampling factor per axis (large glyphs pass 2 —
+ *   AA quality is indistinguishable above ~96px and rasterization is 4x cheaper)
+ * @returns {{width, height, left, top, data: Buffer}|null}
+ *   left/top are offsets of the bitmap's top-left corner relative to the
+ *   glyph origin (left is typically small, top is typically negative —
+ *   above the baseline). Returns null for empty outlines (e.g. space).
+ */
+export function rasterizePath(commands, ss = DEFAULT_SS) {
+  const SS = ss;
+  const polys = flatten(commands);
+  if (polys.length === 0) return null;
+
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const poly of polys) {
+    for (let i = 0; i < poly.length; i += 2) {
+      if (poly[i] < minX) minX = poly[i];
+      if (poly[i] > maxX) maxX = poly[i];
+      if (poly[i + 1] < minY) minY = poly[i + 1];
+      if (poly[i + 1] > maxY) maxY = poly[i + 1];
+    }
+  }
+
+  const left = Math.floor(minX);
+  const top = Math.floor(minY);
+  const width = Math.ceil(maxX) - left;
+  const height = Math.ceil(maxY) - top;
+  if (width <= 0 || height <= 0) return null;
+
+  // pad rows to 4 bytes as required by the AddGlyphs wire format
+  const stride = (width + 3) & ~3;
+  const coverage = new Uint16Array(stride * height);
+
+  // closed edges in supersampled bitmap space
+  const edges = [];
+  for (const poly of polys) {
+    const n = poly.length / 2;
+    for (let i = 0; i < n; ++i) {
+      const j = (i + 1) % n;
+      const x0 = (poly[i * 2] - left) * SS;
+      const y0 = (poly[i * 2 + 1] - top) * SS;
+      const x1 = (poly[j * 2] - left) * SS;
+      const y1 = (poly[j * 2 + 1] - top) * SS;
+      if (y0 !== y1) edges.push([x0, y0, x1, y1]);
+    }
+  }
+
+  const crossings = [];
+  for (let row = 0; row < height * SS; ++row) {
+    const y = row + 0.5;
+    crossings.length = 0;
+    for (const [x0, y0, x1, y1] of edges) {
+      if ((y0 <= y && y1 > y) || (y1 <= y && y0 > y)) {
+        const x = x0 + ((y - y0) * (x1 - x0)) / (y1 - y0);
+        crossings.push([x, y1 > y0 ? 1 : -1]);
+      }
+    }
+    crossings.sort((a, b) => a[0] - b[0]);
+
+    let winding = 0;
+    let spanStart = 0;
+    const py = (row / SS) | 0;
+    for (const [x, dir] of crossings) {
+      if (winding === 0) spanStart = x;
+      winding += dir;
+      if (winding === 0) {
+        // fill supersample cells whose centers are inside [spanStart, x)
+        const from = Math.max(0, Math.ceil(spanStart - 0.5));
+        const to = Math.min(width * SS - 1, Math.floor(x - 0.5));
+        for (let cell = from; cell <= to; ++cell) {
+          coverage[py * stride + ((cell / SS) | 0)]++;
+        }
+      }
+    }
+  }
+
+  const data = Buffer.alloc(stride * height);
+  const full = SS * SS;
+  for (let i = 0; i < coverage.length; ++i) {
+    const c = coverage[i];
+    data[i] = c >= full ? 255 : ((c * 255) / full) | 0;
+  }
+
+  return { width: stride, height, left, top, data };
+}
+
+// flatten M/L/Q/C/Z commands into closed polygons [x0,y0, x1,y1, ...]
+// (shared with the vector/trapezoid glyph path — see lib/trapezoid.js)
+export function flatten(commands) {
+  const polys = [];
+  let cur = null;
+  let x = 0;
+  let y = 0;
+
+  const finish = () => {
+    if (cur && cur.length >= 6) polys.push(cur);
+    cur = null;
+  };
+
+  for (const c of commands) {
+    switch (c.type) {
+      case 'M':
+        finish();
+        cur = [c.x, c.y];
+        x = c.x;
+        y = c.y;
+        break;
+      case 'L':
+        cur.push(c.x, c.y);
+        x = c.x;
+        y = c.y;
+        break;
+      case 'Q': {
+        const [x0, y0] = [x, y];
+        const steps = curveSteps(x0, y0, c.x1, c.y1, c.x, c.y);
+        for (let i = 1; i <= steps; ++i) {
+          const t = i / steps;
+          const mt = 1 - t;
+          cur.push(
+            mt * mt * x0 + 2 * mt * t * c.x1 + t * t * c.x,
+            mt * mt * y0 + 2 * mt * t * c.y1 + t * t * c.y
+          );
+        }
+        x = c.x;
+        y = c.y;
+        break;
+      }
+      case 'C': {
+        const [x0, y0] = [x, y];
+        const steps = curveSteps(x0, y0, c.x1, c.y1, c.x, c.y, c.x2, c.y2);
+        for (let i = 1; i <= steps; ++i) {
+          const t = i / steps;
+          const mt = 1 - t;
+          cur.push(
+            mt * mt * mt * x0 + 3 * mt * mt * t * c.x1 + 3 * mt * t * t * c.x2 + t * t * t * c.x,
+            mt * mt * mt * y0 + 3 * mt * mt * t * c.y1 + 3 * mt * t * t * c.y2 + t * t * t * c.y
+          );
+        }
+        x = c.x;
+        y = c.y;
+        break;
+      }
+      case 'Z':
+        finish();
+        break;
+    }
+  }
+  finish();
+  return polys;
+}
+
+function curveSteps(...coords) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i = 0; i < coords.length; i += 2) {
+    minX = Math.min(minX, coords[i]);
+    maxX = Math.max(maxX, coords[i]);
+    minY = Math.min(minY, coords[i + 1]);
+    maxY = Math.max(maxY, coords[i + 1]);
+  }
+  const size = Math.max(maxX - minX, maxY - minY);
+  return Math.min(24, Math.max(3, Math.ceil(size / 3)));
+}