xbintsc 0.3.69 → 0.3.81

package/runtime/ext_gui/layout_flow_internal.h

@@ -25,6 +25,14 @@ namespace layout_flow_detail {
 
 constexpr float kHuge = 1e18f;
 
+/** Collapse two adjoining vertical margins (CSS margin collapsing): the larger
+ * positive margin wins, a negative margin is subtracted. */
+inline float collapseMargins(float a, float b) {
+  float positive = std::max(0.0f, std::max(a, b));
+  float negative = std::min(0.0f, std::min(a, b));
+  return positive + negative;
+}
+
 struct InlineItem {
   LayoutBox *box = nullptr;
   const XtStyle *style = nullptr;
@@ -37,6 +45,63 @@ struct InlineItem {
   bool force_break = false; // explicit newline (white-space: pre)
 };
 
+/** One float taking part in the current block's formatting context. Floats are
+ * out of flow: they do not advance the block cursor, but inline lines shrink to
+ * the gap they leave. */
+struct ActiveFloat {
+  bool left = true;
+  float x = 0;
+  float width = 0;
+  float top = 0;
+  float height = 0;
+  float bottom() const { return top + height; }
+};
+
+/** The floats in effect while laying out a block's inline content. */
+struct FloatContext {
+  std::vector<ActiveFloat> floats;
+  void prune(float y) {
+    for (auto it = floats.begin(); it != floats.end();) {
+      if (it->bottom() <= y) it = floats.erase(it);
+      else ++it;
+    }
+  }
+  float leftEdge(float x, float y, float bottom) const {
+    for (const ActiveFloat &f : floats) {
+      if (!f.left || f.bottom() <= y || f.top >= bottom) continue;
+      if (f.x + f.width > x) x = f.x + f.width;
+    }
+    return x;
+  }
+  float rightEdge(float x, float y, float bottom) const {
+    for (const ActiveFloat &f : floats) {
+      if (f.left || f.bottom() <= y || f.top >= bottom) continue;
+      if (f.x < x) x = f.x;
+    }
+    return x;
+  }
+  float maxBottom() const {
+    float bottom = 0;
+    for (const ActiveFloat &f : floats)
+      if (f.bottom() > bottom) bottom = f.bottom();
+    return bottom;
+  }
+  bool clears(bool left, bool right, float y) const {
+    for (const ActiveFloat &f : floats) {
+      if (f.bottom() <= y) continue;
+      if ((left && f.left) || (right && !f.left)) return true;
+    }
+    return false;
+  }
+  float clearY(bool left, bool right, float y) const {
+    for (const ActiveFloat &f : floats) {
+      if (f.bottom() <= y) continue;
+      if ((left && f.left) || (right && !f.left)) y = std::max(y, f.bottom());
+    }
+    return y;
+  }
+};
+
 inline float toPx(const Length &length, float base, float em, float root, float vw, float vh,
                   float fallback) {
   switch (length.unit) {
@@ -128,9 +193,10 @@ struct Layouter {
 
   void resolveEdges(LayoutBox *box, float containingWidth) const;
 
-  /** Lay out `box` at (x, y) and return its outer height (margins included).
-   * `inFlow` is false for an absolutely positioned child: it is still laid out,
-   * but the caller ignores the returned height (it is out of flow). */
+  /** Lay out `box` at (x, y) and return its border-box height. The caller owns
+   * the vertical margins (it collapses them and advances the flow). `inFlow` is
+   * false for an absolutely positioned child: it is still laid out, but the
+   * caller ignores the returned height (it is out of flow). */
   float layoutBlock(LayoutBox *box, float x, float y, float availableWidth, float availableHeight,
                     float forcedContentWidth = -1, float forcedContentHeight = -1,
                     bool inFlow = true) const;
@@ -168,12 +234,25 @@ struct Layouter {
 
   void computeInlineGeometry(LayoutBox *box) const;
 
-  /** Lay out an inline formatting context; returns its consumed height. */
+  /** Lay out an inline formatting context; returns its consumed height. When
+   * `floats` is non-null, each line shrinks to the gap left by the floats that
+   * overlap it. */
   float layoutInlineRun(LayoutBox *container, const std::vector<LayoutBox *> &run,
-                        float contentWidth, float y) const;
+                        float contentWidth, float y, const FloatContext *floats = nullptr) const;
 
   float layoutFlex(LayoutBox *container, float contentWidth, float definiteHeight) const;
 
+  /** Flex row main-axis layout, wrapping items into lines when `flex-wrap`
+   * allows it. Returns the used cross size. */
+  float layoutFlexRow(LayoutBox *container, const std::vector<LayoutBox *> &items,
+                      float contentWidth, float definiteHeight, float mainGap,
+                      float crossGap) const;
+
+  /** Flex column main-axis layout (wrapping needs a definite height). */
+  float layoutFlexColumn(LayoutBox *container, const std::vector<LayoutBox *> &items,
+                         float contentWidth, float definiteHeight, float mainGap,
+                         float crossGap) const;
+
   static float sumOf(const std::vector<float> &values);
 
   static void applyJustify(JustifyContent justify, float freeSpace, size_t count, float *offset,

package/runtime/ext_gui/layout_inline.cpp

@@ -113,56 +113,47 @@ void Layouter::computeInlineGeometry(LayoutBox *box) const {
 }
 
 float Layouter::layoutInlineRun(LayoutBox *container, const std::vector<LayoutBox *> &run,
-                                float contentWidth, float y) const {
+                                float contentWidth, float y, const FloatContext *floats) const {
   std::vector<InlineItem> items;
   for (LayoutBox *box : run) flattenInline(box, contentWidth, items);
   if (items.empty()) return 0;
 
-  std::vector<std::vector<InlineItem *>> lines;
+  const XtStyle &containerStyle = *container->style;
+  float cursorY = y;
   std::vector<InlineItem *> line;
   float lineWidth = 0;
-  auto pushLine = [&]() {
-    while (!line.empty() && line.back()->is_space) {
-      lineWidth -= line.back()->width;
-      line.pop_back();
+  float lineAscent = 0;
+  float lineDescent = 0;
+
+  /* Horizontal band left free by the floats overlapping [top, top + height). */
+  auto band = [&](float top, float height, float *x0, float *x1) {
+    *x0 = container->content_x;
+    *x1 = container->content_x + contentWidth;
+    if (floats != nullptr && height > 0) {
+      *x0 = floats->leftEdge(*x0, top, top + height);
+      *x1 = floats->rightEdge(*x1, top, top + height);
     }
-    if (!line.empty()) lines.push_back(line);
-    line.clear();
-    lineWidth = 0;
+    if (*x1 < *x0) *x1 = *x0;
   };
-  for (InlineItem &item : items) {
-    if (item.force_break) {
-      pushLine();
-      continue;
-    }
-    if (item.is_space && line.empty()) continue; // no leading space on a line
-    if (lineWidth + item.width > contentWidth && !line.empty()) pushLine();
-    if (item.is_space && line.empty()) continue;
-    line.push_back(&item);
-    lineWidth += item.width;
-  }
-  pushLine();
 
-  const XtStyle &containerStyle = *container->style;
-  float cursorY = y;
-  for (size_t index = 0; index < lines.size(); index++) {
-    std::vector<InlineItem *> &current = lines[index];
-    float width = 0;
-    float ascent = 0;
-    float descent = 0;
-    for (InlineItem *item : current) {
-      width += item->width;
-      ascent = std::max(ascent, item->ascent);
-      descent = std::max(descent, item->height - item->ascent);
+  auto finalize = [&]() {
+    while (!line.empty() && line.back()->is_space) {
+      lineWidth -= line.back()->width;
+      line.pop_back();
     }
-    float height = ascent + descent;
-    float x = container->content_x;
+    if (line.empty()) return;
+    float height = lineAscent + lineDescent;
+    float x0 = 0;
+    float x1 = 0;
+    band(cursorY, height, &x0, &x1);
+    float available = x1 - x0;
+    float x = x0;
     if (containerStyle.text_align == TextAlign::Center) {
-      x += (contentWidth - width) / 2.0f;
+      x += (available - lineWidth) / 2.0f;
     } else if (containerStyle.text_align == TextAlign::End) {
-      x += contentWidth - width;
+      x += available - lineWidth;
     }
-    for (InlineItem *item : current) {
+    for (InlineItem *item : line) {
       if (item->atomic) {
         /* An out-of-flow item was already placed against its containing block by
          * `layoutBlock`, so it must not be moved back onto the line. */
@@ -180,7 +171,33 @@ float Layouter::layoutInlineRun(LayoutBox *container, const std::vector<LayoutBo
       x += item->width;
     }
     cursorY += height;
+    line.clear();
+    lineWidth = 0;
+    lineAscent = 0;
+    lineDescent = 0;
+  };
+
+  for (InlineItem &item : items) {
+    if (item.force_break) {
+      finalize();
+      continue;
+    }
+    if (item.is_space && line.empty()) continue;  // no leading space on a line
+    /* Break against the band the line would occupy, then place it. */
+    float pendingHeight = std::max(lineAscent + lineDescent, item.height);
+    float x0 = 0;
+    float x1 = 0;
+    band(cursorY, pendingHeight, &x0, &x1);
+    float available = x1 - x0;
+    if (lineWidth + item.width > available && !line.empty()) finalize();
+    if (item.is_space && line.empty()) continue;
+    line.push_back(&item);
+    lineWidth += item.width;
+    lineAscent = std::max(lineAscent, item.ascent);
+    lineDescent = std::max(lineDescent, item.height - item.ascent);
   }
+  finalize();
+
   for (LayoutBox *box : run) computeInlineGeometry(box);
   return cursorY - y;
 }