ntk 8.2.0 → 8.3.1

package/lib/window.js

@@ -1,7 +1,7 @@
 import x11 from 'x11';
 
 import { builtin } from './builtin.js';
-import { safeRelease } from './cleanup.js';
+import { connectionGone, safeRelease } from './cleanup.js';
 import Drawable from './drawable.js';
 import { packIcons, unpackIcons } from './imagedata.js';
 import Pixmap from './pixmap.js';
@@ -332,6 +332,24 @@ function warnHint(key, message) {
   console.warn(`ntk: ${message} Further occurrences are not reported.`);
 }
 
+/**
+ * A GetGeometry reply in ntk's spelling. node-x11 calls the position `xPos`/
+ * `yPos` and the reply's root window `windowid`, neither of which is what X
+ * calls them; the `root` here is the root of the screen the drawable is on,
+ * not this window's parent.
+ */
+function unpackGeometry(res) {
+  return {
+    x: res.xPos,
+    y: res.yPos,
+    width: res.width,
+    height: res.height,
+    depth: res.depth,
+    borderWidth: res.borderWidth,
+    root: res.windowid
+  };
+}
+
 /** A Window, a Pixmap, or a bare XID — all of these name a server resource. */
 function resourceId(value) {
   return typeof value === 'number' ? value : (value?.id ?? 0);
@@ -404,18 +422,37 @@ export default class Window extends Drawable {
     // the whole property without dropping what an earlier one set
     this._sizeHints = null;
     this._wmHints = null;
+    // `wnd.ready` (see the getter): resolved as soon as this wrapper knows
+    // its geometry — at the end of the constructor for a window ntk created,
+    // when GetGeometry replies for one adopted by id
     this._readyPromiseResolve = null;
     this._readyPromise = new Promise((resolve) => {
       this._readyPromiseResolve = resolve;
     });
+    // constructor round trips still outstanding, for an adopted window
+    this._readyPending = 0;
 
     const parentId = args.parent ? args.parent.id : app.display.screen[0].root;
 
     // double buffering (see docs/window.md): windows we created get a
     // backing pixmap when a 2d context is requested, unless opted out
     this._foreign = !!args.id;
+    // Adopting a window is not the same as "another client paints these
+    // pixels", though it is the safe default reading of one. The Composite
+    // overlay window and a window handed over by an embedding host (XEmbed's
+    // plug side, an `--wid` handoff) are ours completely — they are foreign
+    // only in the sense that `createWindow` did not make them, and they are
+    // exactly the windows that most want an unflickering double buffer and a
+    // vblank-paced blit. Saying so is `{ id, backingStore: true }` or
+    // `{ id, present: true }`; from there such a window behaves like any
+    // other window ntk owns (issue #294).
+    this._ownsPixels = !this._foreign || args.backingStore === true || args.present === true;
     this._backingOptOut = args.backingStore === false;
     this._backing = null;
+    // an adopted window has no geometry, depth or visual to build a backing
+    // pixmap from until its constructor's questions reply — see
+    // _enableBackingStoreWhenReady
+    this._backingScheduled = false;
     // What the backing store clears to, and the window attribute it mirrors.
     // Undefined means "nothing was asked for" — see _clearColour.
     this._clearPixel = args.backgroundPixel;
@@ -528,11 +565,19 @@ export default class Window extends Drawable {
       for (const name of forwardedXAttributes) {
         if (args[name] !== undefined) values[name] = args[name];
       }
+      // what setCursor compares against, so setting the cursor a window was
+      // created with is free rather than a redundant round trip
+      this._currentCursor = values.cursor;
       // a window on a non-default visual (GLX, ARGB) also needs its own
       // colormap and an explicit border pixel: inheriting either from a
       // parent of a different depth is a BadMatch (X11 CreateWindow)
       this.visual = args.visual ?? 0;
       this.depth = args.depth ?? 0;
+      // `visual` is the CreateWindow argument, where 0 means CopyFromParent;
+      // `visualId` is the visual the pixels are actually in, which is what a
+      // picture format is picked from (issue #295). CopyFromParent is only
+      // ever the parent's, and the default parent is the root.
+      this.visualId = this.visual || args.parent?.visualId || app.display.screen[0].root_visual;
       if (this.visual) {
         if (values.colormap === undefined) {
           this._ownedColormap = app.createColormap(this.visual);
@@ -549,24 +594,46 @@ export default class Window extends Drawable {
       this.id = args.id;
       this.eventMask = 0;
       this.visual = 0;
+      // nothing is known about another client's window until it answers
+      this.visualId = 0;
       this.depth = 0;
       // an adopted window's geometry is not known until GetGeometry replies
       this._deliveredGeom = null;
-      // populate width and height
-      X.GetGeometry(this.id, (err, res) => {
-        if (!err) {
-          this.width = res.width;
-          this.height = res.height;
-          this.x = res.xPos;
-          this.y = res.yPos;
-          this.depth = res.depth;
-          // nothing was known about this window until now, so until this
-          // reply lands a 'resize' reports both moved and resized (see
-          // _tagResize) rather than guessing
-          this._deliveredGeom ??= { x: this.x, y: this.y, width: this.width, height: this.height };
-        }
-        this._readyPromiseResolve();
-      });
+      // Two questions, because a drawable's pixels take both to describe:
+      // GetGeometry for width, height and depth, GetWindowAttributes for the
+      // visual — depth alone does not name a picture format, and the windows
+      // whose format was picked wrongest are exactly these, the ones another
+      // client chose the visual for (issue #295). They go out in the same
+      // batch, so the pair costs one round trip, not two, and `ready` is the
+      // wait for both.
+      //
+      // Nothing is asked of a connection that is going away: node-x11 throws
+      // synchronously at a request once close() has begun, and adoption
+      // happens from places with no caller to catch — a routed child-event,
+      // XEmbed, the shared glyph cache all build windows from inside the X
+      // event dispatch (issue #321). There is nothing to learn there either,
+      // so `ready` settles with the geometry unknown, the same outcome as a
+      // window destroyed before its reply landed (see the getter).
+      this._readyPending = connectionGone(X) ? 0 : 2;
+      if (this._readyPending) {
+        X.GetGeometry(this.id, (err, res) => {
+          // A window that was destroyed between the id reaching us and this
+          // request reaching the server answers BadWindow, and there is
+          // nothing to record. `ready` still resolves: adopting a window that
+          // has since gone is ordinary for a window manager, and a wait that
+          // never ends is worse than one that ends with width undefined.
+          this._readyPending--;
+          if (err) this._settleReady();
+          else this._applyGeometry(unpackGeometry(res));
+        });
+        X.GetWindowAttributes(this.id, (err, attrs) => {
+          this._readyPending--;
+          if (!err) this.visualId = attrs.visual;
+          this._settleReady();
+        });
+      } else {
+        this._settleReady();
+      }
     }
 
     Window._cacheFor(app).set(this.id, this);
@@ -630,11 +697,21 @@ export default class Window extends Drawable {
     // region and an event selection it never uses. `present: true` is still
     // honoured eagerly, for a caller who wants it up before the first paint.
     this._presentOptOut = args.present === false;
-    if (args.present && !args.id) {
+    if (args.present === true) {
       // fire and forget: until the extensions answer, blits use CopyArea,
-      // which is what they would have done anyway
+      // which is what they would have done anyway. Present needs nothing of
+      // the window but its id, so an adopted one can have it up before its
+      // geometry has even replied.
       this.enablePresent().catch((err) => this.app.options?.onXError?.(err));
     }
+    // A window adopted with ownership declared starts its backing store now
+    // rather than waiting for the first getContext('2d'): the allocation
+    // needs the constructor's replies anyway, so starting it here means it
+    // is normally already there by the time the caller's `await wnd.ready`
+    // returns and it draws.
+    if (this._foreign && this._ownsPixels && !this._backingOptOut) {
+      this._enableBackingStoreWhenReady();
+    }
 
     X.event_consumers[this.id] = this;
     this.on('event', (ev) => {
@@ -714,15 +791,24 @@ export default class Window extends Drawable {
     this.on('child-event', (ev) => {
       const eventName = xevents.eventName[ev.type];
       if (!eventName) return;
+      // Events buffered before `close()` keep being dispatched after it, and
+      // a window this client already saw destroyed has no substructure left
+      // to report. Neither is worth building a child for — and the questions
+      // the constructor would ask on the way out are what used to throw into
+      // the dispatcher (issue #321).
+      if (this._destroyed || connectionGone(X)) return;
       const child = new Window(app, { id: ev.wid });
       const ntkev = { ...ev, parent: this, window: child, target: child };
       // wait until we know that we track correct x,y,w,h values
-      child._readyPromise.then(() => {
+      child.ready.then(() => {
         this.emit(eventName, ntkev);
       });
     });
 
     this.on('newListener', (name) => {
+      // one of ntk's own handlers going on, not a caller asking for an
+      // event: nothing to arm and nothing to select — see _listenInternal
+      if (this._internalListen) return;
       // Listening for 'close' is the opt-in. WM_DELETE_WINDOW only reaches a
       // client that advertised it in WM_PROTOCOLS — a window manager kills
       // anyone else outright — and having to know that, on top of decoding a
@@ -749,6 +835,13 @@ export default class Window extends Drawable {
       const eventMask = xevents.mask[name];
       if (!eventMask) return;
       if ((eventMask & this.eventMask) === 0) {
+        // A connection on its way out can select nothing, and node-x11 throws
+        // synchronously at a request from then on. This hook runs from
+        // `.on()` — including the calls made while adopting a window from
+        // inside the X event dispatch, where there is no caller to catch it
+        // (issue #321). Before the mask is touched, so it goes on saying what
+        // this connection holds.
+        if (connectionGone(X)) return;
         this.eventMask |= eventMask;
         // the selection can legitimately fail — SubstructureRedirect is
         // one-client-only, so `on('map_request')` is how you find out
@@ -756,14 +849,29 @@ export default class Window extends Drawable {
         // error hook rather than dropping it; selectInput() is the
         // explicit form that hands the error straight back.
         X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, (err) => {
-          if (err) this.app.options.onXError?.(err);
+          if (!err) return;
+          // the request failed as a whole, so the server kept the mask it
+          // had: drop the bits again rather than leave `eventMask` claiming
+          // a selection this connection does not hold. selectInput() trusts
+          // it to decide whether a write can be skipped.
+          this.eventMask &= ~eventMask;
+          this.app.options.onXError?.(err);
         });
       }
     });
 
-    this.on('map', () => (this._mapped = true));
-    this.on('unmap', () => (this._mapped = false));
-    this.on('destroy', () => {
+    // ntk's own bookkeeping listens for the same events an app does, and the
+    // hook above reads a listener as a caller expressing interest and selects
+    // for it. For a window ntk created that is free — StructureNotify is in
+    // the CreateWindow value list already — but for an adopted one the
+    // tracked mask starts at zero and the write is absolute, so it would
+    // replace whatever this connection had selected on a window another
+    // client owns (issue #322). Subscribe past the hook: adopting a window
+    // costs no requests and changes no server-side state, and a caller that
+    // wants these events still asks for them, with on('map') or selectInput.
+    this._listenInternal('map', () => (this._mapped = true));
+    this._listenInternal('unmap', () => (this._mapped = false));
+    this._listenInternal('destroy', () => {
       this._destroyed = true;
       this._forget();
       this._teardownFrame(false); // the server has already taken the window
@@ -773,10 +881,100 @@ export default class Window extends Drawable {
     });
 
     if (typeof this.width !== 'undefined') {
-      this._readyPromiseResolve();
+      this._settleReady();
+    }
+  }
+
+  /**
+   * Attach one of ntk's own handlers without the `newListener` hook reading
+   * it as a caller asking for the event. The hook's job is to turn expressed
+   * interest into a server-side selection; ntk's internal bookkeeping
+   * expresses none — it only wants the events that arrive anyway — and on an
+   * adopted window a selection nobody asked for overwrites another
+   * subsystem's (issue #322). The flag is read synchronously by the hook,
+   * which EventEmitter emits before the listener is stored.
+   */
+  _listenInternal(name, fn) {
+    this._internalListen = true;
+    try {
+      this.on(name, fn);
+    } finally {
+      this._internalListen = false;
     }
   }
 
+  /**
+   * Resolves with this window once its geometry is known — immediately for a
+   * window ntk created (it already knows what it asked for), when the
+   * GetGeometry sent by the constructor replies for one adopted by id.
+   *
+   * Adoption is the case that needs it: until the reply lands, `width`,
+   * `height`, `x` and `y` are `undefined` and `depth` is `0`, so anything
+   * that picks a pixel format from the depth — `getContext('2d')`,
+   * `createPattern` — would pick the wrong one. Awaiting is safe
+   * unconditionally, so code that takes windows from either source need not
+   * ask which it has:
+   *
+   *   const wnd = new Window(app, { id: ev.wid });
+   *   await wnd.ready;
+   *   const ctx = wnd.getContext('2d');
+   *
+   * The promise never rejects. A window destroyed before the reply arrives
+   * resolves all the same, with `width` still `undefined` — the request that
+   * hits the gone window is the one that reports it.
+   */
+  get ready() {
+    return this._readyPromise;
+  }
+
+  /**
+   * Ask the server where this window is now — `{ x, y, width, height, depth,
+   * borderWidth, root }`, with `x`/`y` relative to the parent, as X reports
+   * them.
+   *
+   * `wnd.x`/`y`/`width`/`height`/`depth` are kept current from the event
+   * stream and are the cheap answer; this is the round trip for the cases
+   * the events cannot cover — a window nobody selected StructureNotify on, a
+   * window ntk created with the default `depth: 0` (CopyFromParent, whose
+   * real depth only the server knows), or simply the state at a point in
+   * time. The reply is written back to those properties, and resolves
+   * `ready` if it was still pending.
+   */
+  getGeometry() {
+    return new Promise((resolve, reject) => {
+      this.X.GetGeometry(this.id, (err, res) => {
+        if (err) return reject(err);
+        const geometry = unpackGeometry(res);
+        this._applyGeometry(geometry);
+        resolve(geometry);
+      });
+    });
+  }
+
+  /** Record a GetGeometry reply, and let anything waiting on it go. */
+  _applyGeometry({ x, y, width, height, depth }) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.depth = depth;
+    // Only where nothing is known yet: on an adopted window a 'resize'
+    // reports both moved and resized until there is a baseline to compare
+    // against (see _tagResize), and the event stream may already have set
+    // one — that is the delivered geometry, and this reply is not.
+    this._deliveredGeom ??= { x, y, width, height };
+    this._settleReady();
+  }
+
+  /**
+   * Let anything waiting on `ready` go, once the questions the constructor
+   * asked have all been answered. A window ntk created asked none.
+   */
+  _settleReady() {
+    if (this._readyPending > 0) return;
+    this._readyPromiseResolve(this);
+  }
+
   _forget() {
     Window._cacheFor(this.app).delete(this.id);
     delete this.X.event_consumers[this.id];
@@ -790,14 +988,43 @@ export default class Window extends Drawable {
    * an 'expose' (and 'draw') event is emitted only when a real redraw is
    * needed (first paint, resize). Opt out with
    * `createWindow({ backingStore: false })`.
+   *
+   * A window adopted by id is left alone by default — another client's
+   * pixels are not ntk's to buffer — and opts in with
+   * `createWindow({ id, backingStore: true })` (see `_ownsPixels`).
    */
   getContext(name, ...args) {
-    if (name === '2d' && !this._backing && !this._backingOptOut && !this._foreign) {
-      this._enableBackingStore();
+    if (name === '2d' && !this._backing && !this._backingOptOut && this._ownsPixels) {
+      if (this._foreign) this._enableBackingStoreWhenReady();
+      else this._enableBackingStore();
     }
     return super.getContext(name, ...args);
   }
 
+  /**
+   * The backing store for an adopted window, once there is something to build
+   * it out of.
+   *
+   * A pixmap needs a width, a height, a depth and a visual, and an adopted
+   * window knows none of them until `GetGeometry` and `GetWindowAttributes`
+   * reply — so the allocation waits on `ready`. A 2d context taken in the
+   * meantime draws straight to the window and re-binds itself to the pixmap
+   * when it appears (the `_backing` event), which is the same path a resize
+   * reallocation takes.
+   */
+  _enableBackingStoreWhenReady() {
+    if (this._backingScheduled) return;
+    this._backingScheduled = true;
+    this.ready.then(() => {
+      // A window destroyed before the replies arrived still settles `ready`,
+      // with its geometry never filled in — there is no pixmap to make for
+      // one, and CreatePixmap with an undefined size is not the way to find
+      // that out.
+      if (this._destroyed || this._backing || !this.width || !this.height) return;
+      this._enableBackingStore();
+    });
+  }
+
   _enableBackingStore() {
     this._dirty = false;
     this._backingValid = false;
@@ -805,7 +1032,7 @@ export default class Window extends Drawable {
     // Now there is a pixmap to present. Inert where the extensions are
     // missing, so this costs a window on such a server two extension queries
     // that node-x11 answers from its cache after the first.
-    if (!this._presentOptOut && !this._foreign) {
+    if (!this._presentOptOut && this._ownsPixels) {
       this.enablePresent().catch((err) => this.app.options?.onXError?.(err));
     }
 
@@ -817,7 +1044,8 @@ export default class Window extends Drawable {
     // server sends them even if user code only listens to 'draw'
     if (!(this.eventMask & x11.eventMask.Exposure)) {
       this.eventMask |= x11.eventMask.Exposure;
-      this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, () => {});
+      // no callback: it would only buy node-x11's void-sync round trip, see setCursor
+      this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask });
     }
 
     // a pure move is a ConfigureNotify too, and reallocating a backing
@@ -863,8 +1091,11 @@ export default class Window extends Drawable {
     this._clearPixel = pixel;
     if (this._destroyed) return this;
     if (this._clearGc) this.X.ChangeGC(this._clearGc, { foreground: pixel });
-    if (!this._foreign) {
-      this.X.ChangeWindowAttributes(this.id, { backgroundPixel: pixel }, () => {});
+    // The window attribute half is only ours to write on a window whose
+    // pixels are ours — an adopted one has to have said so (see _ownsPixels).
+    if (this._ownsPixels) {
+      // no callback: it would only buy node-x11's void-sync round trip, see setCursor
+      this.X.ChangeWindowAttributes(this.id, { backgroundPixel: pixel });
     }
     const backing = this._backing;
     if (backing && this._clearGc) {
@@ -896,7 +1127,10 @@ export default class Window extends Drawable {
       parent: this,
       width: newW,
       height: newH,
-      depth
+      depth,
+      // it holds this window's pixels, so it is read through this window's
+      // visual — a pixmap has none of its own (issue #295)
+      visual: this.visualId
     });
     if (!this._clearGc) {
       this._clearGc = this.X.AllocID();
@@ -925,7 +1159,11 @@ export default class Window extends Drawable {
 
   _handleExpose(ev) {
     if (this._backingValid) {
-      this.X.CopyArea(this._backing.id, this.id, this._presentGc, ev.x, ev.y, ev.x, ev.y, ev.width, ev.height);
+      // an expose can arrive after the connection started closing, and this
+      // runs inside the event dispatch where a throw has no caller (#321)
+      safeRelease(this.X, () => {
+        this.X.CopyArea(this._backing.id, this.id, this._presentGc, ev.x, ev.y, ev.x, ev.y, ev.width, ev.height);
+      });
     } else {
       this._requestRedraw();
     }
@@ -2997,9 +3235,19 @@ export default class Window extends Drawable {
    *                      pointer stays visible
    */
   setCursor(nameOrShape) {
+    // resolved first: an unknown name has to throw whether or not the memo
+    // below short-circuits the request
     const cursor = nameOrShape == null ? 0 : this.app.cursors.get(nameOrShape);
+    if (cursor === this._currentCursor) return this;
+    this._currentCursor = cursor;
     safeRelease(this.X, () => {
-      this.X.ChangeWindowAttributes(this.id, { cursor }, () => {});
+      // no callback, deliberately: node-x11 guarantees a callback on a *void*
+      // request eventually fires, and buys that by injecting a GetInputFocus
+      // round trip when nothing else in the tick expects a reply (node-x11
+      // issue #85). A callback that ignores its argument costs that round trip
+      // per cursor change and buys nothing — an X error reaches
+      // `client.emit('error')`, and so app's onXError hook, either way.
+      this.X.ChangeWindowAttributes(this.id, { cursor });
     });
     return this;
   }
@@ -3012,7 +3260,8 @@ export default class Window extends Drawable {
     } else {
       return this;
     }
-    this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, () => {});
+    // no callback: it would only buy node-x11's void-sync round trip, see setCursor
+    this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask });
     return this;
   }
 
@@ -3307,7 +3556,13 @@ export default class Window extends Drawable {
   getAttributes() {
     return new Promise((resolve, reject) => {
       safeRelease(this.X, () =>
-        this.X.GetWindowAttributes(this.id, (err, attrs) => (err ? reject(err) : resolve(attrs)))
+        this.X.GetWindowAttributes(this.id, (err, attrs) => {
+          if (err) return reject(err);
+          // the visual names the picture format (see `visualId`), and this
+          // reply is the only place the server ever states it
+          this.visualId = attrs.visual;
+          resolve(attrs);
+        })
       );
     });
   }
@@ -3327,13 +3582,26 @@ export default class Window extends Drawable {
    * either makes you the window manager or rejects with BadAccess because
    * something else already is. The mask is OR-ed into whatever handlers
    * have already asked for.
+   *
+   * A mask this connection already holds is a request that would change
+   * nothing, so it resolves without one — `eventMask` is what this
+   * connection selected and nothing else adds to it behind the caller's
+   * back. It resolves rather than returning undefined because the promise is
+   * the whole interface: an awaited no-op still has to mean "you have it".
    */
   selectInput(mask) {
-    this.eventMask |= mask;
+    const added = mask & ~this.eventMask;
+    if (added === 0) return Promise.resolve(this);
+    this.eventMask |= added;
     return new Promise((resolve, reject) => {
-      this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, (err) =>
-        err ? reject(err) : resolve(this)
-      );
+      this.X.ChangeWindowAttributes(this.id, { eventMask: this.eventMask }, (err) => {
+        if (!err) return resolve(this);
+        // a refused write left the server's mask as it was — give back the
+        // bits, or the next call would find them held and skip a request
+        // that has not happened yet
+        this.eventMask &= ~added;
+        reject(err);
+      });
     });
   }
 
@@ -3515,7 +3783,7 @@ export default class Window extends Drawable {
       // there can be multiple screens (and roots)
       const root = new Window(app, { id: tree.root });
       const wrappers = [...children, root, ...(parent ? [parent] : [])];
-      Promise.all(wrappers.map((w) => w._readyPromise)).then(() => {
+      Promise.all(wrappers.map((w) => w.ready)).then(() => {
         callback(null, { parent, root, children });
       });
     });

package/lib/xembed.js

@@ -559,7 +559,9 @@ export class XEmbedSocket extends EventEmitter {
     // reparent, so its ReparentNotify does not come back to us
     safeRelease(this.X, () => {
       client.eventMask = 0;
-      this.X.ChangeWindowAttributes(client.id, { eventMask: 0 }, () => {});
+      // no callback: it would only buy node-x11's void-sync round trip, see
+      // Window#setCursor
+      this.X.ChangeWindowAttributes(client.id, { eventMask: 0 });
     });
     client.reparentTo(this.app.rootWindow(), x, y);
     client.removeFromSaveSet();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "8.2.0",
+  "version": "8.3.1",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "linebreak": "^1.1.0",
     "parse-color": "^1.0.0",
     "pngjs": "^7.0.0",
-    "x11": "^3.9.0"
+    "x11": "^4.0.1"
   },
   "optionalDependencies": {
     "x11-dri": ">=0.2.0 <1"