xbintsc 0.3.18 → 0.3.35

package/runtime/ext_gui/gui.cpp

@@ -8,25 +8,65 @@
  *
  * The engine is deliberately free of any compiler knowledge: it only uses the
  * public runtime ABI (`rt.h`).
+ *
+ * Input dispatch and per-frame rendering live in `gui_events.cpp`; the shared
+ * process state is declared in `gui_internal.h`.
  */
 
-#include "gui_engine.h"
+#include "gui_internal.h"
+
+#include "image.h"
 #include "paint.h"
 
 #include <stdio.h>
 #include <string.h>
 
-#define XT_GUI_MAX_WINDOWS 64
+namespace guidev {
+
+SDL_GPUDevice *g_device = NULL;
+int g_sdl_initialized = 0;
+int g_quit = 0;
+XtGuiWindow g_windows[XT_GUI_MAX_WINDOWS];
+int g_window_count = 0;
+
+/* Optional application icon embedded at compile time by the driver (`--icon` /
+ * `app.icon`). The symbols live in a small object the driver links into every
+ * GUI program (an empty object when no icon is configured), so the references
+ * are plain: `xt_app_icon_size == 0` means "no icon". */
+extern "C" {
+extern const unsigned char xt_app_icon_data[];
+extern const unsigned long long xt_app_icon_size;
+extern const char xt_app_icon_format[];
+extern const unsigned int xt_app_icon_width;
+extern const unsigned int xt_app_icon_height;
+}
 
-static SDL_GPUDevice *g_device = NULL;
-static int g_sdl_initialized = 0;
-static int g_quit = 0;
-static XtGuiWindow g_windows[XT_GUI_MAX_WINDOWS];
-static int g_window_count = 0;
+/**
+ * Set the window / taskbar / Dock icon from the embedded PNG, if any. Decoding
+ * goes through the same stb_image path as `<img>`, so the icon needs no extra
+ * dependency. Failures are silent: an icon is cosmetic and must never stop the
+ * program from starting.
+ */
+void xt_gui_apply_icon(SDL_Window *window) {
+  if (window == NULL) return;
+  size_t size = (size_t)xt_app_icon_size;
+  if (size == 0) return;
+  if (strcmp(xt_app_icon_format, "png") != 0) return;
+
+  xtgui::Image image;
+  if (!xtgui::xt_image_decode(xt_app_icon_data, size, &image)) return;
+  if (image.width <= 0 || image.height <= 0) return;
+
+  SDL_Surface *surface = SDL_CreateSurfaceFrom(
+      image.width, image.height, SDL_PIXELFORMAT_RGBA32, image.pixels.data(), image.width * 4);
+  if (surface == NULL) return;
+  SDL_SetWindowIcon(window, surface);
+  SDL_DestroySurface(surface);
+}
 
 /* -- initialisation ------------------------------------------------------- */
 
-static int xt_gui_ensure_init(void) {
+static int ensure_init(void) {
   if (g_sdl_initialized) return 1;
   if (!SDL_Init(SDL_INIT_VIDEO)) {
     fprintf(stderr, "xt_gui: SDL_Init failed: %s\n", SDL_GetError());
@@ -48,7 +88,7 @@ static int xt_gui_ensure_init(void) {
 
 /* -- window lookup -------------------------------------------------------- */
 
-static XtGuiWindow *xt_gui_window_by_object(xt_value object) {
+static XtGuiWindow *window_by_object(xt_value object) {
   xt_value index_value = xt_object_get_cstr(object, "__xt_gui_index");
   if (!XT_IS_NUMBER(index_value)) return NULL;
   int index = (int)xt_to_number(index_value);
@@ -56,39 +96,21 @@ static XtGuiWindow *xt_gui_window_by_object(xt_value object) {
   return &g_windows[index];
 }
 
-XtGuiWindow *xt_gui_window_from_this(xt_value thisValue) {
-  return xt_gui_window_by_object(thisValue);
-}
-
-/* -- events --------------------------------------------------------------- */
+}  // namespace guidev
 
-void xt_gui_emit(XtGuiWindow *win, const char *event) {
-  xt_gui_emit_payload(win, event, XT_UNDEFINED);
-}
+using namespace guidev;
 
-void xt_gui_emit_payload(XtGuiWindow *win, const char *event, xt_value payload) {
-  if (win == NULL || !XT_IS_OBJECT(win->object)) return;
-  xt_value listeners = xt_object_get_cstr(win->object, "__xt_gui_events");
-  if (!XT_IS_OBJECT(listeners)) return;
-  xt_value array = xt_object_get(listeners, xt_string_from_cstr(event));
-  if (!XT_IS_ARRAY(array)) return;
-  xt_value args[1];
-  int32_t count = 0;
-  if (!XT_IS_UNDEFINED(payload)) {
-    args[0] = payload;
-    count = 1;
-  }
-  int32_t listener_count = (int32_t)xt_to_number(xt_array_length(array));
-  for (int32_t i = 0; i < listener_count; i++) {
-    xt_value fn = xt_array_get(array, xt_number((double)i));
-    if (XT_IS_FUNCTION(fn)) xt_call_with_this(fn, win->object, count, args);
-  }
+XtGuiWindow *xt_gui_window_from_this(xt_value thisValue) {
+  return window_by_object(thisValue);
 }
 
 void xt_gui_quit_window(XtGuiWindow *win) {
   if (win == NULL || !win->open) return;
   win->open = 0;
   xt_gui_emit(win, "close");
+  win->animation_frames.clear();
+  xt_gui_handles_reset(win);
+  win->document_object = XT_UNDEFINED;
   win->document.reset();
   win->html.clear();
   if (g_device != NULL) {
@@ -111,215 +133,6 @@ void xt_gui_window_viewport(XtGuiWindow *win, float *width, float *height) {
   if (height != NULL) *height = (float)h;
 }
 
-static XtGuiWindow *xt_gui_find_by_window_id(SDL_WindowID id) {
-  SDL_Window *window = SDL_GetWindowFromID(id);
-  if (window == NULL) return NULL;
-  for (int i = 0; i < g_window_count; i++) {
-    if (g_windows[i].window == window) return &g_windows[i];
-  }
-  return NULL;
-}
-
-/* -- input events --------------------------------------------------------- */
-
-/** Deepest element under (x, y), or NULL. */
-static const xtgui::Node *xt_gui_hit_node(XtGuiWindow *win, float x, float y) {
-  if (win->document == nullptr) return nullptr;
-  const xtgui::LayoutBox *box = win->document->layout().hitTest(x, y);
-  const xtgui::Node *node = box != nullptr ? box->node : nullptr;
-  while (node != nullptr && !node->isElement()) node = node->parent;
-  return node;
-}
-
-/** Deepest element under (x, y) as a CSS-like descriptor, or an empty string. */
-std::string xt_gui_hit_test(XtGuiWindow *win, float x, float y) {
-  const xtgui::Node *node = xt_gui_hit_node(win, x, y);
-  return node == nullptr ? std::string() : xtgui::xt_dom_describe(node);
-}
-
-/** Update the hovered element from the pointer position; marks paint dirty. */
-static void xt_gui_update_hover(XtGuiWindow *win, float x, float y) {
-  if (win->document == nullptr) return;
-  if (win->document->setHover(xt_gui_hit_node(win, x, y))) win->geometry.dirty = 1;
-}
-
-static xt_value xt_gui_pointer_payload(const char *type, XtGuiWindow *win, float x, float y,
-                                       int button, int clicks) {
-  xt_value payload = xt_object_new();
-  xt_object_set(payload, xt_string_from_cstr("type"), xt_string_from_cstr(type));
-  xt_object_set(payload, xt_string_from_cstr("x"), xt_number(x));
-  xt_object_set(payload, xt_string_from_cstr("y"), xt_number(y));
-  xt_object_set(payload, xt_string_from_cstr("clientX"), xt_number(x));
-  xt_object_set(payload, xt_string_from_cstr("clientY"), xt_number(y));
-  xt_object_set(payload, xt_string_from_cstr("button"), xt_number(button));
-  xt_object_set(payload, xt_string_from_cstr("clicks"), xt_number(clicks));
-  std::string target = xt_gui_hit_test(win, x, y);
-  if (!target.empty()) {
-    xt_object_set(payload, xt_string_from_cstr("target"), xt_string_from_cstr(target.c_str()));
-  }
-  return payload;
-}
-
-void xt_gui_dispatch_pointer(XtGuiWindow *win, const char *type, float x, float y, int button,
-                             int clicks) {
-  if (win == NULL || !win->open) return;
-  xt_gui_update_hover(win, x, y);
-  if (strcmp(type, "mousedown") == 0 && win->document != nullptr) {
-    if (win->document->setFocus(xt_gui_hit_node(win, x, y))) win->geometry.dirty = 1;
-  }
-  xt_gui_emit_payload(win, type, xt_gui_pointer_payload(type, win, x, y, button, clicks));
-}
-
-void xt_gui_dispatch_wheel(XtGuiWindow *win, float x, float y, float delta_x, float delta_y) {
-  if (win == NULL || !win->open) return;
-  xt_value payload = xt_gui_pointer_payload("wheel", win, x, y, -1, 0);
-  xt_object_set(payload, xt_string_from_cstr("deltaX"), xt_number(delta_x));
-  xt_object_set(payload, xt_string_from_cstr("deltaY"), xt_number(delta_y));
-  xt_gui_emit_payload(win, "wheel", payload);
-}
-
-static xt_value xt_gui_key_payload(const char *type, const char *key, const char *code, bool repeat,
-                                   bool ctrl, bool shift, bool alt, bool meta) {
-  xt_value payload = xt_object_new();
-  xt_object_set(payload, xt_string_from_cstr("type"), xt_string_from_cstr(type));
-  xt_object_set(payload, xt_string_from_cstr("key"), xt_string_from_cstr(key));
-  xt_object_set(payload, xt_string_from_cstr("code"), xt_string_from_cstr(code));
-  xt_object_set(payload, xt_string_from_cstr("repeat"), repeat ? XT_TRUE : XT_FALSE);
-  xt_object_set(payload, xt_string_from_cstr("ctrl"), ctrl ? XT_TRUE : XT_FALSE);
-  xt_object_set(payload, xt_string_from_cstr("shift"), shift ? XT_TRUE : XT_FALSE);
-  xt_object_set(payload, xt_string_from_cstr("alt"), alt ? XT_TRUE : XT_FALSE);
-  xt_object_set(payload, xt_string_from_cstr("meta"), meta ? XT_TRUE : XT_FALSE);
-  return payload;
-}
-
-void xt_gui_dispatch_key(XtGuiWindow *win, const char *type, const char *key, const char *code) {
-  if (win == NULL || !win->open) return;
-  xt_gui_emit_payload(win, type, xt_gui_key_payload(type, key, code, false, false, false, false, false));
-}
-
-static void xt_gui_handle_event(const SDL_Event *event) {
-  if (event->type == SDL_EVENT_QUIT) {
-    g_quit = 1;
-    return;
-  }
-  if (event->type == SDL_EVENT_WINDOW_CLOSE_REQUESTED) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->window.windowID);
-    if (win != NULL && win->open) xt_gui_quit_window(win);
-    return;
-  }
-  if (event->type == SDL_EVENT_WINDOW_RESIZED) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->window.windowID);
-    if (win == NULL || !win->open) return;
-    win->width = event->window.data1;
-    win->height = event->window.data2;
-    if (win->document != NULL) win->document->restyle((float)win->width, (float)win->height);
-    win->geometry.dirty = 1;
-    return;
-  }
-
-  if (event->type == SDL_EVENT_MOUSE_MOTION) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->motion.windowID);
-    xt_gui_dispatch_pointer(win, "mousemove", event->motion.x, event->motion.y, -1, 0);
-    return;
-  }
-  if (event->type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->button.windowID);
-    /* SDL numbers buttons 1/2/3 (left/middle/right); DOM uses 0/1/2. */
-    xt_gui_dispatch_pointer(win, "mousedown", event->button.x, event->button.y,
-                            (int)event->button.button - 1, event->button.clicks);
-    return;
-  }
-  if (event->type == SDL_EVENT_MOUSE_BUTTON_UP) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->button.windowID);
-    if (win == NULL || !win->open) return;
-    int button = (int)event->button.button - 1;
-    xt_gui_dispatch_pointer(win, "mouseup", event->button.x, event->button.y, button,
-                            event->button.clicks);
-    if (button == 0) {
-      xt_gui_dispatch_pointer(win, "click", event->button.x, event->button.y, button,
-                              event->button.clicks);
-    }
-    return;
-  }
-  if (event->type == SDL_EVENT_MOUSE_WHEEL) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->wheel.windowID);
-    /* DOM `deltaY` grows downwards; SDL's grows away from the user. */
-    xt_gui_dispatch_wheel(win, event->wheel.mouse_x, event->wheel.mouse_y, event->wheel.x,
-                          -event->wheel.y);
-    return;
-  }
-  if (event->type == SDL_EVENT_KEY_DOWN || event->type == SDL_EVENT_KEY_UP) {
-    XtGuiWindow *win = xt_gui_find_by_window_id(event->key.windowID);
-    if (win == NULL || !win->open) return;
-    const char *type = event->type == SDL_EVENT_KEY_DOWN ? "keydown" : "keyup";
-    xt_gui_emit_payload(win, type,
-                        xt_gui_key_payload(type, SDL_GetKeyName(event->key.key),
-                                           SDL_GetScancodeName(event->key.scancode),
-                                           event->key.repeat, (event->key.mod & SDL_KMOD_CTRL) != 0,
-                                           (event->key.mod & SDL_KMOD_SHIFT) != 0,
-                                           (event->key.mod & SDL_KMOD_ALT) != 0,
-                                           (event->key.mod & SDL_KMOD_GUI) != 0));
-    return;
-  }
-}
-
-/* -- rendering ------------------------------------------------------------ */
-
-void xt_gui_render_window(XtGuiWindow *win) {
-  if (win == NULL || !win->open || win->window == NULL || g_device == NULL) return;
-  float viewport_width = 0;
-  float viewport_height = 0;
-  xt_gui_window_viewport(win, &viewport_width, &viewport_height);
-
-  /* Drive CSS transitions. */
-  double now = (double)SDL_GetTicks();
-  double delta = win->last_frame_ms > 0.0 ? now - win->last_frame_ms : 0.0;
-  win->last_frame_ms = now;
-  if (win->document != nullptr && win->document->advance(delta)) win->geometry.dirty = 1;
-
-  /* Rebuild the geometry only when the document or viewport changed. */
-  bool can_paint = xt_gui_renderer_ensure(g_device, win->window);
-  if (can_paint && win->geometry.dirty && win->document != nullptr) {
-    xtgui::DisplayList list;
-    xtgui::xt_paint_build(win->document->layout().root(), list);
-    xt_gui_geometry_upload(g_device, &win->geometry, list);
-    float density = SDL_GetWindowPixelDensity(win->window);
-    xt_gui_text_upload(g_device, &win->text_geometry, list, density > 0.0f ? density : 1.0f);
-    xt_gui_image_upload(g_device, &win->image_geometry, list);
-    win->geometry.dirty = 0;
-  }
-
-  SDL_GPUCommandBuffer *cmd = SDL_AcquireGPUCommandBuffer(g_device);
-  if (cmd == NULL) return;
-  SDL_GPUTexture *swapchain = NULL;
-  SDL_AcquireGPUSwapchainTexture(cmd, win->window, &swapchain, NULL, NULL);
-  bool firstFrame = false;
-  if (swapchain != NULL) {
-    SDL_GPUColorTargetInfo target;
-    memset(&target, 0, sizeof(target));
-    target.texture = swapchain;
-    target.clear_color.r = win->background[0];
-    target.clear_color.g = win->background[1];
-    target.clear_color.b = win->background[2];
-    target.clear_color.a = win->background[3];
-    target.load_op = SDL_GPU_LOADOP_CLEAR;
-    target.store_op = SDL_GPU_STOREOP_STORE;
-    SDL_GPURenderPass *pass = SDL_BeginGPURenderPass(cmd, &target, 1, NULL);
-    if (can_paint) {
-      xt_gui_renderer_draw(cmd, pass, &win->geometry, viewport_width, viewport_height);
-      xt_gui_text_draw(cmd, pass, &win->text_geometry, viewport_width, viewport_height);
-      xt_gui_image_draw(cmd, pass, &win->image_geometry, viewport_width, viewport_height);
-    }
-    SDL_EndGPURenderPass(pass);
-    firstFrame = !win->ready;
-    win->ready = 1;
-  }
-  SDL_SubmitGPUCommandBuffer(cmd);
-  /* The first presented frame marks the window ready. Emitting after the
-   * submit lets a `ready` handler safely close/destroy the window. */
-  if (firstFrame) xt_gui_emit(win, "ready");
-}
-
 /* -- createWindow(options) ------------------------------------------------ */
 
 static const char *xt_gui_string_or(xt_value value, const char *fallback) {
@@ -333,7 +146,7 @@ static int xt_gui_int_or(xt_value value, int fallback) {
 }
 
 extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
-  if (!xt_gui_ensure_init()) return XT_UNDEFINED;
+  if (!ensure_init()) return XT_UNDEFINED;
   if (g_window_count >= XT_GUI_MAX_WINDOWS) {
     fprintf(stderr, "xt_gui: too many windows (max %d)\n", XT_GUI_MAX_WINDOWS);
     return XT_UNDEFINED;
@@ -364,6 +177,7 @@ extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
     SDL_DestroyWindow(window);
     return XT_UNDEFINED;
   }
+  xt_gui_apply_icon(window);
 
   int index = g_window_count++;
   XtGuiWindow *record = &g_windows[index];
@@ -378,6 +192,8 @@ extern "C" xt_value xt_gui_create_window(int32_t argc, xt_value *argv) {
   record->text_geometry = XtGuiGeometry();
   record->image_geometry = XtGuiGeometry();
   record->last_frame_ms = 0.0;
+  record->animation_frames.clear();
+  record->next_animation_frame_id = 1;
   record->background[0] = 0.08f;
   record->background[1] = 0.09f;
   record->background[2] = 0.11f;
@@ -408,7 +224,7 @@ extern "C" xt_value xt_gui_run(int32_t argc, xt_value *argv) {
     int had_event = 0;
     while (SDL_PollEvent(&event)) {
       had_event = 1;
-      xt_gui_handle_event(&event);
+      handle_event(&event);
     }
 
     int open = 0;

package/runtime/ext_gui/gui_engine.h

@@ -22,6 +22,8 @@ extern "C" {
 xt_value xt_gui_create_window(int32_t argc, xt_value *argv);
 xt_value xt_gui_run(int32_t argc, xt_value *argv);
 xt_value xt_gui_quit(int32_t argc, xt_value *argv);
+/** `__registerScript(id, fn)`: record an AOT-compiled `<script>` body. */
+xt_value xt_register_script(int32_t argc, xt_value *argv);
 
 #ifdef __cplusplus
 } /* extern "C" */
@@ -30,10 +32,26 @@ xt_value xt_gui_quit(int32_t argc, xt_value *argv);
 
 #include <memory>
 #include <string>
+#include <unordered_map>
+#include <vector>
 
 #include "document.h"
 #include "renderer.h"
 
+/** One element-level event listener registered through `addEventListener`. */
+struct XtGuiNodeListener {
+  std::string type;
+  xt_value fn;
+  bool once;
+  bool capture;
+};
+
+/** One pending `requestAnimationFrame` callback. */
+struct XtGuiAnimationFrame {
+  int id;
+  xt_value fn;
+};
+
 /* One live window. `object` is the JavaScript-visible handle; the record is
  * addressed from it through the hidden `__xt_gui_index` property. */
 struct XtGuiWindow {
@@ -50,10 +68,43 @@ struct XtGuiWindow {
   float background[4];
   int width;
   int height;
+
+  /* -- DOM object model (element handles + events) ----------------------- */
+  /** `document` handle for this window (lazily created). */
+  xt_value document_object = XT_UNDEFINED;
+  /** Bumped on every `loadHTML`; stale handles no-op. */
+  double doc_generation = 1.0;
+  /** Node -> table index / cached handle, so identity is stable. */
+  std::vector<xtgui::Node *> node_order;
+  std::unordered_map<const xtgui::Node *, int> node_index;
+  std::unordered_map<const xtgui::Node *, xt_value> node_handles;
+  /** Element-level listeners, keyed by node. */
+  std::unordered_map<const xtgui::Node *, std::vector<XtGuiNodeListener>> node_listeners;
+  /** Set by a DOM mutation; consumed by the frame loop before repainting. */
+  int struct_dirty = 0;
+  /** Callbacks queued for the next frame, plus the id counter. */
+  std::vector<XtGuiAnimationFrame> animation_frames;
+  int next_animation_frame_id = 1;
 };
 
 /** Resolve a window handle (`this`) to its record, or NULL for a foreign value. */
 XtGuiWindow *xt_gui_window_from_this(xt_value thisValue);
+/** The `document` handle for `win` (created on first use). */
+xt_value xt_gui_document_handle(XtGuiWindow *win);
+/** Node handle for `node` (created and cached on first use). */
+xt_value xt_gui_node_handle(XtGuiWindow *win, const xtgui::Node *node);
+/** Drop every cached handle/listener and bump the document generation. */
+void xt_gui_handles_reset(XtGuiWindow *win);
+/** Deliver `type` to element listeners along the propagation path. */
+void xt_gui_emit_dom_event(XtGuiWindow *win, const char *type, const xtgui::Node *target,
+                           xt_value legacy_payload);
+/** Synthesise a DOM event whose target is `target` (used by element.click()). */
+void xt_gui_dispatch_to_node(XtGuiWindow *win, const xtgui::Node *target, const char *type);
+/** Apply any pending DOM mutation (restyle/relayout) before a synchronous read. */
+void xt_gui_flush_dom(XtGuiWindow *win);
+/** Run every registered `<script data-xt-id>` body found in the document, in
+ * document order, passing `(windowHandle, documentHandle)`. */
+void xt_gui_run_scripts(XtGuiWindow *win);
 /** Shared prototype carrying the window methods. */
 xt_value xt_gui_window_proto(void);
 /** Release GPU claim + destroy the window and mark the record closed. */
@@ -64,6 +115,9 @@ void xt_gui_emit(XtGuiWindow *win, const char *event);
 void xt_gui_emit_payload(XtGuiWindow *win, const char *event, xt_value payload);
 /** Acquire a swapchain frame for `win` and clear it (placeholder paint). */
 void xt_gui_render_window(XtGuiWindow *win);
+/** Run every callback queued with `requestAnimationFrame` for the frame at
+ * `timestamp_ms`, then clear the queue. */
+void xt_gui_run_animation_frames(XtGuiWindow *win, double timestamp_ms);
 /** Current logical window size (CSS viewport), in pixels. */
 void xt_gui_window_viewport(XtGuiWindow *win, float *width, float *height);
 /** CSS-like descriptor of the deepest element at (x, y), or `""` (test/debug). */