ntk 8.12.1 → 8.12.3

package/lib/renderingcontext_2d.js

@@ -2716,7 +2716,14 @@ class RenderingContext2d {
         if (rect.w === 0 || rect.h === 0) return;
         this._setPictureClip(rect);
       }
-      drawGlyphRuns(app, op, src.id, this._dst(), positioned);
+      drawGlyphRuns(
+        app,
+        op,
+        src.id,
+        this._dst(),
+        positioned,
+        rect ?? { x: 0, y: 0, w: this.width, h: this.height },
+      );
       if (rect) this._invalidatePictureClip();
       this._markDirty();
       return;
@@ -2737,6 +2744,7 @@ class RenderingContext2d {
       this._glyphSource.id,
       this.fillMask.id,
       positioned,
+      { x: 0, y: 0, w: this.width, h: this.height },
     );
     R.Composite(
       R.PictOp.In,

package/lib/text/font.js

@@ -75,6 +75,12 @@ export default class Font {
     this.path = path;
     /** stable cache key for glyph pages and font caches */
     this.key = `${path}#${postscriptName || fkFont.postscriptName || ''}`;
+    // What the face's tables say, read once. fontkit's getters walk to the
+    // table on every read, and a text layout asks per run and per word: in
+    // a long document they were most of a relayout (see `metrics`).
+    this._upem = 0;
+    this._vertical = null;
+    this._space = -1;
   }
 
   static loadSync(path, postscriptName) {
@@ -214,28 +220,48 @@ export default class Font {
   }
 
   scale(size) {
-    return size / this.fk.unitsPerEm;
+    return size / (this._upem ||= this.fk.unitsPerEm);
   }
 
   /**
    * Pixel-space metrics for a font size. `ascent`/`capHeight`/`xHeight` are
    * positive (above baseline), `descent` is positive (below baseline).
+   *
+   * A new object every call, which a caller may keep or change; the numbers
+   * behind it are the face's, read from its tables once.
    */
   metrics(size) {
+    const v = (this._vertical ??= {
+      ascent: this.fk.ascent,
+      descent: -this.fk.descent,
+      lineGap: this.fk.lineGap,
+      capHeight: this.fk.capHeight,
+      xHeight: this.fk.xHeight
+    });
     const s = this.scale(size);
-    const ascent = this.fk.ascent * s;
-    const descent = -this.fk.descent * s;
-    const lineGap = this.fk.lineGap * s;
+    const ascent = v.ascent * s;
+    const descent = v.descent * s;
+    const lineGap = v.lineGap * s;
     return {
       ascent,
       descent,
       lineGap,
       lineHeight: ascent + descent + lineGap,
-      capHeight: this.fk.capHeight * s,
-      xHeight: this.fk.xHeight * s
+      capHeight: v.capHeight * s,
+      xHeight: v.xHeight * s
     };
   }
 
+  /**
+   * The advance of U+0020 at `size` — what a run of trailing spaces is
+   * worth to a line. Looked up once: it was a cmap lookup for every word a
+   * layout ended with a space, which in a paragraph is every word.
+   */
+  spaceAdvance(size) {
+    if (this._space < 0) this._space = this.fk.glyphForCodePoint(0x20).advanceWidth;
+    return this._space * this.scale(size);
+  }
+
   hasGlyph(codepoint) {
     return this.fk.hasGlyphForCodePoint(codepoint);
   }

package/lib/text/glyphs.js

@@ -571,8 +571,11 @@ export function routeGlyphSize(app, font, size, policy = policyOf(app), textRend
  * @param {number} srcId source picture (fill color/gradient)
  * @param {number} dstId destination picture
  * @param {Array<{run, x, y}>} positioned visual-order runs with baseline origins
+ * @param {{x: number, y: number, w: number, h: number}} [bounds] the part of
+ *   the destination that can show anything — the clip, or the surface. A
+ *   glyph wholly outside it is not sent (`visibleGlyph`).
  */
-export function drawGlyphRuns(app, op, srcId, dstId, positioned) {
+export function drawGlyphRuns(app, op, srcId, dstId, positioned, bounds = null) {
   const policy = policyOf(app);
   let bitmap = positioned;
   let vector = null;
@@ -590,11 +593,35 @@ export function drawGlyphRuns(app, op, srcId, dstId, positioned) {
       bitmap.push(positioned[i]);
     }
   }
-  if (bitmap.length) drawBitmapGlyphRuns(app, op, srcId, dstId, bitmap, policy);
-  if (vector) drawVectorGlyphRuns(app, op, srcId, dstId, vector);
+  if (bitmap.length) drawBitmapGlyphRuns(app, op, srcId, dstId, bitmap, policy, bounds);
+  if (vector) drawVectorGlyphRuns(app, op, srcId, dstId, vector, bounds);
 }
 
-function drawBitmapGlyphRuns(app, op, srcId, dstId, positioned, policy) {
+/**
+ * Whether a glyph whose origin is at (x, y) can put any ink inside `bounds`,
+ * give or take two ems — no glyph reaches further from its origin than that,
+ * swashes and all.
+ *
+ * Not only a saving: the glyphs of a line wider than 32767 device pixels —
+ * a minified file in a code editor, a long label in a narrow cell — have
+ * origins no request can carry. CompositeGlyphs places its first glyph and
+ * every element after it in 16-bit coordinates, and the vector path's trap
+ * mask would span the whole line, so drawing such a line threw a RangeError
+ * out of the paint however little of it was on screen. What is left after
+ * the cull sits inside a surface, and every coordinate in it fits.
+ */
+function visibleGlyph(bounds, x, y, size) {
+  if (bounds === null) return true;
+  const reach = size * 2;
+  return (
+    x + reach > bounds.x &&
+    x - reach < bounds.x + bounds.w &&
+    y + reach > bounds.y &&
+    y - reach < bounds.y + bounds.h
+  );
+}
+
+function drawBitmapGlyphRuns(app, op, srcId, dstId, positioned, policy, bounds) {
   const Render = app.display.Render;
   const items = [];
   let bits = 8;
@@ -608,6 +635,7 @@ function drawBitmapGlyphRuns(app, op, srcId, dstId, positioned, policy) {
     if (page.bits > bits) bits = page.bits;
   }
   for (const pos of positionGlyphs(positioned)) {
+    if (!visibleGlyph(bounds, pos.x, pos.y, pos.run.size)) continue;
     const page = pages.get(pos.run);
     const e = page.entry(pos.glyph.id);
     items.push({ gs: e.gs, lid: e.lid, adv: e.adv, x: pos.x, y: pos.y });
@@ -646,7 +674,7 @@ const MAX_TRAPS_PER_REQUEST = 6000;
  * Positions are intentionally NOT rounded to whole pixels — fractional
  * advances and origins keep zoom animations smooth.
  */
-function drawVectorGlyphRuns(app, op, srcId, dstId, positioned) {
+function drawVectorGlyphRuns(app, op, srcId, dstId, positioned, bounds = null) {
   // unrounded glyph origins + ink bounding box
   const placed = [];
   let minX = Infinity;
@@ -657,6 +685,7 @@ function drawVectorGlyphRuns(app, op, srcId, dstId, positioned) {
       const gx = cursor + g.dx;
       const gy = y - g.dy;
       cursor += g.ax;
+      if (!visibleGlyph(bounds, gx, gy, run.size)) continue;
       const e = run.font.glyphExtents(g.id, run.size);
       if (!Number.isFinite(e.minX) || e.maxX <= e.minX) continue; // blank glyph
       placed.push({ run, glyph: g, x: gx, y: gy });

package/lib/text/layout.js

@@ -324,10 +324,8 @@ export class TextLayout {
     if (last) {
       const m = TRAILING_WS.exec(last.text);
       if (m) {
-        const spaceGlyph = last.span.font.fk.glyphForCodePoint(0x20);
         const spacing = Number.isFinite(last.span.letterSpacing) ? last.span.letterSpacing : 0;
-        wsWidth =
-          m[0].length * (spaceGlyph.advanceWidth * last.span.font.scale(last.span.size) + spacing);
+        wsWidth = m[0].length * (last.span.font.spaceAdvance(last.span.size) + spacing);
       }
     }
     return { fragments, width, wsWidth, required, start, end };

package/lib/text/shape.js

@@ -25,9 +25,29 @@ function neverSwitches(cp) {
  */
 export function embeddingLevels(text, direction = 'auto') {
   const explicit = direction === 'ltr' || direction === 'rtl' ? direction : null;
+  // Text that nothing can make right-to-left is level 0 throughout, which
+  // is what the algorithm would work out a character at a time: every
+  // layout asks, and most text is Latin, CJK or digits with no bidi at all.
+  if (explicit !== 'rtl' && !MAY_REVERSE.test(text)) {
+    return {
+      levels: new Uint8Array(text.length),
+      paragraphs: text.length ? [{ start: 0, end: text.length - 1, level: 0 }] : []
+    };
+  }
   return bidi.getEmbeddingLevels(text, explicit);
 }
 
+/**
+ * What can raise a level in a left-to-right paragraph: a strong
+ * right-to-left character (Hebrew, Arabic, Syriac, Thaana, N'Ko and their
+ * neighbours, their presentation forms, and the right-to-left blocks of the
+ * supplementary planes, found by their high surrogates), an Arabic number,
+ * RLM and ALM, and every explicit embedding, override and isolate. Anything
+ * else resolves to 0.
+ */
+const MAY_REVERSE =
+  /[\u0590-\u08FF\u200F\u202A-\u202E\u2066-\u2069\uFB1D-\uFDFF\uFE70-\uFEFF]|[\uD802\uD803\uD83A\uD83B]/;
+
 /**
  * Compact embedding-levels encoding for the shaping memo key: a single
  * number when uniform over [start, end) — the common case — else

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.12.1",
+  "version": "8.12.3",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",