(wip) vaev-engine: rework, better commit msg later haha

Author: pauloamed

src/vaev-engine/layout/block.cpp

@@ -1,7 +1,7 @@
 module;
 
-#include <karm-math/au.h>
 #include <karm-core/macros.h>
+#include <karm-math/au.h>
 
 export module Vaev.Engine:layout.block;
 
@@ -122,6 +122,31 @@ Output fragmentEmptyBox(Tree& tree, Input input) {
     }
 }
 
+void _populateChildSpecifiedSizes(Tree& tree, Box& child, Input& childInput, Au horizontalMargins, Opt<Au> blockInlineSize) {
+    if (childInput.intrinsic == IntrinsicSize::AUTO or child.style->display != Display::INLINE) {
+        if (child.style->sizing->width.is<Keywords::Auto>()) {
+            // https://www.w3.org/TR/css-tables-3/#layout-principles
+            // Unlike other block-level boxes, tables do not fill their containing block by default.
+            // When their width computes to auto, they behave as if they had fit-content specified instead.
+            // This is different from most block-level boxes, which behave as if they had stretch instead.
+            if (child.style->display == Display::TABLE_BOX) {
+                // Do nothing. 'fit-content' is kinda intrinsic size, when we don't populate knownSize.
+            } else if (blockInlineSize) {
+                // When the inline size is not known, we cannot enforce it to the child. (?)
+                childInput.knownSize.width = blockInlineSize.unwrap() - horizontalMargins;
+            }
+        } else {
+            childInput.knownSize.width = computeSpecifiedSize(
+                tree, child, child.style->sizing->width, childInput.containingBlock, true
+            );
+        }
+
+        childInput.knownSize.height = computeSpecifiedSize(
+            tree, child, child.style->sizing->height, childInput.containingBlock, false
+        );
+    }
+}
+
 // https://www.w3.org/TR/CSS22/visuren.html#normal-flow
 struct BlockFormatingContext : FormatingContext {
     Au _computeCapmin(Tree& tree, Box& box, Input input, Au inlineSize) {
@@ -157,11 +182,6 @@ struct BlockFormatingContext : FormatingContext {
             return fragmentEmptyBox(tree, input);
         }
 
-        // NOTE: Our parent has no clue about our width but wants us to commit,
-        //       we need to compute it first
-        if (input.fragment and not input.knownSize.width)
-            inlineSize = run(tree, box, input.withFragment(nullptr), startAt, stopAt).width();
-
         Breakpoint currentBreakpoint;
         BaselinePositionsSet firstBaselineSet, lastBaselineSet;
 
@@ -195,36 +215,34 @@ struct BlockFormatingContext : FormatingContext {
                 .pendingVerticalSizes = input.pendingVerticalSizes,
             };
 
-            auto margin = computeMargins(tree, c, childInput);
-
-            Opt<Au> childInlineSize = NONE;
-            if (c.style->sizing->width.is<Keywords::Auto>()) {
-                childInlineSize = inlineSize - margin.horizontal();
-            }
+            UsedSpacings usedSpacings{
+                .padding = computePaddings(tree, c, childInput.containingBlock),
+                .borders = computeBorders(tree, c),
+                .margin = computeMargins(tree, c, childInput)
+            };
 
             if (not impliesRemovingFromFlow(c.style->position)) {
                 // TODO: collapsed margins for sibling elements
-                blockSize += max(margin.top, lastMarginBottom) - lastMarginBottom;
-                if (input.fragment or input.knownSize.x)
-                    childInput.knownSize.width = childInlineSize;
+                blockSize += max(usedSpacings.margin.top, lastMarginBottom) - lastMarginBottom;
             }
 
-            childInput.position = input.position + Vec2Au{margin.start, blockSize};
+            childInput.position = input.position + Vec2Au{usedSpacings.margin.start, blockSize};
 
             // HACK: Table Box mostly behaves like a block box, let's compute its capmin
             //       and avoid duplicating the layout code
             if (c.style->display == Display::Internal::TABLE_BOX) {
                 childInput.capmin = _computeCapmin(tree, box, input, inlineSize);
             }
 
-            auto output = layout(
-                tree,
-                c,
-                childInput
-            );
+            _populateChildSpecifiedSizes(tree, c, childInput, usedSpacings.margin.horizontal(), input.knownSize.x);
+
+            auto output = input.fragment
+                              ? layoutBorderBox(tree, c, childInput, *input.fragment, usedSpacings)
+                              : layoutBorderBox(tree, c, childInput, usedSpacings);
+
             if (not impliesRemovingFromFlow(c.style->position)) {
-                blockSize += output.size.y + margin.bottom;
-                lastMarginBottom = margin.bottom;
+                blockSize += output.size.y + usedSpacings.margin.bottom;
+                lastMarginBottom = usedSpacings.margin.bottom;
             }
 
             maybeProcessChildBreakpoint(
@@ -252,11 +270,14 @@ struct BlockFormatingContext : FormatingContext {
                 blockWasCompletelyLaidOut = output.completelyLaidOut and i + 1 == box.children().len();
             }
 
-            inlineSize = max(inlineSize, output.size.x + margin.horizontal());
+            inlineSize = max(inlineSize, output.size.x + usedSpacings.margin.horizontal());
         }
 
         return {
-            .size = Vec2Au{inlineSize, blockSize},
+            .size = Vec2Au{
+                input.knownSize.x.unwrapOr(inlineSize),
+                input.knownSize.y.unwrapOr(blockSize)
+            },
             .completelyLaidOut = blockWasCompletelyLaidOut,
             .breakpoint = currentBreakpoint,
             .firstBaselineSet = firstBaselineSet,

src/vaev-engine/layout/flex.cpp

@@ -134,7 +134,8 @@ struct FlexItem {
     FlexProps flexItemProps;
     FlexAxis fa;
 
-    // these 2 sizes do NOT account margins
+    Math::Insets<Au> borders;
+    Math::Insets<Au> padding;
     Vec2Au usedSize;
     Math::Insets<Opt<Au>> margin;
 
@@ -152,19 +153,22 @@ struct FlexItem {
     // InsetsAu borders;
 
     FlexItem(Tree& tree, Box& box, bool isRowOriented, Vec2Au containingBlock)
-        : box(&box), flexItemProps(*box.style->flex), fa(isRowOriented) {
+        : box(&box), flexItemProps(*box.style->flex), fa(isRowOriented),
+          borders(computeBorders(tree, box)), padding(computePaddings(tree, box, containingBlock)) {
         // FIXME: check if really needed
         speculateValues(tree, Input{.containingBlock = containingBlock});
         // TODO: not always we will need min/max content sizes,
         //       this can be lazy computed for performance gains
         computeContentSizes(tree, containingBlock);
     }
 
-    void commit(MutCursor<Frag> frag) {
-        frag->metrics.margin.top = margin.top.unwrapOr(speculativeMargin.top);
-        frag->metrics.margin.start = margin.start.unwrapOr(speculativeMargin.start);
-        frag->metrics.margin.end = margin.end.unwrapOr(speculativeMargin.end);
-        frag->metrics.margin.bottom = margin.bottom.unwrapOr(speculativeMargin.bottom);
+    InsetsAu resolvedMargin() {
+        return {
+            margin.top.unwrapOr(speculativeMargin.top),
+            margin.end.unwrapOr(speculativeMargin.end),
+            margin.bottom.unwrapOr(speculativeMargin.bottom),
+            margin.start.unwrapOr(speculativeMargin.start),
+        };
     }
 
     void computeContentSizes(Tree& tree, Vec2Au containingBlock) {
@@ -227,12 +231,26 @@ struct FlexItem {
     }
 
     void speculateValues(Tree& t, Input input) {
-        speculativeSize = layout(t, *box, input).size;
         speculativeMargin = computeMargins(
             t,
             *box,
             input
         );
+
+        // FIXME: whats up with intrinsic sizing here?
+        if (input.intrinsic == IntrinsicSize::AUTO or box->style->display != Display::INLINE) {
+            if (not input.knownSize.width)
+                input.knownSize.width = computeSpecifiedSize(
+                    t, *box, box->style->sizing->width, input.containingBlock, true
+                );
+
+            if (not input.knownSize.height)
+                input.knownSize.height = computeSpecifiedSize(
+                    t, *box, box->style->sizing->height, input.containingBlock, false
+                );
+        }
+
+        speculativeSize = layoutBorderBox(t, *box, input, UsedSpacings{.padding = padding, .borders = borders}).size;
     }
 
     // https://www.w3.org/TR/css-flexbox-1/#valdef-flex-basis-auto
@@ -1428,17 +1446,23 @@ struct FlexFormatingContext : FormatingContext {
             for (auto& flexItem : flexLine.items) {
                 flexItem.position = flexItem.position + flexLine.position + input.position;
 
-                auto out = layout(
-                    tree,
-                    *flexItem.box,
-                    {
-                        .fragment = input.fragment,
-                        .knownSize = {flexItem.usedSize.x, flexItem.usedSize.y},
-                        .position = flexItem.position,
-                        .availableSpace = availableSpace,
-                    }
-                );
-                flexItem.commit(input.fragment);
+                UsedSpacings usedSpacings{
+                    .padding = std::move(flexItem.padding),
+                    .borders = std::move(flexItem.borders),
+                    .margin = flexItem.resolvedMargin(),
+                };
+
+                Input childInput{
+                    .fragment = input.fragment,
+                    .knownSize = {flexItem.usedSize.x, flexItem.usedSize.y},
+                    .position = flexItem.position,
+                    .availableSpace = availableSpace,
+                };
+
+                if (input.fragment)
+                    layoutBorderBox(tree, *flexItem.box, childInput, *input.fragment, usedSpacings);
+                else
+                    layoutBorderBox(tree, *flexItem.box, childInput, usedSpacings);
             }
         }
     }

src/vaev-engine/layout/inline.cpp

@@ -56,18 +56,32 @@ struct InlineFormatingContext : FormatingContext {
 
             auto& atomicBox = *inlineBox.atomicBoxes[boxStrutCell.id];
 
+            // FIXME: Intrinsic sizing for inline boxes is not implemented yet
+            Input childInput{
+                .availableSpace = {inlineSize, input.availableSpace.y},
+                .containingBlock = {
+                    input.knownSize.x.unwrapOr(0_au),
+                    input.knownSize.y.unwrapOr(0_au)
+                },
+            };
+
+            childInput.knownSize.width = computeSpecifiedSize(
+                tree, atomicBox, atomicBox.style->sizing->width, childInput.containingBlock, true
+            );
+
+            childInput.knownSize.height = computeSpecifiedSize(
+                tree, atomicBox, atomicBox.style->sizing->height, childInput.containingBlock, false
+            );
+
             // NOTE: We set the same availableSpace to child inline boxes since line wrapping is possible i.e. in the
             // worst case, they will take up the whole availableSpace, and a line break will be done right before them
-            auto atomicBoxOutput = layout(
+            auto atomicBoxOutput = layoutBorderBox(
                 tree,
                 atomicBox,
-                Input{
-                    .knownSize = {NONE, NONE},
-                    .availableSpace = {inlineSize, input.availableSpace.y},
-                    .containingBlock = {
-                        input.knownSize.x.unwrapOr(0_au),
-                        input.knownSize.y.unwrapOr(0_au)
-                    },
+                childInput,
+                UsedSpacings{
+                    .padding = computePaddings(tree, atomicBox, childInput.containingBlock),
+                    .borders = computeBorders(tree, atomicBox),
                 }
             );
 
@@ -100,19 +114,26 @@ struct InlineFormatingContext : FormatingContext {
                 };
             }
 
-            layout(
-                tree,
-                atomicBox,
-                Input{
-                    .fragment = input.fragment,
-                    .knownSize = knownSize,
-                    .position = input.position + positionInProse,
-                    .containingBlock = {
-                        input.knownSize.x.unwrapOr(0_au),
-                        input.knownSize.y.unwrapOr(0_au)
-                    },
-                }
-            );
+            // TODO: How should pending vertical sizes for fragmentation work here?
+            Input childInput{
+                .fragment = input.fragment,
+                .knownSize = knownSize,
+                .position = input.position + positionInProse,
+                .containingBlock = {
+                    input.knownSize.x.unwrapOr(0_au),
+                    input.knownSize.y.unwrapOr(0_au)
+                },
+            };
+
+            UsedSpacings usedSpacings{
+                .padding = computePaddings(tree, atomicBox, childInput.containingBlock),
+                .borders = computeBorders(tree, atomicBox),
+            };
+
+            if (input.fragment)
+                layoutBorderBox(tree, atomicBox, childInput, *input.fragment, usedSpacings);
+            else
+                layoutBorderBox(tree, atomicBox, childInput, usedSpacings);
         }
 
         if (tree.fc.allowBreak() and not tree.fc.acceptsFit(
@@ -128,7 +149,7 @@ struct InlineFormatingContext : FormatingContext {
         }
 
         return {
-            .size = size,
+            .size = {input.knownSize.x.unwrapOr(size.x), input.knownSize.y.unwrapOr(size.y)},
             .completelyLaidOut = true,
             .firstBaselineSet = firstBaselineSet,
             .lastBaselineSet = lastBaselineSet,