xbintsc 0.3.25 → 0.3.35

package/runtime/ext_gui/dom_api_document.cpp

@@ -0,0 +1,96 @@
+/*
+ * xbintsc GUI engine — `document` node methods (queries + element creation).
+ */
+
+#include "dom_api_internal.h"
+
+#include <cctype>
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+static const xtgui::Node *find_by_tag(const xtgui::Node *node, const std::string &tag) {
+  if (node->isElement() && node->tag == tag) return node;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    if (const xtgui::Node *found = find_by_tag(child.get(), tag)) return found;
+  }
+  return nullptr;
+}
+
+static const xtgui::Node *find_by_id(const xtgui::Node *node, const std::string &id) {
+  if (node->isElement()) {
+    const std::string *value = node->attr("id");
+    if (value != nullptr && *value == id) return node;
+  }
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    if (const xtgui::Node *found = find_by_id(child.get(), id)) return found;
+  }
+  return nullptr;
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+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))));
+}
+
+METHOD(doc_query_selector_all) {
+  (void)env;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr || argc < 1) return xt_array_new(0, NULL);
+  std::vector<const xtgui::Node *> matches =
+      win->document->querySelectorAll(to_string_value(xt_arg(argc, argv, 0)));
+  xt_value array = xt_array_new(0, NULL);
+  for (const xtgui::Node *node : matches) xt_array_push(array, xt_gui_node_handle(win, node));
+  return array;
+}
+
+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))));
+}
+
+METHOD(doc_create_element) {
+  (void)env;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr || argc < 1) return XT_UNDEFINED;
+  std::string tag = to_string_value(xt_arg(argc, argv, 0));
+  for (char &c : tag) c = (char)std::tolower((unsigned char)c);
+  return xt_gui_node_handle(win, win->document->createElement(tag));
+}
+
+METHOD(doc_create_text_node) {
+  (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->createTextNode(to_string_value(xt_arg(argc, argv, 0))));
+}
+
+METHOD(doc_body_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, find_by_tag(win->document->root(), "body"));
+}
+
+METHOD(doc_document_element_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = resolve_window(self);
+  if (win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, find_by_tag(win->document->root(), "html"));
+}
+
+#undef METHOD
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_events.cpp

@@ -0,0 +1,123 @@
+/*
+ * xbintsc GUI engine — DOM event machinery (dispatch, listeners, propagation)
+ * and the `Event` prototype methods.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+static xt_value make_dom_event(XtGuiWindow *win, const char *type, const xtgui::Node *target,
+                               xt_value legacy) {
+  xt_value event = xt_object_new_with_proto(event_proto());
+  xt_object_set(event, xt_string_from_cstr("type"), xt_string_from_cstr(type));
+  xt_object_set(event, xt_string_from_cstr("target"), xt_gui_node_handle(win, target));
+  xt_object_set(event, xt_string_from_cstr("defaultPrevented"), XT_FALSE);
+  xt_object_set(event, xt_string_from_cstr("bubbles"), XT_TRUE);
+  if (XT_IS_OBJECT(legacy)) {
+    static const char *const fields[] = {
+        "x",     "y",    "clientX", "clientY", "button", "clicks",
+        "deltaX", "deltaY", "key",  "code",    "repeat", "ctrl",
+        "shift", "alt",  "meta",
+    };
+    for (const char *field : fields) {
+      xt_value value = xt_object_get_cstr(legacy, field);
+      if (!XT_IS_UNDEFINED(value)) xt_object_set(event, xt_string_from_cstr(field), value);
+    }
+  }
+  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);
+  if (found == win->node_listeners.end()) return;
+  std::vector<XtGuiNodeListener> &list = found->second;
+  for (auto it = list.begin(); it != list.end(); ++it) {
+    if (it->type == type && it->capture == capture && xt_truthy(xt_seq(it->fn, fn))) {
+      list.erase(it);
+      return;
+    }
+  }
+}
+
+static bool call_node_listeners(XtGuiWindow *win, xtgui::Node *node, const char *type,
+                                xt_value event, bool capture) {
+  auto found = win->node_listeners.find(node);
+  if (found == win->node_listeners.end()) return false;
+  std::vector<XtGuiNodeListener> snapshot = found->second;
+  for (const XtGuiNodeListener &listener : snapshot) {
+    if (listener.type != type || listener.capture != capture) continue;
+    if (listener.once) remove_listener(win, node, listener.type, listener.fn, listener.capture);
+    xt_value self = xt_gui_node_handle(win, node);
+    xt_object_set(event, xt_string_from_cstr("currentTarget"), self);
+    xt_value args[1] = {event};
+    xt_call_with_this(listener.fn, self, 1, args);
+    if (value_truthy(xt_object_get_cstr(event, "__stopImmediate"))) return true;
+    if (value_truthy(xt_object_get_cstr(event, "__stop"))) return true;
+  }
+  return value_truthy(xt_object_get_cstr(event, "__stop"));
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(event_prevent_default) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_object_set(self, xt_string_from_cstr("defaultPrevented"), XT_TRUE);
+  return XT_UNDEFINED;
+}
+
+METHOD(event_stop_propagation) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_object_set(self, xt_string_from_cstr("__stop"), XT_TRUE);
+  return XT_UNDEFINED;
+}
+
+METHOD(event_stop_immediate_propagation) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_object_set(self, xt_string_from_cstr("__stop"), XT_TRUE);
+  xt_object_set(self, xt_string_from_cstr("__stopImmediate"), XT_TRUE);
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace domapi
+
+void xt_gui_emit_dom_event(XtGuiWindow *win, const char *type, const xtgui::Node *target,
+                           xt_value legacy) {
+  using namespace domapi;
+  if (win == nullptr || win->document == nullptr || target == nullptr) return;
+  if (win->node_listeners.empty()) return;
+  std::vector<xtgui::Node *> path;
+  for (xtgui::Node *node = const_cast<xtgui::Node *>(target); node != nullptr; node = node->parent) {
+    path.push_back(node);
+  }
+  xt_value event = make_dom_event(win, type, target, legacy);
+  /* Capture phase: root -> target. */
+  for (auto it = path.rbegin(); it != path.rend(); ++it) {
+    if (call_node_listeners(win, *it, type, event, true)) return;
+  }
+  /* Bubble phase: target -> root. */
+  for (auto it = path.begin(); it != path.end(); ++it) {
+    if (call_node_listeners(win, *it, type, event, false)) return;
+  }
+}
+
+void xt_gui_dispatch_to_node(XtGuiWindow *win, const xtgui::Node *target, const char *type) {
+  if (win == nullptr || target == nullptr) return;
+  xt_value legacy = xt_object_new();
+  xt_object_set(legacy, xt_string_from_cstr("type"), xt_string_from_cstr(type));
+  std::string describe = xtgui::xt_dom_describe(target);
+  xt_object_set(legacy, xt_string_from_cstr("target"), xt_string_from_cstr(describe.c_str()));
+  xt_gui_emit_dom_event(win, type, target, legacy);
+}

package/runtime/ext_gui/dom_api_internal.h

@@ -0,0 +1,135 @@
+/*
+ * xbintsc GUI engine — shared declarations for the DOM object model
+ * translation units (`dom_api.cpp`, `dom_api_events.cpp`,
+ * `dom_api_document.cpp`, `dom_api_node.cpp`, `dom_api_node_read.cpp`,
+ * `dom_api_style.cpp`, `dom_api_proto.cpp`).
+ *
+ * The prototypes and the helpers that more than one unit needs live in
+ * `xtgui`-adjacent namespace `domapi` so the three public entry points
+ * (`xt_gui_node_handle` and friends, declared in `gui_engine.h`) can stay at
+ * global scope.
+ */
+#ifndef XT_GUI_DOM_API_INTERNAL_H
+#define XT_GUI_DOM_API_INTERNAL_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "gui_engine.h"
+
+namespace domapi {
+
+/* -- prototypes ----------------------------------------------------------- */
+
+extern xt_value g_node_proto;
+extern xt_value g_document_proto;
+extern xt_value g_event_proto;
+extern xt_value g_class_list_proto;
+extern xt_value g_style_proto;
+
+xt_value node_proto();
+xt_value document_proto();
+xt_value event_proto();
+xt_value class_list_proto();
+xt_value style_proto();
+
+/* -- cross-unit helpers --------------------------------------------------- */
+
+std::string to_string_value(xt_value value);
+bool value_truthy(xt_value value);
+XtGuiWindow *resolve_window(xt_value self);
+xtgui::Node *resolve_node(xt_value self, XtGuiWindow **winOut);
+void mark_dirty(XtGuiWindow *win);
+void set_attribute_raw(xtgui::Node *node, const std::string &name, const std::string &value);
+void remove_attribute_raw(xtgui::Node *node, const std::string &name);
+void set_attribute(XtGuiWindow *win, xtgui::Node *node, const std::string &name,
+                   const std::string &value);
+std::string class_name_of(const xtgui::Node *node);
+void set_class_name(XtGuiWindow *win, xtgui::Node *node, const std::string &value);
+void remove_listener(XtGuiWindow *win, xtgui::Node *node, const std::string &type, xt_value fn,
+                     bool capture);
+
+/* -- method definitions (uniform `(self, env, argc, argv)` ABI) ----------- */
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+/* document */
+METHOD(doc_query_selector);
+METHOD(doc_query_selector_all);
+METHOD(doc_get_element_by_id);
+METHOD(doc_create_element);
+METHOD(doc_create_text_node);
+METHOD(doc_body_get);
+METHOD(doc_document_element_get);
+
+/* node getters */
+METHOD(node_tag_name_get);
+METHOD(node_node_type_get);
+METHOD(node_id_get);
+METHOD(node_id_set);
+METHOD(node_class_name_get);
+METHOD(node_class_name_set);
+METHOD(node_text_content_get);
+METHOD(node_text_content_set);
+METHOD(node_inner_html_get);
+METHOD(node_inner_html_set);
+METHOD(node_parent_node_get);
+METHOD(node_parent_element_get);
+METHOD(node_children_get);
+METHOD(node_child_nodes_get);
+METHOD(node_child_element_count_get);
+METHOD(node_first_element_child_get);
+METHOD(node_last_element_child_get);
+METHOD(node_next_element_sibling_get);
+METHOD(node_previous_element_sibling_get);
+METHOD(node_is_connected_get);
+METHOD(node_class_list_get);
+METHOD(node_style_get);
+
+/* node methods */
+METHOD(node_get_attribute);
+METHOD(node_set_attribute);
+METHOD(node_remove_attribute);
+METHOD(node_has_attribute);
+METHOD(node_query_selector);
+METHOD(node_query_selector_all);
+METHOD(node_matches);
+METHOD(node_append_child);
+METHOD(node_insert_before);
+METHOD(node_remove_child);
+METHOD(node_replace_child);
+METHOD(node_remove);
+METHOD(node_clone_node);
+METHOD(node_get_bounding_rect);
+METHOD(node_offset_width_get);
+METHOD(node_offset_height_get);
+METHOD(node_contains);
+METHOD(node_focus);
+METHOD(node_blur);
+METHOD(node_click);
+METHOD(node_add_event_listener);
+METHOD(node_remove_event_listener);
+METHOD(node_dispatch_event);
+
+/* event methods */
+METHOD(event_prevent_default);
+METHOD(event_stop_propagation);
+METHOD(event_stop_immediate_propagation);
+
+/* classList methods */
+METHOD(class_list_add);
+METHOD(class_list_remove);
+METHOD(class_list_toggle);
+METHOD(class_list_contains);
+
+/* style methods */
+METHOD(style_set_property);
+METHOD(style_get_property_value);
+METHOD(style_remove_property);
+
+#undef METHOD
+
+}  // namespace domapi
+
+#endif /* XT_GUI_DOM_API_INTERNAL_H */

package/runtime/ext_gui/dom_api_node.cpp

@@ -0,0 +1,329 @@
+/*
+ * xbintsc GUI engine — element handle methods (attributes, queries, tree
+ * mutation, geometry reads, focus, events).
+ */
+
+#include "dom_api_internal.h"
+
+#include <algorithm>
+#include <cmath>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+static void collect_matches(const xtgui::Node *node,
+                            const std::vector<xtgui::ComplexSelector> &selectors,
+                            std::vector<const xtgui::Node *> &out) {
+  if (node->isElement()) {
+    for (const xtgui::ComplexSelector &selector : selectors) {
+      if (xtgui::xt_css_match(node, selector)) {
+        out.push_back(node);
+        break;
+      }
+    }
+  }
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    collect_matches(child.get(), selectors, out);
+  }
+}
+
+static xtgui::Node *clone_node(XtGuiWindow *win, const xtgui::Node *source, bool deep) {
+  if (source->isText()) return win->document->createTextNode(source->text);
+  if (!source->isElement()) return nullptr;
+  xtgui::Node *copy = win->document->createElement(source->tag);
+  for (const xtgui::Attr &attr : source->attrs) copy->attrs.push_back(attr);
+  if (deep) {
+    for (const std::unique_ptr<xtgui::Node> &child : source->children) {
+      xtgui::Node *childCopy = clone_node(win, child.get(), true);
+      if (childCopy != nullptr) win->document->appendChild(copy, childCopy);
+    }
+  }
+  return copy;
+}
+
+/** Laid-out border-box size, rounded like the browser `offsetWidth`/
+ * `offsetHeight` (0 when the element has no box yet). Applies pending
+ * mutations first so a read after a write is up to date. */
+static xt_value node_offset_dimension(xt_value self, bool width) {
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr) return xt_number(0);
+  xt_gui_flush_dom(win);
+  const xtgui::LayoutBox *box = win->document->boxOf(node);
+  if (box == nullptr) return xt_number(0);
+  return xt_number((double)std::lround(width ? box->width : box->height));
+}
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(node_get_attribute) {
+  (void)env;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement() || argc < 1) return XT_UNDEFINED;
+  const std::string *value = node->attr(to_string_value(xt_arg(argc, argv, 0)));
+  if (value == nullptr) return XT_UNDEFINED;
+  return xt_string_from_cstr(value->c_str());
+}
+
+METHOD(node_set_attribute) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement() || argc < 2) return XT_UNDEFINED;
+  set_attribute(win, node, to_string_value(xt_arg(argc, argv, 0)),
+                to_string_value(xt_arg(argc, argv, 1)));
+  return XT_UNDEFINED;
+}
+
+METHOD(node_remove_attribute) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || !node->isElement() || argc < 1) return XT_UNDEFINED;
+  remove_attribute_raw(node, to_string_value(xt_arg(argc, argv, 0)));
+  mark_dirty(win);
+  return XT_UNDEFINED;
+}
+
+METHOD(node_has_attribute) {
+  (void)env;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement() || argc < 1) return XT_FALSE;
+  return node->attr(to_string_value(xt_arg(argc, argv, 0))) != nullptr ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_query_selector) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || argc < 1) return XT_UNDEFINED;
+  std::vector<xtgui::ComplexSelector> selectors =
+      xtgui::xt_css_parse_selector_list(to_string_value(xt_arg(argc, argv, 0)));
+  if (selectors.empty()) return XT_UNDEFINED;
+  std::vector<const xtgui::Node *> matches;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    collect_matches(child.get(), selectors, matches);
+  }
+  return matches.empty() ? XT_UNDEFINED : xt_gui_node_handle(win, matches.front());
+}
+
+METHOD(node_query_selector_all) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  xt_value array = xt_array_new(0, NULL);
+  if (node == nullptr || argc < 1) return array;
+  std::vector<xtgui::ComplexSelector> selectors =
+      xtgui::xt_css_parse_selector_list(to_string_value(xt_arg(argc, argv, 0)));
+  std::vector<const xtgui::Node *> matches;
+  for (const std::unique_ptr<xtgui::Node> &child : node->children) {
+    collect_matches(child.get(), selectors, matches);
+  }
+  for (const xtgui::Node *match : matches) xt_array_push(array, xt_gui_node_handle(win, match));
+  return array;
+}
+
+METHOD(node_matches) {
+  (void)env;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || !node->isElement() || argc < 1) return XT_FALSE;
+  std::vector<xtgui::ComplexSelector> selectors =
+      xtgui::xt_css_parse_selector_list(to_string_value(xt_arg(argc, argv, 0)));
+  for (const xtgui::ComplexSelector &selector : selectors) {
+    if (xtgui::xt_css_match(node, selector)) return XT_TRUE;
+  }
+  return XT_FALSE;
+}
+
+METHOD(node_append_child) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 1) return XT_UNDEFINED;
+  xtgui::Node *child = resolve_node(xt_arg(argc, argv, 0), nullptr);
+  if (child == nullptr) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, win->document->appendChild(node, child));
+}
+
+METHOD(node_insert_before) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 1) return XT_UNDEFINED;
+  xtgui::Node *child = resolve_node(xt_arg(argc, argv, 0), nullptr);
+  xtgui::Node *reference = argc >= 2 ? resolve_node(xt_arg(argc, argv, 1), nullptr) : nullptr;
+  if (child == nullptr) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, win->document->insertBefore(node, child, reference));
+}
+
+METHOD(node_remove_child) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 1) return XT_UNDEFINED;
+  xtgui::Node *child = resolve_node(xt_arg(argc, argv, 0), nullptr);
+  if (child == nullptr) return XT_UNDEFINED;
+  win->document->removeChild(node, child);
+  return xt_gui_node_handle(win, child);
+}
+
+METHOD(node_replace_child) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 2) return XT_UNDEFINED;
+  xtgui::Node *newChild = resolve_node(xt_arg(argc, argv, 0), nullptr);
+  xtgui::Node *oldChild = resolve_node(xt_arg(argc, argv, 1), nullptr);
+  if (newChild == nullptr || oldChild == nullptr) return XT_UNDEFINED;
+  return xt_gui_node_handle(win, win->document->replaceChild(node, newChild, oldChild));
+}
+
+METHOD(node_remove) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr) return XT_UNDEFINED;
+  win->document->detach(node);
+  win->struct_dirty = 1;
+  return XT_UNDEFINED;
+}
+
+METHOD(node_clone_node) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr) return XT_UNDEFINED;
+  bool deep = argc >= 1 ? value_truthy(xt_arg(argc, argv, 0)) : false;
+  return xt_gui_node_handle(win, clone_node(win, node, deep));
+}
+
+METHOD(node_get_bounding_rect) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  const xtgui::LayoutBox *box = win->document->boxOf(node);
+  if (box == nullptr) return XT_UNDEFINED;
+  xt_value object = xt_object_new();
+  xt_object_set(object, xt_string_from_cstr("x"), xt_number(box->x));
+  xt_object_set(object, xt_string_from_cstr("y"), xt_number(box->y));
+  xt_object_set(object, xt_string_from_cstr("width"), xt_number(box->width));
+  xt_object_set(object, xt_string_from_cstr("height"), xt_number(box->height));
+  return object;
+}
+
+METHOD(node_offset_width_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return node_offset_dimension(self, true);
+}
+
+METHOD(node_offset_height_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return node_offset_dimension(self, false);
+}
+
+METHOD(node_contains) {
+  (void)env;
+  xtgui::Node *node = resolve_node(self, nullptr);
+  if (node == nullptr || argc < 1) return XT_FALSE;
+  xtgui::Node *other = resolve_node(xt_arg(argc, argv, 0), nullptr);
+  if (other == nullptr) return XT_FALSE;
+  return node->contains(other) ? XT_TRUE : XT_FALSE;
+}
+
+METHOD(node_focus) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  if (win->document->setFocus(node)) win->geometry.dirty = 1;
+  return XT_UNDEFINED;
+}
+
+METHOD(node_blur) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr) return XT_UNDEFINED;
+  if (win->document->focus() == node && win->document->setFocus(nullptr)) win->geometry.dirty = 1;
+  return XT_UNDEFINED;
+}
+
+METHOD(node_click) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr) return XT_UNDEFINED;
+  xt_gui_dispatch_to_node(win, node, "click");
+  return XT_UNDEFINED;
+}
+
+METHOD(node_add_event_listener) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 2) return self;
+  xt_value fn = xt_arg(argc, argv, 1);
+  if (!XT_IS_FUNCTION(fn)) return self;
+  bool capture = false;
+  bool once = false;
+  xt_value options = xt_arg(argc, argv, 2);
+  if (XT_IS_OBJECT(options)) {
+    capture = value_truthy(xt_object_get_cstr(options, "capture"));
+    once = value_truthy(xt_object_get_cstr(options, "once"));
+  } else if (XT_IS_BOOL(options)) {
+    capture = value_truthy(options);
+  }
+  XtGuiNodeListener listener;
+  listener.type = to_string_value(xt_arg(argc, argv, 0));
+  listener.fn = fn;
+  listener.once = once;
+  listener.capture = capture;
+  win->node_listeners[node].push_back(listener);
+  return self;
+}
+
+METHOD(node_remove_event_listener) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 2) return self;
+  bool capture = false;
+  xt_value options = xt_arg(argc, argv, 2);
+  if (XT_IS_OBJECT(options)) capture = value_truthy(xt_object_get_cstr(options, "capture"));
+  else if (XT_IS_BOOL(options)) capture = value_truthy(options);
+  remove_listener(win, node, to_string_value(xt_arg(argc, argv, 0)), xt_arg(argc, argv, 1), capture);
+  return self;
+}
+
+METHOD(node_dispatch_event) {
+  (void)env;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr || argc < 1) return XT_FALSE;
+  xt_value event = xt_arg(argc, argv, 0);
+  std::string type = XT_IS_OBJECT(event) ? to_string_value(xt_object_get_cstr(event, "type"))
+                                         : to_string_value(event);
+  xt_gui_emit_dom_event(win, type.c_str(), node, event);
+  return XT_TRUE;
+}
+
+#undef METHOD
+
+}  // namespace domapi