react-x11 2.51.1 → 2.52.0

package/src/wayland/context2d.js

@@ -67,6 +67,8 @@ const MODE_RRECT = 3;
 const MODE_GRADIENT = 4;
 /** A texture read through a projection: `vParams` is (s/w, t/w, 1/w). */
 const MODE_PROJECTIVE = 5;
+/** A pattern: an image laid down from the fragment's device position. */
+const MODE_PATTERN = 6;
 
 /**
  * The stencil buffer, shared between two uses: bit 7 is the clip (set where
@@ -132,6 +134,12 @@ uniform highp vec2 uViewport;
 uniform int uGradKind;
 uniform vec4 uGradA;
 uniform vec4 uGradB;
+// a pattern: device position to its pixels (the inverse transform it is
+// filled under, a b c d and then e f), its size, and which axes repeat (1 x,
+// 2 y) and whether its rows run bottom up (4: a render target)
+uniform highp vec4 uPatInv;
+uniform highp vec4 uPatOff;
+uniform int uPatFlags;
 
 float sdRoundBox(vec2 p, vec2 b, float r) {
   vec2 q = abs(p) - b + r;
@@ -167,6 +175,28 @@ void main() {
     // Interpolated across the quad in the plane of the screen, s/w, t/w and
     // 1/w are each exact, and so is their quotient: a texture in perspective.
     gl_FragColor = vColor * sampleTex(vParams.xy / vParams.z);
+  } else if (uMode == 6) {
+    // A pattern, from the fragment's device position as a gradient is, so
+    // any shape can be filled with one: back through the transform it was
+    // filled under to its own pixels, wrapped along the axes it repeats on
+    // and clear off the ones it does not, and read at the centre of the
+    // texel it lands in, so a tile drawn at its own size lands pixel for
+    // pixel — a grid's dots do not smear across a seam.
+    highp vec2 p = vec2(gl_FragCoord.x, uViewport.y - gl_FragCoord.y);
+    highp vec2 q = vec2(uPatInv.x * p.x + uPatInv.z * p.y + uPatOff.x,
+                        uPatInv.y * p.x + uPatInv.w * p.y + uPatOff.y);
+    highp vec2 size = uPatOff.zw;
+    highp vec2 t = q / size;
+    float flags = float(uPatFlags);
+    if (mod(flags, 2.0) >= 1.0) t.x = fract(t.x);
+    if (mod(floor(flags / 2.0), 2.0) >= 1.0) t.y = fract(t.y);
+    if (t.x < 0.0 || t.x >= 1.0 || t.y < 0.0 || t.y >= 1.0) {
+      gl_FragColor = vec4(0.0);
+    } else {
+      t = (floor(t * size) + 0.5) / size;
+      if (flags >= 4.0) t.y = 1.0 - t.y;
+      gl_FragColor = vColor * sampleTex(t);
+    }
   } else {
     // Gradients are evaluated per fragment from its device position, so any
     // shape — a cover quad over a path included — can be filled with one.
@@ -415,6 +445,43 @@ export function parseFont(font) {
  */
 const fontIds = new WeakMap();
 let nextFontId = 1;
+const REPETITIONS = new Set(['repeat', 'repeat-x', 'repeat-y', 'no-repeat']);
+
+/**
+ * A pattern: an image or a surface, and the axes it repeats along. Its
+ * texture is looked up as it is filled rather than made here, so a surface
+ * drawn on again after the pattern was made fills with what it holds then,
+ * as a canvas pattern of a canvas does.
+ */
+class Pattern {
+  constructor(source, repetition) {
+    this.source = source;
+    this.repetition = repetition;
+    /** its own transform, under the one it is filled with (`setTransform`) */
+    this.m = null;
+  }
+
+  setTransform(m) {
+    this.m = m
+      ? [m.a ?? 1, m.b ?? 0, m.c ?? 0, m.d ?? 1, m.e ?? 0, m.f ?? 0]
+      : null;
+  }
+}
+
+function invert(m) {
+  const det = m[0] * m[3] - m[1] * m[2];
+  if (!det) return null;
+  const a = m[3] / det;
+  const b = -m[1] / det;
+  const c = -m[2] / det;
+  const d = m[0] / det;
+  return [a, b, c, d, -(a * m[4] + c * m[5]), -(b * m[4] + d * m[5])];
+}
+
+/** A paint that is not a colour: drawn from the fragment's position. */
+const isPaint = (style) =>
+  style instanceof Gradient || style instanceof Pattern;
+
 function fontKey(font) {
   let id = fontIds.get(font);
   if (!id) fontIds.set(font, (id = `f${nextFontId++}`));
@@ -571,6 +638,9 @@ export class WaylandContext2D {
       uGradKind: u('uGradKind'),
       uGradA: u('uGradA'),
       uGradB: u('uGradB'),
+      uPatInv: u('uPatInv'),
+      uPatOff: u('uPatOff'),
+      uPatFlags: u('uPatFlags'),
     };
     shared.buffer = gl.createBuffer();
     gl.bindBuffer(gl.ARRAY_BUFFER, shared.buffer);
@@ -847,9 +917,23 @@ export class WaylandContext2D {
     return new Gradient('radial', [x0, y0, r0, x1, y1, r1]);
   }
 
-  createPattern() {
-    // Patterns need a repeating texture mode; not yet.
-    return null;
+  /**
+   * A pattern of `image` — an ImageData, an ntk `Image`, a surface or a
+   * render target. Null for one with nothing in it, as canvas answers for an
+   * image it cannot use; `repetition` is canvas's, null and `''` meaning
+   * `'repeat'`, and anything else a `SyntaxError`.
+   */
+  createPattern(image, repetition) {
+    const rep =
+      repetition == null || repetition === '' ? 'repeat' : String(repetition);
+    if (!REPETITIONS.has(rep)) {
+      throw new SyntaxError(
+        `createPattern: ${JSON.stringify(rep)} is not a repetition — ` +
+          "expected 'repeat', 'repeat-x', 'repeat-y' or 'no-repeat'.",
+      );
+    }
+    if (!((image?.width | 0) > 0 && (image?.height | 0) > 0)) return null;
+    return new Pattern(image, rep);
   }
 
   // ---- paths ------------------------------------------------------------
@@ -1088,7 +1172,7 @@ export class WaylandContext2D {
 
   _rect(x, y, w, h, radius, style, strokeWidth) {
     if (!(w > 0 && h > 0)) return;
-    if (style instanceof Gradient) {
+    if (isPaint(style)) {
       if (radius <= 0 && strokeWidth === 0)
         return this._gradientQuad(x, y, w, h, style);
       // rounded/stroked gradient: stencil the shape, cover with the gradient
@@ -1226,8 +1310,40 @@ export class WaylandContext2D {
     }
   }
 
+  /** Bind a gradient or a pattern for the next quads; false where there is
+   *  nothing to draw with — a pattern of an image that has gone. */
+  _usePaint(paint) {
+    if (paint instanceof Pattern) return this._usePattern(paint);
+    this._useGradient(paint);
+    return true;
+  }
+
+  /** Bind a pattern's texture, and the way from a device pixel to one of
+   *  its own, as the current batch's uniforms. */
+  _usePattern(pat) {
+    const src = this._textureFor(pat.source);
+    if (!src) return false;
+    const inv = invert(pat.m ? mul(this._m, pat.m) : this._m);
+    if (!inv) return false;
+    const gl = this.gl;
+    this._flush();
+    this._mode = MODE_PATTERN;
+    this._texture = src.tex;
+    this._swizzle = src.swizzle;
+    const rep = pat.repetition;
+    const flags =
+      (rep === 'repeat' || rep === 'repeat-x' ? 1 : 0) +
+      (rep === 'repeat' || rep === 'repeat-y' ? 2 : 0) +
+      (src.flipY ? 4 : 0);
+    gl.useProgram(this._program);
+    gl.uniform4f(this._loc.uPatInv, inv[0], inv[1], inv[2], inv[3]);
+    gl.uniform4f(this._loc.uPatOff, inv[4], inv[5], src.w, src.h);
+    gl.uniform1i(this._loc.uPatFlags, flags);
+    return true;
+  }
+
   _gradientQuad(x, y, w, h, grad) {
-    this._useGradient(grad);
+    if (!this._usePaint(grad)) return;
     const m = this._m;
     const alpha = this.globalAlpha;
     this._quad(
@@ -1277,7 +1393,7 @@ export class WaylandContext2D {
     // only once the device has been claimed.
     this._claim();
     let color = null;
-    if (!(style instanceof Gradient)) {
+    if (!isPaint(style)) {
       color = this._color(style);
       if (color[3] === 0) return;
       if (this._fillCoverage(polys, rule, bounds, color)) return;
@@ -1297,15 +1413,18 @@ export class WaylandContext2D {
     const { x, y, w, h } = bounds;
     const saved = this._m;
     this._m = IDENTITY;
-    if (style instanceof Gradient) {
-      this._m = saved; // gradient endpoints are in user space
-      this._useGradient(style);
+    if (isPaint(style)) {
+      this._m = saved; // a gradient's endpoints, a pattern's origin: user space
+      const painted = this._usePaint(style);
       this._m = IDENTITY;
       const a = this.globalAlpha;
+      // a pattern with nothing to draw with still covers, clear, so the
+      // counts the winding pass left are zeroed as the cover always does
+      if (!painted) this._setMode(MODE_SOLID, null, SWIZZLE_RGBA);
       this._quad(
         [x, y, x + w, y, x + w, y + h, x, y + h],
         UV_UNIT,
-        [a, a, a, a],
+        painted ? [a, a, a, a] : CLEAR,
         ZERO4,
       );
     } else {

package/src/wayland/protocols/index.json

@@ -127,5 +127,11 @@
  "keyboard-shortcuts-inhibit-unstable-v1": [
   "zwp_keyboard_shortcuts_inhibit_manager_v1",
   "zwp_keyboard_shortcuts_inhibitor_v1"
+ ],
+ "xdg-foreign-unstable-v2": [
+  "zxdg_exporter_v2",
+  "zxdg_importer_v2",
+  "zxdg_exported_v2",
+  "zxdg_imported_v2"
  ]
 }

package/src/wayland/protocols/xdg-foreign-unstable-v2.json

@@ -0,0 +1 @@
+[{"name":"zxdg_exporter_v2","version":1,"requests":[{"name":"destroy","type":"destructor","args":[]},{"name":"export_toplevel","args":[{"name":"id","type":"new_id","interface":"zxdg_exported_v2"},{"name":"surface","type":"object","interface":"wl_surface"}]}],"events":[],"enums":{"error":{"entries":[{"name":"invalid_surface","value":0}]}}},{"name":"zxdg_importer_v2","version":1,"requests":[{"name":"destroy","type":"destructor","args":[]},{"name":"import_toplevel","args":[{"name":"id","type":"new_id","interface":"zxdg_imported_v2"},{"name":"handle","type":"string"}]}],"events":[],"enums":{}},{"name":"zxdg_exported_v2","version":1,"requests":[{"name":"destroy","type":"destructor","args":[]}],"events":[{"name":"handle","args":[{"name":"handle","type":"string"}]}],"enums":{}},{"name":"zxdg_imported_v2","version":1,"requests":[{"name":"destroy","type":"destructor","args":[]},{"name":"set_parent_of","args":[{"name":"surface","type":"object","interface":"wl_surface"}]}],"events":[{"name":"destroyed","args":[]}],"enums":{"error":{"entries":[{"name":"invalid_surface","value":0}]}}}]

package/src/wayland/seat.js

@@ -26,7 +26,7 @@
 
 import { EventEmitter } from 'node:events';
 import fs from 'node:fs';
-import { XkbKeymap } from './xkb.js';
+import { XkbKeymap, REAL_MODS, layoutsFromKeymap } from './xkb.js';
 
 /** `wl_seat.capability` bits. */
 export const SEAT_CAP = { POINTER: 1, KEYBOARD: 2, TOUCH: 4 };
@@ -185,7 +185,10 @@ export class WaylandSeat extends EventEmitter {
     this.xkb = null;
     /** X-style modifier mask: depressed | latched | locked */
     this.mods = 0;
+    /** the locked half alone — Caps Lock and Num Lock (keyboardState) */
+    this.locked = 0;
     this.group = 0;
+    this._layouts = null;
     /** pointer buttons currently held, as an X state mask */
     this.buttonMask = 0;
     this.repeat = { rate: 25, delay: 600 };
@@ -437,6 +440,7 @@ export class WaylandSeat extends EventEmitter {
             : null;
         this.keymap = { format, size, text };
         this.xkb = text ? XkbKeymap.parse(text) : null;
+        this._layouts = null;
         this.emit('keymap', this.keymap, this.xkb);
       } catch (err) {
         this.emit(
@@ -473,6 +477,7 @@ export class WaylandSeat extends EventEmitter {
     k.on('modifiers', (serial, depressed, latched, locked, group) => {
       this.lastSerial = serial;
       this.mods = (depressed | latched | locked) & 0xff;
+      this.locked = locked;
       this.group = group;
       this.emit('modifiers', {
         mods: this.mods,
@@ -501,6 +506,28 @@ export class WaylandSeat extends EventEmitter {
     });
   }
 
+  /**
+   * The locks and the layout, in `useKeyboardState()`'s shape
+   * (src/keyboardstate.js). Caps Lock is Lock, which no keymap can move;
+   * Num Lock is wherever this keymap binds the virtual `NumLock`, with the
+   * X convention's Mod2 where it does not say.
+   *
+   * Only as fresh as the last `wl_keyboard.modifiers`, and a compositor sends
+   * those to the client with keyboard focus alone: a lock toggled while
+   * another app has the keyboard arrives when focus comes back. That is the
+   * protocol, not a shortcut — X11's StateNotify reaches every client.
+   */
+  keyboardState() {
+    const numLock = this.xkb?.maskOf('NumLock') || REAL_MODS.Mod2;
+    this._layouts ??= Object.freeze(layoutsFromKeymap(this.keymap?.text));
+    return {
+      capsLock: Boolean(this.locked & REAL_MODS.Lock),
+      numLock: Boolean(this.locked & numLock),
+      group: this.group,
+      layouts: this._layouts,
+    };
+  }
+
   /** A key event in the shape events.js reads, decoded against the keymap. */
   _keyEvent(type, keycode, time, serial, repeat = false) {
     const state = XkbKeymap.stateOf(this.mods, this.group);

package/src/wayland/swapchain.js

@@ -191,6 +191,17 @@ export class WaylandSwapchain {
 
   /** Give the chain buffers of this size, keeping its GBM surface. */
   _resize(w, h) {
+    // The size they already are keeps them: x11-dri makes nothing again and
+    // moves no generation, so the wl_buffers stay too. Dropped, the next
+    // swap answered a buffer the compositor already had — `isNew: false`, no
+    // descriptor — that this chain no longer knew, and imported it with
+    // none. A small surface asks for this on every change of size: `slackFor`
+    // rounds both sides up to the same 128. What each buffer holds is of the
+    // old size, so all of it is owed.
+    if (w === this.allocWidth && h === this.allocHeight) {
+      for (const entry of this.buffers.values()) entry.damage = 'all';
+      return;
+    }
     // In place: the handle stays valid, the context keeps its GL objects and
     // stays current. Buffers from the old generation are gone, so their
     // `wl_buffer`s go with them — the compositor may still be showing one, so
@@ -299,6 +310,18 @@ export class WaylandSwapchain {
       return true;
     }
     this._swapsSinceNew = 0;
+    if (!out.isNew) {
+      // GBM exported this one already, so it carries no descriptor, and the
+      // chain has no wl_buffer for it: the two have lost track of each
+      // other, which no compositor did.
+      this._fail(
+        new Error(
+          `GPU buffer ${id} came round again with no wl_buffer for it ` +
+            '(react-x11 bug: the swapchain dropped a buffer GBM still holds)',
+        ),
+      );
+      return false;
+    }
     return await this._import(id, out, generation, damage);
   }
 

package/src/wayland/xkb.js

@@ -331,6 +331,14 @@ export class XkbKeymap {
     }
   }
 
+  /**
+   * A modifier by name, as the real mask the compositor reports it under —
+   * `'NumLock'` is whichever ModN this keymap binds it to, `'Lock'` is Lock.
+   */
+  maskOf(name) {
+    return this._modMask(name);
+  }
+
   /** A modifier name (real or virtual) as a real mask. */
   _modMask(name) {
     if (name in REAL_MODS) return REAL_MODS[name];
@@ -461,6 +469,135 @@ export class XkbKeymap {
   }
 }
 
+/**
+ * Files the rules add to `xkb_symbols` that are not a layout: the model's
+ * extras (`inet(evdev)`) and every option's (`group(alt_shift_toggle)`,
+ * `compose(rctrl)`). Only consulted where a keymap has one group and so no
+ * group suffix to anchor on.
+ */
+const NOT_LAYOUTS = new Set([
+  'altwin',
+  'capslock',
+  'compose',
+  'ctrl',
+  'eurosign',
+  'fkeys',
+  'grab',
+  'group',
+  'hyper',
+  'inet',
+  'keypad',
+  'kpdl',
+  'level2',
+  'level3',
+  'level5',
+  'nbsp',
+  'parens',
+  'rupeesign',
+  'scrolllock',
+  'shift',
+  'srvr_ctrl',
+  'srvrkeys',
+  'terminate',
+  'typo',
+]);
+
+/** `macintosh_vndr/us(alt)` → `us`: the file, without directory or variant. */
+const fileOf = (token) => token.replace(/\(.*$/, '').replace(/^.*\//, '');
+
+/**
+ * The layout codes a keymap was compiled from — `['us', 'ru']`, what X11
+ * reads out of `_XKB_RULES_NAMES` and what a Wayland client has nothing
+ * like. Pure, and exported for the test.
+ *
+ * The one place a compositor's keymap still says is the **name** of its
+ * `xkb_symbols` section. libxkbcommon names it after the include string the
+ * rules built — `pc+us+ru:2+inet(evdev)+group(alt_shift_toggle)` — with both
+ * `+` and `:` written as `_`:
+ *
+ *     xkb_symbols "pc_us_ru_2_inet(evdev)_group(alt_shift_toggle)" {
+ *       name[1]="English (US)";
+ *       name[2]="Russian";
+ *
+ * The rules put the model's file first, then the layouts in order — each one
+ * after the first followed by its group number — then the model's extras and
+ * the options. So group N is the file right before the bare `N`, group 1 is
+ * the file right before group 2, and with a single group it is the file
+ * before the first extra. `name[N]` is how many groups there are, and an
+ * answer that cannot account for every one of them is no answer: the list
+ * comes back empty, which is what "not known" means in src/keyboardstate.js.
+ *
+ * The `name[N]` strings are not the answer themselves: they are
+ * descriptions, `"Russian"`, where an indicator wants `ru` — the same reason
+ * the X11 path reads the rules rather than XKB's group names.
+ */
+export function layoutsFromKeymap(text) {
+  if (typeof text !== 'string') return [];
+  const at = text.search(/xkb_symbols\s+"/);
+  if (at < 0) return [];
+  const section = text.slice(at);
+  const name = /^xkb_symbols\s+"([^"]*)"/.exec(section)?.[1];
+  let groups = 0;
+  for (const m of section.matchAll(/\bname\[(?:group)?(\d+)\]\s*=/gi)) {
+    groups = Math.max(groups, Number(m[1]));
+  }
+  if (!name || !groups || groups > 4) return [];
+
+  const tokens = splitIncludes(name);
+  const layouts = [];
+  if (groups === 1) {
+    let i = tokens.findIndex((t, n) => n > 0 && NOT_LAYOUTS.has(fileOf(t)));
+    if (i < 0) i = tokens.length;
+    if (i < 2) return [];
+    layouts.push(tokens[i - 1]);
+  } else {
+    let prev = -1;
+    for (let g = 2; g <= groups; g++) {
+      const i = tokens.indexOf(String(g), prev + 1);
+      if (i < 2) return [];
+      if (g === 2) layouts.push(tokens[i - 2]);
+      layouts.push(tokens[i - 1]);
+      prev = i;
+    }
+  }
+  const codes = layouts.map(fileOf);
+  if (codes.some((c) => !/^[a-z][a-z0-9-]*$/i.test(c) || NOT_LAYOUTS.has(c))) {
+    return [];
+  }
+  // `empty` is what a keymap with no layout to name is built from; reporting
+  // it would put "EMPTY" in an indicator (the X11 path drops it too)
+  return codes.every((c) => c === 'empty') ? [] : codes;
+}
+
+/**
+ * `pc_us(dvorak)_ru(phonetic_winkeys)_2` → `['pc', 'us(dvorak)',
+ * 'ru(phonetic_winkeys)', '2']`. Split where a `_`, `+` or `:` stands outside
+ * parentheses — the raw include string spells them that way, and a
+ * variant's own underscores are inside them. Two file names have an
+ * underscore of their own, the `*_vndr/` directories and `srvr_ctrl`, and are
+ * kept whole.
+ */
+function splitIncludes(name) {
+  const guarded = name
+    .replace(/([a-z0-9]+)_vndr\//gi, '$1\u0001vndr/')
+    .replace(/srvr_ctrl/g, 'srvr\u0001ctrl');
+  const out = [];
+  let depth = 0;
+  let cur = '';
+  for (const ch of guarded) {
+    if (ch === '(') depth++;
+    else if (ch === ')') depth = Math.max(0, depth - 1);
+    if (depth === 0 && (ch === '_' || ch === '+' || ch === ':')) {
+      if (cur) out.push(cur);
+      cur = '';
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur) out.push(cur);
+  return out.map((t) => t.replaceAll('\u0001', '_'));
+}
+
 /**
  * `XkbKSIsKeypad`: the one run of keysyms the keypad produces, `KP_Space`
  * through `KP_Equal`. Every keypad key is in it on both of its levels — the