react-x11 2.39.0 → 2.41.0

package/src/components/PasswordInput.js

@@ -4,7 +4,7 @@
 
 import React, { useEffect, useRef, useState } from 'react';
 import { createStyles } from '../styles.js';
-import { useClipboard } from '../appcontext.js';
+import { useAppOrNull, useClipboard } from '../appcontext.js';
 import { windowIdOf } from '../windowid.js';
 import { useTheme } from './theme.js';
 import { Icon } from './Icon.js';
@@ -19,6 +19,7 @@ import {
   XK_KP_ENTER,
   XK_RETURN,
   ctrlChordLetter,
+  primaryModifierHeld,
 } from '../keysyms.js';
 
 const h = React.createElement;
@@ -169,6 +170,7 @@ export function PasswordInput({
   const inputRef = useRef(null);
   const hideTimer = useRef(null);
   const clipboard = useClipboard();
+  const app = useAppOrNull();
   const [ownValue, setOwnValue] = useState(defaultValue ?? '');
   const [ownRevealed, setOwnRevealed] = useState(false);
   const [focused, setFocused] = useState(false);
@@ -282,13 +284,16 @@ export function PasswordInput({
       if (ev.shiftKey) paste('CLIPBOARD');
       return;
     }
-    if (ev.ctrlKey) {
+    if (ev.ctrlKey || ev.metaKey) {
       const letter = ctrlChordLetter(ev);
       // Ctrl+U clears the line, as readline and every pinentry on the desktop
-      // do; Ctrl+V pastes. Nothing for C, X or A — there is no selection to
-      // copy, and the secret does not leave by the clipboard.
-      if (letter === CTRL_U) commit('');
-      else if (letter === CTRL_V) paste('CLIPBOARD');
+      // do; Ctrl+V pastes — ⌘V on the Cocoa backend, where ⌃U still clears,
+      // as it does in a Mac terminal. Nothing for C, X or A — there is no
+      // selection to copy, and the secret does not leave by the clipboard.
+      // Any other chord is a command and never a character of the secret.
+      if (letter === CTRL_U && ev.ctrlKey) commit('');
+      else if (letter === CTRL_V && primaryModifierHeld(ev, app))
+        paste('CLIPBOARD');
       return;
     }
     // A printable character and only that: a control code is not text, and

package/src/editmenu.js

@@ -86,6 +86,9 @@ export function editMenuColors(theme) {
 export function editMenuItems(actions = {}, { canPaste = true } = {}) {
   const has = (verb) => typeof actions[verb] === 'function';
   const selected = Boolean(actions.hasSelection);
+  // `Control` is the primary modifier here, as it is in a menu bar's chord:
+  // ⌘ on the Cocoa backend, which is what the editors answer there and what
+  // `editMenuGeometry` prints when it is told so
   const groups = [
     [
       has('undo') && {
@@ -147,8 +150,12 @@ export function editMenuItems(actions = {}, { canPaste = true } = {}) {
  * @param {Array<{id?, label?, shortcut?, type?, enabled?}>} items
  * @param {(text: string) => number|null} [measure] text width, or null when
  *   nothing can be measured yet
+ * @param {number} [scale]
+ * @param {{primary?: 'Control'|'Super'}} [options] the app's primary
+ *   modifier (keysyms.js): `'Super'` prints the shortcuts the Mac way —
+ *   `⌘Z`, `⇧⌘Z` — since ⌘ is what the text controls answer there
  */
-export function editMenuGeometry(items, measure, scale = 1) {
+export function editMenuGeometry(items, measure, scale = 1, { primary } = {}) {
   const widthOf = (text) => {
     if (!text) return 0;
     const w = measure?.(text);
@@ -161,7 +168,7 @@ export function editMenuGeometry(items, measure, scale = 1) {
   let widest = 0;
   for (const item of items) {
     const separator = isSeparator(item);
-    const shortcut = formatShortcut(item.shortcut);
+    const shortcut = formatShortcut(item.shortcut, { primary });
     const height = (separator ? SEPARATOR_HEIGHT : ROW_HEIGHT) * scale;
     rows.push({ ...item, separator, shortcut, y, height });
     y += height;

package/src/events.js

@@ -1672,6 +1672,18 @@ export class EventManager {
         // its ordinary turn.
         if (step.consumed) return;
       }
+      // A key that typed more than one character has no code point to type
+      // them with: a backend whose keyboard layout composes on its own says
+      // so with `text` — the accent and a letter it does not combine with,
+      // `´s` (src/cocoa/keymap.js). Committed the way an input method's text
+      // is, a composition that opens and closes on this key, which is where
+      // an element that types inserts it — and like a composed key, it is
+      // the key's whole answer.
+      if (native.text && target.composes !== false) {
+        this._composition('Start', target, '', native);
+        this._composition('End', target, String(native.text), native);
+        return;
+      }
       // The element's own behaviour first, focus traversal after it — Tab is
       // an ordinary defaultable key rather than one the focus manager eats on
       // the way past. Cycling first meant an editor could only keep Tab as an
@@ -1705,6 +1717,11 @@ export class EventManager {
    *
    * `entry.handle(ev)` answers whether it took the key.
    *
+   * `entry.reserves(ev)`, optional, answers whether something *outside* the
+   * window is going to answer this key whatever we do — the macOS menu
+   * bar's key equivalents (`MenuBar`, delegated). Such a key is spent
+   * before any binding is offered it (`_runAccelerators`).
+   *
    * Registrations live on the **top-level** manager, which is the one thing
    * a `<popup>`, a nested `<window>` and the window itself all share — the
    * same grouping `_keyManager` resolves keys through. So a chord reaches
@@ -1740,11 +1757,30 @@ export class EventManager {
    * A menu that is *open* suppresses them by another route entirely: it
    * `preventDefault()`s the keys it is being driven with, one layer above
    * this (`components/Menu.js`).
+   *
+   * And a key one of them *reserves* reaches none of them. The Cocoa bridge
+   * shows us every key before `[NSApp sendEvent:]`, where the menu bar's
+   * key equivalent then runs its item regardless — so a binding here that
+   * answered ⌘S too would be a second command on one key, whichever of the
+   * two mounted last. Neither gate applies to that: the menu bar is not in
+   * the window, and a modal `<popup>` does not take keys from it.
    */
   _runAccelerators(ev) {
     const owner = this.topLevelManager;
     const entries = owner._accelerators;
     if (!entries?.size) return;
+    for (const entry of entries) {
+      let reserved = false;
+      try {
+        reserved = Boolean(entry.reserves?.(ev));
+      } catch (error) {
+        reportHandlerError(entry.anchor(), 'an accelerator', error);
+      }
+      if (reserved) {
+        ev.preventDefault();
+        return;
+      }
+    }
     const scopeRoot = owner._scopeRoot();
     const trapped = scopeRoot !== owner.node;
     for (const entry of [...entries].reverse()) {

package/src/frame/index.js

@@ -192,6 +192,11 @@ function shallowEqual(a, b) {
 
 const EMPTY_PROPS = {};
 
+/** How long a rect sent to a pane that acknowledges sizes waits for its
+ *  `pane-sized` before the newest is sent anyway: a frame of a slow page,
+ *  several times over, so a lost answer costs a pause and not the size. */
+export const PANE_SIZED_WAIT_MS = 500;
+
 /**
  * A module of this application, mounted in its own process, its window
  * embedded here.
@@ -552,7 +557,54 @@ function PaneHostView({
     // moves when the box does and when the window does, so it is sent on
     // layout, on a scroll that shifts the box, and on every anchor change
     // of the window, which a move of the window is.
+    //
+    // **The newest rect wins.** A drag sends the host a size a frame, and a
+    // pane whose page takes longer than that to lay out was sent them
+    // faster than it could take them: a pipe hands a pane process one
+    // message a turn of its loop, with a frame in between, so the pane laid
+    // out and painted every size the drag passed through, one a frame, and
+    // went on resizing seconds after the edge stopped. A pane that says it
+    // has painted a size (`pane-sized`) is sent one rect at a time: what
+    // the host comes to while one is out replaces what was waiting, and goes
+    // when the pane says it has painted the last. A pane that never says so
+    // is sent every rect, as before, and one that goes quiet is sent the
+    // newest anyway after `PANE_SIZED_WAIT_MS`.
     let sent = null;
+    let pending = null;
+    let acks = false;
+    let inFlight = false;
+    let waiting = null;
+    const transmit = (rect) => {
+      sent = rect;
+      s.trySend?.({
+        type: 'pane-rect',
+        width: rect.width,
+        height: rect.height,
+        scale: rect.scale,
+        ...(rect.screen && { screen: rect.screen }),
+      });
+      if (!acks) return;
+      inFlight = true;
+      if (waiting) clearTimeout(waiting);
+      waiting = setTimeout(sized, PANE_SIZED_WAIT_MS);
+    };
+    const sameRect = (a, b) =>
+      !!a &&
+      !!b &&
+      a.width === b.width &&
+      a.height === b.height &&
+      a.scale === b.scale &&
+      a.screen?.x === b.screen?.x &&
+      a.screen?.y === b.screen?.y;
+    const sized = () => {
+      if (waiting) clearTimeout(waiting);
+      waiting = null;
+      inFlight = false;
+      const next = pending;
+      pending = null;
+      // a drag that came back to where it was sent from waits for nothing
+      if (next && !sameRect(next, sent)) transmit(next);
+    };
     const syncSize = () => {
       host.setRect(node.abs);
       const sc = node.scale ?? 1;
@@ -565,23 +617,10 @@ function PaneHostView({
             y: Math.round(origin.y + node.abs.y),
           }
         : null;
-      if (
-        sent &&
-        sent.width === width &&
-        sent.height === height &&
-        sent.screen?.x === screen?.x &&
-        sent.screen?.y === screen?.y
-      ) {
-        return;
-      }
-      sent = { width, height, screen };
-      s.trySend?.({
-        type: 'pane-rect',
-        width,
-        height,
-        scale: sc,
-        ...(screen && { screen }),
-      });
+      const rect = { width, height, scale: sc, screen };
+      if (sameRect(rect, pending ?? sent)) return;
+      if (inFlight) pending = rect;
+      else transmit(rect);
     };
     const origAbsolutize = node.absolutize.bind(node);
     node.absolutize = (ox, oy) => {
@@ -624,7 +663,12 @@ function PaneHostView({
         host.windowCursor?.(msg);
       } else if (msg?.type === 'pane-present') {
         host.setRect(node.abs);
-        host.present(msg.id);
+        host.present(msg.id, msg);
+      } else if (msg?.type === 'pane-sized') {
+        // the pane has painted the rect it was last sent: the newest one
+        // waiting goes now, and from here on one is out at a time
+        acks = true;
+        sized();
       } else if (msg?.type === 'pane-cursor') {
         // The pane names its cursor as an element that draws names one for
         // a point: this box is the node the host's pointer is over, so the
@@ -637,6 +681,8 @@ function PaneHostView({
     });
     return () => {
       off();
+      if (waiting) clearTimeout(waiting);
+      waiting = null;
       offAnchor?.();
       offFocus?.();
       node.defaultCursor = undefined;

package/src/globalmenu.js

@@ -54,7 +54,7 @@
 // third-party menus consume dbusmenu. A second exporter is roughly double the
 // work for no consumer that the first one does not already reach.
 
-import { useEffect, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 import { loadTransport, sessionBus } from './bus.js';
 import { desktopIntegrationEnabled } from './desktopintegration.js';
@@ -539,7 +539,20 @@ export function _resetGlobalMenuState() {
  * it. It is exported for a component that draws its own bar and wants the
  * same behaviour.
  */
-export function useGlobalMenu(
+export function useGlobalMenu(menus, options) {
+  return useGlobalMenuExport(menus, options).delegated;
+}
+
+/**
+ * `useGlobalMenu`, with the one more thing `MenuBar` needs to know about the
+ * delegate: which shortcuts it answers by itself. A panel answers none — it
+ * draws the rows, and the key is pressed in our window — but the macOS menu
+ * bar answers the ⌘ chords it holds as key equivalents, and a bar that
+ * matched them as well would run the item twice
+ * (`CocoaGlobalMenuExport.answersShortcut`). Read at key time, so it is
+ * whatever delegate is live then. Not public.
+ */
+export function useGlobalMenuExport(
   menus,
   { onSelect, onAboutToShow, enabled = true } = {},
 ) {
@@ -586,5 +599,10 @@ export function useGlobalMenu(
     exportRef.current?.update(menus ?? []);
   }, [menus]);
 
-  return enabled && exported;
+  const answersShortcut = useCallback(
+    (shortcut) => Boolean(exportRef.current?.answersShortcut?.(shortcut)),
+    [],
+  );
+
+  return { delegated: enabled && exported, answersShortcut };
 }

package/src/index.d.ts

@@ -290,7 +290,10 @@ export interface RootOptions {
    * `resizeWait` is how long, in ms, AppKit may hold a live-resize tick for
    * the app's frame at the new size under `react-x11/cocoa-main`, where
    * the frame is painted on another thread (50 by default; 0 lets the edge
-   * move without waiting).
+   * move without waiting). A `<Frame>` pane's frames of a new size are held
+   * to it as well: within it, the pane's last frame stays at its size while
+   * the next comes, and past it, it is stretched to the pane's new size, as
+   * every one is at 0.
    * `screenPoll` is how often the screen layout is re-read while a
    * {@link useScreens} subscriber is mounted, in ms — 500 by default, 0 for
    * never. macOS has no event for a display plugged in, unplugged or

package/src/keysyms.d.ts

@@ -50,6 +50,36 @@ export function ctrlChordLetter(ev: {
   codepoint?: number | null;
 }): number | null;
 
+/** The modifier token a shortcut's primary means, in a menu `shortcut`'s
+ * vocabulary. */
+export type PrimaryModifier = 'Control' | 'Super';
+
+/**
+ * The modifier this app's shortcuts are pressed with: `'Super'` — ⌘ — where
+ * the backend says so (the Cocoa app does, as `app.primaryModifier`), and
+ * `'Control'` everywhere else. A backend fact, not a platform one: an X11
+ * app under XQuartz keeps Ctrl, like every other X client on that display.
+ */
+export function primaryModifier(
+  app?: { primaryModifier?: PrimaryModifier } | null,
+): PrimaryModifier;
+
+/**
+ * Is the primary modifier down for this event — ⌘ on the Cocoa backend, Ctrl
+ * everywhere else? What the built-in editors test before their
+ * Undo/Cut/Copy/Paste/Select All chords, so the keys the edit menu prints
+ * are the keys that do it.
+ *
+ * ```js
+ * if (primaryModifierHeld(ev, node.app) && ctrlChordLetter(ev) === keysymOf('d'))
+ *   duplicateLine();
+ * ```
+ */
+export function primaryModifierHeld(
+  ev: { ctrlKey?: boolean; metaKey?: boolean } | null | undefined,
+  app?: { primaryModifier?: PrimaryModifier } | null,
+): boolean;
+
 /**
  * The keysym an X11 key *name* stands for — `'Return'`, `'plus'`, `'F5'`,
  * `'s'` — or `undefined` for a name nothing here knows.

package/src/keysyms.js

@@ -247,6 +247,35 @@ export function ctrlChordLetter(ev) {
   return code >= 0x41 && code <= 0x5a ? code + 0x20 : code;
 }
 
+/**
+ * The modifier this app's shortcuts are pressed with: `'Super'` — ⌘ — where
+ * the backend says so (the Cocoa app does, as `app.primaryModifier`), and
+ * `'Control'` everywhere else.
+ *
+ * A backend fact, not a platform one: an X11 app under XQuartz keeps Ctrl,
+ * which is what every other X client on that display answers to.
+ */
+export function primaryModifier(app) {
+  return app?.primaryModifier === 'Super' ? 'Super' : 'Control';
+}
+
+/**
+ * Is the primary modifier down for this event — ⌘ on the Cocoa backend,
+ * Ctrl everywhere else? The test the built-in editors put in front of their
+ * Undo/Cut/Copy/Paste/Select All chords, so the keys the edit menu prints
+ * beside each row are the keys that do it.
+ *
+ * ```js
+ * if (primaryModifierHeld(ev, node.app) && ctrlChordLetter(ev) === keysymOf('d'))
+ *   duplicateLine();
+ * ```
+ */
+export function primaryModifierHeld(ev, app) {
+  return primaryModifier(app) === 'Super'
+    ? Boolean(ev?.metaKey)
+    : Boolean(ev?.ctrlKey);
+}
+
 /**
  * The X11 modifier mask bits, as they arrive on `ev.nativeEvent.buttons`
  * and as `fireEvent` takes them. Bit 3 (Mod1) is Alt and bit 6 (Mod4) is

package/src/menuitem.js

@@ -112,21 +112,62 @@ const KEY_LABELS = {
   Next: 'PgDn',
 };
 
+// The Mac prints a chord as glyphs, in one fixed order whatever order the
+// chord was written in — ⌃⌥⇧⌘ — and with nothing between them: `⇧⌘Z`, never
+// `Cmd+Shift+Z`. `Control` and `Super` are both ⌘ there, for the reason
+// `primaryModifier` gives below: a cross-platform chord is written in the
+// primary modifier, and the Mac's is Command.
+const MAC_MODIFIER_ORDER = ['Alt', 'Shift', 'Command'];
+const MAC_MODIFIER_GLYPHS = { Alt: '⌥', Shift: '⇧', Command: '⌘' };
+
+// The keys a Mac menu draws as a glyph rather than a word. The rest are
+// `KEY_LABELS`' answer, which is already the Mac's for punctuation.
+const MAC_KEY_LABELS = {
+  Return: '↩',
+  KP_Enter: '⌤',
+  Tab: '⇥',
+  BackSpace: '⌫',
+  Delete: '⌦',
+  Escape: '⎋',
+  Left: '←',
+  Right: '→',
+  Up: '↑',
+  Down: '↓',
+  Prior: '⇞',
+  Next: '⇟',
+  Home: '↖',
+  End: '↘',
+};
+
+const keyLabel = (key, labels) =>
+  labels[key] ??
+  KEY_LABELS[key] ??
+  (key.length === 1 ? key.toUpperCase() : key);
+
 /**
  * One `aas` alternative — `['Control', 'S']` — as the string a menu row
- * shows: `Ctrl+S`.
+ * shows: `Ctrl+S`, or `⌘S` where the primary modifier is ⌘.
  *
  * A single-character key is upper-cased because that is how every toolkit
  * prints one, and because dbusmenu carries the *key*, not the character it
  * types: `['Control', 's']` and `['Control', 'S']` are the same binding and
  * must not render differently.
  */
-function formatChord(chord) {
+function formatChord(chord, primary) {
   const { modifiers, key } = splitChord(chord);
-  const parts = [...modifiers].map((token) => MODIFIER_LABELS[token]);
-  if (key != null) {
-    parts.push(KEY_LABELS[key] ?? (key.length === 1 ? key.toUpperCase() : key));
+  if (primary === 'Super') {
+    const held = new Set(
+      [...modifiers].map((token) =>
+        token === 'Control' || token === 'Super' ? 'Command' : token,
+      ),
+    );
+    const glyphs = MAC_MODIFIER_ORDER.filter((token) => held.has(token))
+      .map((token) => MAC_MODIFIER_GLYPHS[token])
+      .join('');
+    return glyphs + (key == null ? '' : keyLabel(key, MAC_KEY_LABELS));
   }
+  const parts = [...modifiers].map((token) => MODIFIER_LABELS[token]);
+  if (key != null) parts.push(keyLabel(key, {}));
   return parts.join('+');
 }
 
@@ -137,11 +178,14 @@ function formatChord(chord) {
  * modifier tokens ending in the key. Only the first alternative is drawn —
  * a row has one shortcut column, and a menu that printed `Ctrl+S / F2` in it
  * would be wider than the menu for the benefit of the rarer binding.
+ *
+ * `primary` is the app's `primaryModifier` (keysyms.js): `'Super'` draws the
+ * chord the way a Mac menu does, `⇧⌘Z` for `['Control', 'Shift', 'Z']`.
  */
-export function formatShortcut(shortcut) {
+export function formatShortcut(shortcut, { primary = 'Control' } = {}) {
   const first = shortcut?.[0];
   if (!Array.isArray(first) || first.length === 0) return '';
-  return formatChord(first);
+  return formatChord(first, primary);
 }
 
 // What UI Events calls the modifiers, which is what `aria-keyshortcuts` is
@@ -160,19 +204,21 @@ const ARIA_MODIFIERS = {
  * dbusmenu's `aas` already has — so unlike the drawn menu, **every**
  * alternative is announced rather than only the first: a screen reader is
  * reading them out, not fitting them in a column.
+ *
+ * `primary` is `formatShortcut`'s: under `'Super'` a `Control` is ⌘, which
+ * UI Events calls `Meta`, so what is announced is what is drawn and bound.
  */
-export function ariaKeyShortcuts(shortcut) {
+export function ariaKeyShortcuts(shortcut, { primary = 'Control' } = {}) {
   if (!isValidShortcut(shortcut)) return undefined;
+  const name = (token) => {
+    if (!MODIFIER_TOKENS.has(token)) return KEY_LABELS[token] ?? token;
+    return primary === 'Super' && token === 'Control'
+      ? 'Meta'
+      : ARIA_MODIFIERS[token];
+  };
+  // a chord naming both `Control` and `Super` is one ⌘ there, said once
   return shortcut
-    .map((chord) =>
-      chord
-        .map((token) =>
-          MODIFIER_TOKENS.has(token)
-            ? ARIA_MODIFIERS[token]
-            : (KEY_LABELS[token] ?? token),
-        )
-        .join('+'),
-    )
+    .map((chord) => [...new Set(chord.map(name))].join('+'))
     .join(' ');
 }
 

package/src/node.d.ts

@@ -73,6 +73,29 @@ export interface Context2D {
    * `'globalCompositeOperation' in ctx`.
    */
   globalCompositeOperation?: string;
+  /**
+   * Canvas's: whether an image drawn scaled or turned is smoothed, or
+   * drawn as its nearest pixels. Native contexts only (macOS, Windows), and
+   * only where the bridge can set it: assign and read back to know.
+   */
+  imageSmoothingEnabled?: boolean;
+  /**
+   * Canvas's: how it is smoothed, `'low'` being bilinear. A native context
+   * starts at `'medium'`, which on macOS resamples the whole source for a
+   * draw through a matrix whatever the clip — so a surface drawn a tile at
+   * a time is far cheaper at `'low'`.
+   */
+  imageSmoothingQuality?: 'low' | 'medium' | 'high';
+  /**
+   * Canvas's: a CSS filter list applied to what is drawn after it. Native
+   * contexts only (macOS, Windows), and only the colour functions —
+   * `grayscale()`, `sepia()`, `saturate()`, `hue-rotate()`, `invert()`,
+   * `brightness()`, `contrast()` and `opacity()` — over a bridge that reads
+   * a surface's pixels back. Anything else does not stick: assign and read
+   * back to know. Absent on X11, whose server runs no colour matrix and
+   * answers a read a round trip later.
+   */
+  filter?: string;
   save(): void;
   restore(): void;
   translate(x: number, y: number): void;

package/src/nodes/editmenupopup.js

@@ -5,6 +5,7 @@
 import { deviceAnchorArea, windowOrigin } from '../anchor.js';
 import { armPasteState, canPaste } from '../pastestate.js';
 import {
+  primaryModifier,
   XK_RETURN,
   XK_KP_ENTER,
   XK_UP,
@@ -125,6 +126,7 @@ export function openEditMenu(node, at, actions = {}) {
     items,
     (text) => app?.fonts?.layout(text, style)?.width,
     s,
+    { primary: primaryModifier(app) },
   );
   const deviceAt = at && {
     ...at,
@@ -221,6 +223,17 @@ export function openEditMenu(node, at, actions = {}) {
   node._editMenu = popup;
   // read *before* the menu takes the keyboard, and handed back on close
   node._editMenuRestore = node._focusManager()?.focused ?? null;
+  // The window losing focus closes it — the user went to another
+  // application, ⌘-Tab or a click on its window. Neither reaches us as a
+  // press: the grab redirects presses only between windows of ours on Cocoa,
+  // and a popup panel never takes the keyboard there, so this is the one
+  // event that says so. The node keeps its focus across the blur, so nothing
+  // in the tree hears it either; the same answer `Menu` and `Select` give
+  // (`useDismissOnWindowBlur`, components/anchor.js).
+  node._editMenuOffBlur =
+    node.root?.onWindowFocusChange?.((focused) => {
+      if (!focused) closeEditMenu(node);
+    }) ?? null;
   // the menu takes the keyboard so arrows and Escape reach it rather than
   // the element behind it
   popup.events?.focus?.(canvas);
@@ -241,6 +254,8 @@ export function closeEditMenu(node) {
   const popup = node?._editMenu;
   if (!popup) return;
   node._editMenu = null;
+  node._editMenuOffBlur?.();
+  node._editMenuOffBlur = null;
   const restore = node._editMenuRestore;
   node._editMenuRestore = null;
   // the popup is a child, so a node destroyed while its menu was up took the
@@ -255,6 +270,10 @@ export function closeEditMenu(node) {
   // menu and a ring appearing on the way back would be news to nobody. A
   // surface that was not focusable in the first place, or that stopped being
   // on screen while the menu was up, gets nothing back rather than the
-  // destroyed menu canvas keeping the keyboard.
-  events.focus(events._canRestoreTo(restore) ? restore : null, 'pointer');
+  // destroyed menu canvas keeping the keyboard. And a restore, which takes
+  // the window no keyboard: a menu closed because the user went to another
+  // application must not drag them back to this one.
+  events.focus(events._canRestoreTo(restore) ? restore : null, 'pointer', {
+    restoring: true,
+  });
 }