xbintsc 0.5.32 → 0.5.37

package/runtime/ext_gui/webgl_texture_3d.cpp

@@ -0,0 +1,215 @@
+/*
+ * xbintsc GUI engine — 3D and 2D-array texture storage and uploads.
+ *
+ * SDL_GPU treats a 3D texture and a 2D-array as layered textures. Uploads are
+ * performed one slice at a time because SDL's multi-slice transfer stride is
+ * not usable for small 3D textures on the Metal backend.
+ */
+
+#include "webgl.h"
+
+#include <cstring>
+#include <vector>
+
+#include "gui_internal.h"
+
+namespace xtgui {
+namespace {
+
+int texel_bytes(SDL_GPUTextureFormat format) {
+  if (format == SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT) return 8;
+  if (format == SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT) return 16;
+  return 4;
+}
+
+/** Upload a whole 3D/2D-array volume. Each slice is uploaded separately:
+ * SDL's multi-slice transfer stride is not usable for a 2-layer 3D texture on
+ * the Metal backend. */
+bool upload_volume(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUTexture *gpu,
+                   int width, int height, int depth, const uint8_t *pixels,
+                   int bytes_per_texel, bool is_3d) {
+  const uint32_t slice_bytes = (uint32_t)(width * height * bytes_per_texel);
+  const uint32_t bytes = slice_bytes * (uint32_t)depth;
+  if (bytes == 0) return true;
+  std::vector<uint8_t> zeros;
+  if (pixels == nullptr) {
+    zeros.assign(bytes, 0);
+    pixels = zeros.data();
+  }
+  SDL_GPUTransferBufferCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+  info.size = bytes;
+  SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(device, &info);
+  if (transfer == nullptr) return false;
+  void *mapped = SDL_MapGPUTransferBuffer(device, transfer, false);
+  if (mapped == nullptr) {
+    SDL_ReleaseGPUTransferBuffer(device, transfer);
+    return false;
+  }
+  memcpy(mapped, pixels, bytes);
+  SDL_UnmapGPUTransferBuffer(device, transfer);
+  SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
+  for (int slice = 0; slice < depth; slice++) {
+    SDL_GPUTextureTransferInfo source;
+    memset(&source, 0, sizeof(source));
+    source.transfer_buffer = transfer;
+    source.offset = (Uint32)slice * slice_bytes;
+    source.pixels_per_row = (Uint32)width;
+    source.rows_per_layer = (Uint32)height;
+    SDL_GPUTextureRegion region;
+    memset(&region, 0, sizeof(region));
+    region.texture = gpu;
+    region.layer = is_3d ? 0 : (Uint32)slice;
+    region.z = is_3d ? (Uint32)slice : 0;
+    region.w = (Uint32)width;
+    region.h = (Uint32)height;
+    region.d = 1;
+    SDL_UploadToGPUTexture(copy, &source, &region, false);
+  }
+  SDL_EndGPUCopyPass(copy);
+  SDL_ReleaseGPUTransferBuffer(device, transfer);
+  return true;
+}
+
+/** Upload a sub-volume of a 3D/2D-array texture, one slice at a time. */
+bool upload_sub_volume(SDL_GPUDevice *device, SDL_GPUCommandBuffer *cmd, SDL_GPUTexture *gpu,
+                       int x, int y, int z, int width, int height, int depth,
+                       const uint8_t *pixels, int bytes_per_texel, bool is_3d) {
+  const uint32_t slice_bytes = (uint32_t)(width * height * bytes_per_texel);
+  const uint32_t bytes = slice_bytes * (uint32_t)depth;
+  if (bytes == 0 || pixels == nullptr) return false;
+  SDL_GPUTransferBufferCreateInfo info;
+  memset(&info, 0, sizeof(info));
+  info.usage = SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD;
+  info.size = bytes;
+  SDL_GPUTransferBuffer *transfer = SDL_CreateGPUTransferBuffer(device, &info);
+  if (transfer == nullptr) return false;
+  void *mapped = SDL_MapGPUTransferBuffer(device, transfer, false);
+  if (mapped == nullptr) {
+    SDL_ReleaseGPUTransferBuffer(device, transfer);
+    return false;
+  }
+  memcpy(mapped, pixels, bytes);
+  SDL_UnmapGPUTransferBuffer(device, transfer);
+  SDL_GPUCopyPass *copy = SDL_BeginGPUCopyPass(cmd);
+  for (int slice = 0; slice < depth; slice++) {
+    SDL_GPUTextureTransferInfo source;
+    memset(&source, 0, sizeof(source));
+    source.transfer_buffer = transfer;
+    source.offset = (Uint32)slice * slice_bytes;
+    source.pixels_per_row = (Uint32)width;
+    source.rows_per_layer = (Uint32)height;
+    SDL_GPUTextureRegion region;
+    memset(&region, 0, sizeof(region));
+    region.texture = gpu;
+    region.layer = is_3d ? 0 : (Uint32)(z + slice);
+    region.z = is_3d ? (Uint32)(z + slice) : 0;
+    region.x = (Uint32)x;
+    region.y = (Uint32)y;
+    region.w = (Uint32)width;
+    region.h = (Uint32)height;
+    region.d = 1;
+    SDL_UploadToGPUTexture(copy, &source, &region, false);
+  }
+  SDL_EndGPUCopyPass(copy);
+  SDL_ReleaseGPUTransferBuffer(device, transfer);
+  return true;
+}
+
+}  // namespace
+
+bool WebGLContext::tex_storage_3d(uint32_t id, int levels, int width, int height, int depth,
+                                  SDL_GPUTextureFormat format, int target) {
+  (void)levels;
+  WebGLTexture *record = texture(id);
+  if (record == nullptr || width <= 0 || height <= 0 || depth <= 0) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  end_pass();
+  ensure_command();
+  if (record->gpu != nullptr) {
+    submit();
+    SDL_WaitForGPUIdle(guidev::g_device);
+    SDL_ReleaseGPUTexture(guidev::g_device, record->gpu);
+    record->gpu = nullptr;
+    record->usage = 0;
+  }
+  record->width = width;
+  record->height = height;
+  record->layers = depth;
+  record->format = format;
+  record->depth = false;
+  record->compressed = false;
+  record->target = target == GL_TEXTURE_3D ? GL_TEXTURE_3D : GL_TEXTURE_2D_ARRAY;
+  record->has_mipmaps = false;
+  if (record->sampler != nullptr && guidev::g_device != nullptr) {
+    SDL_ReleaseGPUSampler(guidev::g_device, record->sampler);
+    record->sampler = nullptr;
+  }
+  record->defined = true;
+  return ensure_texture_gpu(record, false) != nullptr;
+}
+
+bool WebGLContext::tex_image_3d(uint32_t id, int width, int height, int depth,
+                                SDL_GPUTextureFormat format, const uint8_t *pixels,
+                                int target) {
+  WebGLTexture *record = texture(id);
+  if (record == nullptr || width <= 0 || height <= 0 || depth <= 0) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  end_pass();
+  ensure_command();
+  if (cmd_ == nullptr) return false;
+  const int resolved_target = target == GL_TEXTURE_3D ? GL_TEXTURE_3D : GL_TEXTURE_2D_ARRAY;
+  if (record->gpu != nullptr &&
+      (record->width != width || record->height != height || record->layers != depth ||
+       record->format != format || record->target != resolved_target)) {
+    SDL_WaitForGPUIdle(guidev::g_device);
+    SDL_ReleaseGPUTexture(guidev::g_device, record->gpu);
+    record->gpu = nullptr;
+    record->usage = 0;
+  }
+  record->width = width;
+  record->height = height;
+  record->layers = depth;
+  record->format = format;
+  record->depth = false;
+  record->compressed = false;
+  record->target = resolved_target;
+  record->has_mipmaps = false;
+  if (record->sampler != nullptr) {
+    SDL_ReleaseGPUSampler(guidev::g_device, record->sampler);
+    record->sampler = nullptr;
+  }
+  if (ensure_texture_gpu(record, false) == nullptr) return false;
+  record->defined = true;
+  return upload_volume(guidev::g_device, cmd_, record->gpu, width, height, depth, pixels,
+                       texel_bytes(format), resolved_target == GL_TEXTURE_3D);
+}
+
+bool WebGLContext::tex_sub_image_3d(uint32_t id, int x, int y, int z, int width, int height,
+                                      int depth, const uint8_t *pixels) {
+  WebGLTexture *record = texture(id);
+  if (record == nullptr || !record->defined || record->gpu == nullptr ||
+      (record->target != GL_TEXTURE_3D && record->target != GL_TEXTURE_2D_ARRAY)) {
+    set_error(GL_INVALID_OPERATION);
+    return false;
+  }
+  if (x < 0 || y < 0 || z < 0 || width <= 0 || height <= 0 || depth <= 0 ||
+      x + width > record->width || y + height > record->height ||
+      z + depth > record->layers) {
+    set_error(GL_INVALID_VALUE);
+    return false;
+  }
+  end_pass();
+  ensure_command();
+  if (cmd_ == nullptr) return false;
+  return upload_sub_volume(guidev::g_device, cmd_, record->gpu, x, y, z, width, height, depth,
+                           pixels, texel_bytes(record->format),
+                           record->target == GL_TEXTURE_3D);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/webgl_uniform_block.h

@@ -0,0 +1,31 @@
+/*
+ * xbintsc GUI engine — uniform-block bookkeeping shared by programs and draws.
+ */
+#ifndef XT_GUI_WEBGL_UNIFORM_BLOCK_H
+#define XT_GUI_WEBGL_UNIFORM_BLOCK_H
+
+#include <cstdint>
+#include <string>
+
+namespace xtgui {
+
+/** A user uniform block merged into the engine's single std140 block. */
+struct WebGLUniformBlock {
+  std::string name;
+  std::string instance;
+  int binding = 0;
+  int base_offset = 0;
+  int data_size = 0;
+  int member_count = 0;
+};
+
+/** The buffer bound to one indexed uniform-buffer binding point. */
+struct WebGLUniformBinding {
+  uint32_t buffer = 0;
+  uint32_t offset = 0;
+  uint32_t size = 0;
+};
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_WEBGL_UNIFORM_BLOCK_H */

package/runtime/ext_gui/webgl_webgl2.cpp

@@ -125,14 +125,67 @@ bool WebGLContext::is_sync(uint32_t id) const {
   return syncs_.find(id) != syncs_.end();
 }
 
-uint32_t WebGLContext::uniform_block_index(uint32_t program, const std::string &name) const {
-  (void)program;
-  (void)name;
-  /* Uniform blocks are not exposed; answering INVALID_INDEX makes a library
-   * fall back to individual uniforms. */
+uint32_t WebGLContext::uniform_block_index(uint32_t program_id,
+                                           const std::string &name) const {
+  auto found = programs_.find(program_id);
+  if (found == programs_.end()) return 0xFFFFFFFFu;
+  const std::vector<WebGLUniformBlock> &blocks = found->second->blocks;
+  for (size_t i = 0; i < blocks.size(); i++) {
+    if (blocks[i].name == name) return (uint32_t)i;
+  }
   return 0xFFFFFFFFu;
 }
 
+WebGLUniformBlock *WebGLContext::uniform_block(uint32_t program_id, uint32_t index) {
+  auto found = programs_.find(program_id);
+  if (found == programs_.end() || index >= found->second->blocks.size()) return nullptr;
+  return &found->second->blocks[index];
+}
+
+int WebGLContext::uniform_block_parameter(uint32_t program_id, uint32_t index,
+                                          int pname) const {
+  auto found = programs_.find(program_id);
+  if (found == programs_.end() || index >= found->second->blocks.size()) return 0;
+  const WebGLUniformBlock &block = found->second->blocks[index];
+  switch (pname) {
+    case GL_UNIFORM_BLOCK_BINDING:
+      return block.binding;
+    case GL_UNIFORM_BLOCK_DATA_SIZE:
+      return block.data_size;
+    case GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS:
+      return block.member_count;
+    case GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER:
+    case GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+std::string WebGLContext::uniform_block_name(uint32_t program_id, uint32_t index) const {
+  auto found = programs_.find(program_id);
+  if (found == programs_.end() || index >= found->second->blocks.size()) return std::string();
+  return found->second->blocks[index].name;
+}
+
+void WebGLContext::uniform_block_binding(uint32_t program_id, uint32_t index, int binding) {
+  WebGLUniformBlock *block = uniform_block(program_id, index);
+  if (block != nullptr) block->binding = binding;
+}
+
+void WebGLContext::bind_buffer_base(int target, int index, uint32_t buffer_id,
+                                    uint32_t offset, uint32_t size) {
+  if (target != 0x8A11 || index < 0 || index >= 16) return;  // GL_UNIFORM_BUFFER
+  uniform_bindings_[index].buffer = buffer_id;
+  uniform_bindings_[index].offset = offset;
+  uniform_bindings_[index].size = size;
+}
+
+uint32_t WebGLContext::uniform_buffer_binding(int index) const {
+  if (index < 0 || index >= 16) return 0;
+  return uniform_bindings_[index].buffer;
+}
+
 /* -- sampler objects ----------------------------------------------------- */
 
 WebGLSampler *WebGLContext::sampler(uint32_t id) {

package/runtime/ext_gui/window.cpp

@@ -9,6 +9,7 @@
  */
 
 #include "gui_engine.h"
+#include "listener_options.h"
 
 #include <algorithm>
 
@@ -18,6 +19,12 @@
 
 static xt_value g_window_proto = XT_UNDEFINED;
 
+/** String value of a runtime value, as `std::string` ("" for null/undefined). */
+static std::string window_string(xt_value value) {
+  const char *data = xt_string_data(xt_to_string(value));
+  return data != nullptr ? data : "";
+}
+
 /* -- methods -------------------------------------------------------------- */
 
 static xt_value win_set_title(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
@@ -51,6 +58,9 @@ static xt_value win_load_html(xt_value self, xt_value env, int32_t argc, xt_valu
   XtGuiWindow *win = xt_gui_window_from_this(self);
   if (win != nullptr) {
     win->html = html;
+    /* A fresh document starts at the top of the page. */
+    win->scroll_x = 0.0f;
+    win->scroll_y = 0.0f;
     /* Fresh document: invalidate every previously handed-out handle, and drop
      * the decoders that belonged to the old tree. */
     xt_gui_handles_reset(win);
@@ -371,65 +381,6 @@ static xt_value win_cancel_animation_frame(xt_value self, xt_value env, int32_t
   return XT_UNDEFINED;
 }
 
-static xt_value win_on(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  if (argc >= 2) {
-    xt_value name = xt_to_string(xt_arg(argc, argv, 0));
-    xt_value fn = xt_arg(argc, argv, 1);
-    if (XT_IS_FUNCTION(fn)) {
-      xt_value listeners = xt_object_get_cstr(self, "__xt_gui_events");
-      if (!XT_IS_OBJECT(listeners)) {
-        listeners = xt_object_new();
-        xt_object_set(self, xt_string_from_cstr("__xt_gui_events"), listeners);
-      }
-      xt_value array = xt_object_get(listeners, name);
-      if (!XT_IS_ARRAY(array)) {
-        array = xt_array_new(0, NULL);
-        xt_object_set(listeners, name, array);
-      }
-      xt_array_push(array, fn);
-    }
-  }
-  return self;
-}
-
-static xt_value win_off(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  (void)env;
-  if (argc >= 2) {
-    xt_value listeners = xt_object_get_cstr(self, "__xt_gui_events");
-    if (XT_IS_OBJECT(listeners)) {
-      xt_value name = xt_to_string(xt_arg(argc, argv, 0));
-      xt_value fn = xt_arg(argc, argv, 1);
-      xt_value array = xt_object_get(listeners, name);
-      if (XT_IS_ARRAY(array)) {
-        xt_value kept = xt_array_new(0, NULL);
-        int32_t count = (int32_t)xt_to_number(xt_array_length(array));
-        for (int32_t i = 0; i < count; i++) {
-          xt_value candidate = xt_array_get(array, xt_number((double)i));
-          if (candidate != fn) xt_array_push(kept, candidate);
-        }
-        xt_object_set(listeners, name, kept);
-      }
-    }
-  }
-  return self;
-}
-
-/** Web spelling of 'on': 'window.addEventListener(type, fn, options?)'. The
- * optional 'options' argument ('capture'/'once') is accepted and ignored —
- * window-level delivery has no capture phase — so a document written against
- * the browser API compiles and behaves the same here. */
-static xt_value win_add_event_listener(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
-  win_on(self, env, argc, argv);
-  return XT_UNDEFINED;
-}
-
-/** Web spelling of 'off': 'window.removeEventListener(type, fn, options?)'. */
-static xt_value win_remove_event_listener(xt_value self, xt_value env, int32_t argc,
-                                          xt_value *argv) {
-  win_off(self, env, argc, argv);
-  return XT_UNDEFINED;
-}
 
 /* -- input diagnostics ---------------------------------------------------- */
 
@@ -570,12 +521,10 @@ xt_value xt_gui_window_proto(void) {
   define_method(proto, "driver", (void *)win_driver);
   define_method(proto, "requestAnimationFrame", (void *)win_request_animation_frame);
   define_method(proto, "cancelAnimationFrame", (void *)win_cancel_animation_frame);
-  define_method(proto, "on", (void *)win_on);
-  define_method(proto, "off", (void *)win_off);
-  /* Web spellings, so a document written against the browser API runs
-   * unchanged under the engine. */
-  define_method(proto, "addEventListener", (void *)win_add_event_listener);
-  define_method(proto, "removeEventListener", (void *)win_remove_event_listener);
+  /* `on` / `off` and their Web spellings (`addEventListener` /
+   * `removeEventListener` with the listener options bag) live in
+   * `window_events.cpp`. */
+  xt_gui_install_window_events(proto);
   define_method(proto, "hitTest", (void *)win_hit_test);
   define_method(proto, "sendEvent", (void *)win_send_event);
   define_method(proto, "stats", (void *)win_stats);

package/runtime/ext_gui/window_events.cpp

@@ -0,0 +1,125 @@
+/*
+ * xbintsc GUI engine — window-level event listeners.
+ *
+ * `win.on` / `win.off` keep their legacy behaviour (an event name plus a
+ * callback, delivered with the input payload); `win.addEventListener` /
+ * `win.removeEventListener` take the Web options bag (`capture`, `once`,
+ * `passive`, `signal`). Both register in the window's single listener vector, so
+ * a listener added through one spelling can be removed through the other, and
+ * `gui_events.cpp` delivers one merged batch.
+ */
+
+#include "gui_engine.h"
+#include "listener_options.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+namespace {
+
+std::string listener_string(xt_value value) {
+  const char *data = xt_string_data(xt_to_string(value));
+  return data != nullptr ? data : "";
+}
+
+void push_listener(XtGuiWindow *win, const std::string &type, xt_value fn, bool once, bool capture,
+                   bool passive, xt_value signal) {
+  if (win == nullptr || !XT_IS_FUNCTION(fn)) return;
+  XtGuiWindowListener listener;
+  listener.type = type;
+  listener.fn = fn;
+  listener.once = once;
+  listener.capture = capture;
+  listener.passive = passive;
+  listener.signal = signal;
+  win->window_listeners.push_back(listener);
+}
+
+xt_value win_on(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc >= 2) {
+    XtGuiWindow *win = xt_gui_window_from_this(self);
+    xt_value fn = xt_arg(argc, argv, 1);
+    if (win != nullptr && XT_IS_FUNCTION(fn)) {
+      push_listener(win, listener_string(xt_arg(argc, argv, 0)), fn, false, false, false,
+                    XT_UNDEFINED);
+    }
+  }
+  return self;
+}
+
+xt_value win_off(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc >= 2) {
+    XtGuiWindow *win = xt_gui_window_from_this(self);
+    if (win != nullptr) {
+      std::string type = listener_string(xt_arg(argc, argv, 0));
+      xt_value fn = xt_arg(argc, argv, 1);
+      std::vector<XtGuiWindowListener> &listeners = win->window_listeners;
+      listeners.erase(std::remove_if(listeners.begin(), listeners.end(),
+                                     [&](const XtGuiWindowListener &listener) {
+                                       return listener.type == type &&
+                                              xt_truthy(xt_seq(listener.fn, fn));
+                                     }),
+                      listeners.end());
+    }
+  }
+  return self;
+}
+
+/** Web spelling of `on`: `window.addEventListener(type, fn, options?)`. Window
+ * delivery has no capture phase, but `capture` is part of listener identity so
+ * `removeEventListener(type, fn, true)` still matches the right entry. */
+xt_value win_add_event_listener(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 2) return XT_UNDEFINED;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  std::string type = listener_string(xt_arg(argc, argv, 0));
+  xt_value fn = xt_arg(argc, argv, 1);
+  XtGuiListenerOptions options = xt_gui_listener_options(xt_arg(argc, argv, 2));
+  if (win == nullptr || !XT_IS_FUNCTION(fn) || xt_gui_signal_aborted(options.signal)) {
+    return XT_UNDEFINED;
+  }
+  /* The DOM ignores a second registration of the same (type, fn, capture). */
+  for (const XtGuiWindowListener &existing : win->window_listeners) {
+    if (existing.type == type && existing.capture == options.capture &&
+        xt_truthy(xt_seq(existing.fn, fn))) {
+      return XT_UNDEFINED;
+    }
+  }
+  push_listener(win, type, fn, options.once, options.capture, options.passive, options.signal);
+  return XT_UNDEFINED;
+}
+
+/** Web spelling of `off`: `window.removeEventListener(type, fn, options?)`. */
+xt_value win_remove_event_listener(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)env;
+  if (argc < 2) return XT_UNDEFINED;
+  XtGuiWindow *win = xt_gui_window_from_this(self);
+  if (win == nullptr) return XT_UNDEFINED;
+  std::string type = listener_string(xt_arg(argc, argv, 0));
+  xt_value fn = xt_arg(argc, argv, 1);
+  XtGuiListenerOptions options = xt_gui_listener_options(xt_arg(argc, argv, 2));
+  std::vector<XtGuiWindowListener> &listeners = win->window_listeners;
+  for (auto it = listeners.begin(); it != listeners.end(); ++it) {
+    if (it->type == type && it->capture == options.capture && xt_truthy(xt_seq(it->fn, fn))) {
+      listeners.erase(it);
+      return XT_UNDEFINED;
+    }
+  }
+  return XT_UNDEFINED;
+}
+
+}  // namespace
+
+void xt_gui_install_window_events(xt_value proto) {
+  xt_object_set(proto, xt_string_from_cstr("on"),
+                xt_closure_new((void *)win_on, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("off"),
+                xt_closure_new((void *)win_off, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("addEventListener"),
+                xt_closure_new((void *)win_add_event_listener, 0, nullptr));
+  xt_object_set(proto, xt_string_from_cstr("removeEventListener"),
+                xt_closure_new((void *)win_remove_event_listener, 0, nullptr));
+}