xbintsc 0.3.18 → 0.3.35

package/runtime/ext_gui/layout_flex.cpp

@@ -0,0 +1,200 @@
+/*
+ * xbintsc GUI engine — flex formatting context.
+ *
+ * Sizes flex items along the main axis (grow/shrink/basis), resolves the cross
+ * axis (align-items) and places them (justify-content), reusing the block and
+ * inline helpers from `layout_flow.cpp` / `layout_inline.cpp`.
+ */
+
+#include "layout_flow_internal.h"
+
+namespace xtgui {
+namespace layout_flow_detail {
+
+float Layouter::layoutFlex(LayoutBox *container, float contentWidth, float definiteHeight) const {
+  const XtStyle &containerStyle = *container->style;
+  bool isRow = containerStyle.flex_direction == FlexDirection::Row ||
+               containerStyle.flex_direction == FlexDirection::RowReverse;
+  bool reverse = containerStyle.flex_direction == FlexDirection::RowReverse ||
+                 containerStyle.flex_direction == FlexDirection::ColumnReverse;
+  float gap = px(containerStyle.gap, contentWidth, containerStyle.font_size, 0.0f);
+
+  std::vector<LayoutBox *> items;
+  for (const std::unique_ptr<LayoutBox> &child : container->children) {
+    if (child->display != Display::None) items.push_back(child.get());
+  }
+  if (items.empty()) return 0;
+  size_t count = items.size();
+
+  if (isRow) {
+    float mainSize = contentWidth;
+    std::vector<float> outer(count, 0.0f);
+    std::vector<float> mainSizes(count, 0.0f);
+    float sumBase = 0;
+    for (size_t i = 0; i < count; i++) {
+      const XtStyle &style = *items[i]->style;
+      float basis;
+      if (isAuto(style.flex_basis)) {
+        if (!isAuto(style.width)) basis = px(style.width, mainSize, style.font_size, 0.0f);
+        else basis = preferredContentWidth(items[i], mainSize);
+      } else {
+        basis = px(style.flex_basis, mainSize, style.font_size, 0.0f);
+      }
+      resolveEdges(items[i], mainSize);
+      float edges = horizontalEdges(items[i]);
+      outer[i] = basis + edges;
+      mainSizes[i] = outer[i];
+      sumBase += outer[i];
+    }
+    float free = mainSize - sumBase - gap * (float)(count - 1);
+    if (free > 0) {
+      float totalGrow = 0;
+      for (LayoutBox *item : items) totalGrow += item->style->flex_grow;
+      if (totalGrow > 0) {
+        for (size_t i = 0; i < count; i++)
+          mainSizes[i] += free * items[i]->style->flex_grow / totalGrow;
+      }
+    } else if (free < 0) {
+      float totalShrink = 0;
+      for (size_t i = 0; i < count; i++) totalShrink += items[i]->style->flex_shrink * outer[i];
+      if (totalShrink > 0) {
+        for (size_t i = 0; i < count; i++) {
+          mainSizes[i] += free * (items[i]->style->flex_shrink * outer[i]) / totalShrink;
+          mainSizes[i] = std::max(0.0f, mainSizes[i]);
+        }
+      }
+    }
+
+    /* Cross sizes: lay out once to measure, then apply cross alignment. */
+    float crossSize = definiteHeight >= 0 ? definiteHeight : 0;
+    std::vector<float> cross(count, 0.0f);
+    for (size_t i = 0; i < count; i++) {
+      float contentW = mainSizes[i] - horizontalEdges(items[i]);
+      if (contentW < 0) contentW = 0;
+      layoutBlock(items[i], container->content_x, container->content_y, contentWidth,
+                  definiteHeight, contentW);
+      cross[i] = verticalEdges(items[i]) + items[i]->height;
+      if (definiteHeight < 0) crossSize = std::max(crossSize, cross[i]);
+    }
+    if (containerStyle.align_items == AlignItems::Stretch && definiteHeight >= 0) {
+      for (size_t i = 0; i < count; i++) {
+        if (isAuto(items[i]->style->height)) {
+          float contentH = crossSize - verticalEdges(items[i]);
+          if (contentH < 0) contentH = 0;
+          float contentW = mainSizes[i] - horizontalEdges(items[i]);
+          layoutBlock(items[i], container->content_x, container->content_y, contentWidth,
+                      definiteHeight, contentW, contentH);
+        }
+      }
+    }
+
+    /* justify-content: place the main axis. */
+    float freeSpace = mainSize - (sumOf(mainSizes) + gap * (float)(count - 1));
+    float offset = 0;
+    float between = gap;
+    applyJustify(containerStyle.justify_content, freeSpace, count, &offset, &between);
+
+    float cursor = container->content_x + offset;
+    for (size_t k = 0; k < count; k++) {
+      size_t i = reverse ? (count - 1 - k) : k;
+      float crossOffset = crossOffsetFor(containerStyle.align_items, crossSize, cross[i]);
+      float dx = cursor - items[i]->x;
+      float dy = container->content_y + crossOffset - items[i]->y;
+      translate(items[i], dx, dy);
+      cursor += mainSizes[i] + between;
+    }
+    return crossSize;
+  }
+
+  /* Column flex. */
+  float mainSize = definiteHeight >= 0 ? definiteHeight : -1;
+  std::vector<float> outer(count, 0.0f);
+  float sumBase = 0;
+  for (size_t i = 0; i < count; i++) {
+    layoutBlock(items[i], container->content_x, container->content_y, contentWidth, definiteHeight);
+    outer[i] = verticalEdges(items[i]) + items[i]->height;
+    sumBase += outer[i];
+  }
+  std::vector<float> mainSizes = outer;
+  if (mainSize >= 0) {
+    float free = mainSize - sumBase - gap * (float)(count - 1);
+    if (free > 0) {
+      float totalGrow = 0;
+      for (LayoutBox *item : items) totalGrow += item->style->flex_grow;
+      if (totalGrow > 0) {
+        for (size_t i = 0; i < count; i++) {
+          mainSizes[i] += free * items[i]->style->flex_grow / totalGrow;
+          float contentH = mainSizes[i] - verticalEdges(items[i]);
+          if (contentH < 0) contentH = 0;
+          layoutBlock(items[i], container->content_x, container->content_y, contentWidth,
+                      definiteHeight, -1, contentH);
+        }
+      }
+    }
+  } else {
+    mainSize = sumBase + gap * (float)(count - 1);
+  }
+  float freeSpace = mainSize - (sumOf(mainSizes) + gap * (float)(count - 1));
+  float offset = 0;
+  float between = gap;
+  applyJustify(containerStyle.justify_content, freeSpace, count, &offset, &between);
+
+  float cursor = container->content_y + offset;
+  for (size_t k = 0; k < count; k++) {
+    size_t i = reverse ? (count - 1 - k) : k;
+    float dx = container->content_x - items[i]->x;
+    float dy = cursor - items[i]->y;
+    translate(items[i], dx, dy);
+    cursor += mainSizes[i] + between;
+  }
+  return mainSize;
+}
+
+float Layouter::sumOf(const std::vector<float> &values) {
+  float total = 0;
+  for (float value : values) total += value;
+  return total;
+}
+
+void Layouter::applyJustify(JustifyContent justify, float freeSpace, size_t count, float *offset,
+                            float *between) {
+  if (count == 0) return;
+  if (freeSpace < 0) freeSpace = 0;
+  switch (justify) {
+    case JustifyContent::FlexEnd:
+      *offset = freeSpace;
+      break;
+    case JustifyContent::Center:
+      *offset = freeSpace / 2.0f;
+      break;
+    case JustifyContent::SpaceBetween:
+      if (count > 1) *between += freeSpace / (float)(count - 1);
+      break;
+    case JustifyContent::SpaceAround:
+      *between += freeSpace / (float)count;
+      *offset = freeSpace / (2.0f * (float)count);
+      break;
+    case JustifyContent::SpaceEvenly:
+      *between += freeSpace / (float)(count + 1);
+      *offset = freeSpace / (float)(count + 1);
+      break;
+    default:
+      break;
+  }
+}
+
+float Layouter::crossOffsetFor(AlignItems align, float crossSize, float itemCross) {
+  switch (align) {
+    case AlignItems::FlexEnd:
+      return crossSize - itemCross;
+    case AlignItems::Center:
+      return (crossSize - itemCross) / 2.0f;
+    case AlignItems::Baseline:
+      return crossSize - itemCross;
+    default:
+      return 0.0f;
+  }
+}
+
+}  // namespace layout_flow_detail
+}  // namespace xtgui

package/runtime/ext_gui/layout_flow.cpp

@@ -0,0 +1,191 @@
+/*
+ * xbintsc GUI engine — block/flow layout core.
+ *
+ * The box tree is built in `layout.cpp`; this unit turns that tree into
+ * positioned boxes and owns the `Layouter` methods shared by the inline
+ * (`layout_inline.cpp`) and flex (`layout_flex.cpp`) formatting contexts.
+ */
+
+#include "layout_flow_internal.h"
+
+namespace xtgui {
+namespace layout_flow_detail {
+
+const XtStyle *Layouter::styleOf(const Node *node) const {
+  auto it = styles->find(node);
+  return it == styles->end() ? nullptr : &it->second;
+}
+
+float Layouter::px(const Length &length, float base, float em, float fallback) const {
+  return toPx(length, base, em, rootFontSize, vw, vh, fallback);
+}
+
+float Layouter::clampSize(float value, const Length &minLength, const Length &maxLength, float base,
+                          float em) const {
+  if (!isAuto(minLength)) value = std::max(value, px(minLength, base, em, value));
+  if (!isAuto(maxLength)) value = std::min(value, px(maxLength, base, em, value));
+  return value;
+}
+
+float Layouter::textWidth(const std::string &text, const XtStyle &style) const {
+  return xt_text_measure_width(text, specOf(style));
+}
+
+float Layouter::horizontalEdges(const LayoutBox *box) const {
+  return box->margin_left + box->margin_right + box->border_left + box->border_right +
+         box->padding_left + box->padding_right;
+}
+
+float Layouter::verticalEdges(const LayoutBox *box) const {
+  return box->margin_top + box->margin_bottom + box->border_top + box->border_bottom +
+         box->padding_top + box->padding_bottom;
+}
+
+float Layouter::preferredContentWidth(const LayoutBox *box, float available) const {
+  const XtStyle &style = *box->style;
+  if (!isAuto(style.width)) return px(style.width, available, style.font_size, 0.0f);
+  if (box->is_image && box->intrinsic_width > 0) return box->intrinsic_width;
+  float best = 0;
+  for (const std::unique_ptr<LayoutBox> &child : box->children) {
+    if (child->display == Display::None) continue;
+    if (child->is_text) {
+      best = std::max(best, textWidth(child->text, *child->style));
+    } else {
+      best = std::max(best,
+                      preferredContentWidth(child.get(), available) + horizontalEdges(child.get()));
+    }
+  }
+  return best;
+}
+
+void Layouter::translate(LayoutBox *box, float dx, float dy) const {
+  box->x += dx;
+  box->y += dy;
+  box->content_x += dx;
+  box->content_y += dy;
+  for (TextFragment &fragment : box->fragments) {
+    fragment.x += dx;
+    fragment.y += dy;
+  }
+  for (std::unique_ptr<LayoutBox> &child : box->children) translate(child.get(), dx, dy);
+}
+
+void Layouter::resolveEdges(LayoutBox *box, float containingWidth) const {
+  const XtStyle &style = *box->style;
+  float em = style.font_size;
+  box->margin_top = px(style.margin.top, containingWidth, em);
+  box->margin_right = px(style.margin.right, containingWidth, em);
+  box->margin_bottom = px(style.margin.bottom, containingWidth, em);
+  box->margin_left = px(style.margin.left, containingWidth, em);
+  box->padding_top = px(style.padding.top, containingWidth, em);
+  box->padding_right = px(style.padding.right, containingWidth, em);
+  box->padding_bottom = px(style.padding.bottom, containingWidth, em);
+  box->padding_left = px(style.padding.left, containingWidth, em);
+  if (style.border_style == BorderStyle::None) {
+    box->border_top = box->border_right = box->border_bottom = box->border_left = 0;
+  } else {
+    box->border_top = px(style.border_width.top, containingWidth, em);
+    box->border_right = px(style.border_width.right, containingWidth, em);
+    box->border_bottom = px(style.border_width.bottom, containingWidth, em);
+    box->border_left = px(style.border_width.left, containingWidth, em);
+  }
+}
+
+float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWidth,
+                            float availableHeight, float forcedContentWidth,
+                            float forcedContentHeight) const {
+  const XtStyle &style = *box->style;
+  float em = style.font_size;
+  resolveEdges(box, availableWidth);
+
+  float contentWidth;
+  if (forcedContentWidth >= 0) {
+    contentWidth = forcedContentWidth;
+  } else if (isAuto(style.width)) {
+    contentWidth = availableWidth - horizontalEdges(box);
+  } else {
+    contentWidth = px(style.width, availableWidth, em);
+  }
+  contentWidth = clampSize(contentWidth, style.min_width, style.max_width, availableWidth, em);
+  if (contentWidth < 0) contentWidth = 0;
+
+  box->x = x + box->margin_left;
+  box->y = y + box->margin_top;
+  box->content_x = box->x + box->border_left + box->padding_left;
+  box->content_y = box->y + box->border_top + box->padding_top;
+  box->content_width = contentWidth;
+  box->width =
+      box->border_left + box->padding_left + contentWidth + box->padding_right + box->border_right;
+
+  float definiteHeight = -1;
+  if (!isAuto(style.height) && !(style.height.unit == Unit::Percent && availableHeight < 0)) {
+    definiteHeight = px(style.height, availableHeight, em, -1);
+  }
+
+  float contentHeight;
+  if (forcedContentHeight >= 0) {
+    layoutChildren(box, contentWidth, availableHeight, forcedContentHeight);
+    contentHeight = forcedContentHeight;
+  } else {
+    contentHeight = layoutChildren(box, contentWidth, availableHeight, definiteHeight);
+    if (definiteHeight >= 0) contentHeight = definiteHeight;
+    contentHeight = clampSize(contentHeight, style.min_height, style.max_height,
+                              availableHeight < 0 ? contentHeight : availableHeight, em);
+    if (contentHeight < 0) contentHeight = 0;
+  }
+  /* Replaced elements keep their aspect ratio when only one axis is set. */
+  if (box->is_image && forcedContentHeight < 0 && isAuto(style.height) && box->intrinsic_width > 0 &&
+      box->intrinsic_height > 0) {
+    contentHeight = contentWidth * box->intrinsic_height / box->intrinsic_width;
+  }
+  box->content_height = contentHeight;
+  box->height =
+      box->border_top + box->padding_top + contentHeight + box->padding_bottom + box->border_bottom;
+  box->baseline = box->height;
+  return box->margin_top + box->height + box->margin_bottom;
+}
+
+float Layouter::layoutChildren(LayoutBox *block, float contentWidth, float availableHeight,
+                               float definiteHeight) const {
+  if (block->style->display == Display::Flex)
+    return layoutFlex(block, contentWidth, definiteHeight);
+
+  float y = block->content_y;
+  float startY = y;
+  std::vector<LayoutBox *> inlineRun;
+  auto flush = [&]() {
+    if (inlineRun.empty()) return;
+    y += layoutInlineRun(block, inlineRun, contentWidth, y);
+    inlineRun.clear();
+  };
+  for (const std::unique_ptr<LayoutBox> &child : block->children) {
+    Display display = child->display;
+    if (display == Display::None) continue;
+    if (display == Display::Block || display == Display::ListItem || display == Display::Flex) {
+      flush();
+      y += layoutBlock(child.get(), block->content_x, y, contentWidth, availableHeight);
+    } else {
+      inlineRun.push_back(child.get());
+    }
+  }
+  flush();
+  return y - startY;
+}
+
+}  // namespace layout_flow_detail
+
+float xt_layout_text_width(const std::string &text, const XtStyle &style) {
+  return xt_text_measure_width(text, layout_flow_detail::specOf(style));
+}
+
+void xt_layout_run(LayoutBox *root, const std::unordered_map<const Node *, XtStyle> &styles,
+                   float viewportWidth, float viewportHeight) {
+  layout_flow_detail::Layouter layouter;
+  layouter.styles = &styles;
+  layouter.tree = nullptr;
+  layouter.vw = viewportWidth;
+  layouter.vh = viewportHeight;
+  layouter.layoutBlock(root, 0, 0, viewportWidth, viewportHeight);
+}
+
+}  // namespace xtgui

package/runtime/ext_gui/layout_flow_internal.h

@@ -0,0 +1,149 @@
+/*
+ * xbintsc GUI engine — shared internals for the flow layouter.
+ *
+ * `Layouter` is split by formatting context across three translation units:
+ *   - layout_flow.cpp    block/flow core and the public entry points
+ *   - layout_inline.cpp  inline formatting context (line breaking, text runs)
+ *   - layout_flex.cpp    flex formatting context
+ * The struct and its data members live here so each unit can define methods.
+ */
+#ifndef XT_GUI_LAYOUT_FLOW_INTERNAL_H
+#define XT_GUI_LAYOUT_FLOW_INTERNAL_H
+
+#include <algorithm>
+#include <cfloat>
+#include <cstring>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "layout_internal.h"
+#include "text.h"
+
+namespace xtgui {
+namespace layout_flow_detail {
+
+constexpr float kHuge = 1e18f;
+
+struct InlineItem {
+  LayoutBox *box = nullptr;
+  const XtStyle *style = nullptr;
+  std::string text;
+  float width = 0;
+  float height = 0;
+  float ascent = 0;
+  bool is_space = false;
+  bool atomic = false;      // inline-block
+  bool force_break = false; // explicit newline (white-space: pre)
+};
+
+inline float toPx(const Length &length, float base, float em, float root, float vw, float vh,
+                  float fallback) {
+  switch (length.unit) {
+    case Unit::Px:
+    case Unit::Number:
+      return length.value;
+    case Unit::Percent:
+      return base * length.value / 100.0f;
+    case Unit::Em:
+      return em * length.value;
+    case Unit::Rem:
+      return root * length.value;
+    case Unit::Vw:
+      return vw * length.value / 100.0f;
+    case Unit::Vh:
+      return vh * length.value / 100.0f;
+    default:
+      return fallback;
+  }
+}
+
+inline bool isAuto(const Length &length) {
+  return length.unit == Unit::Auto || length.unit == Unit::Invalid || length.unit == Unit::None;
+}
+
+/* Per-character advance as a fraction of the font size is no longer needed
+ * here: text metrics come from the shaping stack (see `text.h`). */
+
+inline 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;
+}
+
+inline float lineHeightOf(const XtStyle &style) {
+  if (style.line_height.unit == Unit::Number) {
+    return style.line_height.value > 0 ? style.line_height.value * style.font_size
+                                       : style.font_size * 1.2f;
+  }
+  if (style.line_height.unit == Unit::Px) return style.line_height.value;
+  float lineHeight = 0;
+  xt_text_metrics(specOf(style), nullptr, nullptr, &lineHeight);
+  return lineHeight > 0 ? lineHeight : style.font_size * 1.2f;
+}
+
+inline float ascentOf(const XtStyle &style) {
+  float ascent = 0;
+  xt_text_metrics(specOf(style), &ascent, nullptr, nullptr);
+  return ascent > 0 ? ascent : style.font_size * 0.8f;
+}
+
+struct Layouter {
+  const std::unordered_map<const Node *, XtStyle> *styles = nullptr;
+  LayoutTree *tree = nullptr;
+  float vw = 0;
+  float vh = 0;
+  float rootFontSize = 16.0f;
+
+  const XtStyle *styleOf(const Node *node) const;
+
+  float px(const Length &length, float base, float em, float fallback = 0.0f) const;
+
+  float clampSize(float value, const Length &minLength, const Length &maxLength, float base,
+                  float em) const;
+
+  float textWidth(const std::string &text, const XtStyle &style) const;
+
+  float horizontalEdges(const LayoutBox *box) const;
+
+  float verticalEdges(const LayoutBox *box) const;
+
+  float preferredContentWidth(const LayoutBox *box, float available) const;
+
+  void translate(LayoutBox *box, float dx, float dy) const;
+
+  void resolveEdges(LayoutBox *box, float containingWidth) const;
+
+  /** Lay out `box` at (x, y) and return its outer height (margins included). */
+  float layoutBlock(LayoutBox *box, float x, float y, float availableWidth, float availableHeight,
+                    float forcedContentWidth = -1, float forcedContentHeight = -1) const;
+
+  /** Lay out the children of `block`; returns the used content height. */
+  float layoutChildren(LayoutBox *block, float contentWidth, float availableHeight,
+                       float definiteHeight) const;
+
+  void flattenInline(LayoutBox *box, float contentWidth, std::vector<InlineItem> &out) const;
+
+  void computeInlineGeometry(LayoutBox *box) const;
+
+  /** Lay out an inline formatting context; returns its consumed height. */
+  float layoutInlineRun(LayoutBox *container, const std::vector<LayoutBox *> &run,
+                        float contentWidth, float y) const;
+
+  float layoutFlex(LayoutBox *container, float contentWidth, float definiteHeight) const;
+
+  static float sumOf(const std::vector<float> &values);
+
+  static void applyJustify(JustifyContent justify, float freeSpace, size_t count, float *offset,
+                           float *between);
+
+  static float crossOffsetFor(AlignItems align, float crossSize, float itemCross);
+};
+
+}  // namespace layout_flow_detail
+}  // namespace xtgui
+
+#endif /* XT_GUI_LAYOUT_FLOW_INTERNAL_H */