xbintsc 0.3.69 → 0.3.79

package/runtime/ext_gui/layout_flex.cpp

@@ -1,8 +1,9 @@
 /*
  * 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
+ * Sizes flex items along the main axis (grow/shrink/basis), wraps them into
+ * lines when `flex-wrap` allows it, resolves the cross axis (align-items /
+ * align-content) and places them (justify-content), reusing the block and
  * inline helpers from `layout_flow.cpp` / `layout_inline.cpp`.
  */
 
@@ -11,151 +12,314 @@
 namespace xtgui {
 namespace layout_flow_detail {
 
+/** Partition `basis` (outer main sizes) into lines, breaking before an item
+ * that no longer fits on the current line. A single line is produced when
+ * `wrap` is false. */
+static std::vector<std::vector<size_t>> breakIntoLines(const std::vector<float> &basis,
+                                                       float mainSize, float gap, bool wrap) {
+  std::vector<std::vector<size_t>> lines;
+  std::vector<size_t> current;
+  float used = 0;
+  for (size_t i = 0; i < basis.size(); i++) {
+    float add = basis[i] + (current.empty() ? 0.0f : gap);
+    if (wrap && !current.empty() && used + add > mainSize + 0.001f) {
+      lines.push_back(current);
+      current.clear();
+      used = 0;
+      add = basis[i];
+    }
+    current.push_back(i);
+    used += add;
+  }
+  if (!current.empty()) lines.push_back(current);
+  return lines;
+}
+
 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);
 
   /* An absolutely positioned child is out of flow: it takes no part in the flex
    * algorithm and is placed against the container's padding box instead. */
   std::vector<LayoutBox *> items;
   for (const std::unique_ptr<LayoutBox> &child : container->children) {
     if (child->display == Display::None || isAbsoluteChild(child.get())) continue;
+    /* Whitespace-only text (source indentation) does not become a flex item. */
+    if (isCollapsibleText(child.get())) continue;
     items.push_back(child.get());
   }
   if (items.empty()) return 0;
+
+  float mainGap =
+      px(isRow ? containerStyle.column_gap : containerStyle.row_gap, contentWidth,
+         containerStyle.font_size, 0.0f);
+  float crossGap =
+      px(isRow ? containerStyle.row_gap : containerStyle.column_gap, contentWidth,
+         containerStyle.font_size, 0.0f);
+  if (isRow)
+    return layoutFlexRow(container, items, contentWidth, definiteHeight, mainGap, crossGap);
+  return layoutFlexColumn(container, items, contentWidth, definiteHeight, mainGap, crossGap);
+}
+
+float Layouter::layoutFlexRow(LayoutBox *container, const std::vector<LayoutBox *> &items,
+                              float contentWidth, float definiteHeight, float mainGap,
+                              float crossGap) const {
+  const XtStyle &containerStyle = *container->style;
+  bool reverse = containerStyle.flex_direction == FlexDirection::RowReverse;
+  bool wrap = containerStyle.flex_wrap != FlexWrap::NoWrap;
+  bool wrapReverse = containerStyle.flex_wrap == FlexWrap::WrapReverse;
   size_t count = items.size();
+  float mainSize = contentWidth;
 
-  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];
+  /* Main-axis basis: flex-basis, then width, then preferred content width. */
+  std::vector<float> basis(count, 0.0f);
+  for (size_t i = 0; i < count; i++) {
+    const XtStyle &style = *items[i]->style;
+    float base;
+    if (isAuto(style.flex_basis)) {
+      if (!isAuto(style.width)) base = px(style.width, mainSize, style.font_size, 0.0f);
+      else base = preferredContentWidth(items[i], mainSize);
+    } else {
+      base = px(style.flex_basis, mainSize, style.font_size, 0.0f);
     }
-    float free = mainSize - sumBase - gap * (float)(count - 1);
+    resolveEdges(items[i], mainSize);
+    basis[i] = base + horizontalEdges(items[i]);
+  }
+
+  std::vector<std::vector<size_t>> lines = breakIntoLines(basis, mainSize, mainGap, wrap);
+  std::vector<float> mainSizes(count, 0.0f);
+  std::vector<float> cross(count, 0.0f);
+  std::vector<float> lineCross(lines.size(), 0.0f);
+
+  for (size_t li = 0; li < lines.size(); li++) {
+    const std::vector<size_t> &line = lines[li];
+    float sumBase = 0;
+    for (size_t i : line) sumBase += basis[i];
+    for (size_t i : line) mainSizes[i] = basis[i];
+    float free = mainSize - sumBase - mainGap * (float)(line.size() - 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;
-      }
+      for (size_t i : line) totalGrow += items[i]->style->flex_grow;
+      if (totalGrow > 0)
+        for (size_t i : line) 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]);
+      for (size_t i : line) totalShrink += items[i]->style->flex_shrink * basis[i];
+      if (totalShrink > 0)
+        for (size_t i : line) {
+          mainSizes[i] += free * (items[i]->style->flex_shrink * basis[i]) / totalShrink;
+          if (mainSizes[i] < 0) mainSizes[i] = 0;
         }
-      }
     }
-
-    /* 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++) {
+    /* Measure each item's cross size by laying it out at its used main size. */
+    for (size_t i : line) {
       float contentW = mainSizes[i] - horizontalEdges(items[i]);
       if (contentW < 0) contentW = 0;
       setContainingBlock(items[i], containingBlockAncestor(items[i]));
-      layoutBlock(items[i], container->content_x, container->content_y, contentWidth,
-                  definiteHeight, contentW);
+      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 (cross[i] > lineCross[li]) lineCross[li] = 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);
-        }
-      }
+  }
+
+  /* Cross-axis sizing and align-content. A single line takes the container's
+   * definite cross size (or its content size); multiple lines share any extra
+   * space according to align-content. */
+  float crossContainer;
+  float lineOffset = 0.0f;
+  float lineStep = crossGap;
+  if (lines.size() == 1) {
+    crossContainer = definiteHeight >= 0 ? definiteHeight : lineCross[0];
+    lineCross[0] = crossContainer;
+  } else {
+    float total = crossGap * (float)(lines.size() - 1);
+    for (float value : lineCross) total += value;
+    crossContainer = definiteHeight >= 0 ? definiteHeight : total;
+    float remaining = crossContainer - total;
+    if (remaining < 0) remaining = 0;
+    switch (containerStyle.align_content) {
+      case AlignContent::Stretch:
+        for (float &value : lineCross) value += remaining / (float)lines.size();
+        break;
+      case AlignContent::FlexEnd:
+        lineOffset = remaining;
+        break;
+      case AlignContent::Center:
+        lineOffset = remaining / 2.0f;
+        break;
+      case AlignContent::SpaceBetween:
+        if (lines.size() > 1) lineStep += remaining / (float)(lines.size() - 1);
+        break;
+      case AlignContent::SpaceAround:
+        lineStep += remaining / (float)lines.size();
+        lineOffset = remaining / (2.0f * (float)lines.size());
+        break;
+      default:
+        break;
     }
+  }
 
-    /* justify-content: place the main axis. */
-    float freeSpace = mainSize - (sumOf(mainSizes) + gap * (float)(count - 1));
+  for (size_t li = 0; li < lines.size(); li++) {
+    const std::vector<size_t> &line = lines[li];
+    float lineStart = wrapReverse ? crossContainer - lineOffset - lineCross[li] : lineOffset;
+    float sumMain = 0;
+    for (size_t i : line) sumMain += mainSizes[i];
+    float freeSpace = mainSize - (sumMain + mainGap * (float)(line.size() - 1));
     float offset = 0;
-    float between = gap;
-    applyJustify(containerStyle.justify_content, freeSpace, count, &offset, &between);
-
+    float between = mainGap;
+    applyJustify(containerStyle.justify_content, freeSpace, line.size(), &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]);
+    for (size_t k = 0; k < line.size(); k++) {
+      size_t i = reverse ? line[line.size() - 1 - k] : line[k];
+      bool stretch = containerStyle.align_items == AlignItems::Stretch &&
+                     isAuto(items[i]->style->height) &&
+                     (definiteHeight >= 0 || lines.size() > 1);
+      if (stretch) {
+        float contentH = lineCross[li] - 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);
+        cross[i] = lineCross[li];
+      }
+      float crossOffset = crossOffsetFor(containerStyle.align_items, lineCross[li], cross[i]);
       float dx = cursor + items[i]->margin_left - items[i]->x;
-      float dy = container->content_y + crossOffset + items[i]->margin_top - items[i]->y;
+      float dy =
+          container->content_y + lineStart + crossOffset + items[i]->margin_top - items[i]->y;
       translate(items[i], dx, dy);
       cursor += mainSizes[i] + between;
     }
-    return crossSize;
+    lineOffset += lineCross[li] + lineStep;
   }
+  return crossContainer;
+}
 
-  /* Column flex. */
-  float mainSize = definiteHeight >= 0 ? definiteHeight : -1;
+float Layouter::layoutFlexColumn(LayoutBox *container, const std::vector<LayoutBox *> &items,
+                                 float contentWidth, float definiteHeight, float mainGap,
+                                 float crossGap) const {
+  const XtStyle &containerStyle = *container->style;
+  bool reverse = containerStyle.flex_direction == FlexDirection::ColumnReverse;
+  bool wrap = containerStyle.flex_wrap != FlexWrap::NoWrap && definiteHeight >= 0;
+  bool wrapReverse = containerStyle.flex_wrap == FlexWrap::WrapReverse;
+  size_t count = items.size();
+
+  /* Column items have to be laid out to learn their main (height) size. */
   std::vector<float> outer(count, 0.0f);
-  float sumBase = 0;
   for (size_t i = 0; i < count; i++) {
     setContainingBlock(items[i], containingBlockAncestor(items[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);
+
+  if (!wrap) {
+    float mainSize = definiteHeight >= 0 ? definiteHeight : -1;
+    std::vector<float> mainSizes = outer;
+    if (mainSize >= 0) {
+      float free = mainSize - sumOf(outer) - mainGap * (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 = sumOf(outer) + mainGap * (float)(count - 1);
     }
-  } else {
-    mainSize = sumBase + gap * (float)(count - 1);
+    float freeSpace = mainSize - (sumOf(mainSizes) + mainGap * (float)(count - 1));
+    float offset = 0;
+    float between = mainGap;
+    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]->margin_left - items[i]->x;
+      float dy = cursor + items[i]->margin_top - items[i]->y;
+      translate(items[i], dx, dy);
+      cursor += mainSizes[i] + between;
+    }
+    return mainSize;
+  }
+
+  /* Wrapped columns: lines run top-to-bottom and are placed side by side. */
+  std::vector<std::vector<size_t>> lines = breakIntoLines(outer, definiteHeight, mainGap, true);
+  std::vector<float> mainSizes(count, 0.0f);
+  std::vector<float> lineCross(lines.size(), 0.0f);
+  for (size_t li = 0; li < lines.size(); li++) {
+    const std::vector<size_t> &line = lines[li];
+    float sumBase = 0;
+    for (size_t i : line) sumBase += outer[i];
+    for (size_t i : line) mainSizes[i] = outer[i];
+    float free = definiteHeight - sumBase - mainGap * (float)(line.size() - 1);
+    if (free > 0) {
+      float totalGrow = 0;
+      for (size_t i : line) totalGrow += items[i]->style->flex_grow;
+      if (totalGrow > 0)
+        for (size_t i : line) mainSizes[i] += free * items[i]->style->flex_grow / totalGrow;
+    }
+    for (size_t i : line) {
+      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);
+      float crossSize = horizontalEdges(items[i]) + items[i]->width;
+      if (crossSize > lineCross[li]) lineCross[li] = crossSize;
+    }
+  }
+  float total = crossGap * (float)(lines.size() - 1);
+  for (float value : lineCross) total += value;
+  float lineOffset = 0.0f;
+  float lineStep = crossGap;
+  float remaining = contentWidth - total;
+  if (remaining < 0) remaining = 0;
+  switch (containerStyle.align_content) {
+    case AlignContent::Stretch:
+      for (float &value : lineCross) value += remaining / (float)lines.size();
+      break;
+    case AlignContent::FlexEnd:
+      lineOffset = remaining;
+      break;
+    case AlignContent::Center:
+      lineOffset = remaining / 2.0f;
+      break;
+    case AlignContent::SpaceBetween:
+      if (lines.size() > 1) lineStep += remaining / (float)(lines.size() - 1);
+      break;
+    case AlignContent::SpaceAround:
+      lineStep += remaining / (float)lines.size();
+      lineOffset = remaining / (2.0f * (float)lines.size());
+      break;
+    default:
+      break;
   }
-  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]->margin_left - items[i]->x;
-    /* Margins keep the item's outer box on the main axis, exactly like block
-     * flow — a negative `margin-top` pulls the item up instead of being
-     * silently dropped. */
-    float dy = cursor + items[i]->margin_top - items[i]->y;
-    translate(items[i], dx, dy);
-    cursor += mainSizes[i] + between;
+  for (size_t li = 0; li < lines.size(); li++) {
+    const std::vector<size_t> &line = lines[li];
+    float lineStart = wrapReverse ? contentWidth - lineOffset - lineCross[li] : lineOffset;
+    float sumMain = 0;
+    for (size_t i : line) sumMain += mainSizes[i];
+    float freeSpace = definiteHeight - (sumMain + mainGap * (float)(line.size() - 1));
+    float offset = 0;
+    float between = mainGap;
+    applyJustify(containerStyle.justify_content, freeSpace, line.size(), &offset, &between);
+    float cursor = container->content_y + offset;
+    for (size_t k = 0; k < line.size(); k++) {
+      size_t i = reverse ? line[line.size() - 1 - k] : line[k];
+      float dx = container->content_x + lineStart + items[i]->margin_left - items[i]->x;
+      float dy = cursor + items[i]->margin_top - items[i]->y;
+      translate(items[i], dx, dy);
+      cursor += mainSizes[i] + between;
+    }
+    lineOffset += lineCross[li] + lineStep;
   }
-  return mainSize;
+  return contentWidth;
 }
 
 float Layouter::sumOf(const std::vector<float> &values) {

package/runtime/ext_gui/layout_flow.cpp

@@ -44,7 +44,7 @@ float Layouter::verticalEdges(const LayoutBox *box) const {
 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;
+  if ((box->is_image || box->is_canvas) && 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;
@@ -201,7 +201,7 @@ float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWid
   if (contentWidth < 0) contentWidth = 0;
 
   box->x = x + box->margin_left;
-  box->y = y + box->margin_top;
+  box->y = y;
   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;
@@ -225,8 +225,8 @@ float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWid
     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) {
+  if ((box->is_image || box->is_canvas) && 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;
@@ -239,9 +239,10 @@ float Layouter::layoutBlock(LayoutBox *box, float x, float y, float availableWid
   publishContainingBlock(box);
   layoutAbsoluteChildren(box, contentWidth, availableHeight);
   applyPosition(box);
-  /* An absolutely positioned box consumes no space in its parent's flow. */
-  if (!inFlow) return 0;
-  return box->margin_top + box->height + box->margin_bottom;
+  /* The caller owns the vertical margins: it collapses them and advances the
+   * flow itself, so the border-box height is what comes back. */
+  (void)inFlow;
+  return box->height;
 }
 
 bool Layouter::isAbsoluteChild(const LayoutBox *box) {
@@ -266,11 +267,17 @@ float Layouter::layoutChildren(LayoutBox *block, float contentWidth, float avail
 
   float y = block->content_y;
   float startY = y;
+  /* The bottom margin of the last in-flow block, waiting to collapse with the
+   * next block's top margin. */
+  float pending = 0.0f;
+  bool hasBlock = false;
   std::vector<LayoutBox *> inlineRun;
+  FloatContext floats;
   auto flush = [&]() {
     if (inlineRun.empty()) return;
     /* Source whitespace between block boxes collapses away (HTML's model), so a
-     * run that carries no visible content produces no line at all. */
+     * run that carries no visible content produces no line at all — and,
+     * crucially, does not break margin adjacency with the next block. */
     bool visible = false;
     for (LayoutBox *box : inlineRun) {
       if (!isCollapsibleText(box)) {
@@ -278,8 +285,20 @@ float Layouter::layoutChildren(LayoutBox *block, float contentWidth, float avail
         break;
       }
     }
-    if (visible) y += layoutInlineRun(block, inlineRun, contentWidth, y);
+    if (!visible) {
+      /* Source whitespace only: no line, and it does not break margin
+       * adjacency with the next block. */
+      inlineRun.clear();
+      return;
+    }
+    /* Inline content breaks adjacency: apply the pending margin here instead of
+     * letting it collapse into the next block. */
+    y += pending;
+    pending = 0.0f;
+    floats.prune(y);
+    y += layoutInlineRun(block, inlineRun, contentWidth, y, &floats);
     inlineRun.clear();
+    hasBlock = true;
   };
   for (const std::unique_ptr<LayoutBox> &child : block->children) {
     Display display = child->display;
@@ -289,16 +308,73 @@ float Layouter::layoutChildren(LayoutBox *block, float contentWidth, float avail
        * its own size. */
       continue;
     }
+    const XtStyle *childStyle = child->style;
+    if (childStyle != nullptr && childStyle->float_side != FloatSide::None) {
+      /* A float interrupts the inline run (content before it is placed first,
+       * then the float affects the lines that follow), and takes no flow space
+       * of its own. */
+      flush();
+      resolveEdges(child.get(), contentWidth);
+      float edges = horizontalEdges(child.get());
+      float available = contentWidth - edges;
+      if (available < 0) available = 0;
+      float outerWidth;
+      if (!isAuto(childStyle->width)) {
+        outerWidth = px(childStyle->width, contentWidth, childStyle->font_size, 0.0f) + edges;
+      } else {
+        outerWidth = preferredContentWidth(child.get(), contentWidth);
+        if (outerWidth > available) outerWidth = available;
+        outerWidth += edges;
+      }
+      float contentW = outerWidth - edges;
+      if (contentW < 0) contentW = 0;
+      float floatX = childStyle->float_side == FloatSide::Left
+                         ? block->content_x
+                         : block->content_x + contentWidth - outerWidth;
+      setContainingBlock(child.get(), containingBlockAncestor(block));
+      float height =
+          layoutBlock(child.get(), floatX, y, contentWidth, availableHeight, contentW);
+      ActiveFloat entry;
+      entry.left = childStyle->float_side == FloatSide::Left;
+      entry.x = child->x;
+      entry.width = child->width + child->margin_left + child->margin_right;
+      entry.top = y;
+      entry.height = height + child->margin_top + child->margin_bottom;
+      floats.floats.push_back(entry);
+      continue;
+    }
     if (display == Display::Block || display == Display::ListItem || display == Display::Flex ||
         child->style == nullptr) {
       flush();
+      resolveEdges(child.get(), contentWidth);
+      /* Adjacent vertical margins collapse: the gap is the collapsed value of
+       * the waiting bottom margin and this child's top margin. */
+      float top = child->margin_top;
+      float gap = hasBlock ? collapseMargins(pending, top) : top;
+      float desired = y + gap;
+      if (childStyle != nullptr && childStyle->clear != Clear::None) {
+        bool clearLeft = childStyle->clear == Clear::Left || childStyle->clear == Clear::Both;
+        bool clearRight = childStyle->clear == Clear::Right || childStyle->clear == Clear::Both;
+        float clearY = floats.clearY(clearLeft, clearRight, y) + top;
+        if (desired < clearY) desired = clearY;
+      }
+      y = desired;
       setContainingBlock(child.get(), containingBlockAncestor(block));
       y += layoutBlock(child.get(), block->content_x, y, contentWidth, availableHeight);
+      pending = child->margin_bottom;
+      hasBlock = true;
     } else {
       inlineRun.push_back(child.get());
     }
   }
   flush();
+  /* The last bottom margin is part of the content box: it escapes only if the
+   * parent has no bottom padding/border (handled by the parent's caller). */
+  y += pending;
+  /* Grow to contain the floats: a block with only floated children would
+   * otherwise collapse to zero height. */
+  float floatBottom = floats.maxBottom();
+  if (floatBottom > y) y = floatBottom;
   return y - startY;
 }