ntk 8.1.1 → 8.3.0

package/lib/text/glyphs.js

@@ -1,6 +1,7 @@
 import GlyphSet from '../glyphset.js';
 import Picture from '../picture.js';
 import Pixmap from '../pixmap.js';
+import { fontPageToken, sharedGlyphsFor } from '../sharedglyphs.js';
 import { trapezoidize } from '../trapezoid.js';
 
 /**
@@ -37,6 +38,25 @@ function policyOf(app) {
   return app.textPolicy ? { ...DEFAULT_TEXT_POLICY, ...app.textPolicy } : DEFAULT_TEXT_POLICY;
 }
 
+/** a fresh AddGlyphs object — fresh per call because node-x11 mutates what
+ *  it is given (pads rows, divides offX by 64); the source bitmap survives */
+function uploadGlyph(lid, bitmap, adv) {
+  return {
+    id: lid,
+    width: bitmap ? bitmap.width : 0,
+    height: bitmap ? bitmap.height : 0,
+    // XRender GLYPHINFO places the image at origin - (x, y); node-x11
+    // packs -x and +y, so x here is the bitmap's left bearing and y its
+    // (negated, y-down) top — i.e. the ascent above the baseline
+    x: bitmap ? bitmap.left : 0,
+    y: bitmap ? -bitmap.top : 0,
+    // node-x11 AddGlyphs expects 26.6 fixed point and divides by 64
+    offX: adv * 64,
+    offY: 0,
+    image: bitmap ? bitmap.data : Buffer.alloc(0)
+  };
+}
+
 /**
  * Server-side glyph cache for one (font face, pixel size) pair.
  *
@@ -51,32 +71,52 @@ function policyOf(app) {
  *   (`offX`), so the server advances the pen automatically and runs of
  *   unkerned text need no per-glyph position data at all.
  * - Bitmaps upload lazily, once per glyph, batched into one AddGlyphs
- *   request per draw that introduces new glyphs.
+ *   request per draw that introduces new glyphs — and, when the display's
+ *   shared glyph directory is live (docs/shared-glyphs.md), re-bind to the
+ *   display-wide set so other ntk processes skip the work entirely.
  */
 export class GlyphPage {
   constructor(app, font, size) {
     this.app = app;
     this.font = font;
     this.size = size;
-    this.glyphset = new GlyphSet(app);
-    this.entries = new Map(); // font glyph id -> { lid, adv }
-    this.bytes = 0; // uploaded bitmap bytes, for the LRU budget
+    // With shared glyphs off this page is exactly what it always was: a
+    // private set from birth. With them on, the set is minted lazily — a
+    // page that resolves entirely from the directory never creates one.
+    this.glyphset = sharedGlyphsFor(app) ? null : new GlyphSet(app);
+    this.entries = new Map(); // font glyph id -> { lid, adv, gs }
+    this.bytes = 0; // privately uploaded bitmap bytes, for the LRU budget
+    this._lids = 0; // next private lid (dense, upload order)
+    this._maxLid = -1; // widest id this page composites, private or shared
+    this._privateCount = 0; // entries still bound to the private set
+    this._shared = undefined; // SharedPage binding, resolved on first ensure
   }
 
   /** number of bits per glyph needed to address this page's ids */
   get bits() {
-    return this.entries.size <= 256 ? 8 : 16;
+    return this._maxLid > 255 ? 16 : 8;
   }
 
   /**
-   * Ensure all glyphs of a shaped run are uploaded; returns nothing.
-   * New glyphs are rasterized and sent in a single AddGlyphs request.
+   * Ensure all glyphs of a shaped run are drawable; returns nothing.
+   *
+   * New glyphs are rasterized and sent in a single AddGlyphs request to the
+   * page's private set — this draw's pixels never wait on anything. When the
+   * shared directory is live they are also asked about (docs/shared-glyphs.md):
+   * the reply re-binds their entries to the display-wide set — uploading the
+   * retained bitmap only when this process was first to need the glyph — and
+   * once nothing private remains the private set is freed. Every later draw
+   * of those glyphs, in this process and every other, is then pure
+   * CompositeGlyphs. A page that wants the shared entries *before* first
+   * paint warms up front: see `warmSharedGlyphs`.
    */
   ensure(glyphs) {
     let batch = null;
+    let ask = null;
+    const shared = this._sharedBinding();
     for (const g of glyphs) {
       if (this.entries.has(g.id)) continue;
-      const lid = this.entries.size;
+      const lid = this._lids++;
       if (lid >= 65536) {
         // 2^16 distinct glyphs at one size — not reachable in practice
         // (fonts cap at 65535 glyphs) but fail loudly rather than corrupt
@@ -84,36 +124,77 @@ export class GlyphPage {
       }
       const adv = Math.round(this.font.advanceOf(g.id, this.size));
       const bitmap = this.font.rasterize(g.id, this.size);
-      this.entries.set(g.id, { lid, adv });
+      if (!this.glyphset) this.glyphset = new GlyphSet(this.app);
+      if (lid > this._maxLid) this._maxLid = lid;
+      this.entries.set(g.id, { lid, adv, gs: this.glyphset.id, private: true });
+      this._privateCount++;
       if (!batch) batch = [];
-      batch.push({
-        id: lid,
-        width: bitmap ? bitmap.width : 0,
-        height: bitmap ? bitmap.height : 0,
-        // XRender GLYPHINFO places the image at origin - (x, y); node-x11
-        // packs -x and +y, so x here is the bitmap's left bearing and y its
-        // (negated, y-down) top — i.e. the ascent above the baseline
-        x: bitmap ? bitmap.left : 0,
-        y: bitmap ? -bitmap.top : 0,
-        // node-x11 AddGlyphs expects 26.6 fixed point and divides by 64
-        offX: adv * 64,
-        offY: 0,
-        image: bitmap ? bitmap.data : Buffer.alloc(0)
-      });
+      batch.push(uploadGlyph(lid, bitmap, adv));
       this.bytes += bitmap ? bitmap.data.length : 0;
+      if (shared && shared.open) {
+        if (!ask) ask = [];
+        ask.push({ key: g.id, payload: { bitmap, adv } });
+      }
     }
     if (batch) this.glyphset.addGlyphs(batch);
+    if (ask) shared.ask(ask);
   }
 
   entry(fontGlyphId) {
     return this.entries.get(fontGlyphId);
   }
 
-  /** free the server-side glyphset (LRU eviction / shutdown) */
+  /** the shared side of this page, bound on first use; null when the
+   *  feature is off or the font's bytes cannot be content-addressed */
+  _sharedBinding() {
+    if (this._shared !== undefined) return this._shared;
+    const client = sharedGlyphsFor(this.app);
+    const token = client ? fontPageToken(this.font, this.size) : null;
+    this._shared = token
+      ? client.bindPage({
+          token,
+          indices: true, // member keys are the font glyph indices themselves
+          makeGlyph: (key, payload, lid) => {
+            // absent from the shared set: upload the bitmap retained at
+            // mint time, or rasterize now on the warm path (which retained
+            // nothing precisely because the glyph was expected to be there)
+            const bitmap =
+              payload.bitmap !== undefined ? payload.bitmap : this.font.rasterize(key, this.size);
+            return uploadGlyph(lid, bitmap, payload.adv);
+          },
+          adopt: (key, lid, gsid, payload) => this._adoptShared(key, lid, gsid, payload)
+        })
+      : null;
+    return this._shared;
+  }
+
+  /** re-bind one glyph to the shared set (confirmed present, or uploaded by
+   *  us); drop the private set once nothing composites from it any more */
+  _adoptShared(key, lid, gsid, payload) {
+    const prev = this.entries.get(key);
+    this.entries.set(key, { lid, adv: payload.adv, gs: gsid });
+    if (lid > this._maxLid) this._maxLid = lid;
+    if (prev && prev.private && --this._privateCount === 0 && this.glyphset) {
+      // ordered after any CompositeGlyphs already issued, like the LRU's
+      // frees; new glyphs during a directory outage mint a fresh set
+      this.glyphset.destroy();
+      this.glyphset = null;
+      this.bytes = 0;
+      this._lids = 0;
+    }
+  }
+
+  /** free the server-side glyphset and shared alias (LRU eviction / shutdown) */
   destroy() {
-    this.glyphset.destroy();
+    if (this.glyphset) this.glyphset.destroy();
+    this.glyphset = null;
+    if (this._shared) this._shared.destroy();
+    this._shared = undefined;
     this.entries.clear();
     this.bytes = 0;
+    this._lids = 0;
+    this._maxLid = -1;
+    this._privateCount = 0;
   }
 }
 
@@ -133,6 +214,42 @@ export function getGlyphPage(app, font, size) {
   return page;
 }
 
+/**
+ * Warm one (font, size) page from the shared glyph directory before first
+ * paint (docs/shared-glyphs.md): resolve `text`'s glyphs into shared-set
+ * entries so that the first draw of already-shared text rasterizes nothing
+ * and uploads nothing — the cold-start win a synchronous first `fillText`
+ * cannot have, since it cannot wait for the directory's answer and falls
+ * back to a private upload for exactly one frame instead.
+ *
+ * Glyphs the directory has never seen are rasterized here and uploaded once,
+ * which is the same work the first draw would have done. Resolves `true`
+ * when the page ended up bound to the shared cache; `false` means the
+ * feature is off or degraded and drawing will use the private path — either
+ * way the following draws are correct.
+ *
+ * @param {App} app
+ * @param {Font} font
+ * @param {number} size pixel size
+ * @param {string} text whose glyphs to warm (shaped with defaults)
+ * @returns {Promise<boolean>}
+ */
+export async function warmSharedGlyphs(app, font, size, text) {
+  if (!sharedGlyphsFor(app)) return false;
+  const page = getGlyphPage(app, font, size);
+  const shared = page._sharedBinding();
+  if (!shared || !shared.open) return false;
+  const ask = [];
+  const seen = new Set();
+  for (const g of font.shape(String(text), size).glyphs) {
+    if (page.entries.has(g.id) || seen.has(g.id)) continue;
+    seen.add(g.id);
+    ask.push({ key: g.id, payload: { adv: Math.round(font.advanceOf(g.id, size)) } });
+  }
+  if (ask.length) await shared.ask(ask);
+  return shared.open && shared.bound;
+}
+
 /**
  * Evict least-recently-used glyph pages until uploaded bitmaps fit the
  * policy budget. `inUse` pages (referenced by requests queued this draw)
@@ -225,6 +342,67 @@ export function positionGlyphs(positioned) {
   return out;
 }
 
+/**
+ * Ink extents of positioned runs, in whatever coordinates their origins are
+ * given in — the union of every glyph's bounding box, laid out exactly as
+ * `positionGlyphs` lays it out (pen at `x`, glyph at `pen + dx`, `y - dy`,
+ * pen advanced by `ax`).
+ *
+ * Returns `null` when nothing inks: a run of spaces has extents but no
+ * bounding box, and neither does an empty array. Blank glyphs report an
+ * empty `cbox` (`minX` infinite), which the comparisons below drop on their
+ * own.
+ *
+ * This is what sizes a glyph shadow's coverage surface — the run-shaped
+ * counterpart of the context's `_shapedInk`, which measures one shaped
+ * string from its own origin.
+ *
+ * @param {Array<{run, x, y}>} positioned
+ * @returns {{minX: number, minY: number, maxX: number, maxY: number}|null}
+ */
+export function positionedRunsInk(positioned) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const { run, x, y } of positioned) {
+    let cursor = x;
+    for (const g of run.glyphs) {
+      const e = run.font.glyphExtents(g.id, run.size);
+      const gx = cursor + g.dx;
+      const gy = y - g.dy;
+      cursor += g.ax;
+      if (gx + e.minX < minX) minX = gx + e.minX;
+      if (gx + e.maxX > maxX) maxX = gx + e.maxX;
+      if (gy + e.minY < minY) minY = gy + e.minY;
+      if (gy + e.maxY > maxY) maxY = gy + e.maxY;
+    }
+  }
+  return minX <= maxX && minY <= maxY ? { minX, minY, maxX, maxY } : null;
+}
+
+// Identity, not content, for anything that wants to name a run cheaply.
+// A shaped run is immutable and shared — the shaping memo hands the same
+// object back, and a TextLayout holds on to the ones its lines are made of
+// — so a small integer per object is a complete name for the glyphs in it,
+// bought at O(1) instead of O(glyphs). Weak, so naming a run keeps nothing
+// alive.
+const runIds = new WeakMap();
+let nextRunId = 0;
+
+/**
+ * A stable small integer for one run object, for cache keys that would
+ * otherwise have to serialize its glyphs. Runs built fresh on every draw
+ * (rather than kept, as a `TextLayout` keeps them) get a fresh id each time
+ * and so never hit such a cache — which is the honest answer, since nothing
+ * cheap can tell them apart.
+ */
+export function runId(run) {
+  let id = runIds.get(run);
+  if (id === undefined) runIds.set(run, (id = ++nextRunId));
+  return id;
+}
+
 /**
  * Decide how a (face, size) renders: cached bitmap glyphs or per-draw
  * trapezoids. See DEFAULT_TEXT_POLICY for the reasoning; the middle band
@@ -361,7 +539,7 @@ function drawBitmapGlyphRuns(app, op, srcId, dstId, positioned, policy) {
   for (const pos of positionGlyphs(positioned)) {
     const page = pages.get(pos.run);
     const e = page.entry(pos.glyph.id);
-    items.push({ gs: page.glyphset.id, lid: e.lid, adv: e.adv, x: pos.x, y: pos.y });
+    items.push({ gs: e.gs, lid: e.lid, adv: e.adv, x: pos.x, y: pos.y });
   }
   const encoded = encodeGlyphItems(items, bits);
   if (!encoded) return;

package/lib/widgets/svgview.js

@@ -220,9 +220,11 @@ function pathBBox(path) {
  * inline `style` beats the presentation attribute, the initial fill is black
  * and the initial stroke is none, `<line>` never fills, `<use>` paints its
  * target with the *use* element's style, and non-rendered subtrees
- * contribute nothing. It starts at the root's children rather than the root,
- * because `draw` does: presentation attributes on the root `<svg>` are not
- * applied, and a scan that applied them would disagree with what is painted.
+ * contribute nothing. It starts at the root element itself, because `draw`
+ * does: the root `<svg>` is an ordinary element for inheritance, and every
+ * mainstream icon set puts `fill`/`stroke` there (issue #306). The two walks
+ * have to agree — a scan that skipped the root would disagree with what is
+ * painted.
  *
  * @returns {{ kind: 'mono'|'multi', solo: string|null }} `solo` is the one
  *   paint a `mono` document uses — a colour, or the literal `'currentColor'`
@@ -284,7 +286,7 @@ function scanPaints(root, ids) {
     }
   };
 
-  kids(root, INHERITED.fill, INHERITED.stroke, 0);
+  visit(root, INHERITED.fill, INHERITED.stroke, 0);
   return {
     kind: multi || paints.size > 1 ? 'multi' : 'mono',
     solo: paints.size === 1 ? [...paints][0] : null
@@ -433,7 +435,7 @@ export default class SvgView {
     this._renderChildren(
       this._root,
       ctx,
-      { ...INHERITED, color: opts.color ?? this.color },
+      this._style(this._root, { ...INHERITED, color: opts.color ?? this.color }),
       1,
       0
     );