ntk 3.10.0 → 3.10.1

package/lib/renderingcontext_2d.js

@@ -999,6 +999,34 @@ class RenderingContext2d {
 
   // rasterize one clip entry into a temp a8 and In-composite it onto the mask
   _intersectClip(entry) {
+    // Intersecting with a *rectangle* is just "keep the inside, clear the
+    // outside", and up to four FillRectangles say that exactly — no temp
+    // pixmap to allocate and free, no rasterization, and no full-surface
+    // Composite. The general path below costs the whole surface per clip
+    // however small the rectangle is, which is what made nested clipping the
+    // dominant cost of a frame: scrolling a table clipped roughly 170 times
+    // per repaint, and at 900x600 that alone was ~92 megapixels of work
+    // before a single glyph was drawn.
+    if (entry.rect) {
+      const r = entry.rect;
+      const x = Math.max(0, Math.min(r.x, this.width));
+      const y = Math.max(0, Math.min(r.y, this.height));
+      const right = Math.max(x, Math.min(r.x + r.w, this.width));
+      const bottom = Math.max(y, Math.min(r.y + r.h, this.height));
+      const outside = [];
+      if (y > 0) outside.push(0, 0, this.width, y);
+      if (bottom < this.height) {
+        outside.push(0, bottom, this.width, this.height - bottom);
+      }
+      if (x > 0) outside.push(0, y, x, bottom - y);
+      if (right < this.width) {
+        outside.push(right, y, this.width - right, bottom - y);
+      }
+      if (outside.length) {
+        this.Render.FillRectangles(this.Render.PictOp.Src, this.clipMask.id, [0, 0, 0, 0], outside);
+      }
+      return;
+    }
     const tmpPixmap = new Pixmap(this.window.app, { depth: 8, width: this.width, height: this.height });
     const tmpMask = new Picture(this.window.app, { drawable: tmpPixmap, format: this.Render.a8 });
     this.Render.FillRectangles(this.Render.PictOp.Src, tmpMask.id, [0, 0, 0, 0], [0, 0, this.width, this.height]);

package/lib/widgets/markdownview.js

@@ -352,14 +352,66 @@ export default class MarkdownView {
       }
     }
 
+    // Two widths per column from here on: `cols` is the outer width the grid
+    // is drawn at, `inner` is what a cell is laid out at. `inner` is kept
+    // alongside rather than derived as `cols[c] - hpad * 2`, and that is not
+    // tidiness. Adding a padding and subtracting it again is not the identity
+    // in binary floating point — for a natural width of 48.953125 at size 16
+    // the round trip returns 48.95312499999999 — and a token handed a maxWidth
+    // a few ULPs below its own measured width is *wider than its container*,
+    // so TextLayout force-breaks it. That is a `value` header rendered as
+    // `valu` over `e`, on some fonts and not others, depending on nothing more
+    // than whether the width happens to survive the round trip.
     const cols = natural.map((w) => w + hpad * 2);
+    const inner = natural.slice();
     const total = cols.reduce((a, b) => a + b, 0);
     if (total > width) {
-      // proportional shrink; the floor keeps narrow columns readable even
-      // if wide neighbors then push the table slightly past the container
-      const minCol = Math.min(t.size * 2.5 + hpad * 2, width / ncols);
+      // Shrink towards each column's *min-content* width — the widest word it
+      // holds that cannot be broken — and never past it. The floor used to be
+      // a flat 2.5em guess with no relation to the content, so a column whose
+      // longest word was wider than that got a maxWidth below the word and the
+      // word came apart.
+      //
+      // Min-content is the widest whitespace-delimited token, each measured
+      // *unconstrained*. Laying the whole cell out at a tiny maxWidth looks
+      // like the obvious probe and is not one: a token wider than the
+      // container is force-broken rather than left to overflow whenever a
+      // single cluster fits, so the probe reports a fragment's width. It is
+      // not even monotonic in maxWidth — see the test that pins that. An
+      // unconstrained token cannot be broken at all.
+      //
+      // A token split across spans — `**val**ue` — is measured as its halves
+      // and so under-measured. Rare, and still far above the flat guess this
+      // replaced. Only measured here: a table that fits needs no minimums.
+      const content = new Array(ncols).fill(0);
+      for (const row of cellSpans) {
+        for (let c = 0; c < ncols; c++) {
+          for (const span of row[c]) {
+            for (const token of String(span.text ?? '').split(/\s+/)) {
+              if (!token) continue;
+              const measure = new TextLayout(fonts, [{ ...span, text: token }], styles.base, {
+                lineHeight: t.lineHeight
+              });
+              content[c] = Math.max(content[c], measure.width);
+            }
+          }
+        }
+      }
+      const mins = content.map((w) => w + hpad * 2);
+      // Space above the minimums is shared in proportion to how much each
+      // column asked for, so a wide column gives up more than a narrow one.
+      // When the minimums themselves do not fit, the table overflows rather
+      // than breaking words — which is what a browser does with the same
+      // content, and is the lesser of the two evils.
+      const slack = width - mins.reduce((a, b) => a + b, 0);
+      const want = cols.reduce((a, w, c) => a + Math.max(0, w - mins[c]), 0);
       for (let c = 0; c < ncols; c++) {
-        cols[c] = Math.max(minCol, (cols[c] / total) * width);
+        cols[c] =
+          slack <= 0 || want <= 0
+            ? mins[c]
+            : mins[c] + (Math.max(0, cols[c] - mins[c]) / want) * slack;
+        // Never below min-content, whatever the arithmetic above produced.
+        inner[c] = Math.max(content[c], cols[c] - hpad * 2);
       }
     }
     const tableW = cols.reduce((a, b) => a + b, 0);
@@ -369,7 +421,7 @@ export default class MarkdownView {
     for (let r = 0; r < cellSpans.length; r++) {
       const layouts = cellSpans[r].map((spans, c) =>
         new TextLayout(fonts, spans.length ? spans : '', styles.base, {
-          maxWidth: cols[c] - hpad * 2,
+          maxWidth: inner[c],
           align: block.align[c] ?? 'left',
           lineHeight: t.lineHeight
         })

package/package.json

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