xbintsc 0.5.37 → 0.5.41

package/runtime/ext_gui/canvas_stroke.cpp

@@ -30,6 +30,27 @@ bool same_point(const CanvasPoint &a, const CanvasPoint &b) {
   return std::fabs(a.x - b.x) < 1e-6f && std::fabs(a.y - b.y) < 1e-6f;
 }
 
+/** Twice the signed area of a closed polygon (shoelace). */
+float signed_area(const CanvasSubpath &loop) {
+  float sum = 0.0f;
+  const size_t count = loop.size();
+  for (size_t i = 0; i < count; i++) {
+    const CanvasPoint &a = loop[i];
+    const CanvasPoint &b = loop[(i + 1) % count];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum;
+}
+
+/** Append one stroke piece to the batch, normalising its winding: a stroke is
+ * filled as one nonzero path, so a join that happened to be wound the other
+ * way would cancel the quads it overlaps instead of covering them. */
+void append_piece(std::vector<CanvasSubpath> *loops, CanvasSubpath piece) {
+  if (piece.size() < 3) return;
+  if (signed_area(piece) < 0.0f) std::reverse(piece.begin(), piece.end());
+  loops->push_back(std::move(piece));
+}
+
 }  // namespace
 
 void Canvas2D::stroke_subpath(const CanvasSubpath &points, bool closed, const CanvasPaint &paint) {
@@ -54,10 +75,12 @@ void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float h
   const size_t n = pts.size();
   if (n < 2) return;
 
-  auto fill_loop = [&](const CanvasSubpath &loop) {
-    canvas_detail::fill_loop(image_.pixels, image_.width, image_.height, loop, paint,
-                             state_.global_alpha);
-  };
+  /* Every segment, join and cap becomes one polygon; the whole polyline is
+   * filled in a single coverage pass instead of one pass per piece (which was
+   * the dominant cost of a many-segment stroke). */
+  std::vector<CanvasSubpath> loops;
+  loops.reserve(n * 2 + 2);
+
   auto fill_disc = [&](const CanvasPoint &p) {
     CanvasSubpath disc;
     const int segments = 24;
@@ -66,7 +89,7 @@ void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float h
       float angle = 2.0f * kPi * ((float)i / (float)segments);
       disc.push_back(CanvasPoint{p.x + half * std::cos(angle), p.y + half * std::sin(angle)});
     }
-    fill_loop(disc);
+    append_piece(&loops, std::move(disc));
   };
 
   /* Segments. A square cap extends the first/last quad along the line by half
@@ -92,7 +115,7 @@ void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float h
     }
     CanvasSubpath quad{CanvasPoint{p.x + nx, p.y + ny}, CanvasPoint{q.x + nx, q.y + ny},
                        CanvasPoint{q.x - nx, q.y - ny}, CanvasPoint{p.x - nx, p.y - ny}};
-    fill_loop(quad);
+    append_piece(&loops, std::move(quad));
   }
 
   /* Joins: round adds a disc, bevel a triangle, miter the intersect of the two
@@ -120,7 +143,7 @@ void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float h
     CanvasPoint a{p.x - v1y * half * side, p.y + v1x * half * side};
     CanvasPoint b{p.x - v2y * half * side, p.y + v2x * half * side};
     if (state_.line_join == 2) {
-      fill_loop(CanvasSubpath{a, b, p});
+      append_piece(&loops, CanvasSubpath{a, b, p});
       return;
     }
     float t = ((b.x - a.x) * v2y - (b.y - a.y) * v2x) / cross;
@@ -128,9 +151,9 @@ void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float h
     float miterLength = std::sqrt((miter.x - p.x) * (miter.x - p.x) +
                                   (miter.y - p.y) * (miter.y - p.y));
     if (std::isfinite(miterLength) && miterLength <= half * state_.miter_limit) {
-      fill_loop(CanvasSubpath{a, miter, b, p});
+      append_piece(&loops, CanvasSubpath{a, miter, b, p});
     } else {
-      fill_loop(CanvasSubpath{a, b, p});
+      append_piece(&loops, CanvasSubpath{a, b, p});
     }
   };
 
@@ -148,6 +171,11 @@ void Canvas2D::stroke_polyline(const CanvasSubpath &points, bool closed, float h
       fill_disc(pts.back());
     }
   }
+
+  if (!loops.empty()) {
+    canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, paint,
+                              state_.global_alpha, false, clip_mask());
+  }
 }
 
 void Canvas2D::dash_polyline(const CanvasSubpath &points, bool closed,

package/runtime/ext_gui/canvas_style.cpp

@@ -144,6 +144,65 @@ void Canvas2D::set_global_alpha(float alpha) {
   state_.global_alpha = alpha;
 }
 
+void Canvas2D::set_global_composite_operation(const std::string &value) {
+  std::string lower = lower_ascii(value);
+  struct Entry {
+    const char *name;
+    int value;
+  };
+  static const Entry entries[] = {
+      {"source-over", kCanvasCompositeSourceOver},
+      {"source-in", kCanvasCompositeSourceIn},
+      {"source-out", kCanvasCompositeSourceOut},
+      {"source-atop", kCanvasCompositeSourceAtop},
+      {"destination-over", kCanvasCompositeDestinationOver},
+      {"destination-in", kCanvasCompositeDestinationIn},
+      {"destination-out", kCanvasCompositeDestinationOut},
+      {"destination-atop", kCanvasCompositeDestinationAtop},
+      {"lighter", kCanvasCompositeLighter},
+      {"copy", kCanvasCompositeCopy},
+      {"xor", kCanvasCompositeXor},
+      {"multiply", kCanvasCompositeMultiply},
+      {"screen", kCanvasCompositeScreen},
+      {"overlay", kCanvasCompositeOverlay},
+      {"darken", kCanvasCompositeDarken},
+      {"lighten", kCanvasCompositeLighten},
+      {"color-dodge", kCanvasCompositeColorDodge},
+      {"color-burn", kCanvasCompositeColorBurn},
+      {"hard-light", kCanvasCompositeHardLight},
+      {"soft-light", kCanvasCompositeSoftLight},
+      {"difference", kCanvasCompositeDifference},
+      {"exclusion", kCanvasCompositeExclusion},
+      {"hue", kCanvasCompositeHue},
+      {"saturation", kCanvasCompositeSaturation},
+      {"color", kCanvasCompositeColor},
+      {"luminosity", kCanvasCompositeLuminosity},
+  };
+  for (const Entry &entry : entries) {
+    if (lower == entry.name) {
+      state_.global_composite = entry.value;
+      state_.global_composite_string = entry.name;
+      return;
+    }
+  }
+}
+
+void Canvas2D::set_shadow_color(const std::string &css) {
+  parse_color_into(css, state_.shadow_color, &state_.shadow_color_string);
+}
+
+void Canvas2D::set_shadow_blur(float blur) {
+  if (!positive_finite(blur)) return;
+  state_.shadow_blur = blur;
+}
+
+void Canvas2D::set_image_smoothing_quality(const std::string &value) {
+  std::string lower = lower_ascii(value);
+  if (lower == "low" || lower == "medium" || lower == "high") {
+    state_.image_smoothing_quality = lower;
+  }
+}
+
 void Canvas2D::set_font(const std::string &font) {
   state_.font = parse_font_string(font);
   state_.font_string = font;

package/runtime/ext_gui/canvas_text.cpp

@@ -0,0 +1,140 @@
+/*
+ * xbintsc GUI engine — Canvas2D text drawing.
+ *
+ * `fillText`/`strokeText` shape a run with HarfBuzz and blit FreeType glyph
+ * coverage through the rasteriser. The state and path live in `canvas.h`; this
+ * unit only owns the text entry points and the optional `maxWidth` condense.
+ */
+
+#include "canvas.h"
+
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "canvas_internal.h"
+#include "perf.h"
+
+namespace xtgui {
+
+float Canvas2D::measure_text(const std::string &text) const {
+  return xt_text_measure_width(text, state_.font);
+}
+
+void Canvas2D::paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
+                          bool stroke, float max_width) {
+  Font *font = xt_text_resolve(state_.font);
+  if (font == nullptr) return;
+  /* Layout and paint share the bounded shaping cache: a label redrawn every
+   * frame is shaped once, not once per frame. `maxWidth` only condenses the
+   * drawn run, so it does not affect the shaped result. */
+  const ShapedRun *run = xt_text_shape_cached(text, font);
+  if (run == nullptr) return;
+  const std::vector<ShapedGlyph> &glyphs = run->glyphs;
+  float width = run->width;
+  float ascent = 0.0f, descent = 0.0f, lineHeight = 0.0f;
+  xt_text_metrics(state_.font, &ascent, &descent, &lineHeight);
+
+  /* The optional `maxWidth` condenses the run horizontally instead of clipping
+   * it: advances and glyph bitmaps are squeezed by the same factor. */
+  float horizontal = 1.0f;
+  if (max_width > 0.0f && width > max_width && width > 0.0001f) {
+    horizontal = max_width / width;
+  }
+
+  float originX = x;
+  if (state_.text_align == 1) {
+    originX -= width * horizontal * 0.5f;
+  } else if (state_.text_align == 2) {
+    originX -= width * horizontal;
+  }
+  float originY = y;
+  switch (state_.text_baseline) {
+    case 1:
+      originY += ascent;
+      break;
+    case 2:
+      originY += (ascent - descent) * 0.5f;
+      break;
+    case 3:
+      originY -= descent;
+      break;
+    case 4:
+      originY += ascent * 0.8f;
+      break;
+    case 5:
+      originY -= descent;
+      break;
+    default:
+      break;
+  }
+
+  float scale = state_.transform.scale();
+  if (scale <= 0.0001f) scale = 1.0f;
+  bool scaled = std::fabs(scale - 1.0f) > 0.01f;
+
+  /* Scaling a face is a cached lookup, but it was still one path key + hash
+   * per glyph. There are at most a handful of faces in a run, so remember the
+   * sized face for the ones this call touches. */
+  Font *scaled_from[8] = {nullptr};
+  Font *scaled_to[8] = {nullptr};
+  int scaled_count = 0;
+  auto sized_face = [&](Font *face) -> Font * {
+    for (int i = 0; i < scaled_count; i++) {
+      if (scaled_from[i] == face) return scaled_to[i];
+    }
+    Font *sized = xt_text_scale(face, state_.font.pixel_size * scale);
+    if (sized == nullptr) sized = face;
+    if (scaled_count < 8) {
+      scaled_from[scaled_count] = face;
+      scaled_to[scaled_count] = sized;
+      scaled_count += 1;
+    }
+    return sized;
+  };
+
+  float penX = 0.0f;
+  for (const ShapedGlyph &glyph : glyphs) {
+    float userX = originX + (penX + glyph.x_offset) * horizontal;
+    float userY = originY + glyph.y_offset;
+    float deviceX = 0.0f, deviceY = 0.0f;
+    to_device(userX, userY, &deviceX, &deviceY);
+    Font *face = glyph.font != nullptr ? glyph.font : font;
+    if (scaled) face = sized_face(face);
+    const GlyphImage *image = xt_text_glyph_cached(face, glyph.glyph);
+    if (image != nullptr && image->width > 0 && image->height > 0) {
+      const float left = deviceX + (float)image->left * horizontal;
+      const float top = deviceY - (float)image->top;
+      mark_dirty(left, top, left + (float)image->width * horizontal,
+                 top + (float)image->height);
+      canvas_detail::blit_glyph(image_.pixels, image_.width, image_.height, image->pixels,
+                                image->width, image->height, image->left, image->top, deviceX,
+                                deviceY, horizontal, paint, state_.global_alpha, clip_mask());
+    }
+    penX += glyph.x_advance;
+  }
+  (void)stroke;
+  generation_++;
+}
+
+void Canvas2D::fill_text(const std::string &text, float x, float y, float max_width) {
+  if (begin_shadow_layer()) {
+    fill_text(text, x, y, max_width);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
+  paint_text(text, x, y, fill_paint(), false, max_width);
+}
+
+void Canvas2D::stroke_text(const std::string &text, float x, float y, float max_width) {
+  if (begin_shadow_layer()) {
+    stroke_text(text, x, y, max_width);
+    end_shadow_layer();
+    return;
+  }
+  g_perf_frame.canvasDraws += 1;
+  paint_text(text, x, y, stroke_paint(), true, max_width);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/css.h

@@ -81,6 +81,13 @@ struct Rule {
 
 struct StyleSheet {
   std::vector<Rule> rules;
+  /* Facts the cascade can act on once per sheet instead of once per element (a
+   * `@media` block, a `::before` rule or a `transition` declaration used to be
+   * discovered by scanning every rule for every node). */
+  bool has_pseudo_elements = false;
+  bool has_hover = false;
+  bool has_focus = false;
+  bool has_transitions = false;
 };
 
 /** Dynamic element state consulted by `:hover` / `:focus` while matching. */

package/runtime/ext_gui/css_sheet.cpp

@@ -140,6 +140,27 @@ void parseRules(const std::string &text, const std::string &media, int *order,
   }
 }
 
+/** Record the sheet-wide facts the cascade consults per run (see `StyleSheet`).
+ * `:hover`/`:focus` are matched by substring so a nested `:not(:hover)` rule is
+ * still recognised — a false positive only costs the restyle that is already
+ * being skipped. */
+void computeSheetFlags(StyleSheet *sheet) {
+  for (const Rule &rule : sheet->rules) {
+    for (const ComplexSelector &selector : rule.selectors) {
+      for (const CompoundSelector &compound : selector.compounds) {
+        if (!compound.pseudo_element.empty()) sheet->has_pseudo_elements = true;
+        for (const std::string &pseudo : compound.pseudoClasses) {
+          if (pseudo.find("hover") != std::string::npos) sheet->has_hover = true;
+          if (pseudo.find("focus") != std::string::npos) sheet->has_focus = true;
+        }
+      }
+    }
+    for (const Declaration &declaration : rule.declarations) {
+      if (declaration.property.compare(0, 10, "transition") == 0) sheet->has_transitions = true;
+    }
+  }
+}
+
 }  // namespace
 
 std::vector<Declaration> xt_css_parse_declarations(const std::string &text) {
@@ -167,6 +188,7 @@ StyleSheet xt_css_parse_stylesheet(const std::string &text) {
   std::string clean = stripComments(text);
   int order = 0;
   parseRules(clean, "", &order, &sheet);
+  computeSheetFlags(&sheet);
   return sheet;
 }
 

package/runtime/ext_gui/document.cpp

@@ -4,6 +4,8 @@
 
 #include "document.h"
 
+#include "perf.h"
+
 namespace xtgui {
 
 void XtDocument::collectStyleText(const Node *node, std::string *out) const {
@@ -43,11 +45,15 @@ void XtDocument::load(const std::string &html, float viewportWidth, float viewpo
 void XtDocument::restyle(float viewportWidth, float viewportHeight) {
   viewportWidth_ = viewportWidth;
   viewportHeight_ = viewportHeight;
+  g_perf_frame.restyles += 1;
   if (root_ != nullptr) {
     MatchState state;
     state.hover = hover_;
     state.focus = focus_;
-    xt_style_compute(root_.get(), sheet_, styles_, viewportWidth, viewportHeight, state, &pseudos_);
+    bool hasTransitions = sheet_.has_transitions;
+    xt_style_compute(root_.get(), sheet_, styles_, viewportWidth, viewportHeight, state, &pseudos_,
+                     &hasTransitions);
+    has_transitions_ = hasTransitions;
     startTransitions();
     updateDisplay();
   }
@@ -119,6 +125,10 @@ void applyNumber(XtStyle *style, const std::string &property, float value) {
 
 void XtDocument::startTransitions() {
   if (display_.empty()) return;  // first style computation: nothing to animate from
+  /* Without a `transition` declaration anywhere in the sheet (or in an inline
+   * style) no transition can start, so skip the O(nodes) scan `restyle` would
+   * otherwise do every time. */
+  if (!has_transitions_) return;
   static const char *const kProperties[] = {"background-color", "color", "border-color",
                                            "border-radius", "transform"};
   for (auto &entry : styles_) {
@@ -186,6 +196,17 @@ void XtDocument::startTransitions() {
 }
 
 void XtDocument::updateDisplay() {
+  /* Without a `transition` declaration in the sheet (or an inline style) no
+   * transition can ever start, so the displayed style *is* the cascade result:
+   * skip the per-node deep copy of the whole style map (and keep `display_`
+   * empty, which `styleOf` already falls back from). */
+  if (!has_transitions_) {
+    if (!transitions_.empty()) transitions_.clear();
+    if (!display_.empty()) display_.clear();
+    layout_.compute(root_.get(), styles_, viewportWidth_, viewportHeight_, &mediaSizes_,
+                    &canvasInfo_);
+    return;
+  }
   display_ = styles_;
   for (size_t i = 0; i < transitions_.size();) {
     ActiveTransition &transition = transitions_[i];
@@ -232,6 +253,8 @@ bool XtDocument::advance(double delta_ms) {
 bool XtDocument::setHover(const Node *node) {
   if (hover_ == node) return false;
   hover_ = node;
+  /* No `:hover` rule anywhere: the state changed but the paint cannot. */
+  if (!sheet_.has_hover) return false;
   restyle(viewportWidth_, viewportHeight_);
   return true;
 }
@@ -239,6 +262,7 @@ bool XtDocument::setHover(const Node *node) {
 bool XtDocument::setFocus(const Node *node) {
   if (focus_ == node) return false;
   focus_ = node;
+  if (!sheet_.has_focus) return false;
   restyle(viewportWidth_, viewportHeight_);
   return true;
 }

package/runtime/ext_gui/document.h

@@ -93,6 +93,10 @@ class XtDocument {
 
   /** Mark the document as needing a restyle/relayout before the next paint. */
   void invalidate() { dirty_ = true; }
+  /** Whether a restyle is pending (peek; `takeDirty` consumes it). The frame
+   * loop uses this to skip reconciling media/canvas tables when nothing in the
+   * document changed. */
+  bool dirty() const { return dirty_; }
   bool takeDirty() {
     bool was = dirty_;
     dirty_ = false;
@@ -127,6 +131,10 @@ class XtDocument {
   MediaSizeMap mediaSizes_;                            // `<video>` intrinsic sizes
   CanvasInfoMap canvasInfo_;                           // `<canvas>` sizes + ids
   std::vector<ActiveTransition> transitions_;
+  /** Whether any computed style declares a `transition` (from the sheet or an
+   * inline `style="…"`): when false the document skips the transition snapshot
+   * and `display_` stays empty. */
+  bool has_transitions_ = false;
   double clock_ms_ = 0.0;
   LayoutTree layout_;
   const Node *hover_ = nullptr;

package/runtime/ext_gui/dom_api_canvas.cpp

@@ -80,6 +80,9 @@ std::string canvas_string_arg(int32_t argc, xt_value *argv, int32_t index) {
 METHOD(node_get_context) {
   (void)env;
   std::string mode = string_arg(argc, argv, 0);
+  /* After `transferControlToOffscreen` the element has no usable context; the
+   * OffscreenCanvas owns it. */
+  if (value_truthy(xt_object_get_cstr(self, "__xt_gui_offscreen"))) return XT_NULL;
   XtGuiWindow *win = nullptr;
   xtgui::Node *node = resolve_node(self, &win);
   if (mode == "webgl" || mode == "experimental-webgl" || mode == "webgl2") {
@@ -466,8 +469,20 @@ METHOD(canvas_draw_image) {
   xtgui::Canvas2D *canvas = context_canvas(self);
   if (canvas == nullptr || argc < 3) return XT_UNDEFINED;
   XtGuiWindow *win = nullptr;
-  xtgui::Node *source = resolve_node(xt_arg(argc, argv, 0), &win);
+  xt_value source_value = xt_arg(argc, argv, 0);
   const xtgui::Image *image = nullptr;
+  /* An `OffscreenCanvas` (or a transferred one) has no DOM node; its bitmap is
+   * reachable through the process-wide canvas id. */
+  if (XT_IS_OBJECT(source_value)) {
+    xt_value canvas_id = xt_object_get_cstr(source_value, "__xt_gui_canvas");
+    if (XT_IS_NUMBER(canvas_id)) {
+      xtgui::Canvas2D *offscreen = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
+      if (offscreen != nullptr) {
+        image = &offscreen->image();
+      }
+    }
+  }
+  xtgui::Node *source = resolve_node(source_value, &win);
   if (source != nullptr && source->isElement() && source->isTag("img")) {
     const std::string *src = source->attr("src");
     if (src != nullptr) image = xtgui::xt_image_load(*src);

package/runtime/ext_gui/dom_api_canvas_image.cpp

@@ -54,6 +54,15 @@ xt_value make_image_data(int width, int height, const std::vector<unsigned char>
 
 /** Decode a `createPattern` source: an `<img>` or another `<canvas>`. */
 bool source_image(XtGuiWindow *win, xt_value value, xtgui::Image *out) {
+  if (XT_IS_OBJECT(value)) {
+    xt_value canvas_id = xt_object_get_cstr(value, "__xt_gui_canvas");
+    if (XT_IS_NUMBER(canvas_id)) {
+      xtgui::Canvas2D *offscreen = xtgui::xt_canvas_by_id((uint64_t)xt_to_number(canvas_id));
+      if (offscreen == nullptr) return false;
+      *out = offscreen->image();
+      return out->width > 0 && out->height > 0;
+    }
+  }
   xtgui::Node *node = resolve_node(value, &win);
   if (node == nullptr || !node->isElement()) return false;
   if (node->isTag("img")) {