react-x11 2.15.0 → 2.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-x11",
-  "version": "2.15.0",
+  "version": "2.15.2",
   "description": "react renderer with X11 as a target",
   "main": "./src/index.js",
   "files": [

package/src/wayland/context2d.js

@@ -532,7 +532,7 @@ export class WaylandContext2D {
    */
   begin(width, height, timestamp = 0) {
     this.init();
-    this._device.owner = this;
+    this._take();
     const t = this._target;
     if (t) {
       t.bind();
@@ -612,7 +612,7 @@ export class WaylandContext2D {
     // Mid stencil-then-cover the state is set up for the pass, not for a
     // plain batch, and the device cannot have changed hands under it.
     if (this._device.owner === this || this._stencilling) return;
-    this._device.owner = this;
+    this._take();
     this._makeCurrent?.();
     this.init();
     // As `begin()` has it: a target's size *is* the projection.
@@ -624,6 +624,26 @@ export class WaylandContext2D {
     this._applyState();
   }
 
+  /**
+   * Take the device, drawing whatever the last owner still had buffered.
+   *
+   * A context batches: its quads sit in a vertex buffer until the mode
+   * changes, the buffer fills, or someone flushes. So the handover is where
+   * the outgoing owner's batch is drawn — otherwise a frame's worth of work
+   * can sit there while the pixels it was meant to produce are read by
+   * whoever comes next, and stay there until that context happens to draw
+   * something of a different kind (#578). The state is still the outgoing
+   * owner's at this point, which is what the flush needs.
+   *
+   * It is also what device.js's invariant rests on: the owner is the only
+   * context that can be holding anything.
+   */
+  _take() {
+    const previous = this._device.owner;
+    if (previous && previous !== this) previous._flush();
+    this._device.owner = this;
+  }
+
   /** Give the device up, so the next draw through this context re-takes it. */
   _release() {
     if (this._device.owner === this) this._device.owner = null;
@@ -1950,6 +1970,11 @@ export class WaylandContext2D {
 
   /** Two triangles from four corners, in order TL, TR, BR, BL. */
   _quad(pos, uv, color, params) {
+    // Buffering is taking the device, not a step before it: the quad is GL
+    // work that has been decided on and not yet issued, and the handover in
+    // `_take` is the only thing that can get it issued before someone reads
+    // the pixels it makes. A property compare in the common case.
+    this._claim();
     if (this._n + 6 > MAX_VERTS) this._flush();
     const v = this._verts;
     let o = this._n * STRIDE;
@@ -1974,6 +1999,7 @@ export class WaylandContext2D {
 
   /** One triangle, for the stencil pass. Colour and params are irrelevant. */
   _tri(x0, y0, x1, y1, x2, y2) {
+    this._claim();
     if (this._n + 3 > MAX_VERTS) this._flush();
     const v = this._verts;
     let o = this._n * STRIDE;

package/src/wayland/device.js

@@ -16,6 +16,15 @@
 // back. Whoever drew in between does not have to know who comes next, and a
 // caller does not have to know there is a device at all.
 //
+// Claiming is also a *batch boundary*: a 2d context buffers its quads and
+// draws them in one call later, so the outgoing owner is flushed on the way
+// out. That is what makes the invariant this module offers true — **only the
+// owner can have work still buffered** — and the invariant is what lets
+// anyone about to read a target's pixels get them by flushing one context
+// (`flushDevice`) rather than by knowing which one drew them. Without it a
+// held surface context's whole frame could sit in a vertex buffer while the
+// `drawImage` that should show it sampled the texture behind it (#578).
+//
 // One record per `gl`, keyed weakly: a GPU that goes away takes its record
 // with it.
 const devices = new WeakMap();
@@ -53,3 +62,17 @@ export function releaseDevice(gl) {
   const device = shared(gl) ? devices.get(gl) : null;
   if (device) device.owner = null;
 }
+
+/**
+ * Draw what is still buffered, so that a target's texture holds everything
+ * that has been drawn into it.
+ *
+ * The owner is the only context that can be holding anything (see above), so
+ * flushing it is flushing the device. Call before *reading* a target's pixels
+ * behind the contexts' backs — a framebuffer blit, a scroll copy — the way
+ * `releaseDevice` is called after writing them.
+ */
+export function flushDevice(gl) {
+  const device = shared(gl) ? devices.get(gl) : null;
+  device?.owner?.flush();
+}

package/src/wayland/target.js

@@ -21,7 +21,7 @@
 // asking EGL for it means the window's own config no longer has to carry
 // stencil bits at all; the request in glcontext.js stays as belt and braces.
 
-import { releaseDevice } from './device.js';
+import { flushDevice, releaseDevice } from './device.js';
 
 export class GLTarget {
   /**
@@ -133,6 +133,9 @@ export class GLTarget {
    */
   blitTo(drawFbo, rects, dstWidth = this.width, dstHeight = this.height) {
     const gl = this.gl;
+    // Reading these pixels, so everything drawn into them has to be in the
+    // texture and not still in a context's vertex buffer (device.js).
+    flushDevice(gl);
     gl.bindFramebuffer(gl.READ_FRAMEBUFFER, this.fbo);
     gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, drawFbo);
     gl.disable(gl.SCISSOR_TEST);
@@ -201,6 +204,11 @@ export class GLTarget {
     const sy = dstY0 - dy;
 
     const gl = this.gl;
+    // A scroll reads this target before it writes it, so anything a context
+    // still has buffered has to land first — or the band that moves is the
+    // frame before last's, and the buffered quads arrive afterwards at the
+    // position the scroll just left (device.js).
+    flushDevice(gl);
     const scratch = scratchFor(gl, bw, bh);
     // out: this[sx,sy,bw,bh] -> scratch[0,0]
     gl.bindFramebuffer(gl.READ_FRAMEBUFFER, this.fbo);

package/src/wayland/xkb.js

@@ -17,7 +17,7 @@
 //   xkb_types      `type "FOUR_LEVEL" { modifiers= Shift+LevelThree;
 //                     map[Shift]= 2; ... }`       modifier set -> level
 //   xkb_symbols    `key <AD01> { [ q, Q ] };`     keycode -> keysyms per level,
-//                  with `symbols[Group2]` and `type=` where given
+//                  with `symbols[Group2]`/`symbols[2]` and `type=` where given
 //                  `modifier_map Mod5 { <LVL3> }` real modifier -> keycodes
 //   xkb_compat     `interpret ISO_Level3_Shift { virtualModifier= LevelThree; }`
 //                                                keysym -> virtual modifier
@@ -187,17 +187,32 @@ export class XkbKeymap {
       // explicit per-group or global type
       const typeAll = body.match(/(?:^|[,{\s])type\s*=\s*"([^"]+)"/);
       const typeByGroup = new Map();
-      for (const t of body.matchAll(/type\[Group(\d)\]\s*=\s*"([^"]+)"/g))
+      for (const t of body.matchAll(/type\[(?:Group)?(\d)\]\s*=\s*"([^"]+)"/g))
         typeByGroup.set(+t[1], t[2]);
       // symbols[GroupN]= [ a, b ]  and the bare form { [ a, b ] }
+      //
+      // The group subscript has two spellings, and the one this file was
+      // written against is the one a compositor never sends. `xkbcomp -xkb`
+      // writes `symbols[Group1]`; **libxkbcommon writes `symbols[1]`**, and
+      // libxkbcommon is what serialises the keymap on the other end of
+      // `wl_keyboard.keymap` — so every keymap that reaches this parser for
+      // real uses the bare number. Both are accepted, because a keymap also
+      // arrives here from `xkbcomp` output in a test or a bug report.
       const lists = [];
       for (const g of body.matchAll(
-        /symbols\[Group(\d)\]\s*=\s*\[([^\]]*)\]/g,
+        /symbols\[(?:Group)?(\d)\]\s*=\s*\[([^\]]*)\]/g,
       )) {
         lists[+g[1] - 1] = g[2];
       }
       if (lists.length === 0) {
-        const bare = body.match(/\[([^\]]*)\]/);
+        // The bare form, `key <ESC> { [ Escape ] };` — the list is the one
+        // bracket that is *not* a subscript, which is what the leading
+        // delimiter says: a subscript is always glued to the word in front
+        // of it (`symbols[`, `type[`, `actions[`). Matching any bracket at
+        // all is how an unrecognised subscript spelling used to end up here
+        // and take `[1]` for the symbol list, which decodes every key on the
+        // keyboard to the keysym named `1`.
+        const bare = body.match(/(?:^|[,{\s])\[([^\]]*)\]/);
         if (bare) lists[0] = bare[1];
       }
       for (let gi = 0; gi < lists.length; gi++) {