xbintsc 0.5.23 → 0.5.32

package/runtime/ext_gui/dom_api_document.cpp

@@ -34,8 +34,28 @@ static const xtgui::Node *find_by_id(const xtgui::Node *node, const std::string
 METHOD(doc_query_selector) {
   (void)env;
   XtGuiWindow *win = resolve_window(self);
-  if (win == nullptr || win->document == nullptr || argc < 1) return XT_UNDEFINED;
-  return xt_gui_node_handle(win, win->document->querySelector(to_string_value(xt_arg(argc, argv, 0))));
+  if (win == nullptr || argc < 1) return XT_UNDEFINED;
+  std::string selector = to_string_value(xt_arg(argc, argv, 0));
+  const xtgui::Node *node =
+      win->document != nullptr ? win->document->querySelector(selector) : nullptr;
+  if (node != nullptr) return xt_gui_node_handle(win, node);
+  /* A page that is already parsed has no such element: answer undefined, like
+   * the browser. Only a query made *before* `loadHTML` earns a pending handle
+   * that binds once the tree exists. */
+  if (win != nullptr && !win->html.empty()) return XT_UNDEFINED;
+  return pending_handle(win, pending_by_selector, selector);
+}
+
+/* -- pending lookup helpers (see `dom_api.cpp`) --------------------------- */
+
+xtgui::Node *document_find_by_id(XtGuiWindow *win, const std::string &id) {
+  if (win == nullptr || win->document == nullptr) return nullptr;
+  return const_cast<xtgui::Node *>(find_by_id(win->document->root(), id));
+}
+
+xtgui::Node *document_query_selector(XtGuiWindow *win, const std::string &selector) {
+  if (win == nullptr || win->document == nullptr) return nullptr;
+  return const_cast<xtgui::Node *>(win->document->querySelector(selector));
 }
 
 METHOD(doc_query_selector_all) {
@@ -52,9 +72,16 @@ METHOD(doc_query_selector_all) {
 METHOD(doc_get_element_by_id) {
   (void)env;
   XtGuiWindow *win = resolve_window(self);
-  if (win == nullptr || win->document == nullptr || argc < 1) return XT_UNDEFINED;
-  return xt_gui_node_handle(
-      win, find_by_id(win->document->root(), to_string_value(xt_arg(argc, argv, 0))));
+  if (win == nullptr || argc < 1) return XT_UNDEFINED;
+  std::string id = to_string_value(xt_arg(argc, argv, 0));
+  const xtgui::Node *node =
+      win->document != nullptr ? find_by_id(win->document->root(), id) : nullptr;
+  if (node != nullptr) return xt_gui_node_handle(win, node);
+  if (win != nullptr && !win->html.empty()) return XT_UNDEFINED;
+  /* The page has not been loaded yet (a module queried the id while it
+   * initialized): answer with a pending handle that binds to the real node once
+   * the document is parsed. */
+  return pending_handle(win, pending_by_id, id);
 }
 
 METHOD(doc_create_element) {
@@ -66,6 +93,70 @@ METHOD(doc_create_element) {
   return xt_gui_node_handle(win, win->document->createElement(tag));
 }
 
+/** `createElementNS(ns, name)`: the engine has no namespaces, so the qualified
+ * name after `:` is what gets created (`createElementNS(svgNS, "svg:rect")`). */
+METHOD(doc_create_element_ns) {
+  (void)env;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr || argc < 2) return XT_UNDEFINED;
+  std::string name = to_string_value(xt_arg(argc, argv, 1));
+  size_t colon = name.rfind(':');
+  if (colon != std::string::npos) name = name.substr(colon + 1);
+  for (char &c : name) c = (char)std::tolower((unsigned char)c);
+  return xt_gui_node_handle(win, win->document->createElement(name));
+}
+
+/** `document.hidden` / `visibilityState`: a window in the main loop is always
+ * visible, and reporting hidden would make a page pause its own loop. */
+METHOD(doc_hidden_get) {
+  (void)self;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return XT_FALSE;
+}
+
+METHOD(doc_visibility_state_get) {
+  (void)self;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_string_from_cstr("visible");
+}
+
+/** `document.readyState`: the page is fully parsed before any script runs. */
+METHOD(doc_ready_state_get) {
+  (void)self;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_string_from_cstr("complete");
+}
+
+METHOD(doc_title_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr) return xt_string_from_cstr("");
+  const xtgui::Node *title = find_by_tag(win->document->root(), "title");
+  std::string text;
+  if (title != nullptr) {
+    for (const std::unique_ptr<xtgui::Node> &child : title->children) {
+      if (!child->isElement()) text += child->text;
+    }
+  }
+  return xt_string_from_cstr(text.c_str());
+}
+
+METHOD(doc_default_view_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = resolve_window(self);
+  return win != nullptr ? win->object : XT_UNDEFINED;
+}
+
 METHOD(doc_create_text_node) {
   (void)env;
   XtGuiWindow *win = resolve_window(self);

package/runtime/ext_gui/dom_api_events.cpp

@@ -31,6 +31,26 @@ static xt_value make_dom_event(XtGuiWindow *win, const char *type, const xtgui::
   return event;
 }
 
+/** A detached event object, as `new Event(type)` / `new CustomEvent(type, init)`
+ * builds: no target yet, but the standard fields and `detail`. */
+xt_value event_construct(xt_value type, xt_value init) {
+  std::string name = to_string_value(type);
+  xt_value event = xt_object_new_with_proto(event_proto());
+  xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr(name.c_str()));
+  xt_object_set(event, xt_string_from_cstr("target"), XT_NULL);
+  xt_object_set(event, xt_string_from_cstr("currentTarget"), XT_NULL);
+  xt_object_set(event, xt_string_from_cstr("defaultPrevented"), XT_FALSE);
+  xt_value bubbles = xt_object_get_cstr(init, "bubbles");
+  xt_object_set(event, xt_string_from_cstr("bubbles"), XT_IS_UNDEFINED(bubbles) ? XT_FALSE : bubbles);
+  xt_value cancelable = xt_object_get_cstr(init, "cancelable");
+  xt_object_set(event, xt_string_from_cstr("cancelable"),
+                XT_IS_UNDEFINED(cancelable) ? XT_FALSE : cancelable);
+  xt_value detail = xt_object_get_cstr(init, "detail");
+  xt_object_set(event, xt_string_from_cstr("detail"),
+                XT_IS_UNDEFINED(detail) ? XT_NULL : detail);
+  return event;
+}
+
 void remove_listener(XtGuiWindow *win, xtgui::Node *node, const std::string &type, xt_value fn,
                      bool capture) {
   auto found = win->node_listeners.find(node);

package/runtime/ext_gui/dom_api_internal.h

@@ -29,6 +29,20 @@ extern xt_value g_class_list_proto;
 extern xt_value g_style_proto;
 extern xt_value g_canvas_proto;
 extern xt_value g_canvas_gradient_proto;
+extern xt_value g_webgl_proto;
+extern xt_value g_webgl2_proto;
+extern xt_value g_webgl_buffer_proto;
+extern xt_value g_webgl_texture_proto;
+extern xt_value g_webgl_shader_proto;
+extern xt_value g_webgl_program_proto;
+extern xt_value g_webgl_framebuffer_proto;
+extern xt_value g_webgl_renderbuffer_proto;
+extern xt_value g_webgl_uniform_proto;
+extern xt_value g_webgl_vertex_array_proto;
+extern xt_value g_webgl_sampler_proto;
+extern xt_value g_webgl_query_proto;
+extern xt_value g_webgl_sync_proto;
+extern xt_value g_webgl_transform_feedback_proto;
 
 xt_value node_proto();
 xt_value document_proto();
@@ -37,6 +51,14 @@ xt_value class_list_proto();
 xt_value style_proto();
 xt_value canvas_proto();
 xt_value canvas_gradient_proto();
+xt_value webgl_proto();
+xt_value webgl2_proto();
+/** The prototype a WebGL object of `kind` inherits (`buffer`, `texture`, …),
+ * so `buffer instanceof WebGLBuffer` holds. */
+xt_value webgl_object_proto(const std::string &kind);
+
+/** Create/return the 2D context for a pending `<canvas>` handle (before load). */
+xt_value xt_canvas_pending_context(xt_value self, XtGuiWindow *win);
 
 /* -- canvas helpers shared by `dom_api_canvas*.cpp` ----------------------- */
 
@@ -51,6 +73,42 @@ xt_value canvas_gradient_handle(xt_value context, const xtgui::Canvas2D *canvas,
  * `canvas` (stale or created by another canvas). */
 uint64_t canvas_gradient_id(xt_value handle, const xtgui::Canvas2D *canvas);
 
+/* -- WebGL helpers shared by `dom_api_webgl*.cpp` ------------------------- */
+
+/** The engine WebGL context behind a context handle, or null. */
+xtgui::WebGLContext *webgl_from_context(xt_value self);
+/** The numeric context id stored on a context handle (0 when absent). */
+uint64_t webgl_context_id(xt_value self);
+/** Create the JavaScript handle for a canvas's WebGL context. */
+xt_value webgl_context_handle(xt_value element, xtgui::WebGLContext *context);
+/** The id stored on an object handle under `key`, or 0. */
+uint32_t webgl_object_id(xt_value handle, const char *key);
+/** Build an object handle (`{__xt_gl_context, __xt_gl_<key>}`). */
+xt_value webgl_make_object(xt_value context, const char *key, uint32_t id,
+                           const std::string &kind);
+double webgl_number(int32_t argc, xt_value *argv, int32_t index, double fallback);
+int webgl_int(int32_t argc, xt_value *argv, int32_t index, int fallback);
+std::string webgl_string(int32_t argc, xt_value *argv, int32_t index);
+/** Read an array/typed array of numbers. */
+std::vector<double> webgl_numbers(xt_value value);
+/** Read the raw bytes of a typed array / ArrayBuffer (or a byte array). */
+std::vector<uint8_t> webgl_bytes(xt_value value);
+/** Store `count` bytes into a typed array / array handle. */
+void webgl_write_bytes(xt_value target, const uint8_t *bytes, size_t count);
+/** Read the `UNPACK_FLIP_Y_WEBGL` / `UNPACK_PREMULTIPLY_ALPHA_WEBGL` flags set
+ * through `pixelStorei`. */
+void webgl_unpack_flags(xt_value context, bool *flip_y, bool *premultiply);
+
+/** How a pending handle names the node it will bind to. */
+enum PendingKind { pending_by_id = 1, pending_by_selector = 2 };
+
+/** A handle for a node the document does not have yet: it binds on first use
+ * after `loadHTML` has parsed the page (`resolve_node` does the lookup). */
+xt_value pending_handle(XtGuiWindow *win, int kind, const std::string &key);
+/** The first element with `id` / matching `selector`, or null. */
+xtgui::Node *document_find_by_id(XtGuiWindow *win, const std::string &id);
+xtgui::Node *document_query_selector(XtGuiWindow *win, const std::string &selector);
+
 /* -- cross-unit helpers --------------------------------------------------- */
 
 std::string to_string_value(xt_value value);
@@ -82,6 +140,12 @@ METHOD(doc_query_selector);
 METHOD(doc_query_selector_all);
 METHOD(doc_get_element_by_id);
 METHOD(doc_create_element);
+METHOD(doc_create_element_ns);
+METHOD(doc_hidden_get);
+METHOD(doc_visibility_state_get);
+METHOD(doc_ready_state_get);
+METHOD(doc_title_get);
+METHOD(doc_default_view_get);
 METHOD(doc_create_text_node);
 METHOD(doc_body_get);
 METHOD(doc_document_element_get);
@@ -135,6 +199,9 @@ METHOD(node_add_event_listener);
 METHOD(node_remove_event_listener);
 METHOD(node_dispatch_event);
 
+/* event construction (a detached `Event`/`CustomEvent` handle) */
+xt_value event_construct(xt_value type, xt_value init);
+
 /* event methods */
 METHOD(event_prevent_default);
 METHOD(event_stop_propagation);
@@ -238,6 +305,217 @@ METHOD(style_set_property);
 METHOD(style_get_property_value);
 METHOD(style_remove_property);
 
+/* WebGL context: state and queries */
+METHOD(webgl_canvas_get);
+METHOD(webgl_drawing_buffer_width_get);
+METHOD(webgl_drawing_buffer_height_get);
+METHOD(webgl_enable);
+METHOD(webgl_disable);
+METHOD(webgl_is_enabled);
+METHOD(webgl_clear);
+METHOD(webgl_clear_color);
+METHOD(webgl_clear_depth);
+METHOD(webgl_clear_stencil);
+METHOD(webgl_color_mask);
+METHOD(webgl_depth_func);
+METHOD(webgl_depth_mask);
+METHOD(webgl_depth_range);
+METHOD(webgl_blend_color);
+METHOD(webgl_blend_equation);
+METHOD(webgl_blend_equation_separate);
+METHOD(webgl_blend_func);
+METHOD(webgl_blend_func_separate);
+METHOD(webgl_cull_face);
+METHOD(webgl_front_face);
+METHOD(webgl_viewport);
+METHOD(webgl_scissor);
+METHOD(webgl_finish);
+METHOD(webgl_flush);
+METHOD(webgl_hint);
+METHOD(webgl_line_width);
+METHOD(webgl_polygon_offset);
+METHOD(webgl_sample_coverage);
+METHOD(webgl_pixel_storei);
+METHOD(webgl_get_error);
+METHOD(webgl_get_parameter);
+METHOD(webgl_get_supported_extensions);
+METHOD(webgl_get_extension);
+METHOD(webgl_get_context_attributes);
+METHOD(webgl_is_context_lost);
+METHOD(webgl_stencil_func);
+METHOD(webgl_stencil_func_separate);
+METHOD(webgl_stencil_op);
+METHOD(webgl_stencil_op_separate);
+METHOD(webgl_stencil_mask);
+METHOD(webgl_stencil_mask_separate);
+METHOD(webgl_get_shader_precision_format);
+
+/* WebGL shaders, programs and uniforms */
+METHOD(webgl_create_shader);
+METHOD(webgl_delete_shader);
+METHOD(webgl_shader_source);
+METHOD(webgl_compile_shader);
+METHOD(webgl_get_shader_parameter);
+METHOD(webgl_get_shader_info_log);
+METHOD(webgl_get_shader_source);
+METHOD(webgl_create_program);
+METHOD(webgl_delete_program);
+METHOD(webgl_attach_shader);
+METHOD(webgl_detach_shader);
+METHOD(webgl_link_program);
+METHOD(webgl_use_program);
+METHOD(webgl_get_program_parameter);
+METHOD(webgl_get_program_info_log);
+METHOD(webgl_get_attached_shaders);
+METHOD(webgl_validate_program);
+METHOD(webgl_get_active_uniform);
+METHOD(webgl_get_active_attrib);
+METHOD(webgl_get_uniform_location);
+METHOD(webgl_get_attrib_location);
+METHOD(webgl_bind_attrib_location);
+METHOD(webgl_get_uniform);
+METHOD(webgl_uniform1f);
+METHOD(webgl_uniform2f);
+METHOD(webgl_uniform3f);
+METHOD(webgl_uniform4f);
+METHOD(webgl_uniform1i);
+METHOD(webgl_uniform2i);
+METHOD(webgl_uniform3i);
+METHOD(webgl_uniform4i);
+METHOD(webgl_uniform1fv);
+METHOD(webgl_uniform2fv);
+METHOD(webgl_uniform3fv);
+METHOD(webgl_uniform4fv);
+METHOD(webgl_uniform1iv);
+METHOD(webgl_uniform2iv);
+METHOD(webgl_uniform3iv);
+METHOD(webgl_uniform4iv);
+METHOD(webgl_uniform_matrix2fv);
+METHOD(webgl_uniform_matrix3fv);
+METHOD(webgl_uniform_matrix4fv);
+
+/* WebGL buffers, vertex attributes and draws */
+METHOD(webgl_create_buffer);
+METHOD(webgl_delete_buffer);
+METHOD(webgl_bind_buffer);
+METHOD(webgl_buffer_data);
+METHOD(webgl_buffer_sub_data);
+METHOD(webgl_get_buffer_parameter);
+METHOD(webgl_enable_vertex_attrib_array);
+METHOD(webgl_disable_vertex_attrib_array);
+METHOD(webgl_vertex_attrib_pointer);
+METHOD(webgl_vertex_attrib1f);
+METHOD(webgl_vertex_attrib2f);
+METHOD(webgl_vertex_attrib3f);
+METHOD(webgl_vertex_attrib4f);
+METHOD(webgl_vertex_attrib1fv);
+METHOD(webgl_vertex_attrib2fv);
+METHOD(webgl_vertex_attrib3fv);
+METHOD(webgl_vertex_attrib4fv);
+METHOD(webgl_get_vertex_attrib);
+METHOD(webgl_draw_arrays);
+METHOD(webgl_draw_elements);
+
+/* WebGL textures, framebuffers and readback */
+METHOD(webgl_create_texture);
+METHOD(webgl_delete_texture);
+METHOD(webgl_bind_texture);
+METHOD(webgl_active_texture);
+METHOD(webgl_tex_parameteri);
+METHOD(webgl_tex_parameterf);
+METHOD(webgl_get_tex_parameter);
+METHOD(webgl_tex_image_2d);
+METHOD(webgl_tex_sub_image_2d);
+METHOD(webgl_generate_mipmap);
+METHOD(webgl_create_framebuffer);
+METHOD(webgl_delete_framebuffer);
+METHOD(webgl_bind_framebuffer);
+METHOD(webgl_framebuffer_texture_2d);
+METHOD(webgl_check_framebuffer_status);
+METHOD(webgl_create_renderbuffer);
+METHOD(webgl_delete_renderbuffer);
+METHOD(webgl_bind_renderbuffer);
+METHOD(webgl_renderbuffer_storage);
+METHOD(webgl_framebuffer_renderbuffer);
+METHOD(webgl_get_renderbuffer_parameter);
+METHOD(webgl_read_pixels);
+
+/* WebGL 2 context extensions */
+METHOD(webgl2_create_vertex_array);
+METHOD(webgl2_delete_vertex_array);
+METHOD(webgl2_bind_vertex_array);
+METHOD(webgl2_is_vertex_array);
+METHOD(webgl2_vertex_attrib_ipointer);
+METHOD(webgl2_vertex_attrib_i4i);
+METHOD(webgl2_vertex_attrib_i4iv);
+METHOD(webgl2_vertex_attrib_i4ui);
+METHOD(webgl2_vertex_attrib_i4uiv);
+METHOD(webgl2_vertex_attrib_divisor);
+METHOD(webgl2_draw_arrays_instanced);
+METHOD(webgl2_draw_elements_instanced);
+METHOD(webgl2_draw_range_elements);
+METHOD(webgl2_uniform1ui);
+METHOD(webgl2_uniform2ui);
+METHOD(webgl2_uniform3ui);
+METHOD(webgl2_uniform4ui);
+METHOD(webgl2_create_sampler);
+METHOD(webgl2_delete_sampler);
+METHOD(webgl2_bind_sampler);
+METHOD(webgl2_sampler_parameteri);
+METHOD(webgl2_sampler_parameterf);
+METHOD(webgl2_get_sampler_parameter);
+METHOD(webgl2_create_query);
+METHOD(webgl2_delete_query);
+METHOD(webgl2_begin_query);
+METHOD(webgl2_end_query);
+METHOD(webgl2_get_query);
+METHOD(webgl2_get_query_parameter);
+METHOD(webgl2_create_transform_feedback);
+METHOD(webgl2_delete_transform_feedback);
+METHOD(webgl2_bind_transform_feedback);
+METHOD(webgl2_begin_transform_feedback);
+METHOD(webgl2_end_transform_feedback);
+METHOD(webgl2_pause_transform_feedback);
+METHOD(webgl2_resume_transform_feedback);
+METHOD(webgl2_transform_feedback_varyings);
+METHOD(webgl2_get_transform_feedback_varying);
+METHOD(webgl2_fence_sync);
+METHOD(webgl2_delete_sync);
+METHOD(webgl2_client_wait_sync);
+METHOD(webgl2_wait_sync);
+METHOD(webgl2_get_sync_parameter);
+METHOD(webgl2_bind_buffer_base);
+METHOD(webgl2_bind_buffer_range);
+METHOD(webgl2_get_indexed_parameter);
+METHOD(webgl2_copy_buffer_sub_data);
+METHOD(webgl2_get_buffer_sub_data);
+METHOD(webgl2_get_uniform_indices);
+METHOD(webgl2_get_active_uniforms);
+METHOD(webgl2_get_uniform_block_index);
+METHOD(webgl2_get_active_uniform_block_parameter);
+METHOD(webgl2_get_active_uniform_block_name);
+METHOD(webgl2_uniform_block_binding);
+METHOD(webgl2_tex_storage_2d);
+METHOD(webgl2_tex_storage_3d);
+METHOD(webgl2_tex_image_3d);
+METHOD(webgl2_tex_sub_image_3d);
+METHOD(webgl2_compressed_tex_image2d);
+METHOD(webgl2_compressed_tex_sub_image2d);
+METHOD(webgl2_compressed_tex_image3d);
+METHOD(webgl2_compressed_tex_sub_image3d);
+METHOD(webgl2_clear_buffer_fi);
+METHOD(webgl2_clear_buffer_fv);
+METHOD(webgl2_clear_buffer_iv);
+METHOD(webgl2_clear_buffer_uiv);
+METHOD(webgl2_draw_buffers);
+METHOD(webgl2_read_buffer);
+METHOD(webgl2_blit_framebuffer);
+METHOD(webgl2_framebuffer_texture_layer);
+METHOD(webgl2_invalidate_framebuffer);
+METHOD(webgl2_invalidate_sub_framebuffer);
+METHOD(webgl2_get_internalformat_parameter);
+METHOD(webgl2_get_frag_data_location);
+
 #undef METHOD
 
 }  // namespace domapi

package/runtime/ext_gui/dom_api_proto.cpp

@@ -117,6 +117,12 @@ xt_value document_proto() {
   define_method(proto, "querySelectorAll", (void *)doc_query_selector_all);
   define_method(proto, "getElementById", (void *)doc_get_element_by_id);
   define_method(proto, "createElement", (void *)doc_create_element);
+  define_method(proto, "createElementNS", (void *)doc_create_element_ns);
+  define_getter(proto, "hidden", (void *)doc_hidden_get);
+  define_getter(proto, "visibilityState", (void *)doc_visibility_state_get);
+  define_getter(proto, "readyState", (void *)doc_ready_state_get);
+  define_getter(proto, "title", (void *)doc_title_get);
+  define_getter(proto, "defaultView", (void *)doc_default_view_get);
   define_method(proto, "createTextNode", (void *)doc_create_text_node);
   /* `document.addEventListener` / element listener plumbing come from the node
    * prototype and operate on the document root node. */