ntk 6.6.0 → 6.6.1

package/lib/window.js

@@ -348,6 +348,9 @@ export default class Window extends Drawable {
     this._foreign = !!args.id;
     this._backingOptOut = args.backingStore === false;
     this._backing = null;
+    // What the backing store clears to, and the window attribute it mirrors.
+    // Undefined means "nothing was asked for" — see _clearColour.
+    this._clearPixel = args.backgroundPixel;
     this._dirty = false;
     this._presentPending = false;
 
@@ -696,9 +699,60 @@ export default class Window extends Drawable {
     });
   }
 
+  /**
+   * The pixel the backing store's unpainted area is cleared to.
+   *
+   * A pixmap's contents start *undefined* — whatever was in that memory — so
+   * something has to be written before it can be presented, and the same goes
+   * for the region a grow adds. What that something is follows the window's
+   * own `backgroundPixel`, which is exactly what the server would paint into
+   * exposed area on a window with no backing store. Without one: transparent
+   * for a depth-32 ARGB window, and the screen's white otherwise.
+   */
+  _clearColour() {
+    if (this._clearPixel !== undefined) return this._clearPixel;
+    const depth = this.depth || this.display.screen[0].root_depth;
+    return depth === 32 ? 0 : this.display.screen[0].white_pixel;
+  }
+
+  /**
+   * The window's background colour, as an X pixel value.
+   *
+   * A double-buffered window has two of them and they have to agree: the X
+   * window attribute the server paints into exposed area, and the colour the
+   * backing store clears to. Setting one and not the other is why a resize
+   * could show white on a window that draws itself dark.
+   *
+   * The backing store's *headroom* — the area a future grow will expand
+   * into, which by definition holds nothing yet — is recoloured too, so a
+   * later resize does not expose the previous colour.
+   */
+  setBackgroundPixel(pixel) {
+    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 }, () => {});
+    }
+    const backing = this._backing;
+    if (backing && this._clearGc) {
+      const rects = [];
+      if (backing.width > this.width) {
+        rects.push(this.width, 0, backing.width - this.width, backing.height);
+      }
+      if (backing.height > this.height) {
+        rects.push(0, this.height, this.width, backing.height - this.height);
+      }
+      if (rects.length) this.X.PolyFillRectangle(backing.id, this._clearGc, rects);
+    }
+    return this;
+  }
+
   // grow-only backing pixmap (re)allocation, with headroom (see
-  // BACKING_GRANULARITY); new area is cleared to the window's background
-  // (white for opaque windows, fully transparent for depth-32 ARGB ones)
+  // BACKING_GRANULARITY). What is already drawn is carried across and only
+  // the region the grow adds is cleared (see _clearColour) — clearing the
+  // whole pixmap made the *entire* window flash the clear colour between a
+  // resize and the redraw, not just the new strip.
   _allocBacking(w, h) {
     const cur = this._backing;
     if (cur && cur.width >= w && cur.height >= h) return;
@@ -715,11 +769,21 @@ export default class Window extends Drawable {
     if (!this._clearGc) {
       this._clearGc = this.X.AllocID();
       this.X.CreateGC(this._clearGc, pixmap.id, {
-        foreground: depth === 32 ? 0 : this.display.screen[0].white_pixel,
+        foreground: this._clearColour(),
         graphicsExposures: 0
       });
     }
-    this.X.PolyFillRectangle(pixmap.id, this._clearGc, [0, 0, newW, newH]);
+    if (cur) {
+      // The new pixmap is strictly larger, so the old content lands at the
+      // same coordinates and only the L-shaped remainder is new.
+      this.X.CopyArea(cur.id, pixmap.id, this._clearGc, 0, 0, 0, 0, cur.width, cur.height);
+      const rects = [];
+      if (newW > cur.width) rects.push(cur.width, 0, newW - cur.width, newH);
+      if (newH > cur.height) rects.push(0, cur.height, cur.width, newH - cur.height);
+      if (rects.length) this.X.PolyFillRectangle(pixmap.id, this._clearGc, rects);
+    } else {
+      this.X.PolyFillRectangle(pixmap.id, this._clearGc, [0, 0, newW, newH]);
+    }
     if (cur) cur.destroy();
     this._backing = pixmap;
     this._backingValid = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ntk",
-  "version": "6.6.0",
+  "version": "6.6.1",
   "description": "Desktop UI toolkit for X11 with canvas-like 2d and OpenGL rendering",
   "author": "Andrey Sidorov <sidorares@yandex.ru>",
   "license": "MIT",