ntk 8.12.9 → 8.12.11

package/lib/glswapchain.js

@@ -12,14 +12,19 @@
 // and every later frame in that buffer is a Present of a pixmap the server
 // already has.
 //
-// Two rules shape the code. **A buffer belongs to the server until IdleNotify
+// Three rules shape the code. **A buffer belongs to the server until IdleNotify
 // says otherwise** — drawing into one before then paints whatever is on
-// screen — so a buffer is released back to GBM there and nowhere else. And
-// **a pixmap must exist before it is presented**: a new buffer's import is
+// screen — so a buffer is released back to GBM there and nowhere else. **A
+// pixmap must exist before it is presented**: a new buffer's import is
 // confirmed by a round trip before the first Present names it, or the Present
 // would fail with BadPixmap. A new buffer appears a handful of times per
 // generation (and never again in steady state), so that round trip is a
-// startup cost, not a per-frame one.
+// startup cost, not a per-frame one. And **a surface is never destroyed while
+// it is current** (`_destroySurface`): destroying one takes its GBM surface —
+// the native window under the EGL surface — with it, while EGL still holds
+// the EGL surface as current, and on NVIDIA's driver the next surface made
+// current after that swaps nothing but EGL_BAD_SURFACE. A resize retires the
+// generation being drawn into, so every resize of a window killed its GL.
 
 import { GLError, glError } from './gl.js';
 
@@ -88,6 +93,9 @@ export class GLSwapchain {
     this.onReady = null;
     /** called once the first buffer has been imported, or it failed */
     this.onValidated = null;
+    /** called with the error when the chain fails after it validated — the
+     *  one failure `onValidated` has no way left to report */
+    this.onError = null;
     this._validated = false;
 
     this._eid = this.X.AllocID();
@@ -107,10 +115,44 @@ export class GLSwapchain {
     const h = Math.max(1, Math.round(height));
     const gen = this.generation;
     if (gen && gen.width === w && gen.height === h) return gen.surface;
+    // The new generation first, and only then the old one's retirement: a
+    // driver that refuses the new size leaves the chain drawing where it
+    // was, and the old surface — current, as a rule, since this runs at the
+    // top of a frame — is let go by `_destroySurface`, which unbinds it.
+    // A generation that had to go linear keeps that layout: whatever refused
+    // the tiled buffer — the server, or EGL itself — has not changed since.
+    const surface = this._newGeneration(w, h, gen ? gen.linear : false);
     this._retire(gen);
-    // a generation that had to go linear keeps that layout: whatever refused
-    // the tiled buffer — the server, or EGL itself — has not changed since
-    return this._newGeneration(w, h, gen ? gen.linear : false);
+    return surface;
+  }
+
+  /**
+   * Destroy a generation's surface, unbinding it first if it is the one
+   * current on the connection.
+   *
+   * The currency is the connection's (`app._glCurrentSurface`, which the
+   * context sets whenever it binds): every direct surface on it shares one
+   * GPU context, and exactly one surface is current. Unbinding leaves no
+   * surface current and says so (`app._glCurrent`), so the next GL call of
+   * whichever context draws next binds its own, as it would after another
+   * surface stole currency.
+   */
+  _destroySurface(surface) {
+    const app = this.window.app;
+    if (app && app._glCurrentSurface === surface) {
+      try {
+        this.gpu.makeCurrent(null);
+      } catch {
+        // nothing is current now either way
+      }
+      app._glCurrentSurface = null;
+      app._glCurrent = null;
+    }
+    try {
+      surface.destroy();
+    } catch {
+      // already gone
+    }
   }
 
   /** A GBM surface at this size, in the layout asked for. */
@@ -384,14 +426,20 @@ export class GLSwapchain {
   _fail(err) {
     if (this.error) return;
     this.error = err;
-    this._validate(err);
+    // Before validation the failure is `ready`'s rejection. After it — a
+    // swap refused mid-life — nothing is waiting on `ready` any more, and a
+    // chain that only recorded the error left its window showing its last
+    // frame, or nothing, with no word to anyone.
+    if (this._validated) this.onError?.(err);
+    else this._validate(err);
   }
 
   _retire(gen) {
     if (!gen || gen.retired) return;
     gen.retired = true;
     this.retired.push(gen);
-    this.generation = null;
+    // `surfaceFor` retires the old generation after making the new one
+    if (this.generation === gen) this.generation = null;
     this._sweep(gen);
   }
 
@@ -409,11 +457,7 @@ export class GLSwapchain {
     if (gen.pixmaps.size || this.importing) return;
     const index = this.retired.indexOf(gen);
     if (index >= 0) this.retired.splice(index, 1);
-    try {
-      gen.surface.destroy();
-    } catch {
-      // already gone
-    }
+    this._destroySurface(gen.surface);
   }
 
   _freePixmap(pixmap) {
@@ -429,14 +473,11 @@ export class GLSwapchain {
     this.destroyed = true;
     this.onReady = null;
     this.onValidated = null;
+    this.onError = null;
     for (const gen of this._generations()) {
       for (const entry of gen.pixmaps.values()) this._freePixmap(entry.pixmap);
       gen.pixmaps.clear();
-      try {
-        gen.surface.destroy();
-      } catch {
-        // already gone
-      }
+      this._destroySurface(gen.surface);
     }
     this.generation = null;
     this.retired.length = 0;

package/lib/renderingcontext_cgl.js

@@ -416,7 +416,24 @@ does not make it retroactive. Either:
   _fail(err) {
     if (this.error) return;
     this.error = err;
-    this._settleReady?.(err);
+    // before `ready` settled this is its rejection; after, the one word the
+    // failure gets is `onError` (the GLES flavor's contract)
+    if (this._settleReady) this._settleReady(err);
+    else this._errorHandler?.(err);
+  }
+
+  /**
+   * Called once, with the coded error `error` then holds, when the context
+   * fails after `ready` resolved — a flush refused, or a surface that could
+   * not be exported again after the window came back. A failure before that
+   * is `ready`'s rejection, and only that.
+   */
+  set onError(fn) {
+    this._errorHandler = fn;
+  }
+
+  get onError() {
+    return this._errorHandler;
   }
 
   destroy() {

package/lib/renderingcontext_gles.js

@@ -167,6 +167,12 @@ does not make it retroactive. Either:
     this.ready.catch(() => {});
     this.swapchain.onReady = () => this._onFrameAvailable();
     this._frameWanted = null;
+    // …and a failure after `ready` resolved, which nothing awaits any more
+    this._errorHandler = null;
+    this.swapchain.onError = (err) => {
+      this.error = err;
+      this._errorHandler?.(err);
+    };
 
     // GL entry points and constants, bound so that whichever surface this
     // context owns is the current one when they run
@@ -208,24 +214,28 @@ does not make it retroactive. Either:
    */
   makeCurrent() {
     if (this.error || this._destroyed || this.window._destroyed) return this;
-    const width = this.window.width;
-    const height = this.window.height;
-    if (width !== this._width || height !== this._height) {
-      this._width = width;
-      this._height = height;
-      this._surface = null; // a new size is a new generation
-    }
+    // a new size is a new generation, which `_bind` asks the chain for
+    this._width = this.window.width;
+    this._height = this.window.height;
     this._bind();
     return this;
   }
 
   _bind() {
     if (this.error || this._destroyed) return;
-    if (!this._surface) {
-      this._surface = this.swapchain.surfaceFor(this._width ?? this.window.width, this._height ?? this.window.height);
-    }
+    // Asked of the chain every time rather than cached here: the chain also
+    // replaces its generation on its own — the linear retry after the server
+    // refuses a buffer — and a surface cached across that is one the chain
+    // has destroyed. At the same size it is a comparison and a return.
+    this._surface = this.swapchain.surfaceFor(
+      this._width ?? this.window.width,
+      this._height ?? this.window.height
+    );
     this.gpu.makeCurrent(this._surface);
     this.app._glCurrent = this;
+    // which surface is current, for the chain: it never destroys that one
+    // without unbinding it first (GLSwapchain#_destroySurface)
+    this.app._glCurrentSurface = this._surface;
   }
 
   /**
@@ -252,6 +262,20 @@ does not make it retroactive. Either:
     this._frameWanted?.();
   }
 
+  /**
+   * Called once, with the coded error `error` then holds, when the context
+   * fails after `ready` resolved — the driver refusing a swap mid-life. A
+   * failure before that is `ready`'s rejection, and only that. Either way
+   * the context draws nothing more, and a caller with a fallback shows it.
+   */
+  set onError(fn) {
+    this._errorHandler = fn;
+  }
+
+  get onError() {
+    return this._errorHandler;
+  }
+
   /**
    * Show the frame just drawn.
    *
@@ -266,9 +290,8 @@ does not make it retroactive. Either:
     // A resize seen only now still gets picked up: the next frame binds a
     // generation at the new size. Checked after the swap so the frame that was
     // drawn at the old size is the one that goes out.
-    if (this.window.width !== this._width || this.window.height !== this._height) {
-      this._surface = null;
-    }
+    this._width = this.window.width;
+    this._height = this.window.height;
     return sent;
   }
 
@@ -288,10 +311,14 @@ does not make it retroactive. Either:
   destroy() {
     if (this._destroyed) return;
     this._destroyed = true;
+    this._errorHandler = null;
+    // unbinds this context's surface first where it is the current one
+    // (GLSwapchain#_destroySurface)
     this.swapchain.destroy();
     this.window._setGenericEventSink(0, null);
     if (this.app._glCurrent === this) {
       this.app._glCurrent = null;
+      this.app._glCurrentSurface = null;
       try {
         this.gpu.makeCurrent(null);
       } catch {

package/lib/text/layout.js

@@ -5,9 +5,12 @@ import { drawGlyphRuns } from './glyphs.js';
 import { embeddingLevels, normalizedLevels, reorderRuns } from './shape.js';
 import { worthKeeping } from './paragraphs.js';
 
-const WS = new Set([0x20, 0x09, 0xa0]);
+// The white space a line may end on and hang past its edge: spaces and tabs,
+// as CSS hangs them. A no-break space is not one — CSS measures it, and
+// ` ` at the end of a cell or a span is there to take room.
+const WS = new Set([0x20, 0x09]);
 const HARD_BREAKS = /[\n\r\u2028\u2029]+$/;
-const TRAILING_WS = /[ \t\u00a0]+$/;
+const TRAILING_WS = /[ \t]+$/;
 
 function isWsGlyph(g) {
   return g.codePoints.length > 0 && g.codePoints.every((cp) => WS.has(cp));

package/lib/text/shape.js

@@ -104,18 +104,16 @@ function spacedFeatures(features) {
 /**
  * Space a shaped run's glyphs apart by `spacing` px: added to the advance of
  * every glyph that has one, so a combining mark keeps sitting on its base.
- * An rtl run stores its glyphs in visual order, and its spacing belongs on
- * the *reading* side of each glyph — the left — so there the glyph is drawn
- * that much further along its advance as well.
+ * The gap is on each glyph's right in an rtl run as in an ltr one — where
+ * CoreText's kerning attribute and browsers put it — so a line that changes
+ * direction keeps one gap between every two neighbours: on the reading side
+ * of an rtl run's glyphs it came out twice where the direction changed one
+ * way and not at all where it changed back.
  */
 function spaceGlyphs(shaped, spacing) {
-  const rtl = shaped.direction === 'rtl';
   let width = 0;
   for (const g of shaped.glyphs) {
-    if (g.ax > 0) {
-      g.ax += spacing;
-      if (rtl) g.dx += spacing;
-    }
+    if (g.ax > 0) g.ax += spacing;
     width += g.ax;
   }
   shaped.width = width;

package/package.json

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