xbintsc 0.3.15 → 0.3.16

package/runtime/ext_gui/layout.h

@@ -0,0 +1,93 @@
+/*
+ * xbintsc GUI engine — layout (box tree + geometry).
+ *
+ * `LayoutTree::compute` turns the styled DOM into a tree of `LayoutBox`es with
+ * absolute (viewport-relative) geometry. It implements the slice a UI needs:
+ * block flow, a simple inline formatting context with greedy line breaking
+ * (text metrics come from the HarfBuzz/FreeType stack) and single-line
+ * Flexbox. `<img>` is a replaced element sized from its intrinsic dimensions.
+ *
+ * Coordinates are absolute: `x`/`y` is the border-box origin measured from the
+ * viewport's top-left corner.
+ */
+#ifndef XT_GUI_LAYOUT_H
+#define XT_GUI_LAYOUT_H
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "dom.h"
+#include "style.h"
+
+namespace xtgui {
+
+/** A positioned text fragment (a wrapped text box can span several lines).
+ * `text` holds the run this fragment covers (a word or a run of spaces). */
+struct TextFragment {
+  float x = 0;
+  float y = 0;
+  float width = 0;
+  float height = 0;
+  std::string text;
+};
+
+struct LayoutBox {
+  const Node *node = nullptr;
+  const XtStyle *style = nullptr;
+
+  bool is_text = false;
+  std::string text;               // only for text boxes
+  std::vector<TextFragment> fragments;
+
+  /* Replaced element (currently `<img>`): source + intrinsic pixel size. */
+  bool is_image = false;
+  std::string image_src;
+  float intrinsic_width = 0;
+  float intrinsic_height = 0;
+
+  Display display = Display::Inline;
+
+  /* Resolved (px) box edges. */
+  float margin_top = 0, margin_right = 0, margin_bottom = 0, margin_left = 0;
+  float padding_top = 0, padding_right = 0, padding_bottom = 0, padding_left = 0;
+  float border_top = 0, border_right = 0, border_bottom = 0, border_left = 0;
+
+  /* Absolute geometry; `x`/`y`/`width`/`height` are the border box. */
+  float x = 0, y = 0, width = 0, height = 0;
+  float content_x = 0, content_y = 0, content_width = 0, content_height = 0;
+  float baseline = 0;
+
+  LayoutBox *parent = nullptr;
+  std::vector<std::unique_ptr<LayoutBox>> children;
+};
+
+class LayoutTree {
+ public:
+  void compute(const Node *root, const std::unordered_map<const Node *, XtStyle> &styles,
+               float viewportWidth, float viewportHeight);
+  void clear() {
+    root_.reset();
+    index_.clear();
+  }
+
+  const LayoutBox *root() const { return root_.get(); }
+  const LayoutBox *find(const Node *node) const;
+  /** Deepest box whose border box contains the viewport-relative point. */
+  const LayoutBox *hitTest(float x, float y) const;
+  /** Human-readable geometry dump, for diagnostics/tests. */
+  std::string dump() const;
+
+ private:
+  std::unique_ptr<LayoutBox> root_;
+  std::unordered_map<const Node *, const LayoutBox *> index_;
+  XtStyle root_style_;
+};
+
+/** Text width under `style` (shaped with the HarfBuzz/FreeType stack). */
+float xt_layout_text_width(const std::string &text, const XtStyle &style);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_LAYOUT_H */

package/runtime/ext_gui/paint.cpp

@@ -0,0 +1,137 @@
+/*
+ * xbintsc GUI engine — display list construction.
+ */
+
+#include "paint.h"
+
+#include <cstdio>
+#include <utility>
+
+#include "style.h"
+
+namespace xtgui {
+
+namespace {
+
+std::string formatColor(const Color &color) {
+  char buffer[32];
+  std::snprintf(buffer, sizeof(buffer), "#%02x%02x%02x%02x", (int)(color.r * 255.0f + 0.5f),
+                (int)(color.g * 255.0f + 0.5f), (int)(color.b * 255.0f + 0.5f),
+                (int)(color.a * 255.0f + 0.5f));
+  return buffer;
+}
+
+FontSpec specOf(const XtStyle &style) {
+  FontSpec spec;
+  spec.family = style.font_family;
+  spec.pixel_size = style.font_size;
+  spec.weight = style.font_weight;
+  spec.italic = style.font_style == FontStyle::Italic;
+  return spec;
+}
+
+void addRect(DisplayList &out, float x, float y, float width, float height, float radius,
+             const Color &color) {
+  if (width <= 0.0f || height <= 0.0f || color.a <= 0.0f) return;
+  PaintRect rect;
+  rect.x = x;
+  rect.y = y;
+  rect.width = width;
+  rect.height = height;
+  rect.radius = radius;
+  rect.color = color;
+  out.rects.push_back(rect);
+}
+
+void addTextRuns(const LayoutBox *box, const XtStyle &style, DisplayList &out) {
+  if (box->fragments.empty() || style.color.a <= 0.0f) return;
+  FontSpec spec = specOf(style);
+  float ascent = 0;
+  xt_text_metrics(spec, &ascent, nullptr, nullptr);
+  if (ascent <= 0.0f) ascent = style.font_size * 0.8f;
+  for (const TextFragment &fragment : box->fragments) {
+    if (fragment.text.empty()) continue;
+    PaintText run;
+    run.x = fragment.x;
+    run.baseline = fragment.y + ascent;
+    run.width = fragment.width;
+    run.height = fragment.height;
+    run.color = style.color;
+    run.text = fragment.text;
+    run.font = spec;
+    out.texts.push_back(std::move(run));
+  }
+}
+
+void paintBox(const LayoutBox *box, DisplayList &out) {
+  if (box == nullptr) return;
+  const XtStyle *style = box->style;
+
+  if (style != nullptr && box->display != Display::None) {
+    if (box->is_text) {
+      addTextRuns(box, *style, out);
+    } else {
+      /* Background first, then the (sharp-cornered) border ring on top, then the
+       * children, so their content paints over the padding. */
+      if (style->has_background) {
+        addRect(out, box->x, box->y, box->width, box->height, style->border_radius,
+                style->background);
+      }
+      if (style->border_style != BorderStyle::None && style->has_border_color) {
+        const Color bc = style->border_color;
+        float top = box->border_top;
+        float right = box->border_right;
+        float bottom = box->border_bottom;
+        float left = box->border_left;
+        float inner_height = box->height - top - bottom;
+        /* Top/bottom span the whole width and overlap the side edges, which is
+         * harmless (same colour) and avoids seams from float rounding. */
+        addRect(out, box->x, box->y, box->width, top, 0.0f, bc);
+        addRect(out, box->x, box->y + box->height - bottom, box->width, bottom, 0.0f, bc);
+        addRect(out, box->x, box->y + top, left, inner_height, 0.0f, bc);
+        addRect(out, box->x + box->width - right, box->y + top, right, inner_height, 0.0f, bc);
+      }
+      if (box->is_image && !box->image_src.empty() && box->content_width > 0.0f &&
+          box->content_height > 0.0f) {
+        PaintImage image;
+        image.x = box->content_x;
+        image.y = box->content_y;
+        image.width = box->content_width;
+        image.height = box->content_height;
+        image.src = box->image_src;
+        out.images.push_back(std::move(image));
+      }
+    }
+  }
+
+  for (const std::unique_ptr<LayoutBox> &child : box->children) paintBox(child.get(), out);
+}
+
+}  // namespace
+
+void xt_paint_build(const LayoutBox *root, DisplayList &out) { paintBox(root, out); }
+
+std::string DisplayList::dump() const {
+  std::string text;
+  char buffer[192];
+  for (const PaintRect &rect : rects) {
+    std::snprintf(buffer, sizeof(buffer), "rect x=%.1f y=%.1f w=%.1f h=%.1f r=%.1f color=%s\n",
+                  rect.x, rect.y, rect.width, rect.height, rect.radius,
+                  formatColor(rect.color).c_str());
+    text += buffer;
+  }
+  for (const PaintText &run : texts) {
+    std::snprintf(buffer, sizeof(buffer),
+                  "text x=%.1f baseline=%.1f size=%.1f color=%s \"%s\"\n", run.x, run.baseline,
+                  run.font.pixel_size, formatColor(run.color).c_str(), run.text.c_str());
+    text += buffer;
+  }
+  for (const PaintImage &image : images) {
+    std::snprintf(buffer, sizeof(buffer), "image x=%.1f y=%.1f w=%.1f h=%.1f src=%s\n", image.x,
+                  image.y, image.width, image.height, image.src.c_str());
+    text += buffer;
+  }
+  return text;
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/paint.h

@@ -0,0 +1,75 @@
+/*
+ * xbintsc GUI engine — display list (paint).
+ *
+ * `xt_paint_build` walks the laid-out box tree and produces a painter's-order
+ * list of shapes. It is deliberately backend-agnostic: the GPU renderer turns
+ * the same list into triangles (rectangles) and glyph quads (text), and
+ * diagnostics/tests can inspect it without a GPU.
+ *
+ * Rectangles and text are kept in separate lists: backgrounds/borders are drawn
+ * first, then all text on top. That matches almost every static UI and lets the
+ * renderer use one draw call per list instead of switching pipelines per shape.
+ */
+#ifndef XT_GUI_PAINT_H
+#define XT_GUI_PAINT_H
+
+#include <string>
+#include <vector>
+
+#include "css.h"
+#include "layout.h"
+#include "text.h"
+
+namespace xtgui {
+
+/** A solid, optionally rounded, rectangle. Coordinates are viewport-relative. */
+struct PaintRect {
+  float x = 0;
+  float y = 0;
+  float width = 0;
+  float height = 0;
+  float radius = 0;
+  Color color;
+};
+
+/** A run of text to draw at `x`/`baseline` (viewport-relative). */
+struct PaintText {
+  float x = 0;
+  float baseline = 0;
+  float width = 0;
+  float height = 0;
+  Color color;
+  std::string text;
+  FontSpec font;
+};
+
+/** An image to draw, scaled into the given rectangle (viewport-relative). */
+struct PaintImage {
+  float x = 0;
+  float y = 0;
+  float width = 0;
+  float height = 0;
+  std::string src;
+};
+
+struct DisplayList {
+  std::vector<PaintRect> rects;
+  std::vector<PaintText> texts;
+  std::vector<PaintImage> images;
+
+  void clear() {
+    rects.clear();
+    texts.clear();
+    images.clear();
+  }
+  bool empty() const { return rects.empty() && texts.empty() && images.empty(); }
+  /** Human-readable dump, one shape per line (for diagnostics/tests). */
+  std::string dump() const;
+};
+
+/** Build the display list for a laid-out tree and append it to `out`. */
+void xt_paint_build(const LayoutBox *root, DisplayList &out);
+
+}  // namespace xtgui
+
+#endif /* XT_GUI_PAINT_H */