xbintsc 0.3.69 → 0.3.79

package/runtime/ext_gui/canvas.h

@@ -0,0 +1,170 @@
+/*
+ * xbintsc GUI engine — `<canvas>` 2D drawing.
+ *
+ * A `Canvas2D` owns one RGBA8 bitmap and the 2D drawing state (fill/stroke
+ * style, line width, transform, text settings). It is the engine-side object
+ * behind `canvas.getContext("2d")`; the DOM bindings live in
+ * `dom_api_canvas.cpp` and the pixels reach the screen through the same GPU
+ * texture path as images and video (`renderer_image.cpp`).
+ *
+ * The rasteriser is deliberately small and self-written (no Skia/Cairo): it
+ * fills rectangles, polygons and flattened arcs with sub-scanline coverage
+ * anti-aliasing, and blits FreeType glyph bitmaps for `fillText`. The pieces
+ * live in `canvas_raster.cpp`; this header only exposes the object model.
+ *
+ * Canvas pixels are *not* touched by the garbage collector: a canvas is owned
+ * by the window (keyed by its DOM node) and released with the document.
+ */
+#ifndef XT_GUI_CANVAS_H
+#define XT_GUI_CANVAS_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "image.h"
+#include "text.h"
+
+namespace xtgui {
+
+/** A 2D affine transform, laid out like the DOM `DOMMatrix` (a b c d e f). */
+struct CanvasTransform {
+  float a = 1.0f, b = 0.0f, c = 0.0f, d = 1.0f, e = 0.0f, f = 0.0f;
+
+  void apply(float x, float y, float *outX, float *outY) const {
+    *outX = a * x + c * y + e;
+    *outY = b * x + d * y + f;
+  }
+  /** True when the transform keeps axis-aligned rectangles axis aligned (no
+   * rotation or skew), which lets the rasteriser use its fast rectangle path. */
+  bool axis_aligned() const { return b == 0.0f && c == 0.0f; }
+  /** Approximate uniform scale, used to size stroked lines and text. */
+  float scale() const;
+};
+
+/** A point in device (canvas) space. */
+struct CanvasPoint {
+  float x = 0.0f;
+  float y = 0.0f;
+};
+
+/** One subpath of the current path (device space). */
+using CanvasSubpath = std::vector<CanvasPoint>;
+
+class Canvas2D {
+ public:
+  Canvas2D(int width, int height);
+  ~Canvas2D();
+
+  int width() const { return image_.width; }
+  int height() const { return image_.height; }
+  uint64_t id() const { return id_; }
+  /** Bumped by every draw; the renderer re-uploads when it changes. */
+  uint64_t generation() const { return generation_; }
+  const Image &image() const { return image_; }
+  /** Resize the bitmap, discarding its contents (the DOM `canvas.width = …`
+   * behaviour). */
+  void resize(int width, int height);
+
+  /* -- state ------------------------------------------------------------- */
+  void save();
+  void restore();
+
+  /* -- transform --------------------------------------------------------- */
+  void translate(float x, float y);
+  void rotate(float radians);
+  void scale(float sx, float sy);
+  void transform(float a, float b, float c, float d, float e, float f);
+  void set_transform(float a, float b, float c, float d, float e, float f);
+  void reset_transform() { state_.transform = CanvasTransform(); }
+
+  /* -- style ------------------------------------------------------------- */
+  void set_fill_style(const std::string &css);
+  const std::string &fill_style() const { return state_.fill_style; }
+  void set_stroke_style(const std::string &css);
+  const std::string &stroke_style() const { return state_.stroke_style; }
+  void set_line_width(float width) { state_.line_width = width > 0.0f ? width : 0.0f; }
+  float line_width() const { return state_.line_width; }
+  void set_global_alpha(float alpha);
+  float global_alpha() const { return state_.global_alpha; }
+  void set_font(const std::string &font);
+  const std::string &font() const { return state_.font_string; }
+  void set_text_align(const std::string &value);
+  const std::string &text_align() const { return state_.text_align_string; }
+  void set_text_baseline(const std::string &value);
+  const std::string &text_baseline() const { return state_.text_baseline_string; }
+
+  /* -- paths ------------------------------------------------------------- */
+  void begin_path();
+  void close_path();
+  void move_to(float x, float y);
+  void line_to(float x, float y);
+  void rect(float x, float y, float width, float height);
+  void arc(float cx, float cy, float radius, float start, float end, bool counterclockwise);
+  void quadratic_curve_to(float cpx, float cpy, float x, float y);
+  void bezier_curve_to(float c1x, float c1y, float c2x, float c2y, float x, float y);
+  void fill();
+  void stroke();
+
+  /* -- rectangles -------------------------------------------------------- */
+  void clear_rect(float x, float y, float width, float height);
+  void fill_rect(float x, float y, float width, float height);
+  void stroke_rect(float x, float y, float width, float height);
+
+  /* -- text -------------------------------------------------------------- */
+  float measure_text(const std::string &text) const;
+  void fill_text(const std::string &text, float x, float y);
+  void stroke_text(const std::string &text, float x, float y);
+
+  /* -- images ------------------------------------------------------------ */
+  /** Draw `source` scaled into the destination rectangle, sampling the source
+   * rectangle `(sx, sy, sw, sh)`. `source` is RGBA8. */
+  void draw_image(const Image &source, float dx, float dy, float dw, float dh, float sx, float sy,
+                  float sw, float sh);
+
+  /* -- test hook --------------------------------------------------------- */
+  /** Copy an `(x, y, w, h)` region to `out` (RGBA8, row-major). Out-of-bounds
+   * pixels are transparent. Returns false when the region is empty. */
+  bool get_image_data(int x, int y, int width, int height, std::vector<unsigned char> *out) const;
+
+ private:
+  struct State {
+    CanvasTransform transform;
+    float line_width = 1.0f;
+    float global_alpha = 1.0f;
+    FontSpec font;
+    std::string font_string = "10px sans-serif";
+    int text_align = 0;      // 0 start/left, 1 center, 2 right/end
+    int text_baseline = 0;   // 0 alphabetic, 1 top, 2 middle, 3 bottom, 4 hanging, 5 ideographic
+    std::string text_align_string = "start";
+    std::string text_baseline_string = "alphabetic";
+    std::string fill_style = "#000000";
+    std::string stroke_style = "#000000";
+    float fill_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+    float stroke_color[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+  };
+
+  /** Transform a user-space point into device space. */
+  void to_device(float x, float y, float *outX, float *outY) const;
+  /** The current path transformed into device space. */
+  std::vector<CanvasSubpath> device_subpaths() const;
+  /** Add one device-space polygon loop to `out`. */
+  void flatten_arc(float cx, float cy, float radius, float start, float end, bool ccw,
+                   CanvasSubpath *out) const;
+  void stroke_subpath(const CanvasSubpath &points, bool closed, const float color[4]);
+  void paint_text(const std::string &text, float x, float y, const float color[4], bool stroke);
+
+  Image image_;
+  uint64_t id_ = 0;
+  uint64_t generation_ = 0;
+  State state_;
+  std::vector<State> stack_;
+  std::vector<CanvasSubpath> path_;
+};
+
+/** The canvas with the given process-wide id, or null. Used by the renderer. */
+Canvas2D *xt_canvas_by_id(uint64_t id);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_CANVAS_H */

package/runtime/ext_gui/canvas_internal.h

@@ -0,0 +1,59 @@
+/*
+ * xbintsc GUI engine — canvas rasteriser internals.
+ *
+ * The public object model lives in `canvas.h`; these functions are the
+ * software rasteriser `canvas.cpp` calls. They are deliberately small,
+ * self-contained and free of SDL so they can be unit-tested by reasoning about
+ * pixels alone.
+ */
+#ifndef XT_GUI_CANVAS_INTERNAL_H
+#define XT_GUI_CANVAS_INTERNAL_H
+
+#include <cstdint>
+#include <vector>
+
+#include "canvas.h"
+
+namespace xtgui {
+namespace canvas_detail {
+
+/** Source-over blend `color` (0..1) with `coverage` (0..1) into one RGBA8
+ * pixel. `alpha` folds in `globalAlpha`. */
+void blend_pixel(unsigned char *pixel, const float color[4], float coverage, float alpha);
+
+/** Fill one closed polygon loop (already in device space) with `color`,
+ * anti-aliased, blending source-over. */
+void fill_loop(std::vector<unsigned char> &pixels, int width, int height,
+               const std::vector<CanvasPoint> &loop, const float color[4], float alpha);
+
+/** Fill several loops as one path with the nonzero winding rule (so a contour
+ * inside another punches a hole). */
+void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
+                const std::vector<std::vector<CanvasPoint>> &loops, const float color[4],
+                float alpha);
+
+/** Fill a device-space axis-aligned rectangle, anti-aliased. Used by the
+ * `fillRect`/`clearRect` fast path when the transform preserves axis
+ * alignment. */
+void fill_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
+               float x1, float y1, const float color[4], float alpha);
+
+/** Clear a device-space axis-aligned rectangle to transparent. */
+void clear_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
+                float x1, float y1);
+
+/** Blit an RGBA8 source image into the destination rectangle using nearest
+ * sampling, source-over. Runs in device space (no transform). */
+void draw_image(std::vector<unsigned char> &pixels, int width, int height, const Image &source,
+                float dx, float dy, float dw, float dh, float sx, float sy, float sw, float sh,
+                float alpha);
+
+/** Composite one grayscale glyph bitmap at `(x, baselineY)` with `color`. */
+void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
+                const std::vector<unsigned char> &glyph, int glyphWidth, int glyphHeight, int left,
+                int top, float x, float baselineY, const float color[4], float alpha);
+
+}  // namespace canvas_detail
+}  // namespace xtgui
+
+#endif /* XT_GUI_CANVAS_INTERNAL_H */

package/runtime/ext_gui/canvas_raster.cpp

@@ -0,0 +1,254 @@
+/*
+ * xbintsc GUI engine — the software rasteriser behind `<canvas>`.
+ *
+ * Everything here is CPU-side and backend-free. Polygons are filled with the
+ * nonzero winding rule and vertical sub-scanline sampling (4 samples per pixel
+ * row) plus analytic horizontal coverage, which gives cheap anti-aliasing
+ * without a full analytic rasteriser. Rectangles take a faster axis-aligned
+ * path, and glyphs are composited from their FreeType coverage masks.
+ */
+
+#include "canvas_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+namespace xtgui {
+namespace canvas_detail {
+
+namespace {
+
+constexpr int kSubSamples = 4;
+
+int clamp_byte(float value) {
+  int result = (int)(value + 0.5f);
+  if (result < 0) result = 0;
+  if (result > 255) result = 255;
+  return result;
+}
+
+/** One edge crossing on the current sub-scanline. */
+struct Crossing {
+  float x;
+  int winding;
+};
+
+}  // namespace
+
+void blend_pixel(unsigned char *pixel, const float color[4], float coverage, float alpha) {
+  float sa = color[3] * coverage * alpha;
+  if (sa <= 0.0f) return;
+  if (sa > 1.0f) sa = 1.0f;
+  float da = pixel[3] / 255.0f;
+  float out_a = sa + da * (1.0f - sa);
+  if (out_a <= 0.0f) {
+    pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
+    return;
+  }
+  const float inv = 1.0f / out_a;
+  pixel[0] = (unsigned char)clamp_byte((color[0] * sa + (pixel[0] / 255.0f) * da * (1.0f - sa)) * inv * 255.0f);
+  pixel[1] = (unsigned char)clamp_byte((color[1] * sa + (pixel[1] / 255.0f) * da * (1.0f - sa)) * inv * 255.0f);
+  pixel[2] = (unsigned char)clamp_byte((color[2] * sa + (pixel[2] / 255.0f) * da * (1.0f - sa)) * inv * 255.0f);
+  pixel[3] = (unsigned char)clamp_byte(out_a * 255.0f);
+}
+
+/** Add the horizontal span `[xa, xb)` into a bbox-relative coverage row. */
+static void add_span(float *row, int rowOriginX, float xa, float xb, float weight, int clipX0,
+                     int clipX1) {
+  if (xb <= xa) return;
+  if (xa < (float)clipX0) xa = (float)clipX0;
+  if (xb > (float)clipX1) xb = (float)clipX1;
+  if (xb <= xa) return;
+  int ia = (int)std::floor(xa);
+  int ib = (int)std::ceil(xb) - 1;
+  if (ib < ia) return;
+  if (ia == ib) {
+    row[ia - rowOriginX] += (xb - xa) * weight;
+    return;
+  }
+  row[ia - rowOriginX] += ((float)(ia + 1) - xa) * weight;
+  for (int x = ia + 1; x < ib; x++) row[x - rowOriginX] += weight;
+  float last = xb - (float)ib;
+  if (last > 0.0f) row[ib - rowOriginX] += last * weight;
+}
+
+void fill_loops(std::vector<unsigned char> &pixels, int width, int height,
+                const std::vector<std::vector<CanvasPoint>> &loops, const float color[4],
+                float alpha) {
+  if (width <= 0 || height <= 0 || loops.empty()) return;
+  bool havePoint = false;
+  float minX = 0.0f, maxX = 0.0f, minY = 0.0f, maxY = 0.0f;
+  for (const std::vector<CanvasPoint> &loop : loops) {
+    for (const CanvasPoint &point : loop) {
+      if (!havePoint) {
+        minX = maxX = point.x;
+        minY = maxY = point.y;
+        havePoint = true;
+      } else {
+        minX = std::min(minX, point.x);
+        maxX = std::max(maxX, point.x);
+        minY = std::min(minY, point.y);
+        maxY = std::max(maxY, point.y);
+      }
+    }
+  }
+  if (!havePoint) return;
+  int x0 = std::max(0, (int)std::floor(minX));
+  int x1 = std::min(width, (int)std::ceil(maxX));
+  int y0 = std::max(0, (int)std::floor(minY));
+  int y1 = std::min(height, (int)std::ceil(maxY));
+  if (x1 <= x0 || y1 <= y0) return;
+
+  int boxWidth = x1 - x0;
+  std::vector<float> coverage((size_t)boxWidth * (size_t)(y1 - y0), 0.0f);
+  const float weight = 1.0f / (float)kSubSamples;
+
+  std::vector<Crossing> crossings;
+  for (int py = y0; py < y1; py++) {
+    float *row = coverage.data() + (size_t)(py - y0) * (size_t)boxWidth;
+    for (int sample = 0; sample < kSubSamples; sample++) {
+      float sy = (float)py + ((float)sample + 0.5f) / (float)kSubSamples;
+      crossings.clear();
+      for (const std::vector<CanvasPoint> &loop : loops) {
+        if (loop.size() < 3) continue;
+        for (size_t i = 0; i < loop.size(); i++) {
+          const CanvasPoint &p0 = loop[i];
+          const CanvasPoint &p1 = loop[(i + 1) % loop.size()];
+          if (p0.y == p1.y) continue;
+          float top = std::min(p0.y, p1.y);
+          float bottom = std::max(p0.y, p1.y);
+          if (sy < top || sy >= bottom) continue;
+          float t = (sy - p0.y) / (p1.y - p0.y);
+          Crossing crossing;
+          crossing.x = p0.x + t * (p1.x - p0.x);
+          crossing.winding = p1.y > p0.y ? 1 : -1;
+          crossings.push_back(crossing);
+        }
+      }
+      if (crossings.empty()) continue;
+      std::sort(crossings.begin(), crossings.end(),
+                [](const Crossing &a, const Crossing &b) { return a.x < b.x; });
+      int winding = 0;
+      float spanStart = 0.0f;
+      for (const Crossing &crossing : crossings) {
+        if (winding == 0) spanStart = crossing.x;
+        winding += crossing.winding;
+        if (winding == 0) add_span(row, x0, spanStart, crossing.x, weight, x0, x1);
+      }
+    }
+  }
+
+  for (int py = y0; py < y1; py++) {
+    const float *row = coverage.data() + (size_t)(py - y0) * (size_t)boxWidth;
+    unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)x0) * 4;
+    for (int px = 0; px < boxWidth; px++) {
+      float c = row[px];
+      if (c <= 0.0f) continue;
+      if (c > 1.0f) c = 1.0f;
+      blend_pixel(dst + (size_t)px * 4, color, c, alpha);
+    }
+  }
+}
+
+void fill_loop(std::vector<unsigned char> &pixels, int width, int height,
+               const std::vector<CanvasPoint> &loop, const float color[4], float alpha) {
+  fill_loops(pixels, width, height, std::vector<std::vector<CanvasPoint>>{loop}, color, alpha);
+}
+
+void fill_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
+               float x1, float y1, const float color[4], float alpha) {
+  if (x1 < x0) std::swap(x0, x1);
+  if (y1 < y0) std::swap(y0, y1);
+  int ix0 = std::max(0, (int)std::floor(x0));
+  int ix1 = std::min(width, (int)std::ceil(x1));
+  int iy0 = std::max(0, (int)std::floor(y0));
+  int iy1 = std::min(height, (int)std::ceil(y1));
+  for (int py = iy0; py < iy1; py++) {
+    float cy = std::min(y1, (float)(py + 1)) - std::max(y0, (float)py);
+    if (cy <= 0.0f) continue;
+    unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)ix0) * 4;
+    for (int px = ix0; px < ix1; px++) {
+      float cx = std::min(x1, (float)(px + 1)) - std::max(x0, (float)px);
+      if (cx <= 0.0f) continue;
+      blend_pixel(dst + (size_t)(px - ix0) * 4, color, cx * cy, alpha);
+    }
+  }
+}
+
+void clear_rect(std::vector<unsigned char> &pixels, int width, int height, float x0, float y0,
+                float x1, float y1) {
+  if (x1 < x0) std::swap(x0, x1);
+  if (y1 < y0) std::swap(y0, y1);
+  int ix0 = std::max(0, (int)std::floor(x0));
+  int ix1 = std::min(width, (int)std::ceil(x1));
+  int iy0 = std::max(0, (int)std::floor(y0));
+  int iy1 = std::min(height, (int)std::ceil(y1));
+  for (int py = iy0; py < iy1; py++) {
+    float cy = std::min(y1, (float)(py + 1)) - std::max(y0, (float)py);
+    if (cy <= 0.0f) continue;
+    unsigned char *dst = pixels.data() + ((size_t)py * (size_t)width + (size_t)ix0) * 4;
+    for (int px = ix0; px < ix1; px++) {
+      float cx = std::min(x1, (float)(px + 1)) - std::max(x0, (float)px);
+      if (cx <= 0.0f) continue;
+      unsigned char *pixel = dst + (size_t)(px - ix0) * 4;
+      float keep = 1.0f - cx * cy;
+      if (keep <= 0.0f) {
+        pixel[0] = pixel[1] = pixel[2] = pixel[3] = 0;
+      } else {
+        pixel[3] = (unsigned char)clamp_byte(pixel[3] * keep);
+      }
+    }
+  }
+}
+
+void draw_image(std::vector<unsigned char> &pixels, int width, int height, const Image &source,
+                float dx, float dy, float dw, float dh, float sx, float sy, float sw, float sh,
+                float alpha) {
+  if (source.width <= 0 || source.height <= 0 || dw <= 0.0f || dh <= 0.0f || sw <= 0.0f ||
+      sh <= 0.0f)
+    return;
+  int ix0 = std::max(0, (int)std::floor(dx));
+  int ix1 = std::min(width, (int)std::ceil(dx + dw));
+  int iy0 = std::max(0, (int)std::floor(dy));
+  int iy1 = std::min(height, (int)std::ceil(dy + dh));
+  for (int py = iy0; py < iy1; py++) {
+    for (int px = ix0; px < ix1; px++) {
+      float u = ((float)px + 0.5f - dx) / dw;
+      float v = ((float)py + 0.5f - dy) / dh;
+      if (u < 0.0f || u >= 1.0f || v < 0.0f || v >= 1.0f) continue;
+      int sxi = (int)(sx + u * sw);
+      int syi = (int)(sy + v * sh);
+      if (sxi < 0) sxi = 0;
+      if (syi < 0) syi = 0;
+      if (sxi >= source.width) sxi = source.width - 1;
+      if (syi >= source.height) syi = source.height - 1;
+      const unsigned char *texel =
+          source.pixels.data() + ((size_t)syi * (size_t)source.width + (size_t)sxi) * 4;
+      float color[4] = {texel[0] / 255.0f, texel[1] / 255.0f, texel[2] / 255.0f, texel[3] / 255.0f};
+      blend_pixel(pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4, color, 1.0f, alpha);
+    }
+  }
+}
+
+void blit_glyph(std::vector<unsigned char> &pixels, int width, int height,
+                const std::vector<unsigned char> &glyph, int glyphWidth, int glyphHeight, int left,
+                int top, float x, float baselineY, const float color[4], float alpha) {
+  int originX = (int)std::lround(x) + left;
+  int originY = (int)std::lround(baselineY) - top;
+  for (int gy = 0; gy < glyphHeight; gy++) {
+    int py = originY + gy;
+    if (py < 0 || py >= height) continue;
+    for (int gx = 0; gx < glyphWidth; gx++) {
+      int px = originX + gx;
+      if (px < 0 || px >= width) continue;
+      float coverage = glyph[(size_t)gy * (size_t)glyphWidth + (size_t)gx] / 255.0f;
+      if (coverage <= 0.0f) continue;
+      blend_pixel(pixels.data() + ((size_t)py * (size_t)width + (size_t)px) * 4, color, coverage,
+                  alpha);
+    }
+  }
+}
+
+}  // namespace canvas_detail
+}  // namespace xtgui

package/runtime/ext_gui/document.cpp

@@ -31,6 +31,8 @@ void XtDocument::load(const std::string &html, float viewportWidth, float viewpo
   styles_.clear();
   display_.clear();
   transitions_.clear();
+  mediaSizes_.clear();
+  canvasInfo_.clear();
   clock_ms_ = 0.0;
   std::string css;
   collectStyleText(root_.get(), &css);
@@ -195,7 +197,8 @@ void XtDocument::updateDisplay() {
       i++;
     }
   }
-  layout_.compute(root_.get(), display_, viewportWidth_, viewportHeight_);
+  layout_.compute(root_.get(), display_, viewportWidth_, viewportHeight_, &mediaSizes_,
+                  &canvasInfo_);
 }
 
 bool XtDocument::advance(double delta_ms) {
@@ -228,6 +231,26 @@ const XtStyle *XtDocument::styleOf(const Node *node) const {
 
 const LayoutBox *XtDocument::boxOf(const Node *node) const { return layout_.find(node); }
 
+bool XtDocument::setMediaSize(const Node *node, float width, float height, uint64_t id) {
+  MediaSize &entry = mediaSizes_[node];
+  if (entry.width == width && entry.height == height && entry.id == id) return false;
+  entry.width = width;
+  entry.height = height;
+  entry.id = id;
+  dirty_ = true;
+  return true;
+}
+
+bool XtDocument::setCanvasInfo(const Node *node, float width, float height, uint64_t id) {
+  CanvasInfo &entry = canvasInfo_[node];
+  if (entry.width == width && entry.height == height && entry.id == id) return false;
+  entry.width = width;
+  entry.height = height;
+  entry.id = id;
+  dirty_ = true;
+  return true;
+}
+
 std::vector<const Node *> XtDocument::querySelectorAll(const std::string &selectorText) const {
   std::vector<const Node *> matches;
   if (root_ == nullptr) return matches;

package/runtime/ext_gui/document.h

@@ -95,6 +95,15 @@ class XtDocument {
     dirty_ = false;
     return was;
   }
+
+  /* -- media (`<video>`) metadata --------------------------------------- */
+  /** Record (or update) the decoded size and decoder id of one `<video>` node.
+   * Returns true when the stored value changed, so the caller can invalidate a
+   * layout that was computed with the old value. */
+  bool setMediaSize(const Node *node, float width, float height, uint64_t id);
+  /** Record (or update) the pixel size and render id of one `<canvas>` node.
+   * Returns true when the stored value changed. */
+  bool setCanvasInfo(const Node *node, float width, float height, uint64_t id);
   /** Serialized DOM, for diagnostics. */
   std::string toDebugString() const;
 
@@ -110,6 +119,8 @@ class XtDocument {
   StyleSheet sheet_;
   std::unordered_map<const Node *, XtStyle> styles_;   // target (cascade)
   std::unordered_map<const Node *, XtStyle> display_;  // after transitions
+  MediaSizeMap mediaSizes_;                            // `<video>` intrinsic sizes
+  CanvasInfoMap canvasInfo_;                           // `<canvas>` sizes + ids
   std::vector<ActiveTransition> transitions_;
   double clock_ms_ = 0.0;
   LayoutTree layout_;

package/runtime/ext_gui/dom_api.cpp

@@ -32,6 +32,7 @@ xt_value g_document_proto = XT_UNDEFINED;
 xt_value g_event_proto = XT_UNDEFINED;
 xt_value g_class_list_proto = XT_UNDEFINED;
 xt_value g_style_proto = XT_UNDEFINED;
+xt_value g_canvas_proto = XT_UNDEFINED;
 
 /* -- small helpers -------------------------------------------------------- */
 
@@ -173,6 +174,8 @@ void xt_gui_node_handle_forget(XtGuiWindow *win, const xtgui::Node *node) {
     win->node_index.erase(index);
   }
   win->node_handles.erase(node);
+  /* A destroyed canvas node must not keep its bitmap or GPU texture alive. */
+  xt_gui_canvas_forget(win, node);
 }
 
 /** Forget the handles of `node` and every descendant. Runs before the subtree