ntk 7.5.0 → 7.6.1

package/lib/renderingcontext_2d.js

@@ -1106,10 +1106,23 @@ class RenderingContext2d {
         // a segment that is already at least r long
         if (dot >= 0 && r * r <= shortest) continue;
         const cross = ax * by - ay * bx;
-        // r·tan(φ/2) > min(|a|, |b|), squared. A non-positive denominator is
-        // the reversal the tangent is infinite at.
-        const denom = Math.sqrt(la * lb) + dot;
-        if (denom <= 0 || (r * cross) ** 2 > shortest * denom * denom) {
+        // r·tan(φ/2) > min(|a|, |b|), squared. A non-positive denominator
+        // is the reversal the tangent is infinite at — but near one the
+        // denominator is pure cancellation (√(la·lb) and -dot agree to ~15
+        // digits), so an exact double-back lands a few ulps to either side
+        // of 0. The same-x bursts of issue #259 have cross exactly 0 too,
+        // so when denom rounded positive neither test here fired and the
+        // extruder met the reversal itself, normalizing a zero-length
+        // tangent into NaN join vertices. Below its own noise floor denom
+        // only means "within microradians of a reversal", where the true
+        // tangent exceeds a million and no segment can hold the join: cut
+        // unconditionally.
+        const ab = Math.sqrt(la * lb);
+        const denom = ab + dot;
+        if (
+          denom <= ab * 1e-12 ||
+          (r * cross) ** 2 > shortest * denom * denom
+        ) {
           (cuts ??= []).push(i);
         }
       }
@@ -1277,6 +1290,27 @@ class RenderingContext2d {
         for (const run of dashed.runs) extrudeRun(cleanRun(run), false);
       }
     }
+    // Nothing non-finite may reach the server: FIXED encoding turns NaN
+    // into 0, so one poisoned vertex renders as a wedge to the origin on a
+    // real display — while the in-process server quietly drops it, which
+    // is why no headless pixel test can see this for us (issue #259). The
+    // cuts above are meant to keep the extruder off that path; this keeps
+    // a future miss from being catastrophic. A sum is finite iff every
+    // term is.
+    let w = 0;
+    for (let i = 0; i < tris.length; i += 6) {
+      const sum =
+        tris[i] +
+        tris[i + 1] +
+        tris[i + 2] +
+        tris[i + 3] +
+        tris[i + 4] +
+        tris[i + 5];
+      if (!Number.isFinite(sum)) continue;
+      if (w < i) for (let k = 0; k < 6; k++) tris[w + k] = tris[i + k];
+      w += 6;
+    }
+    if (w < tris.length) tris.length = w;
     if (!tris.length) return;
 
     const op = this._op();
@@ -1396,14 +1430,35 @@ class RenderingContext2d {
   }
 
   /**
-   * Composite shaped glyph runs onto this context, honouring the clip.
+   * Composite glyph runs onto this context, honouring the clip. This is
+   * the primitive `fillText` and `TextLayout.draw` are built on, and it is
+   * public: the run shape below is a documented contract
+   * (docs/text.md#glyph-runs), so renderers that position glyphs
+   * themselves — a terminal grid, a tabular column — can hand-build runs
+   * instead of shaping.
+   *
+   * @param {number} op Render.PictOp (`ctx.Render.PictOp.Over` for normal text)
+   * @param {Picture} src source picture the glyphs paint with — a solid
+   *   (`ctx.createSolidPicture(r, g, b, a)`, premultiplied 0..1) or a gradient
+   * @param {Array<{run, x, y, textRendering?}>} positioned runs in visual
+   *   order; `x`/`y` is the run's baseline origin in device space. `run` is
+   *   `{ font, size, glyphs }` — a `Font`, a pixel size, and glyphs
+   *   `{ id, ax, dx, dy }` in drawing order: `id` a font glyph id
+   *   (`Font.shape()`'s `glyphs[].id`, or `Font.glyphIdFor(cp)`), `ax` the
+   *   pen advance in px, `dx`/`dy` the drawing offset from the pen position
+   *   (y-up: positive `dy` raises the glyph). The pen starts at `x`; each
+   *   glyph inks at `(pen + dx, y - dy)` and then advances it by `ax`.
+   *   `Font.shape()` returns runs of exactly this shape; extra fields
+   *   (`codePoints`, `width`, …) are ignored. `textRendering` optionally
+   *   overrides the bitmap/vector routing per run (docs/text.md).
    *
    * CompositeGlyphs writes straight to the destination picture, so it has
    * no way to consult our clip mask — text drawn through it used to spill
    * out of clipped boxes while every fill and stroke stayed inside. With a
    * clip active, render the glyph coverage into the scratch a8 mask
    * instead, intersect that with the clip, and paint the real source
-   * through the result — the same shape as _fillPolys.
+   * through the result — the same shape as _fillPolys. A rectangular clip
+   * takes the server-side fast path below instead of the mask.
    */
   drawGlyphs(op, src, positioned) {
     const app = this.window.app;
@@ -1652,6 +1707,80 @@ class RenderingContext2d {
     this._fillPolys(flattenPath(tmp._cmds, this._m), "nonzero");
   }
 
+  /**
+   * Fill a batch of axis-aligned rectangles: `fillRect` once per rectangle
+   * semantically — fillStyle, globalAlpha, the composite op, the clip and
+   * damage reporting all apply — but priced for the "many small rectangles
+   * per frame" caller (issue #253): terminal cell backgrounds, sparkline
+   * bars, heat maps, row striping.
+   *
+   * `rects` is an array of `[x, y, w, h]` quadruples or one flat
+   * `[x0, y0, w0, h0, x1, ...]` array; rectangles with non-positive width
+   * or height are skipped.
+   *
+   * A solid-colour fillStyle under an identity transform and a rectangular
+   * (or absent) clip compiles the whole list into a single
+   * `Render.FillRectangles`, where N `fillRect` calls cost N composites.
+   * Gradient/Picture styles, transforms and non-rectangular clips fall
+   * back to that `fillRect` loop, so the answer is always right and only
+   * the request count varies.
+   */
+  fillRects(rects) {
+    if (!rects || !rects.length || this.globalAlpha <= 0) return;
+    // normalize to one flat list, dropping empty rectangles up front — the
+    // wire encodes width and height unsigned, so a negative would wrap
+    const flat = [];
+    if (Array.isArray(rects[0])) {
+      for (const r of rects) {
+        if (r[2] > 0 && r[3] > 0) flat.push(r[0], r[1], r[2], r[3]);
+      }
+    } else {
+      for (let i = 0; i + 3 < rects.length; i += 4) {
+        if (rects[i + 2] > 0 && rects[i + 3] > 0)
+          flat.push(rects[i], rects[i + 1], rects[i + 2], rects[i + 3]);
+      }
+    }
+    if (!flat.length) return;
+
+    const clip = this._clips.length ? this._clipRect() : null;
+    if (
+      !matIsIdentity(this._m) ||
+      !isPlainColor(this._fillStyle) ||
+      (this._clips.length && !clip)
+    ) {
+      for (let i = 0; i < flat.length; i += 4)
+        this.fillRect(flat[i], flat[i + 1], flat[i + 2], flat[i + 3]);
+      return;
+    }
+    if (clip && (clip.w === 0 || clip.h === 0)) return; // clipped away
+    const R = this.Render;
+    if (clip) {
+      R.SetPictureClipRectangles(this.picture.id, 0, 0, [
+        clip.x,
+        clip.y,
+        clip.w,
+        clip.h,
+      ]);
+    }
+    // globalAlpha folds into the premultiplied colour — scaling all four
+    // components is exactly what compositing at that opacity means, for
+    // any composite op (the mask slot would only scale the source the same
+    // way)
+    const color = this._foldedColor(this._fillStyle);
+    // stay under the server's maximum request size
+    const chunk = 10000 * 4;
+    for (let i = 0; i < flat.length; i += chunk) {
+      R.FillRectangles(
+        this._op(),
+        this.picture.id,
+        color,
+        i === 0 && flat.length <= chunk ? flat : flat.slice(i, i + chunk),
+      );
+    }
+    if (clip) this._resetPictureClip();
+    this._markDirty();
+  }
+
   strokeRect(x, y, w, h) {
     const m = this._m;
     if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {

package/lib/surface.js

@@ -1,5 +1,6 @@
 import Picture from './picture.js';
 import Pixmap from './pixmap.js';
+import { safeRelease } from './cleanup.js';
 
 /**
  * An offscreen drawing surface: a pixmap, its Picture, and enough of the
@@ -103,6 +104,67 @@ export class Surface {
     return this.pixmap.getContext(name, ...args);
   }
 
+  /**
+   * Scroll the pixels of `src` (surface coordinates, `{x, y, width, height}`)
+   * by (dx, dy) in place, server-side: one CopyArea of the band that
+   * survives the shift, in place of the caller re-drawing everything that
+   * merely moved. Returns true when the copy was issued; false means
+   * "nothing survives the shift here", and the caller repaints `src` exactly
+   * as it would have without this method — every refusal is the status quo.
+   *
+   * Refused when the delta is fractional (a sub-pixel shift changes every
+   * pixel, so there is nothing to copy), when it is zero, when nothing of
+   * `src` survives the shift after clamping to the surface, or on a
+   * destroyed surface.
+   *
+   * This is `Window#scrollRegion` for a retained offscreen surface, minus
+   * the damage bookkeeping a pixmap does not have: the caller draws the
+   * exposed strip and composites as usual. The overlapping self-copy is
+   * fully defined — pixmap contents cannot be occluded, and the server
+   * fetches the source region before storing. The copy goes out with a
+   * shared graphicsExposures: 0 GC — one per app and depth, created on
+   * first use and released with the connection, where a default GC would
+   * emit a NoExposure event per copy — and in-order with the caller's
+   * follow-up drawing of the exposed strip on the same connection.
+   */
+  copyWithin(src, dx, dy) {
+    if (this._destroyed) return false;
+    if (!Number.isInteger(dx) || !Number.isInteger(dy) || (dx === 0 && dy === 0)) return false;
+    const x0 = Math.max(0, Math.floor(src.x));
+    const y0 = Math.max(0, Math.floor(src.y));
+    const x1 = Math.min(this.width, Math.ceil(src.x + src.width));
+    const y1 = Math.min(this.height, Math.ceil(src.y + src.height));
+    // the band that survives: dest = clamped src ∩ (clamped src + delta)
+    const dstX0 = Math.max(x0, x0 + dx);
+    const dstY0 = Math.max(y0, y0 + dy);
+    const dstX1 = Math.min(x1, x1 + dx);
+    const dstY1 = Math.min(y1, y1 + dy);
+    if (dstX1 <= dstX0 || dstY1 <= dstY0) return false;
+    const X = this.app.X;
+    // a GC is valid for any drawable of its depth on the screen, so one per
+    // app and depth serves every surface — the upload-GC pattern in image.js
+    const gcs = (this.app._surfaceCopyGC ??= {});
+    safeRelease(X, () => {
+      let gc = gcs[this.depth];
+      if (!gc) {
+        gc = gcs[this.depth] = X.AllocID();
+        X.CreateGC(gc, this.pixmap.id, { graphicsExposures: 0 });
+      }
+      X.CopyArea(
+        this.pixmap.id,
+        this.pixmap.id,
+        gc,
+        dstX0 - dx,
+        dstY0 - dy,
+        dstX0,
+        dstY0,
+        dstX1 - dstX0,
+        dstY1 - dstY0
+      );
+    });
+    return true;
+  }
+
   destroy() {
     if (this._destroyed) return;
     this._destroyed = true;

package/lib/text/font.js

@@ -240,6 +240,27 @@ export default class Font {
     return this.fk.hasGlyphForCodePoint(codepoint);
   }
 
+  /**
+   * Glyph id for a codepoint, or `null` when this face does not cover it —
+   * the lookup twin of `hasGlyph`, for callers that position glyphs
+   * themselves (a terminal grid, a tabular column) and hand runs straight
+   * to `ctx.drawGlyphs` without shaping. See docs/text.md#glyph-runs.
+   *
+   * `null` rather than 0: fontkit resolves an uncovered codepoint to the
+   * `.notdef` glyph, and a caller building runs wants "not covered" as a
+   * branch (pick a fallback face) rather than as a tofu box discovered on
+   * screen. This is a cmap lookup only — no shaping, so no ligatures,
+   * kerning or contextual forms; text that needs those goes through
+   * `shape()`.
+   *
+   * @param {number} codepoint Unicode codepoint (`str.codePointAt(i)`)
+   * @returns {number|null} font glyph id, as `shape()` would report in `glyphs[].id`
+   */
+  glyphIdFor(codepoint) {
+    if (!this.fk.hasGlyphForCodePoint(codepoint)) return null;
+    return this.fk.glyphForCodePoint(codepoint).id;
+  }
+
   /**
    * Shape a run of text: returns glyphs with pixel-space positioning.
    * RTL runs come back in visual (left-to-right drawing) order.

package/package.json

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