ntk 8.1.1 → 8.3.0

package/lib/window.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,23 +594,33 @@ 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
+      // 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.
+      this._readyPending = 2;
       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();
+        // 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();
       });
     }
 
@@ -630,11 +685,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) => {
@@ -717,7 +782,7 @@ export default class Window extends Drawable {
       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);
       });
     });
@@ -773,10 +838,82 @@ export default class Window extends Drawable {
     });
 
     if (typeof this.width !== 'undefined') {
-      this._readyPromiseResolve();
+      this._settleReady();
     }
   }
 
+  /**
+   * 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 +927,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 +971,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 +983,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 +1030,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 +1066,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();
@@ -2997,9 +3170,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 +3195,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 +3491,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);
+        })
       );
     });
   }
@@ -3515,7 +3705,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.1.1",
+  "version": "8.3.0",
   "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"