react-x11 2.22.7 → 2.22.9

package/src/nodes/paint.js

@@ -318,13 +318,22 @@ export class NodePaint {
     return false;
   }
 
-  _paintChildren(ctx) {
+  /**
+   * The children, in paint order — or those up to and including `upTo`: an
+   * X11 pane over a `<glarea>` holds its own child and what is under it,
+   * never what is over it (src/gloverlay.js, `_paintPane`).
+   */
+  _paintChildren(ctx, upTo = null) {
     // A retained presenter replays a node's `paint` into a visual of that
     // node's own — its children have visuals of their own, so it sets this
     // for the duration of the call (src/cocoa/presenter.js, `paintSelf`).
     // Never set on the X11 or surface paths, where a frame is one walk.
     if (this._ownPaintOnly) return;
-    const order = this.paintOrder();
+    let order = this.paintOrder();
+    if (upTo !== null) {
+      const at = order.indexOf(upTo);
+      if (at !== -1) order = order.slice(0, at + 1);
+    }
     if (order.length === 0) return;
     if (!this.clipsChildren()) {
       this._paintChildList(ctx, order);

package/src/nodes/text.js

@@ -56,21 +56,6 @@ const textStripBelowFor = (app) =>
     ? textStripBelowEnv
     : TEXT_STRIP_BELOW);
 
-/**
- * Downward shift that recreates CSS "half-leading". ntk's TextLayout puts
- * the first baseline at exactly `ascent` and packs each line's leading
- * (font line gap + any lineHeight surplus) entirely *below* the glyphs, so
- * a layout drawn at the top of its measured box rides visually high —
- * most noticeable centered in buttons/inputs (fonts like Helvetica carry a
- * 0.5em line gap). CSS instead splits that leading evenly above and below
- * the ink (see seek-oss capsize for the metrics background).
- */
-function halfLeading(layout) {
-  const last = layout.lines?.[layout.lines.length - 1];
-  if (!last) return 0;
-  return Math.max(0, (layout.height - (last.baseline + last.descent)) / 2);
-}
-
 /** A selected line with nothing on it still shows, so a blank line inside a
  * selection does not read as the highlight having stopped. */
 const EMPTY_LINE_BAND = 4;
@@ -469,9 +454,10 @@ export class TextNode extends Node {
    * ever optically even by luck. `lineHeight` cannot fix it: it scales the
    * box and the leading still splits evenly, so it moves both edges alike.
    *
-   * Measured in the coordinates the layout is **drawn** in, not the ones it
-   * reports: `halfLeading` shifts it, and deriving the baseline from the
-   * metrics again would silently disagree the day that shift changes.
+   * Measured from the baselines the layout reports, which are where it
+   * draws them: the engine splits a line's leading above and below the
+   * glyphs, and deriving the baseline from the metrics again would silently
+   * disagree with it.
    *
    * The amounts are fractions of a pixel and stay that way — the glyphs are
    * placed from them (`_placedLayout`). What must not stay fractional is the
@@ -505,9 +491,8 @@ export class TextNode extends Node {
     // one backend and half-covers two rows on the other. Rounded, the
     // baseline sits on a pixel wherever the box does.
     const capHeight = Math.round(measured);
-    const shift = halfLeading(layout);
-    const firstBaseline = shift + lines[0].baseline;
-    const lastBaseline = shift + lines[lines.length - 1].baseline;
+    const firstBaseline = lines[0].baseline;
+    const lastBaseline = lines[lines.length - 1].baseline;
     return {
       top: Math.max(0, firstBaseline - capHeight),
       bottom: Math.max(0, Math.ceil(layout.height) - lastBaseline),
@@ -530,7 +515,7 @@ export class TextNode extends Node {
     return {
       layout,
       x: content.x,
-      y: content.y + halfLeading(layout) - (trim ? trim.top : 0),
+      y: content.y - (trim ? trim.top : 0),
     };
   }
 

package/src/nodes/textinput.js

@@ -618,15 +618,14 @@ export class TextInputNode extends Node {
    * it fills. Centred on the **capitals**, not on the line box and not on
    * the ink.
    *
-   * The layout box carries the line's leading entirely below the glyphs, so
-   * centring that pushes the text visually up (see `halfLeading`). Centring
-   * ascent + descent — what this did — fixes the leading but not the
-   * asymmetry underneath it: a font's ascent clears its capitals by
-   * `ascent - capHeight`, which is not its descent, so a single line of
-   * text sits off-centre by a number that belongs to the typeface. At 14px
-   * that is 0.7px of extra space above the capitals in SF NS and 2.5px the
-   * other way in Helvetica — visible in a field, where there is one short
-   * line and a border close on both sides to measure it against.
+   * Centring the line box centres its ascent + descent, because the engine
+   * splits the leading evenly round them, and that is not enough: a font's
+   * ascent clears its capitals by `ascent - capHeight`, which is not its
+   * descent, so a single line of text sits off-centre by a number that
+   * belongs to the typeface. At 14px that is 0.7px of extra space above the
+   * capitals in SF NS and 2.5px the other way in Helvetica — visible in a
+   * field, where there is one short line and a border close on both sides
+   * to measure it against.
    *
    * So: put the baseline where the space above the capitals equals the
    * space under it. A `<text>` says the same thing as `textBoxTrim`, but a

package/src/win32/fonts.js

@@ -486,9 +486,9 @@ export class Win32FontManager {
       );
     }
 
-    // `descent` is what halfLeading() in nodes/text.js subtracts to recreate
-    // CSS half-leading, and DirectWrite reports a baseline and a height per
-    // line rather than a descent.
+    // Every engine answers a descent per line — a field and the edit menu
+    // measure a line's ink as its ascent plus its descent — and DirectWrite
+    // reports a baseline and a height per line rather than a descent.
     const lines = (raw.lines ?? []).map((line) => ({
       ...line,
       descent: Math.max(0, line.height - line.baseline),