react-x11 2.15.3 → 2.16.1

package/src/wayland/xkb.js

@@ -19,8 +19,10 @@
 //   xkb_symbols    `key <AD01> { [ q, Q ] };`     keycode -> keysyms per level,
 //                  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
+//   xkb_compat     `interpret ISO_Level3_Shift { virtualModifier= LevelThree;
+//                     useModMapMods= level1; }`  keysym -> virtual modifier,
+//                                                and which of a key's symbols
+//                                                may name it
 //
 // From the last two, a virtual modifier like `LevelThree` resolves to the
 // real modifier bit the compositor will actually report in
@@ -29,8 +31,10 @@
 // that does not say.
 //
 // What is not read: key actions (the compositor applies those; we only see
-// their effect in the modifier state), indicators, geometry, and the
-// per-type `preserve` rules.
+// their effect in the modifier state), indicators and geometry. The per-type
+// `preserve` rules *are* read, for the one thing they decide here: whether
+// Caps Lock still has a capitalisation to do after the type has chosen a
+// level (`_capitalises`).
 //
 // The output is two things. `keycode2keysyms` is the X core shape —
 // `[g1l1, g1l2, g2l1, g2l2, …]` — because that is what `keyboard.js`'s
@@ -38,7 +42,7 @@
 // `decode()` is the full answer, using the key's real type so that level 3
 // and 4 (AltGr) resolve where the two-level core shape cannot express them.
 
-import { charOf } from '../keysyms.js';
+import { charOf, keysymToUpper } from '../keysyms.js';
 import { keysymFromName } from './keysymnames.js';
 
 /** Real modifier bits, as X and XKB both number them. */
@@ -135,7 +139,7 @@ export class XkbKeymap {
     while ((m = re.exec(s))) {
       const body = balanced(s, m.index + m[0].length - 1);
       re.lastIndex = m.index + m[0].length + body.length;
-      const type = { name: m[1], mods: [], map: [], levels: 1 };
+      const type = { name: m[1], mods: [], map: [], preserve: [], levels: 1 };
       const mods = body.match(/modifiers\s*=\s*([^;]+);/);
       if (mods)
         type.mods = mods[1]
@@ -153,6 +157,17 @@ export class XkbKeymap {
         type.map.push({ set, level });
         if (level > type.levels) type.levels = level;
       }
+      // `preserve[Lock+LevelThree]= Lock;` — the modifiers this state does
+      // *not* consume, which is the whole of whether Caps Lock still applies
+      // on a key whose type otherwise swallows Lock.
+      for (const e of body.matchAll(/preserve\[([^\]]+)\]\s*=\s*([^;]+);/gi)) {
+        const split = (x) =>
+          x
+            .split('+')
+            .map((y) => y.trim())
+            .filter((y) => y && y !== 'none' && y !== 'None');
+        type.preserve.push({ set: split(e[1]), kept: split(e[2]) });
+      }
       for (const e of body.matchAll(/level_name\[(?:Level)?(\d+)\]/gi)) {
         if (+e[1] > type.levels) type.levels = +e[1];
       }
@@ -161,6 +176,10 @@ export class XkbKeymap {
   }
 
   _parseCompat(s) {
+    // `interpret.useModMapMods= AnyLevel;` — the section default, which every
+    // keymap states, and which an interpretation overrides for itself.
+    const dflt = s.match(/interpret\.useModMapMods\s*=\s*([A-Za-z0-9_]+)/i);
+    const level1 = (word) => /^level(?:1|One)$/i.test(word ?? '');
     // interpret <keysym>[+cond] { virtualModifier= X; ... }
     const re = /interpret\s+([A-Za-z0-9_]+)(?:\+[^{]*)?\s*\{/g;
     let m;
@@ -170,7 +189,12 @@ export class XkbKeymap {
       const vm = body.match(/virtualModifier\s*=\s*([A-Za-z0-9_]+)/i);
       if (!vm) continue;
       const sym = keysymFromName(m[1]);
-      if (sym) (this._interp ??= new Map()).set(sym, vm[1]);
+      if (!sym) continue;
+      const umm = body.match(/useModMapMods\s*=\s*([A-Za-z0-9_]+)/i);
+      (this._interp ??= new Map()).set(sym, {
+        vmod: vm[1],
+        level1Only: level1(umm ? umm[1] : dflt?.[1]),
+      });
     }
   }
 
@@ -256,24 +280,51 @@ export class XkbKeymap {
   }
 
   /**
-   * Virtual modifier -> real modifier: the keys whose keysym `interpret`
-   * binds to the virtual modifier are looked up in `modifier_map`, and the
-   * real bits found there are the answer.
+   * Virtual modifier -> real modifier: a key's `interpret`ed keysyms name the
+   * virtual modifiers the key sets, and the key's `modifier_map` bits are
+   * what those virtual modifiers turn out to mean.
+   *
+   * Which of a key's keysyms may name one is `useModMapMods`, and it is the
+   * whole of AltGr working. `<RALT>` sits in `modifier_map Mod1` beside the
+   * other Alt keys and *also* carries `ISO_Level3_Shift`, on a secondary
+   * group or a second level:
+   *
+   *     key <RALT> { type= "ONE_LEVEL", symbols[1]= [ Alt_R ],
+   *                                     symbols[2]= [ ISO_Level3_Shift ] };
+   *     modifier_map Mod1 { <LALT>, <RALT>, <ALT>, <META> };
+   *     modifier_map Mod5 { <LVL3> };
+   *
+   * Attributing a key's bits to every keysym on it collected Mod1 from
+   * `<RALT>` on top of Mod5 from `<LVL3>`, so `LevelThree` resolved to
+   * `Mod1|Mod5` — and since `_levelFor` matches the masked state for
+   * equality, a real AltGr press (Mod5 alone) never reached level 3. AltGr
+   * did nothing and the third and fourth level of every layout were
+   * unreachable. `useModMapMods= level1`, which is what the keymap says for
+   * `ISO_Level3_Shift`, means a key contributes only where the keysym is its
+   * **primary** symbol — group 1, level 1 — and `<RALT>`'s primary symbol is
+   * `Alt_R`, so it never should have contributed.
    */
   _resolveVmods() {
-    const bySym = new Map(); // keysym -> real mask, from modmap via symbols
+    const bind = (vmod, bits) =>
+      this.vmods.set(vmod, (this.vmods.get(vmod) ?? 0) | bits);
     for (const [code, key] of this.keys) {
       const bits = this.modmap.get(code);
       if (!bits) continue;
-      for (const g of key.groups)
-        for (const sym of g?.syms ?? [])
-          if (sym) bySym.set(sym, (bySym.get(sym) ?? 0) | bits);
+      for (let gi = 0; gi < key.groups.length; gi++) {
+        const syms = key.groups[gi]?.syms ?? [];
+        for (let li = 0; li < syms.length; li++) {
+          const interp = syms[li] && this._interp?.get(syms[li]);
+          if (!interp) continue;
+          if (interp.level1Only && (gi || li)) continue;
+          bind(interp.vmod, bits);
+        }
+      }
     }
-    for (const { sym, bit } of this._modmapSyms ?? [])
-      bySym.set(sym, (bySym.get(sym) ?? 0) | bit);
-    for (const [sym, vmod] of this._interp ?? []) {
-      const real = bySym.get(sym);
-      if (real) this.vmods.set(vmod, (this.vmods.get(vmod) ?? 0) | real);
+    // `modifier_map Shift { Shift_L };` — the bare-keysym form names no key,
+    // so there is no level to test it against.
+    for (const { sym, bit } of this._modmapSyms ?? []) {
+      const interp = this._interp?.get(sym);
+      if (interp) bind(interp.vmod, bit);
     }
     for (const [name, bit] of Object.entries(VMOD_FALLBACK)) {
       if (!this.vmods.has(name)) this.vmods.set(name, bit);
@@ -286,6 +337,13 @@ export class XkbKeymap {
     return this.vmods.get(name) ?? 0;
   }
 
+  /** A list of modifier names as one real mask. */
+  _maskOf(names) {
+    let mask = 0;
+    for (const name of names) mask |= this._modMask(name);
+    return mask;
+  }
+
   /**
    * The X core keyboard mapping — two keysyms per group, up to four groups —
    * which is what `GetKeyboardMapping` would have answered.
@@ -319,17 +377,37 @@ export class XkbKeymap {
    */
   _levelFor(type, mods) {
     if (!type) return mods & REAL_MODS.Shift ? 1 : 0;
-    let relevant = 0;
-    for (const m of type.mods) relevant |= this._modMask(m);
+    const relevant = this._maskOf(type.mods);
     const masked = mods & relevant;
     for (const { set, level } of type.map) {
-      let want = 0;
-      for (const m of set) want |= this._modMask(m);
-      if (want === masked) return level - 1;
+      if (this._maskOf(set) === masked) return level - 1;
     }
     return 0;
   }
 
+  /**
+   * Whether Caps Lock still has a capitalisation to do.
+   *
+   * XKB's rule: Lock is effective, and the key's type did not **consume** it.
+   * A type that names Lock among its modifiers consumed it — `ALPHABETIC`'s
+   * `map[Lock]= 2` has already picked the level Caps Lock wanted, and
+   * capitalising on top would be doing it twice. Unless the type says
+   * otherwise: `preserve[Lock+LevelThree]= Lock` hands Lock back, which is how
+   * German's AltGr levels capitalise (`ſ` -> `S`) while its Shift levels,
+   * reached through `map[Lock]`, do not.
+   */
+  _capitalises(type, mods) {
+    if (!(mods & REAL_MODS.Lock)) return false;
+    if (!type) return true;
+    const relevant = this._maskOf(type.mods);
+    if (!(relevant & REAL_MODS.Lock)) return true;
+    const masked = mods & relevant;
+    for (const { set, kept } of type.preserve)
+      if (this._maskOf(set) === masked)
+        return (this._maskOf(kept) & REAL_MODS.Lock) !== 0;
+    return false;
+  }
+
   /**
    * Decode a key event.
    *
@@ -349,31 +427,17 @@ export class XkbKeymap {
     let level = this._levelFor(g.type, mods);
     if (level >= g.syms.length || !g.syms[level]) {
       // Lock on a one-level key, or Shift on a key with no upper level:
-      // fall back the way the core protocol does — the first symbol,
-      // uppercased when it has a case.
+      // fall back the way the core protocol does, to the first symbol. Any
+      // capitalisation it has coming is the separate step below.
       level = 0;
     }
     let keysym = g.syms[level] ?? 0;
-    // Caps Lock on a plain two-level alphabetic key whose type does not
-    // fold Lock (a keymap with only "TWO_LEVEL" for letters): X core rule.
-    if (
-      level === 0 &&
-      mods & REAL_MODS.Lock &&
-      g.syms.length >= 2 &&
-      !(mods & REAL_MODS.Shift)
-    ) {
-      const lower = charOf(g.syms[0]);
-      const upper = charOf(g.syms[1]);
-      if (
-        lower &&
-        upper &&
-        lower !== upper &&
-        lower.toUpperCase() === upper &&
-        g.type?.mods?.includes('Lock') === false
-      ) {
-        keysym = g.syms[1];
-      }
-    }
+    // Caps Lock capitalises the keysym the type already chose, rather than
+    // reaching for an uppercase sibling level. Pairing levels works for
+    // `[a, A]` and nothing else: AZERTY's `é` key is `[é, 2, ~, ˘]`, where
+    // level 2 is a digit, and German's AltGr `ſ` has no sibling at all — so
+    // `é`, `à`, `è`, `ç`, `ù` and every Cyrillic letter stayed lowercase.
+    if (this._capitalises(g.type, mods)) keysym = keysymToUpper(keysym);
     if (!keysym) return undefined;
     const ch = charOf(keysym);
     const codepoint = ch ? ch.codePointAt(0) : undefined;
@@ -398,24 +462,71 @@ export class XkbKeymap {
 }
 
 /**
- * The type XKB assigns a key that names none: one symbol is ONE_LEVEL, two
- * are ALPHABETIC when they are a case pair and TWO_LEVEL otherwise, four are
- * FOUR_LEVEL(_ALPHABETIC / _SEMIALPHABETIC).
+ * `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
+ * navigation keysym (`KP_Home`) as much as the digit (`KP_7`).
+ */
+function isKeypad(sym) {
+  return sym >= 0xff80 && sym <= 0xffbd;
+}
+
+/**
+ * `XkbKSIsLower` and `XkbKSIsUpper`: a keysym has a case, and is the lower or
+ * the upper one of the pair.
+ *
+ * Two independent questions rather than one pairing — which is the same
+ * mistake `decode()` used to make about Caps Lock, in the one other place it
+ * was made. German's `s` is `[s, S, ſ, ẞ]`, and `ſ` does not *pair* with `ẞ`
+ * (`'ſ'.toUpperCase()` is `'S'`), but `ſ` is a lowercase letter and `ẞ` is an
+ * uppercase one, which is all the type ladder asks. Pairing them made the key
+ * FOUR_LEVEL_SEMIALPHABETIC, whose `preserve[Lock+LevelThree]` hands Lock back
+ * — so Caps+AltGr capitalised a level that was already capital.
+ */
+function isLower(sym) {
+  const ch = charOf(sym);
+  return !!ch && ch.toLowerCase() === ch && ch.toUpperCase() !== ch;
+}
+function isUpper(sym) {
+  const ch = charOf(sym);
+  return !!ch && ch.toUpperCase() === ch && ch.toLowerCase() !== ch;
+}
+
+/**
+ * The type XKB assigns a key that names none — xkbcomp's `FindAutomaticType`,
+ * which libxkbcommon inherits. Two symbols are ALPHABETIC when they are a
+ * case pair, **KEYPAD when either of them is a keypad keysym**, and TWO_LEVEL
+ * otherwise; three or four are the FOUR_LEVEL family along the same ladder.
+ *
+ * The keypad rung is not decoration: libxkbcommon writes the keypad bare —
+ * `key <KP7> { [ KP_Home, KP_7 ] };` — so *every* keypad key lands here, and
+ * `[KP_Home, KP_7]` is not a case pair. Without the rung it fell through to
+ * TWO_LEVEL, whose `map[Shift]= 2` puts the digit on Shift and leaves NumLock
+ * with nothing to do, which inverted the whole keypad: the digits typed
+ * `KP_Home`/`KP_Up`/`KP_End` and moved the cursor, and holding Shift is what
+ * produced a number. The keymap's own KEYPAD type — `modifiers= Shift+NumLock;
+ * map[NumLock]= 2;` — is the one that belongs.
  */
 function implicitType(syms) {
-  const n = syms.filter(Boolean).length;
+  // The width is the length of the list with only *trailing* NoSymbols
+  // trimmed, which is how libxkbcommon counts it. A NoSymbol in the middle
+  // is a level that types nothing, not an absent one: counting the non-zero
+  // entries instead made `key <ALT> { [ NoSymbol, Alt_L ] };` a one-level key
+  // whose only level was NoSymbol, so <ALT>, <META>, <SUPR> and <HYPR>
+  // decoded to nothing in every modifier state.
+  let n = syms.length;
+  while (n > 0 && !syms[n - 1]) n--;
   if (n <= 1) return 'ONE_LEVEL';
-  const casePair = (a, b) => {
-    const la = charOf(a);
-    const lb = charOf(b);
-    return la && lb && la !== lb && la.toUpperCase() === lb;
-  };
-  if (n === 2) return casePair(syms[0], syms[1]) ? 'ALPHABETIC' : 'TWO_LEVEL';
-  if (casePair(syms[0], syms[1]))
-    return casePair(syms[2], syms[3])
+  const cased = (a, b) => isLower(a) && isUpper(b);
+  const keypad = isKeypad(syms[0]) || isKeypad(syms[1]);
+  if (n === 2) {
+    if (cased(syms[0], syms[1])) return 'ALPHABETIC';
+    return keypad ? 'KEYPAD' : 'TWO_LEVEL';
+  }
+  if (cased(syms[0], syms[1]))
+    return cased(syms[2], syms[3])
       ? 'FOUR_LEVEL_ALPHABETIC'
       : 'FOUR_LEVEL_SEMIALPHABETIC';
-  return 'FOUR_LEVEL';
+  return keypad ? 'FOUR_LEVEL_KEYPAD' : 'FOUR_LEVEL';
 }
 
 /** Everything from `//` or `#` to the end of the line, outside strings. */

package/src/windowid.js

@@ -105,8 +105,54 @@ export function topLevelWindows(app) {
   );
 }
 
+/**
+ * The root-level `<popup>`s this connection is currently rendering — the
+ * half `topLevelWindows()` leaves out, in the order they were added.
+ *
+ * Only interesting when there are no top-level windows at all: a menu-bar
+ * app whose whole UI is a popover a tray click opens has no `<window>` for
+ * anything to belong to, and the popup *is* the top of that tree
+ * (`useTopLevelWindow`). With a window in the tree these stay out of it, for
+ * the reason they are out of `topLevelWindows()` — override-redirect is
+ * never what a dialog should be transient for.
+ */
+function rootLevelPopups(app) {
+  if (!app) return [];
+  return (app._rootChildren ?? []).filter(
+    (node) => node?.isWindow && node.isPopup && node.window?.id,
+  );
+}
+
 let warnedAboutAmbiguity = false;
 
+/**
+ * One of several candidates, on the inference `useTopLevelWindow` documents:
+ * one is exact, uniquely focused wins, and anything else is the most
+ * recently opened plus a development warning that says so.
+ */
+function pickOwner(candidates, what) {
+  if (candidates.length <= 1) return candidates[0] ?? null;
+
+  const focused = candidates.filter((w) => w.events?.windowFocused);
+  if (focused.length === 1) return focused[0];
+
+  // Nothing separates them. `windowFocused` also defaults to true on an
+  // ntk too old to report focus changes, so "all of them" is the same
+  // answer as "none of them" and both land here.
+  if (process.env.NODE_ENV !== 'production' && !warnedAboutAmbiguity) {
+    warnedAboutAmbiguity = true;
+    console.warn(
+      `react-x11: this tree has ${candidates.length} ${what}, none of them ` +
+        'uniquely focused, so the owner window is a guess (the most ' +
+        'recently opened). Pass the window explicitly to be exact:\n' +
+        '  const win = useRef(null);\n' +
+        '  const { openFile } = useFileDialog({ parentWindow: win });\n' +
+        '  return <window ref={win}>…</window>;',
+    );
+  }
+  return candidates[candidates.length - 1];
+}
+
 /**
  * The window a component belongs to, resolved when it is read.
  *
@@ -134,6 +180,13 @@ let warnedAboutAmbiguity = false;
  * - several with nothing to separate them: the most recently opened, and a
  *   development warning naming `parentWindow` as the way to be exact. A
  *   guess that says it is guessing beats a guess that does not.
+ * - **no top-level window at all: the root-level `<popup>` that has the
+ *   keyboard.** A menu-bar app is a tray item and a popover, and nothing
+ *   else — there is no `<window>` for a shortcut, a file dialog or the
+ *   global menu to belong to, and answering `null` made every one of them
+ *   quietly do nothing (issue #616). A `grabKeyboard` popup is where the
+ *   keys are by construction, so it is preferred over one that is merely
+ *   up; among equals the same focus/most-recent inference applies.
  *
  * Returns a **ref-like object** rather than a number: the window is not
  * realized on the first render, so a value read then would be `null` on the
@@ -146,27 +199,16 @@ export function useTopLevelWindow() {
     () => ({
       get current() {
         const windows = topLevelWindows(app);
-        if (windows.length <= 1) return windows[0] ?? null;
-
-        const focused = windows.filter((w) => w.events?.windowFocused);
-        if (focused.length === 1) return focused[0];
+        if (windows.length) return pickOwner(windows, 'top-level windows');
 
-        // Nothing separates them. `windowFocused` also defaults to true on an
-        // ntk too old to report focus changes, so "all of them" is the same
-        // answer as "none of them" and both land here.
-        if (process.env.NODE_ENV !== 'production' && !warnedAboutAmbiguity) {
-          warnedAboutAmbiguity = true;
-          console.warn(
-            `react-x11: this tree has ${windows.length} top-level windows and ` +
-              'none of them is uniquely focused, so the owner window is a ' +
-              'guess (the most recently opened). Pass the window explicitly ' +
-              'to be exact:\n' +
-              '  const win = useRef(null);\n' +
-              '  const { openFile } = useFileDialog({ parentWindow: win });\n' +
-              '  return <window ref={win}>…</window>;',
-          );
-        }
-        return windows[windows.length - 1];
+        // A popup-only tree — the tray popover. Not reached while the app
+        // has a window, so nothing that already worked changes shape.
+        const popups = rootLevelPopups(app);
+        const keyboard = popups.filter((node) => node.props?.grabKeyboard);
+        return pickOwner(
+          keyboard.length ? keyboard : popups,
+          'root-level popups and no window at all',
+        );
       },
     }),
     [app],