xbintsc 0.5.36 → 0.5.38

package/runtime/ext_gui/browser_media.cpp

@@ -0,0 +1,176 @@
+/*
+ * xbintsc GUI engine — live `matchMedia` lists.
+ *
+ * `window.matchMedia(query)` returns one cached `MediaQueryList` per query. The
+ * engine re-evaluates every live list on a window resize (the same evaluator
+ * `@media` rules use) and dispatches a `change` event when the match flips, so
+ * a page can react to a viewport change instead of polling `matches`.
+ */
+
+#include "gui_engine.h"
+
+
+#include <string>
+#include <vector>
+
+#include "css.h"
+
+namespace {
+
+std::string string_value(xt_value value) {
+  const char *data = xt_string_data(xt_to_string(value));
+  return data != nullptr ? data : "";
+}
+
+xt_value listeners_of(xt_value self, bool create) {
+  xt_value listeners = xt_object_get_cstr(self, "__xt_gui_media_listeners");
+  if (XT_IS_ARRAY(listeners) || !create) return listeners;
+  listeners = xt_array_new(0, nullptr);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_media_listeners"), listeners);
+  return listeners;
+}
+
+void add_listener(xt_value self, xt_value fn, bool once, xt_value signal) {
+  if (!XT_IS_FUNCTION(fn)) return;
+  xt_value entry = xt_object_new();
+  xt_object_set(entry, xt_string_from_cstr("fn"), fn);
+  xt_object_set(entry, xt_string_from_cstr("once"), once ? XT_TRUE : XT_FALSE);
+  xt_object_set(entry, xt_string_from_cstr("signal"), signal);
+  xt_array_push(listeners_of(self, true), entry);
+}
+
+void remove_listener(xt_value self, xt_value fn) {
+  xt_value listeners = listeners_of(self, false);
+  if (!XT_IS_ARRAY(listeners)) return;
+  xt_value kept = xt_array_new(0, nullptr);
+  int32_t count = (int32_t)xt_to_number(xt_array_length(listeners));
+  for (int32_t i = 0; i < count; i++) {
+    xt_value entry = xt_array_get(listeners, xt_number((double)i));
+    if (!xt_truthy(xt_seq(xt_object_get_cstr(entry, "fn"), fn))) xt_array_push(kept, entry);
+  }
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_media_listeners"), kept);
+}
+
+void call_change_listener(xt_value fn, xt_value list, xt_value event) {
+  if (!XT_IS_FUNCTION(fn)) return;
+  xt_value args[1] = {event};
+  xt_call_with_this(fn, list, 1, args);
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(media_add_event_listener) {
+  (void)env;
+  if (argc < 2 || string_value(xt_arg(argc, argv, 0)) != "change") return XT_UNDEFINED;
+  bool once = false;
+  xt_value options = xt_arg(argc, argv, 2);
+  if (XT_IS_OBJECT(options)) once = xt_truthy(xt_object_get_cstr(options, "once")) != 0;
+  add_listener(self, xt_arg(argc, argv, 1), once, XT_UNDEFINED);
+  return XT_UNDEFINED;
+}
+
+METHOD(media_remove_event_listener) {
+  (void)env;
+  if (argc < 2 || string_value(xt_arg(argc, argv, 0)) != "change") return XT_UNDEFINED;
+  remove_listener(self, xt_arg(argc, argv, 1));
+  return XT_UNDEFINED;
+}
+
+/** Legacy `addListener(fn)` / `removeListener(fn)`. */
+METHOD(media_add_listener) {
+  (void)env;
+  if (argc >= 1) add_listener(self, xt_arg(argc, argv, 0), false, XT_UNDEFINED);
+  return XT_UNDEFINED;
+}
+
+METHOD(media_remove_listener) {
+  (void)env;
+  if (argc >= 1) remove_listener(self, xt_arg(argc, argv, 0));
+  return XT_UNDEFINED;
+}
+
+METHOD(media_onchange_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_object_get_cstr(self, "__xt_gui_media_onchange");
+}
+
+METHOD(media_onchange_set) {
+  (void)env;
+  if (argc >= 1) {
+    xt_object_set(self, xt_string_from_cstr("__xt_gui_media_onchange"), xt_arg(argc, argv, 0));
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+xt_value build_list(const std::string &query, bool matches) {
+  xt_value list = xt_object_new();
+  xt_object_set(list, xt_string_from_cstr("media"), xt_string_from_cstr(query.c_str()));
+  xt_object_set(list, xt_string_from_cstr("matches"), matches ? XT_TRUE : XT_FALSE);
+  xt_object_set(list, xt_string_from_cstr("__xt_gui_media_query"),
+                xt_string_from_cstr(query.c_str()));
+  xt_object_set(list, xt_string_from_cstr("addEventListener"),
+                xt_closure_new((void *)media_add_event_listener, 0, nullptr));
+  xt_object_set(list, xt_string_from_cstr("removeEventListener"),
+                xt_closure_new((void *)media_remove_event_listener, 0, nullptr));
+  xt_object_set(list, xt_string_from_cstr("addListener"),
+                xt_closure_new((void *)media_add_listener, 0, nullptr));
+  xt_object_set(list, xt_string_from_cstr("removeListener"),
+                xt_closure_new((void *)media_remove_listener, 0, nullptr));
+  xt_object_define_getter(list, xt_string_from_cstr("onchange"),
+                          xt_closure_new((void *)media_onchange_get, 0, nullptr));
+  xt_object_define_setter(list, xt_string_from_cstr("onchange"),
+                          xt_closure_new((void *)media_onchange_set, 0, nullptr));
+  return list;
+}
+
+}  // namespace
+
+xt_value xt_browser_media_list(xt_value window, const std::string &query) {
+  XtGuiWindow *win = xt_gui_window_from_this(window);
+  if (win == nullptr) return build_list(query, false);
+  auto cached = win->media_lists_by_query.find(query);
+  if (cached != win->media_lists_by_query.end()) return cached->second;
+  float width = 0.0f;
+  float height = 0.0f;
+  xt_gui_window_viewport(win, &width, &height);
+  xt_value list = build_list(query, xtgui::xt_css_media_matches(query, width, height));
+  win->media_lists.push_back(list);
+  win->media_lists_by_query[query] = list;
+  return list;
+}
+
+void xt_gui_media_lists_notify(XtGuiWindow *win) {
+  if (win == nullptr) return;
+  float width = 0.0f;
+  float height = 0.0f;
+  xt_gui_window_viewport(win, &width, &height);
+  for (xt_value list : win->media_lists) {
+    if (!XT_IS_OBJECT(list)) continue;
+    std::string query = string_value(xt_object_get_cstr(list, "__xt_gui_media_query"));
+    bool matches = xtgui::xt_css_media_matches(query, width, height);
+    bool was = xt_truthy(xt_object_get_cstr(list, "matches"));
+    xt_object_set(list, xt_string_from_cstr("matches"), matches ? XT_TRUE : XT_FALSE);
+    if (was == matches) continue;
+    xt_value event = xt_object_new();
+    xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr("change"));
+    xt_object_set(event, xt_string_from_cstr("media"), xt_string_from_cstr(query.c_str()));
+    xt_object_set(event, xt_string_from_cstr("matches"), matches ? XT_TRUE : XT_FALSE);
+    xt_value onchange = xt_object_get_cstr(list, "__xt_gui_media_onchange");
+    call_change_listener(onchange, list, event);
+    xt_value listeners = listeners_of(list, false);
+    if (!XT_IS_ARRAY(listeners)) continue;
+    xt_value snapshot = xt_array_new(0, nullptr);
+    int32_t count = (int32_t)xt_to_number(xt_array_length(listeners));
+    for (int32_t i = 0; i < count; i++) {
+      xt_array_push(snapshot, xt_array_get(listeners, xt_number((double)i)));
+    }
+    for (int32_t i = 0; i < count; i++) {
+      xt_value entry = xt_array_get(snapshot, xt_number((double)i));
+      call_change_listener(xt_object_get_cstr(entry, "fn"), list, event);
+    }
+  }
+}

package/runtime/ext_gui/browser_navigation.cpp

@@ -0,0 +1,130 @@
+/*
+ * xbintsc GUI engine — window navigation and focus.
+ *
+ * `scrollTo` / `scrollBy` move the page viewport (painting and hit testing
+ * subtract the offset), `scrollX`/`scrollY` (and the `page*Offset` aliases)
+ * report it, and `focus` / `blur` raise the OS window and toggle
+ * `document.hasFocus()` plus the corresponding window events.
+ */
+
+#include "gui_engine.h"
+
+#include <cmath>
+
+namespace {
+
+xt_value scroll_axis(xt_value options, const char *name) {
+  if (!XT_IS_OBJECT(options)) return XT_UNDEFINED;
+  return xt_object_get_cstr(options, name);
+}
+
+double coordinate(xt_value value, double fallback) {
+  return XT_IS_NUMBER(value) ? xt_to_number(value) : fallback;
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+/** `scrollTo(x, y)` / `scrollTo({ left, top })`. */
+METHOD(win_scroll_to) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_value options = xt_arg(argc, argv, 0);
+  double x = 0;
+  double y = 0;
+  if (XT_IS_OBJECT(options) && !XT_IS_ARRAY(options)) {
+    x = coordinate(scroll_axis(options, "left"), coordinate(scroll_axis(options, "x"), 0));
+    y = coordinate(scroll_axis(options, "top"), coordinate(scroll_axis(options, "y"), 0));
+  } else {
+    x = coordinate(options, 0);
+    if (argc >= 2) y = coordinate(xt_arg(argc, argv, 1), 0);
+  }
+  xt_gui_scroll_to(win, (float)x, (float)y);
+  return XT_UNDEFINED;
+}
+
+METHOD(win_scroll_by) {
+  (void)env;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || argc < 1) return XT_UNDEFINED;
+  xt_value options = xt_arg(argc, argv, 0);
+  double dx = 0;
+  double dy = 0;
+  if (XT_IS_OBJECT(options) && !XT_IS_ARRAY(options)) {
+    dx = coordinate(scroll_axis(options, "left"), coordinate(scroll_axis(options, "x"), 0));
+    dy = coordinate(scroll_axis(options, "top"), coordinate(scroll_axis(options, "y"), 0));
+  } else {
+    dx = coordinate(options, 0);
+    if (argc >= 2) dy = coordinate(xt_arg(argc, argv, 1), 0);
+  }
+  xt_gui_scroll_to(win, win->scroll_x + (float)dx, win->scroll_y + (float)dy);
+  return XT_UNDEFINED;
+}
+
+METHOD(win_scroll_x_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  return xt_number(win != nullptr ? (double)win->scroll_x : 0.0);
+}
+
+METHOD(win_scroll_y_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  return xt_number(win != nullptr ? (double)win->scroll_y : 0.0);
+}
+
+METHOD(win_focus) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || !win->open) return XT_UNDEFINED;
+  if (win->window != nullptr) SDL_RaiseWindow(win->window);
+  if (!win->focused) {
+    win->focused = 1;
+    xt_gui_emit(win, "focus");
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(win_blur) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr || !win->open) return XT_UNDEFINED;
+  if (win->focused) {
+    win->focused = 0;
+    xt_gui_emit(win, "blur");
+  }
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace
+
+void xt_browser_install_window_navigation(xt_value proto) {
+  xt_object_set(proto, xt_string_from_cstr("scrollTo"),
+                xt_closure_new((void *)win_scroll_to, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("scroll"),
+                xt_closure_new((void *)win_scroll_to, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("scrollBy"),
+                xt_closure_new((void *)win_scroll_by, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("focus"),
+                xt_closure_new((void *)win_focus, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("blur"),
+                xt_closure_new((void *)win_blur, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("scrollX"),
+                          xt_closure_new((void *)win_scroll_x_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("scrollY"),
+                          xt_closure_new((void *)win_scroll_y_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("pageXOffset"),
+                          xt_closure_new((void *)win_scroll_x_get, 0, nullptr));
+  xt_object_define_getter(proto, xt_string_from_cstr("pageYOffset"),
+                          xt_closure_new((void *)win_scroll_y_get, 0, nullptr));
+}

package/runtime/ext_gui/canvas.cpp

@@ -85,9 +85,20 @@ void Canvas2D::resize(int width, int height) {
   image_.width = width;
   image_.height = height;
   image_.pixels.assign((size_t)width * (size_t)height * 4, 0);
+  if (!alpha_) {
+    /* `{ alpha: false }`: the canvas has an opaque black backdrop, so cleared
+     * pixels are black rather than transparent. */
+    for (size_t i = 3; i < image_.pixels.size(); i += 4) image_.pixels[i] = 255;
+  }
   generation_++;
 }
 
+void Canvas2D::set_alpha(bool alpha) {
+  if (alpha_ == alpha) return;
+  alpha_ = alpha;
+  resize(image_.width, image_.height);
+}
+
 void Canvas2D::save() { stack_.push_back(state_); }
 
 void Canvas2D::restore() {
@@ -214,7 +225,8 @@ void Canvas2D::ellipse(float cx, float cy, float rx, float ry, float rotation, f
   append_path_points(points);
 }
 
-void Canvas2D::round_rect(float x, float y, float width, float height, float radius) {
+void Canvas2D::round_rect(float x, float y, float width, float height, float radius_tl,
+                          float radius_tr, float radius_br, float radius_bl) {
   if (width < 0.0f) {
     x += width;
     width = -width;
@@ -223,18 +235,25 @@ void Canvas2D::round_rect(float x, float y, float width, float height, float rad
     y += height;
     height = -height;
   }
-  float maxRadius = std::min(width, height) * 0.5f;
-  if (radius < 0.0f) radius = 0.0f;
-  if (radius > maxRadius) radius = maxRadius;
-  move_to(x + radius, y);
-  line_to(x + width - radius, y);
-  quadratic_curve_to(x + width, y, x + width, y + radius);
-  line_to(x + width, y + height - radius);
-  quadratic_curve_to(x + width, y + height, x + width - radius, y + height);
-  line_to(x + radius, y + height);
-  quadratic_curve_to(x, y + height, x, y + height - radius);
-  line_to(x, y + radius);
-  quadratic_curve_to(x, y, x + radius, y);
+  const float maxRadius = std::min(width, height) * 0.5f;
+  float radii[4] = {radius_tl, radius_tr, radius_br, radius_bl};
+  for (float &radius : radii) {
+    if (radius < 0.0f) radius = 0.0f;
+    if (radius > maxRadius) radius = maxRadius;
+  }
+  const float tl = radii[0];
+  const float tr = radii[1];
+  const float br = radii[2];
+  const float bl = radii[3];
+  move_to(x + tl, y);
+  line_to(x + width - tr, y);
+  quadratic_curve_to(x + width, y, x + width, y + tr);
+  line_to(x + width, y + height - br);
+  quadratic_curve_to(x + width, y + height, x + width - br, y + height);
+  line_to(x + bl, y + height);
+  quadratic_curve_to(x, y + height, x, y + height - bl);
+  line_to(x, y + tl);
+  quadratic_curve_to(x, y, x + tl, y);
   close_path();
 }
 
@@ -274,9 +293,14 @@ void Canvas2D::to_device(float x, float y, float *outX, float *outY) const {
 }
 
 std::vector<CanvasSubpath> Canvas2D::device_subpaths() const {
+  return device_subpaths_of(path_);
+}
+
+std::vector<CanvasSubpath> Canvas2D::device_subpaths_of(
+    const std::vector<CanvasSubpath> &paths) const {
   std::vector<CanvasSubpath> result;
-  result.reserve(path_.size());
-  for (const CanvasSubpath &subpath : path_) {
+  result.reserve(paths.size());
+  for (const CanvasSubpath &subpath : paths) {
     CanvasSubpath device;
     device.reserve(subpath.size());
     for (const CanvasPoint &point : subpath) {
@@ -289,23 +313,25 @@ std::vector<CanvasSubpath> Canvas2D::device_subpaths() const {
   return result;
 }
 
-CanvasPaint Canvas2D::make_paint(uint64_t gradient_id, const float color[4]) const {
+CanvasPaint Canvas2D::make_paint(uint64_t gradient_id, uint64_t pattern_id,
+                                 const float color[4]) const {
   CanvasPaint paint;
   paint.color = color;
   paint.gradient = gradient_id == 0 ? nullptr : find_gradient(gradient_id);
+  paint.pattern = pattern_id == 0 ? nullptr : find_pattern(pattern_id);
   paint.inverse = state_.transform.inverted();
   return paint;
 }
 
 CanvasPaint Canvas2D::fill_paint() const {
-  return make_paint(state_.fill_gradient, state_.fill_color);
+  return make_paint(state_.fill_gradient, state_.fill_pattern, state_.fill_color);
 }
 
 CanvasPaint Canvas2D::stroke_paint() const {
-  return make_paint(state_.stroke_gradient, state_.stroke_color);
+  return make_paint(state_.stroke_gradient, state_.stroke_pattern, state_.stroke_color);
 }
 
-void Canvas2D::fill() {
+void Canvas2D::fill(bool even_odd) {
   std::vector<CanvasSubpath> subpaths = device_subpaths();
   std::vector<CanvasSubpath> loops;
   for (CanvasSubpath &subpath : subpaths) {
@@ -314,7 +340,20 @@ void Canvas2D::fill() {
   }
   if (loops.empty()) return;
   canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, fill_paint(),
-                            state_.global_alpha);
+                            state_.global_alpha, even_odd);
+  generation_++;
+}
+
+void Canvas2D::fill_paths(const std::vector<CanvasSubpath> &paths, bool even_odd) {
+  std::vector<CanvasSubpath> subpaths = device_subpaths_of(paths);
+  std::vector<CanvasSubpath> loops;
+  for (CanvasSubpath &subpath : subpaths) {
+    if (subpath.size() < 3) continue;
+    loops.push_back(std::move(subpath));
+  }
+  if (loops.empty()) return;
+  canvas_detail::fill_loops(image_.pixels, image_.width, image_.height, loops, fill_paint(),
+                            state_.global_alpha, even_odd);
   generation_++;
 }
 
@@ -330,6 +369,18 @@ void Canvas2D::stroke() {
   generation_++;
 }
 
+void Canvas2D::stroke_paths(const std::vector<CanvasSubpath> &paths) {
+  std::vector<CanvasSubpath> subpaths = device_subpaths_of(paths);
+  const CanvasPaint paint = stroke_paint();
+  for (const CanvasSubpath &subpath : subpaths) {
+    if (subpath.size() < 2) continue;
+    bool closed = subpath.size() >= 3 && subpath.front().x == subpath.back().x &&
+                  subpath.front().y == subpath.back().y;
+    stroke_subpath(subpath, closed, paint);
+  }
+  generation_++;
+}
+
 void Canvas2D::clear_rect(float x, float y, float width, float height) {
   float x0, y0, x1, y1;
   to_device(x, y, &x0, &y0);
@@ -378,7 +429,7 @@ float Canvas2D::measure_text(const std::string &text) const {
 }
 
 void Canvas2D::paint_text(const std::string &text, float x, float y, const CanvasPaint &paint,
-                          bool stroke) {
+                          bool stroke, float max_width) {
   Font *font = xt_text_resolve(state_.font);
   if (font == nullptr) return;
   std::vector<ShapedGlyph> glyphs;
@@ -386,11 +437,18 @@ void Canvas2D::paint_text(const std::string &text, float x, float y, const Canva
   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 * 0.5f;
+    originX -= width * horizontal * 0.5f;
   } else if (state_.text_align == 2) {
-    originX -= width;
+    originX -= width * horizontal;
   }
   float originY = y;
   switch (state_.text_baseline) {
@@ -419,7 +477,7 @@ void Canvas2D::paint_text(const std::string &text, float x, float y, const Canva
 
   float penX = 0.0f;
   for (const ShapedGlyph &glyph : glyphs) {
-    float userX = originX + penX + glyph.x_offset;
+    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);
@@ -431,8 +489,8 @@ void Canvas2D::paint_text(const std::string &text, float x, float y, const Canva
     GlyphImage image;
     if (xt_text_rasterize(face, glyph.glyph, image) && image.width > 0 && image.height > 0) {
       canvas_detail::blit_glyph(image_.pixels, image_.width, image_.height, image.pixels, image.width,
-                                image.height, image.left, image.top, deviceX, deviceY, paint,
-                                state_.global_alpha);
+                                image.height, image.left, image.top, deviceX, deviceY, horizontal,
+                                paint, state_.global_alpha);
     }
     penX += glyph.x_advance;
   }
@@ -440,12 +498,12 @@ void Canvas2D::paint_text(const std::string &text, float x, float y, const Canva
   generation_++;
 }
 
-void Canvas2D::fill_text(const std::string &text, float x, float y) {
-  paint_text(text, x, y, fill_paint(), false);
+void Canvas2D::fill_text(const std::string &text, float x, float y, float max_width) {
+  paint_text(text, x, y, fill_paint(), false, max_width);
 }
 
-void Canvas2D::stroke_text(const std::string &text, float x, float y) {
-  paint_text(text, x, y, stroke_paint(), true);
+void Canvas2D::stroke_text(const std::string &text, float x, float y, float max_width) {
+  paint_text(text, x, y, stroke_paint(), true, max_width);
 }
 
 void Canvas2D::draw_image(const Image &source, float dx, float dy, float dw, float dh, float sx,