ntk 4.2.0 → 4.3.0

package/lib/window.js

@@ -693,6 +693,66 @@ export default class Window extends Drawable {
     });
   }
 
+  /**
+   * Scroll the pixels of `rect` (window coordinates, `{x, y, width, height}`)
+   * by (dx, dy) within the retained backing store, server-side: one CopyArea
+   * of the band that survives the shift, in place of the caller re-drawing
+   * everything that merely moved. Returns true when the blit was issued;
+   * false means "not possible here", and the caller repaints `rect` exactly
+   * as it would have without this method — every refusal is the status quo.
+   *
+   * Refused when there is no (valid) backing store, when the delta is
+   * fractional (a sub-pixel shift changes every pixel, so there is nothing
+   * to copy), when it is zero, or when nothing of `rect` survives the shift
+   * after clamping to window ∩ backing.
+   *
+   * Backing-store only, deliberately: pixmap contents cannot be occluded, so
+   * an overlapping self-copy is fully defined (the server fetches the source
+   * region before storing) and the GraphicsExpose handling a window-drawable
+   * scroll would need never exists. The copy goes out with the present GC —
+   * graphicsExposures: 0, where the 2d context's GC would emit a NoExposure
+   * packet per copy — and in-order with the caller's follow-up drawing of
+   * the exposed strip on the same connection.
+   *
+   * The whole of `rect` is marked dirty, so the next present shows the
+   * scrolled band through the normal fence-aware path; the caller only has
+   * to draw the strip the shift exposed, plus any chrome that moved with
+   * the content (a scrollbar thumb, say).
+   */
+  scrollRegion(rect, dx, dy) {
+    if (!this._backing || !this._backingValid) return false;
+    if (!Number.isInteger(dx) || !Number.isInteger(dy) || (dx === 0 && dy === 0)) return false;
+    // clamp like a present: the backing is grow-only, so it can be larger
+    // than the window after a shrink
+    const w = Math.min(this.width, this._backing.width);
+    const h = Math.min(this.height, this._backing.height);
+    const x0 = Math.max(0, Math.floor(rect.x));
+    const y0 = Math.max(0, Math.floor(rect.y));
+    const x1 = Math.min(w, Math.ceil(rect.x + rect.width));
+    const y1 = Math.min(h, Math.ceil(rect.y + rect.height));
+    // the band that survives: dest = clamped rect ∩ (clamped rect + delta)
+    const dstX0 = Math.max(x0, x0 + dx);
+    const dstY0 = Math.max(y0, y0 + dy);
+    const dstX1 = Math.min(x1, x1 + dx);
+    const dstY1 = Math.min(y1, y1 + dy);
+    if (dstX1 <= dstX0 || dstY1 <= dstY0) return false;
+    safeRelease(this.X, () => {
+      this.X.CopyArea(
+        this._backing.id,
+        this._backing.id,
+        this._presentGc,
+        dstX0 - dx,
+        dstY0 - dy,
+        dstX0,
+        dstY0,
+        dstX1 - dstX0,
+        dstY1 - dstY0
+      );
+    });
+    this._markDirty({ x: x0, y: y0, w: x1 - x0, h: y1 - y0 });
+    return true;
+  }
+
   /*
    * Frame clock. Noisy events (see events_map coalesce), synthetic redraws
    * and requestAnimationFrame callbacks are delivered in "frames", paced by

package/package.json

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