ntk 8.2.0 → 8.3.0

package/lib/text/glyphs.js

@@ -1,6 +1,7 @@
 import GlyphSet from '../glyphset.js';
 import Picture from '../picture.js';
 import Pixmap from '../pixmap.js';
+import { fontPageToken, sharedGlyphsFor } from '../sharedglyphs.js';
 import { trapezoidize } from '../trapezoid.js';
 
 /**
@@ -37,6 +38,25 @@ function policyOf(app) {
   return app.textPolicy ? { ...DEFAULT_TEXT_POLICY, ...app.textPolicy } : DEFAULT_TEXT_POLICY;
 }
 
+/** a fresh AddGlyphs object — fresh per call because node-x11 mutates what
+ *  it is given (pads rows, divides offX by 64); the source bitmap survives */
+function uploadGlyph(lid, bitmap, adv) {
+  return {
+    id: lid,
+    width: bitmap ? bitmap.width : 0,
+    height: bitmap ? bitmap.height : 0,
+    // XRender GLYPHINFO places the image at origin - (x, y); node-x11
+    // packs -x and +y, so x here is the bitmap's left bearing and y its
+    // (negated, y-down) top — i.e. the ascent above the baseline
+    x: bitmap ? bitmap.left : 0,
+    y: bitmap ? -bitmap.top : 0,
+    // node-x11 AddGlyphs expects 26.6 fixed point and divides by 64
+    offX: adv * 64,
+    offY: 0,
+    image: bitmap ? bitmap.data : Buffer.alloc(0)
+  };
+}
+
 /**
  * Server-side glyph cache for one (font face, pixel size) pair.
  *
@@ -51,32 +71,52 @@ function policyOf(app) {
  *   (`offX`), so the server advances the pen automatically and runs of
  *   unkerned text need no per-glyph position data at all.
  * - Bitmaps upload lazily, once per glyph, batched into one AddGlyphs
- *   request per draw that introduces new glyphs.
+ *   request per draw that introduces new glyphs — and, when the display's
+ *   shared glyph directory is live (docs/shared-glyphs.md), re-bind to the
+ *   display-wide set so other ntk processes skip the work entirely.
  */
 export class GlyphPage {
   constructor(app, font, size) {
     this.app = app;
     this.font = font;
     this.size = size;
-    this.glyphset = new GlyphSet(app);
-    this.entries = new Map(); // font glyph id -> { lid, adv }
-    this.bytes = 0; // uploaded bitmap bytes, for the LRU budget
+    // With shared glyphs off this page is exactly what it always was: a
+    // private set from birth. With them on, the set is minted lazily — a
+    // page that resolves entirely from the directory never creates one.
+    this.glyphset = sharedGlyphsFor(app) ? null : new GlyphSet(app);
+    this.entries = new Map(); // font glyph id -> { lid, adv, gs }
+    this.bytes = 0; // privately uploaded bitmap bytes, for the LRU budget
+    this._lids = 0; // next private lid (dense, upload order)
+    this._maxLid = -1; // widest id this page composites, private or shared
+    this._privateCount = 0; // entries still bound to the private set
+    this._shared = undefined; // SharedPage binding, resolved on first ensure
   }
 
   /** number of bits per glyph needed to address this page's ids */
   get bits() {
-    return this.entries.size <= 256 ? 8 : 16;
+    return this._maxLid > 255 ? 16 : 8;
   }
 
   /**
-   * Ensure all glyphs of a shaped run are uploaded; returns nothing.
-   * New glyphs are rasterized and sent in a single AddGlyphs request.
+   * Ensure all glyphs of a shaped run are drawable; returns nothing.
+   *
+   * New glyphs are rasterized and sent in a single AddGlyphs request to the
+   * page's private set — this draw's pixels never wait on anything. When the
+   * shared directory is live they are also asked about (docs/shared-glyphs.md):
+   * the reply re-binds their entries to the display-wide set — uploading the
+   * retained bitmap only when this process was first to need the glyph — and
+   * once nothing private remains the private set is freed. Every later draw
+   * of those glyphs, in this process and every other, is then pure
+   * CompositeGlyphs. A page that wants the shared entries *before* first
+   * paint warms up front: see `warmSharedGlyphs`.
    */
   ensure(glyphs) {
     let batch = null;
+    let ask = null;
+    const shared = this._sharedBinding();
     for (const g of glyphs) {
       if (this.entries.has(g.id)) continue;
-      const lid = this.entries.size;
+      const lid = this._lids++;
       if (lid >= 65536) {
         // 2^16 distinct glyphs at one size — not reachable in practice
         // (fonts cap at 65535 glyphs) but fail loudly rather than corrupt
@@ -84,36 +124,77 @@ export class GlyphPage {
       }
       const adv = Math.round(this.font.advanceOf(g.id, this.size));
       const bitmap = this.font.rasterize(g.id, this.size);
-      this.entries.set(g.id, { lid, adv });
+      if (!this.glyphset) this.glyphset = new GlyphSet(this.app);
+      if (lid > this._maxLid) this._maxLid = lid;
+      this.entries.set(g.id, { lid, adv, gs: this.glyphset.id, private: true });
+      this._privateCount++;
       if (!batch) batch = [];
-      batch.push({
-        id: lid,
-        width: bitmap ? bitmap.width : 0,
-        height: bitmap ? bitmap.height : 0,
-        // XRender GLYPHINFO places the image at origin - (x, y); node-x11
-        // packs -x and +y, so x here is the bitmap's left bearing and y its
-        // (negated, y-down) top — i.e. the ascent above the baseline
-        x: bitmap ? bitmap.left : 0,
-        y: bitmap ? -bitmap.top : 0,
-        // node-x11 AddGlyphs expects 26.6 fixed point and divides by 64
-        offX: adv * 64,
-        offY: 0,
-        image: bitmap ? bitmap.data : Buffer.alloc(0)
-      });
+      batch.push(uploadGlyph(lid, bitmap, adv));
       this.bytes += bitmap ? bitmap.data.length : 0;
+      if (shared && shared.open) {
+        if (!ask) ask = [];
+        ask.push({ key: g.id, payload: { bitmap, adv } });
+      }
     }
     if (batch) this.glyphset.addGlyphs(batch);
+    if (ask) shared.ask(ask);
   }
 
   entry(fontGlyphId) {
     return this.entries.get(fontGlyphId);
   }
 
-  /** free the server-side glyphset (LRU eviction / shutdown) */
+  /** the shared side of this page, bound on first use; null when the
+   *  feature is off or the font's bytes cannot be content-addressed */
+  _sharedBinding() {
+    if (this._shared !== undefined) return this._shared;
+    const client = sharedGlyphsFor(this.app);
+    const token = client ? fontPageToken(this.font, this.size) : null;
+    this._shared = token
+      ? client.bindPage({
+          token,
+          indices: true, // member keys are the font glyph indices themselves
+          makeGlyph: (key, payload, lid) => {
+            // absent from the shared set: upload the bitmap retained at
+            // mint time, or rasterize now on the warm path (which retained
+            // nothing precisely because the glyph was expected to be there)
+            const bitmap =
+              payload.bitmap !== undefined ? payload.bitmap : this.font.rasterize(key, this.size);
+            return uploadGlyph(lid, bitmap, payload.adv);
+          },
+          adopt: (key, lid, gsid, payload) => this._adoptShared(key, lid, gsid, payload)
+        })
+      : null;
+    return this._shared;
+  }
+
+  /** re-bind one glyph to the shared set (confirmed present, or uploaded by
+   *  us); drop the private set once nothing composites from it any more */
+  _adoptShared(key, lid, gsid, payload) {
+    const prev = this.entries.get(key);
+    this.entries.set(key, { lid, adv: payload.adv, gs: gsid });
+    if (lid > this._maxLid) this._maxLid = lid;
+    if (prev && prev.private && --this._privateCount === 0 && this.glyphset) {
+      // ordered after any CompositeGlyphs already issued, like the LRU's
+      // frees; new glyphs during a directory outage mint a fresh set
+      this.glyphset.destroy();
+      this.glyphset = null;
+      this.bytes = 0;
+      this._lids = 0;
+    }
+  }
+
+  /** free the server-side glyphset and shared alias (LRU eviction / shutdown) */
   destroy() {
-    this.glyphset.destroy();
+    if (this.glyphset) this.glyphset.destroy();
+    this.glyphset = null;
+    if (this._shared) this._shared.destroy();
+    this._shared = undefined;
     this.entries.clear();
     this.bytes = 0;
+    this._lids = 0;
+    this._maxLid = -1;
+    this._privateCount = 0;
   }
 }
 
@@ -133,6 +214,42 @@ export function getGlyphPage(app, font, size) {
   return page;
 }
 
+/**
+ * Warm one (font, size) page from the shared glyph directory before first
+ * paint (docs/shared-glyphs.md): resolve `text`'s glyphs into shared-set
+ * entries so that the first draw of already-shared text rasterizes nothing
+ * and uploads nothing — the cold-start win a synchronous first `fillText`
+ * cannot have, since it cannot wait for the directory's answer and falls
+ * back to a private upload for exactly one frame instead.
+ *
+ * Glyphs the directory has never seen are rasterized here and uploaded once,
+ * which is the same work the first draw would have done. Resolves `true`
+ * when the page ended up bound to the shared cache; `false` means the
+ * feature is off or degraded and drawing will use the private path — either
+ * way the following draws are correct.
+ *
+ * @param {App} app
+ * @param {Font} font
+ * @param {number} size pixel size
+ * @param {string} text whose glyphs to warm (shaped with defaults)
+ * @returns {Promise<boolean>}
+ */
+export async function warmSharedGlyphs(app, font, size, text) {
+  if (!sharedGlyphsFor(app)) return false;
+  const page = getGlyphPage(app, font, size);
+  const shared = page._sharedBinding();
+  if (!shared || !shared.open) return false;
+  const ask = [];
+  const seen = new Set();
+  for (const g of font.shape(String(text), size).glyphs) {
+    if (page.entries.has(g.id) || seen.has(g.id)) continue;
+    seen.add(g.id);
+    ask.push({ key: g.id, payload: { adv: Math.round(font.advanceOf(g.id, size)) } });
+  }
+  if (ask.length) await shared.ask(ask);
+  return shared.open && shared.bound;
+}
+
 /**
  * Evict least-recently-used glyph pages until uploaded bitmaps fit the
  * policy budget. `inUse` pages (referenced by requests queued this draw)
@@ -422,7 +539,7 @@ function drawBitmapGlyphRuns(app, op, srcId, dstId, positioned, policy) {
   for (const pos of positionGlyphs(positioned)) {
     const page = pages.get(pos.run);
     const e = page.entry(pos.glyph.id);
-    items.push({ gs: page.glyphset.id, lid: e.lid, adv: e.adv, x: pos.x, y: pos.y });
+    items.push({ gs: e.gs, lid: e.lid, adv: e.adv, x: pos.x, y: pos.y });
   }
   const encoded = encodeGlyphItems(items, bits);
   if (!encoded) return;

package/lib/widgets/svgview.js

@@ -220,9 +220,11 @@ function pathBBox(path) {
  * inline `style` beats the presentation attribute, the initial fill is black
  * and the initial stroke is none, `<line>` never fills, `<use>` paints its
  * target with the *use* element's style, and non-rendered subtrees
- * contribute nothing. It starts at the root's children rather than the root,
- * because `draw` does: presentation attributes on the root `<svg>` are not
- * applied, and a scan that applied them would disagree with what is painted.
+ * contribute nothing. It starts at the root element itself, because `draw`
+ * does: the root `<svg>` is an ordinary element for inheritance, and every
+ * mainstream icon set puts `fill`/`stroke` there (issue #306). The two walks
+ * have to agree — a scan that skipped the root would disagree with what is
+ * painted.
  *
  * @returns {{ kind: 'mono'|'multi', solo: string|null }} `solo` is the one
  *   paint a `mono` document uses — a colour, or the literal `'currentColor'`
@@ -284,7 +286,7 @@ function scanPaints(root, ids) {
     }
   };
 
-  kids(root, INHERITED.fill, INHERITED.stroke, 0);
+  visit(root, INHERITED.fill, INHERITED.stroke, 0);
   return {
     kind: multi || paints.size > 1 ? 'multi' : 'mono',
     solo: paints.size === 1 ? [...paints][0] : null
@@ -433,7 +435,7 @@ export default class SvgView {
     this._renderChildren(
       this._root,
       ctx,
-      { ...INHERITED, color: opts.color ?? this.color },
+      this._style(this._root, { ...INHERITED, color: opts.color ?? this.color }),
       1,
       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();