xbintsc 0.3.18 → 0.3.35

package/runtime/ext_gui/dom.cpp

@@ -1,19 +1,16 @@
 /*
- * xbintsc GUI engine — HTML tokenizer + tree builder.
+ * xbintsc GUI engine — DOM node model.
  *
- * The tokenizer is a single pass that also swallows the contents of raw-text
- * elements (<style>, <script>, ...). The tree builder keeps a stack of open
- * elements and applies a small set of HTML "implied end tag" rules, which is
- * all a UI document needs.
+ * Defines the `Node` helpers shared by the HTML tree builder (`dom_parse.cpp`)
+ * and the serializer (`dom_serialize.cpp`). The tree is deliberately simple:
+ * document/element/text nodes are one type so the rest of the engine can walk
+ * it without casts.
  */
 
 #include "dom.h"
 
-#include <algorithm>
-#include <cctype>
-#include <cstdlib>
-#include <cstring>
-#include <unordered_map>
+#include <memory>
+#include <utility>
 
 namespace xtgui {
 
@@ -37,6 +34,42 @@ Node *Node::append(std::unique_ptr<Node> child) {
   return raw;
 }
 
+std::unique_ptr<Node> Node::detachChild(Node *child) {
+  for (auto it = children.begin(); it != children.end(); ++it) {
+    if (it->get() == child) {
+      std::unique_ptr<Node> owned = std::move(*it);
+      children.erase(it);
+      owned->parent = nullptr;
+      return owned;
+    }
+  }
+  return nullptr;
+}
+
+Node *Node::insertChild(std::unique_ptr<Node> child, Node *reference) {
+  child->parent = this;
+  Node *raw = child.get();
+  if (reference == nullptr) {
+    children.push_back(std::move(child));
+    return raw;
+  }
+  for (auto it = children.begin(); it != children.end(); ++it) {
+    if (it->get() == reference) {
+      children.insert(it, std::move(child));
+      return raw;
+    }
+  }
+  children.push_back(std::move(child));
+  return raw;
+}
+
+bool Node::contains(const Node *node) const {
+  for (const Node *current = node; current != nullptr; current = current->parent) {
+    if (current == this) return true;
+  }
+  return false;
+}
+
 Node *Node::addElement(const std::string &tagName) {
   auto node = std::make_unique<Node>(NodeType::Element);
   node->tag = tagName;
@@ -76,397 +109,4 @@ int Node::elementSiblingCount() const {
   return count;
 }
 
-/* -- helpers -------------------------------------------------------------- */
-
-static bool isAsciiAlpha(char c) {
-  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
-}
-
-static bool isWhitespace(char c) {
-  return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f';
-}
-
-static std::string toLower(const std::string &text) {
-  std::string out = text;
-  for (char &c : out) c = (char)std::tolower((unsigned char)c);
-  return out;
-}
-
-static std::string trim(const std::string &text) {
-  size_t begin = 0;
-  size_t end = text.size();
-  while (begin < end && isWhitespace(text[begin])) begin++;
-  while (end > begin && isWhitespace(text[end - 1])) end--;
-  return text.substr(begin, end - begin);
-}
-
-/** Decode the handful of entities that show up in UI text. */
-static std::string decodeEntities(const std::string &text) {
-  if (text.find('&') == std::string::npos) return text;
-  std::string out;
-  out.reserve(text.size());
-  for (size_t i = 0; i < text.size(); i++) {
-    if (text[i] != '&') {
-      out.push_back(text[i]);
-      continue;
-    }
-    size_t semi = text.find(';', i + 1);
-    if (semi == std::string::npos || semi - i > 12) {
-      out.push_back('&');
-      continue;
-    }
-    std::string name = text.substr(i + 1, semi - i - 1);
-    if (name == "amp") out.push_back('&');
-    else if (name == "lt") out.push_back('<');
-    else if (name == "gt") out.push_back('>');
-    else if (name == "quot") out.push_back('"');
-    else if (name == "apos") out.push_back('\'');
-    else if (name == "nbsp") out.push_back(' ');
-    else if (!name.empty() && name[0] == '#') {
-      long code = 0;
-      if (name.size() > 1 && (name[1] == 'x' || name[1] == 'X')) {
-        for (size_t k = 2; k < name.size(); k++) {
-          char digit = (char)std::tolower((unsigned char)name[k]);
-          int value = (digit >= '0' && digit <= '9') ? digit - '0'
-                      : (digit >= 'a' && digit <= 'f') ? digit - 'a' + 10
-                                                       : -1;
-          if (value < 0) break;
-          code = code * 16 + value;
-        }
-      } else {
-        code = strtol(name.c_str() + 1, nullptr, 10);
-      }
-      if (code > 0 && code < 128) out.push_back((char)code);
-      else out.push_back('?');
-    } else {
-      out.append(text, i, semi - i + 1);
-      i = semi;
-      continue;
-    }
-    i = semi;
-  }
-  return out;
-}
-
-static const std::unordered_map<std::string, bool> &voidElements() {
-  static const std::unordered_map<std::string, bool> set = {
-      {"area", true},   {"base", true},   {"br", true},    {"col", true},
-      {"embed", true},  {"hr", true},     {"img", true},   {"input", true},
-      {"link", true},   {"meta", true},   {"param", true}, {"source", true},
-      {"track", true},  {"wbr", true},
-  };
-  return set;
-}
-
-/** Elements whose content is treated as raw text. `script` is discarded. */
-static bool isRawText(const std::string &tag, bool *keepText) {
-  if (tag == "style" || tag == "title" || tag == "textarea") {
-    *keepText = true;
-    return true;
-  }
-  if (tag == "script" || tag == "xmp" || tag == "iframe" || tag == "noembed" ||
-      tag == "noframes" || tag == "plaintext") {
-    *keepText = false;
-    return true;
-  }
-  return false;
-}
-
-/* -- tokenizer ------------------------------------------------------------ */
-
-enum class TokenKind { Start, End, Text, EndOfFile };
-
-struct Token {
-  TokenKind kind = TokenKind::EndOfFile;
-  std::string name;
-  std::vector<Attr> attrs;
-  bool selfClosing = false;
-};
-
-class Tokenizer {
- public:
-  explicit Tokenizer(const std::string &html) : html_(html) {}
-
-  std::vector<Token> run() {
-    std::vector<Token> tokens;
-    while (position_ < html_.size()) {
-      if (html_[position_] == '<' && position_ + 1 < html_.size()) {
-        char next = html_[position_ + 1];
-        if (next == '!') {
-          skipBogusComment();
-          continue;
-        }
-        if (next == '/') {
-          Token token = readEndTag();
-          if (!token.name.empty()) tokens.push_back(std::move(token));
-          continue;
-        }
-        if (isAsciiAlpha(next)) {
-          Token token = readStartTag();
-          tokens.push_back(token);
-          bool keepText = false;
-          if (isRawText(token.name, &keepText) && !token.selfClosing) {
-            readRawText(token.name, keepText, tokens);
-          }
-          continue;
-        }
-      }
-      std::string text = readText();
-      if (!text.empty()) {
-        Token token;
-        token.kind = TokenKind::Text;
-        token.name = decodeEntities(text);
-        tokens.push_back(std::move(token));
-      }
-    }
-    return tokens;
-  }
-
- private:
-  const std::string &html_;
-  size_t position_ = 0;
-
-  void skipBogusComment() {
-    if (html_.compare(position_, 4, "<!--") == 0) {
-      size_t end = html_.find("-->", position_ + 4);
-      position_ = (end == std::string::npos) ? html_.size() : end + 3;
-      return;
-    }
-    size_t end = html_.find('>', position_);
-    position_ = (end == std::string::npos) ? html_.size() : end + 1;
-  }
-
-  std::string readText() {
-    size_t start = position_;
-    while (position_ < html_.size() && html_[position_] != '<') position_++;
-    return html_.substr(start, position_ - start);
-  }
-
-  std::string readName() {
-    size_t start = position_;
-    while (position_ < html_.size()) {
-      char c = html_[position_];
-      if (isWhitespace(c) || c == '/' || c == '>') break;
-      position_++;
-    }
-    return toLower(html_.substr(start, position_ - start));
-  }
-
-  void skipWhitespace() {
-    while (position_ < html_.size() && isWhitespace(html_[position_])) position_++;
-  }
-
-  Token readStartTag() {
-    Token token;
-    token.kind = TokenKind::Start;
-    position_++;  // consume '<'
-    token.name = readName();
-    while (position_ < html_.size()) {
-      skipWhitespace();
-      if (position_ >= html_.size()) break;
-      char c = html_[position_];
-      if (c == '>') {
-        position_++;
-        break;
-      }
-      if (c == '/') {
-        token.selfClosing = true;
-        position_++;
-        continue;
-      }
-      readAttribute(token);
-    }
-    return token;
-  }
-
-  void readAttribute(Token &token) {
-    size_t start = position_;
-    while (position_ < html_.size()) {
-      char c = html_[position_];
-      if (isWhitespace(c) || c == '=' || c == '>' || c == '/') break;
-      position_++;
-    }
-    std::string name = toLower(html_.substr(start, position_ - start));
-    if (name.empty()) {
-      position_++;
-      return;
-    }
-    skipWhitespace();
-    std::string value;
-    if (position_ < html_.size() && html_[position_] == '=') {
-      position_++;
-      skipWhitespace();
-      if (position_ < html_.size() && (html_[position_] == '"' || html_[position_] == '\'')) {
-        char quote = html_[position_++];
-        size_t begin = position_;
-        while (position_ < html_.size() && html_[position_] != quote) position_++;
-        value = html_.substr(begin, position_ - begin);
-        if (position_ < html_.size()) position_++;
-      } else {
-        size_t begin = position_;
-        while (position_ < html_.size() && !isWhitespace(html_[position_]) && html_[position_] != '>') position_++;
-        value = html_.substr(begin, position_ - begin);
-      }
-    }
-    token.attrs.push_back({name, decodeEntities(value)});
-  }
-
-  Token readEndTag() {
-    Token token;
-    token.kind = TokenKind::End;
-    position_ += 2;  // consume '</'
-    token.name = readName();
-    size_t end = html_.find('>', position_);
-    position_ = (end == std::string::npos) ? html_.size() : end + 1;
-    return token;
-  }
-
-  void readRawText(const std::string &tag, bool keepText, std::vector<Token> &tokens) {
-    size_t start = position_;
-    std::string close = "</" + tag;
-    while (position_ < html_.size()) {
-      if (html_[position_] == '<' && toLower(html_.substr(position_, close.size())) == close) {
-        break;
-      }
-      position_++;
-    }
-    std::string raw = html_.substr(start, position_ - start);
-    if (keepText && !raw.empty()) {
-      Token text;
-      text.kind = TokenKind::Text;
-      text.name = raw;
-      tokens.push_back(std::move(text));
-    }
-    if (position_ < html_.size()) {
-      Token end = readEndTag();
-      tokens.push_back(std::move(end));
-    }
-  }
-};
-
-/* -- tree builder --------------------------------------------------------- */
-
-namespace {
-
-bool isBlockTag(const std::string &tag) {
-  static const std::unordered_map<std::string, bool> set = {
-      {"address", true}, {"article", true}, {"aside", true},  {"blockquote", true},
-      {"div", true},     {"dl", true},      {"fieldset", true}, {"figure", true},
-      {"footer", true},  {"form", true},    {"h1", true},       {"h2", true},
-      {"h3", true},      {"h4", true},      {"h5", true},       {"h6", true},
-      {"header", true},  {"hr", true},      {"main", true},     {"nav", true},
-      {"ol", true},      {"p", true},       {"pre", true},      {"section", true},
-      {"table", true},   {"ul", true},
-  };
-  return set.count(tag) != 0;
-}
-
-bool isHeading(const std::string &tag) {
-  return tag.size() == 2 && tag[0] == 'h' && tag[1] >= '1' && tag[1] <= '6';
-}
-
-/** Whether a start tag implicitly closes the currently open element. */
-bool closesOpenElement(const std::string &open, const std::string &next) {
-  if (open.empty()) return false;
-  if (next == "li" && open == "li") return true;
-  if ((next == "dt" || next == "dd") && (open == "dt" || open == "dd")) return true;
-  if (next == "option" && open == "option") return true;
-  if (next == "p" && open == "p") return true;
-  if (isHeading(next) && (isHeading(open) || open == "p")) return true;
-  if (isBlockTag(next) && open == "p") return true;
-  if ((next == "td" || next == "th") && (open == "td" || open == "th")) return true;
-  if (next == "tr" && (open == "td" || open == "th" || open == "tr")) return true;
-  if ((next == "thead" || next == "tbody" || next == "tfoot") &&
-      (open == "td" || open == "th" || open == "tr" || open == "thead" ||
-       open == "tbody" || open == "tfoot")) {
-    return true;
-  }
-  return false;
-}
-
-}  // namespace
-
-std::unique_ptr<Node> xt_html_parse(const std::string &html) {
-  Tokenizer tokenizer(html);
-  std::vector<Token> tokens = tokenizer.run();
-
-  auto document = std::make_unique<Node>(NodeType::Document);
-  std::vector<Node *> stack;
-  stack.push_back(document.get());
-
-  for (Token &token : tokens) {
-    if (token.kind == TokenKind::Text) {
-      Node *current = stack.back();
-      /* Text inside <style>/<title> is kept verbatim; elsewhere keep it too so
-       * layout can collapse whitespace later. */
-      current->addText(token.name);
-      continue;
-    }
-    if (token.kind == TokenKind::Start) {
-      while (stack.size() > 1 && closesOpenElement(stack.back()->tag, token.name)) {
-        stack.pop_back();
-      }
-      Node *element = stack.back()->addElement(token.name);
-      element->attrs = std::move(token.attrs);
-      bool isVoid = voidElements().count(token.name) != 0;
-      if (!isVoid && !token.selfClosing) stack.push_back(element);
-      continue;
-    }
-    if (token.kind == TokenKind::End) {
-      for (size_t i = stack.size(); i-- > 1;) {
-        if (stack[i]->tag == token.name) {
-          stack.resize(i);
-          break;
-        }
-      }
-    }
-  }
-
-  return document;
-}
-
-/* -- serialization (diagnostics) ------------------------------------------ */
-
-static void serialize(const Node *node, std::string &out) {
-  if (node->type == NodeType::Document) {
-    for (const std::unique_ptr<Node> &child : node->children) serialize(child.get(), out);
-    return;
-  }
-  if (node->type == NodeType::Text) {
-    out += trim(node->text);
-    return;
-  }
-  out += "<" + node->tag;
-  for (const Attr &attr : node->attrs) out += " " + attr.name + "=\"" + attr.value + "\"";
-  out += ">";
-  for (const std::unique_ptr<Node> &child : node->children) serialize(child.get(), out);
-  out += "</" + node->tag + ">";
-}
-
-std::string xt_dom_to_string(const Node *node) {
-  std::string out;
-  if (node != nullptr) serialize(node, out);
-  return out;
-}
-
-std::string xt_dom_describe(const Node *node) {
-  if (node == nullptr) return "";
-  if (node->isText()) return "#text";
-  if (!node->isElement()) return "#document";
-  std::string out = node->tag;
-  const std::string *id = node->attr("id");
-  if (id != nullptr && !id->empty()) out += "#" + *id;
-  const std::string *classes = node->attr("class");
-  if (classes != nullptr) {
-    size_t index = 0;
-    while (index < classes->size()) {
-      while (index < classes->size() && std::isspace((unsigned char)(*classes)[index])) index++;
-      size_t start = index;
-      while (index < classes->size() && !std::isspace((unsigned char)(*classes)[index])) index++;
-      if (index > start) out += "." + classes->substr(start, index - start);
-    }
-  }
-  return out;
-}
-
 }  // namespace xtgui

package/runtime/ext_gui/dom.h

@@ -49,6 +49,13 @@ struct Node {
   Node *addText(const std::string &data);
   Node *append(std::unique_ptr<Node> child);
 
+  /** Detach a direct child, transferring ownership to the caller. */
+  std::unique_ptr<Node> detachChild(Node *child);
+  /** Insert `child` before `reference` (append when `reference` is nullptr). */
+  Node *insertChild(std::unique_ptr<Node> child, Node *reference);
+  /** True when `node` is this node or a descendant of it. */
+  bool contains(const Node *node) const;
+
   /** First element child (skips text), or NULL. */
   Node *firstElementChild() const;
   /** Total number of element children with the same tag, and this node's index. */

package/runtime/ext_gui/dom_api.cpp

@@ -0,0 +1,164 @@
+/*
+ * xbintsc GUI engine — the DOM object model exposed to TypeScript.
+ *
+ * Node/document handles are plain runtime objects with a shared prototype,
+ * exactly like the window handles in `window.cpp`. Each handle carries hidden
+ * properties:
+ *
+ *   __xt_gui_win   the owning window object (resolved with xt_gui_window_from_this)
+ *   __xt_gui_gen   the document generation it was created for
+ *   __xt_gui_node  an index into the window's node table (element handles)
+ *   __xt_gui_doc   true for the singleton `document` handle
+ *
+ * A DOM mutation marks the document dirty; the frame loop restyles/relayouts
+ * before the next paint.
+ *
+ * This unit owns the shared prototypes, the generic helpers and the public
+ * handle entry points. Event machinery lives in `dom_api_events.cpp`, the
+ * prototype table in `dom_api_proto.cpp`, and the element methods in the
+ * remaining `dom_api_*.cpp` units.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cctype>
+#include <string>
+#include <vector>
+
+namespace domapi {
+
+xt_value g_node_proto = XT_UNDEFINED;
+xt_value g_document_proto = XT_UNDEFINED;
+xt_value g_event_proto = XT_UNDEFINED;
+xt_value g_class_list_proto = XT_UNDEFINED;
+xt_value g_style_proto = XT_UNDEFINED;
+
+/* -- small helpers -------------------------------------------------------- */
+
+static const char *to_cstr(xt_value value, const char *fallback = "") {
+  const char *data = xt_string_data(xt_to_string(value));
+  return data != nullptr ? data : fallback;
+}
+
+std::string to_string_value(xt_value value) { return std::string(to_cstr(value)); }
+
+bool value_truthy(xt_value value) { return xt_truthy(value) != 0; }
+
+/* -- handle plumbing ------------------------------------------------------ */
+
+XtGuiWindow *resolve_window(xt_value self) {
+  return xt_gui_window_from_this(xt_object_get_cstr(self, "__xt_gui_win"));
+}
+
+/** Resolve a node handle to its node, or NULL when it is stale/foreign. */
+xtgui::Node *resolve_node(xt_value self, XtGuiWindow **winOut) {
+  XtGuiWindow *win = resolve_window(self);
+  if (winOut != nullptr) *winOut = win;
+  if (win == nullptr || win->document == nullptr) return nullptr;
+  xt_value gen = xt_object_get_cstr(self, "__xt_gui_gen");
+  if (!XT_IS_NUMBER(gen) || xt_to_number(gen) != win->doc_generation) return nullptr;
+  if (value_truthy(xt_object_get_cstr(self, "__xt_gui_doc"))) {
+    return const_cast<xtgui::Node *>(win->document->root());
+  }
+  xt_value index = xt_object_get_cstr(self, "__xt_gui_node");
+  if (!XT_IS_NUMBER(index)) return nullptr;
+  int slot = (int)xt_to_number(index);
+  if (slot < 0 || slot >= (int)win->node_order.size()) return nullptr;
+  return win->node_order[(size_t)slot];
+}
+
+void mark_dirty(XtGuiWindow *win) {
+  if (win != nullptr && win->document != nullptr) win->document->invalidate();
+  if (win != nullptr) win->struct_dirty = 1;
+}
+
+/* -- attribute / class helpers -------------------------------------------- */
+
+void set_attribute_raw(xtgui::Node *node, const std::string &name, const std::string &value) {
+  for (xtgui::Attr &attr : node->attrs) {
+    if (attr.name == name) {
+      attr.value = value;
+      return;
+    }
+  }
+  node->attrs.push_back({name, value});
+}
+
+void remove_attribute_raw(xtgui::Node *node, const std::string &name) {
+  for (auto it = node->attrs.begin(); it != node->attrs.end(); ++it) {
+    if (it->name == name) {
+      node->attrs.erase(it);
+      return;
+    }
+  }
+}
+
+void set_attribute(XtGuiWindow *win, xtgui::Node *node, const std::string &name,
+                   const std::string &value) {
+  set_attribute_raw(node, name, value);
+  mark_dirty(win);
+}
+
+std::string class_name_of(const xtgui::Node *node) {
+  const std::string *value = node->attr("class");
+  return value != nullptr ? *value : std::string();
+}
+
+void set_class_name(XtGuiWindow *win, xtgui::Node *node, const std::string &value) {
+  if (value.empty()) {
+    remove_attribute_raw(node, "class");
+    mark_dirty(win);
+  } else {
+    set_attribute(win, node, "class", value);
+  }
+}
+
+}  // namespace domapi
+
+xt_value xt_gui_node_handle(XtGuiWindow *win, const xtgui::Node *node) {
+  if (win == nullptr || node == nullptr) return XT_UNDEFINED;
+  auto cached = win->node_handles.find(node);
+  if (cached != win->node_handles.end()) return cached->second;
+  int slot;
+  auto found = win->node_index.find(node);
+  if (found != win->node_index.end()) {
+    slot = found->second;
+  } else {
+    slot = (int)win->node_order.size();
+    win->node_order.push_back(const_cast<xtgui::Node *>(node));
+    win->node_index[node] = slot;
+  }
+  xt_value handle = xt_object_new_with_proto(domapi::node_proto());
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_win"), win->object);
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_gen"), xt_number(win->doc_generation));
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_node"), xt_number((double)slot));
+  win->node_handles[node] = handle;
+  return handle;
+}
+
+xt_value xt_gui_document_handle(XtGuiWindow *win) {
+  if (win == nullptr) return XT_UNDEFINED;
+  if (!XT_IS_OBJECT(win->document_object)) {
+    xt_value handle = xt_object_new_with_proto(domapi::document_proto());
+    xt_object_set(handle, xt_string_from_cstr("__xt_gui_win"), win->object);
+    xt_object_set(handle, xt_string_from_cstr("__xt_gui_doc"), XT_TRUE);
+    win->document_object = handle;
+  }
+  xt_object_set(win->document_object, xt_string_from_cstr("__xt_gui_gen"),
+                xt_number(win->doc_generation));
+  return win->document_object;
+}
+
+void xt_gui_handles_reset(XtGuiWindow *win) {
+  if (win == nullptr) return;
+  win->doc_generation += 1.0;
+  win->node_order.clear();
+  win->node_index.clear();
+  win->node_handles.clear();
+  win->node_listeners.clear();
+  win->struct_dirty = 0;
+  if (XT_IS_OBJECT(win->document_object)) {
+    xt_object_set(win->document_object, xt_string_from_cstr("__xt_gui_gen"),
+                  xt_number(win->doc_generation));
+  }
+}

package/runtime/ext_gui/dom_api.h

@@ -0,0 +1,12 @@
+/*
+ * xbintsc GUI engine — DOM object model entry points.
+ *
+ * The implementation lives in `dom_api.cpp`; this header only pulls in the
+ * shared engine definitions so translation units can include either one.
+ */
+#ifndef XT_GUI_DOM_API_H
+#define XT_GUI_DOM_API_H
+
+#include "gui_engine.h"
+
+#endif /* XT_GUI_DOM_API_H */