Changeset 93651 in webkit

Timestamp:

Aug 23, 2011 4:10:45 PM (13 years ago)

Author:

tony@chromium.org

Message:

Add handling of mix-width and max-width for flexitems
​https://bugs.webkit.org/show_bug.cgi?id=66723

Reviewed by David Hyatt.

Source/WebCore:

If we flex past a min/max width value, we need to mark the flexitem as
a fixed width and re-start the flexing algorithm. We use a HashMap to
keep track of fixed width items.

This patch also split out the size computation from the actual layout
to avoid unnecessary layouts caused by restarting the flexing algorithm.

Test: css3/flexbox/003.html

• rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::layoutHorizontalBlock):
(WebCore::RenderFlexibleBox::runFreeSpaceAllocationAlgorithm):

• rendering/RenderFlexibleBox.h:

LayoutTests:

• css3/flexbox/003-expected.txt: Added.
• css3/flexbox/003.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/css3/flexbox/003-expected.txt (added)
• LayoutTests/css3/flexbox/003.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/rendering/RenderFlexibleBox.cpp (modified) (5 diffs)
• Source/WebCore/rendering/RenderFlexibleBox.h (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2011-08-23  Tony Chang  <tony@chromium.org>
+
+        Add handling of mix-width and max-width for flexitems
+        https://bugs.webkit.org/show_bug.cgi?id=66723
+
+        Reviewed by David Hyatt.
+
+        * css3/flexbox/003-expected.txt: Added.
+        * css3/flexbox/003.html: Added.
+
 2011-08-23  Adam Barth  <abarth@webkit.org>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2011-08-23  Tony Chang  <tony@chromium.org>
+
+        Add handling of mix-width and max-width for flexitems
+        https://bugs.webkit.org/show_bug.cgi?id=66723
+
+        Reviewed by David Hyatt.
+
+        If we flex past a min/max width value, we need to mark the flexitem as
+        a fixed width and re-start the flexing algorithm.  We use a HashMap to
+        keep track of fixed width items.
+
+        This patch also split out the size computation from the actual layout
+        to avoid unnecessary layouts caused by restarting the flexing algorithm.
+
+        Test: css3/flexbox/003.html
+
+        * rendering/RenderFlexibleBox.cpp:
+        (WebCore::RenderFlexibleBox::layoutHorizontalBlock):
+        (WebCore::RenderFlexibleBox::runFreeSpaceAllocationAlgorithm):
+        * rendering/RenderFlexibleBox.h:
+
 2011-08-23  Pratik Solanki  <psolanki@apple.com>
 

trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

@@ -100 +100 @@
     m_overflow.clear();
 
-    // FIXME: Assume horizontal layout until flex-direction is added.
+    // FIXME: Assume horizontal layout until flex-flow is added.
     layoutHorizontalBlock(relayoutChildren);
 
@@ -117 +117 @@
 static LayoutUnit preferredFlexItemContentWidth(RenderBox* child)
 {
+    // FIXME: Handle vertical writing modes with horizontal flexing.
     if (child->style()->width().isAuto())
         return child->maxPreferredLogicalWidth() - child->borderLeft() - child->borderRight() - child->verticalScrollbarWidth() - child->paddingLeft() - child->paddingRight();
@@ -129 +130 @@
     FlexibleBoxIterator iterator(this);
 
-    computePreferredSize(relayoutChildren, iterator, preferredSize, totalPositiveFlexibility, totalNegativeFlexibility);
+    computePreferredSizeHorizontal(relayoutChildren, iterator, preferredSize, totalPositiveFlexibility, totalNegativeFlexibility);
     LayoutUnit availableFreeSpace = contentWidth() - preferredSize;
 
-    LayoutUnit xOffset = borderLeft() + paddingLeft();
-    LayoutUnit yOffset = borderTop() + paddingTop();
-    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
-        LayoutUnit childPreferredSize = preferredFlexItemContentWidth(child);
-        // FIXME: Handle max-width and min-width (we should clamp to the max/min value and restart the algorithm).
-        if (availableFreeSpace > 0 && totalPositiveFlexibility > 0)
-            childPreferredSize += lroundf(availableFreeSpace * child->style()->flexboxWidthPositiveFlex() / totalPositiveFlexibility);
-        else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0)
-            childPreferredSize += lroundf(availableFreeSpace * child->style()->flexboxWidthNegativeFlex() / totalNegativeFlexibility);
-
-        childPreferredSize += child->borderLeft() + child->borderRight() + child->paddingLeft() + child->paddingRight();
-        child->setOverrideSize(LayoutSize(childPreferredSize, 0));
-        child->setChildNeedsLayout(true);
-        child->layoutIfNeeded();
-
-        setHeight(std::max(height(), borderTop() + paddingTop() + child->marginTop() + child->height() + child->marginBottom() + paddingBottom() + borderBottom() + horizontalScrollbarHeight()));
-
-        if (child->style()->marginLeft().isAuto())
-            child->setMarginLeft(availableFreeSpace > 0 ? lroundf(availableFreeSpace / totalPositiveFlexibility) : 0);
-        if (child->style()->marginRight().isAuto())
-            child->setMarginRight(availableFreeSpace > 0 ? lroundf(availableFreeSpace / totalPositiveFlexibility) : 0);
-
-        xOffset += child->marginLeft();
-        child->setLocation(IntPoint(xOffset, yOffset));
-        xOffset += child->width() + child->marginRight();
+    InflexibleFlexItemSize inflexibleItems;
+    while (!runFreeSpaceAllocationAlgorithmHorizontal(availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems)) {
+        ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
+        ASSERT(inflexibleItems.size() > 0);
     }
 
@@ -168 +148 @@
 }
 
-void RenderFlexibleBox::computePreferredSize(bool relayoutChildren, FlexibleBoxIterator& iterator, LayoutUnit& preferredSize, float& totalPositiveFlexibility, float& totalNegativeFlexibility)
+void RenderFlexibleBox::computePreferredSizeHorizontal(bool relayoutChildren, FlexibleBoxIterator& iterator, LayoutUnit& preferredSize, float& totalPositiveFlexibility, float& totalNegativeFlexibility)
 {
     preferredSize = 0;
     totalPositiveFlexibility = totalNegativeFlexibility = 0;
 
+    // FIXME: Handle vertical writing modes with horizontal flexing.
     LayoutUnit flexboxAvailableLogicalWidth = availableLogicalWidth();
     for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
@@ -201 +182 @@
 }
 
+// Returns true if we successfully ran the algorithm and sized the flex items.
+bool RenderFlexibleBox::runFreeSpaceAllocationAlgorithmHorizontal(LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems)
+{
+    FlexibleBoxIterator iterator(this);
+
+    // FIXME: Handle vertical writing modes with horizontal flexing.
+    LayoutUnit flexboxAvailableLogicalWidth = availableLogicalWidth();
+    WTF::Vector<LayoutUnit> childSizes;
+    for (RenderBox* child = iterator.first(); child; child = iterator.next()) {
+        LayoutUnit childPreferredSize;
+        if (inflexibleItems.contains(child))
+            childPreferredSize = inflexibleItems.get(child);
+        else {
+            childPreferredSize = preferredFlexItemContentWidth(child);
+            if (availableFreeSpace > 0 && totalPositiveFlexibility > 0) {
+                childPreferredSize += lroundf(availableFreeSpace * child->style()->flexboxWidthPositiveFlex() / totalPositiveFlexibility);
+
+                Length childMaxWidth = child->style()->maxWidth();
+                if (!childMaxWidth.isUndefined() && childMaxWidth.isSpecified() && childPreferredSize > childMaxWidth.calcValue(flexboxAvailableLogicalWidth)) {
+                    childPreferredSize = childMaxWidth.calcValue(flexboxAvailableLogicalWidth);
+                    availableFreeSpace -= childPreferredSize - preferredFlexItemContentWidth(child);
+                    totalPositiveFlexibility -= child->style()->flexboxWidthPositiveFlex();
+
+                    inflexibleItems.set(child, childPreferredSize);
+                    return false;
+                }
+            } else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0) {
+                childPreferredSize += lroundf(availableFreeSpace * child->style()->flexboxWidthNegativeFlex() / totalNegativeFlexibility);
+
+                Length childMinWidth = child->style()->minWidth();
+                if (!childMinWidth.isUndefined() && childMinWidth.isSpecified() && childPreferredSize < childMinWidth.calcValue(flexboxAvailableLogicalWidth)) {
+                    childPreferredSize = childMinWidth.calcValue(flexboxAvailableLogicalWidth);
+                    availableFreeSpace += preferredFlexItemContentWidth(child) - childPreferredSize;
+                    totalNegativeFlexibility -= child->style()->flexboxWidthNegativeFlex();
+
+                    inflexibleItems.set(child, childPreferredSize);
+                    return false;
+                }
+            }
+        }
+        childSizes.append(childPreferredSize);
+    }
+
+    // Now that we know the sizes, layout and position the flex items.
+    LayoutUnit xOffset = borderLeft() + paddingLeft();
+    LayoutUnit yOffset = borderTop() + paddingTop();
+    setHeight(0);
+    size_t i = 0;
+    for (RenderBox* child = iterator.first(); child; child = iterator.next(), ++i) {
+        LayoutUnit childPreferredSize = childSizes[i];
+        childPreferredSize += child->borderLeft() + child->borderRight() + child->paddingLeft() + child->paddingRight();
+        // FIXME: Handle vertical writing modes with horizontal flexing.
+        child->setOverrideSize(LayoutSize(childPreferredSize, 0));
+        child->setChildNeedsLayout(true);
+        child->layoutIfNeeded();
+
+        setHeight(std::max(height(), borderTop() + paddingTop() + child->marginTop() + child->height() + child->marginBottom() + paddingBottom() + borderBottom() + horizontalScrollbarHeight()));
+
+        if (child->style()->marginLeft().isAuto())
+            child->setMarginLeft(availableFreeSpace > 0 ? lroundf(availableFreeSpace / totalPositiveFlexibility) : 0);
+        if (child->style()->marginRight().isAuto())
+            child->setMarginRight(availableFreeSpace > 0 ? lroundf(availableFreeSpace / totalPositiveFlexibility) : 0);
+
+        xOffset += child->marginLeft();
+        child->setLocation(IntPoint(xOffset, yOffset));
+        xOffset += child->width() + child->marginRight();
+    }
+    return true;
+}
+
 }
 

trunk/Source/WebCore/rendering/RenderFlexibleBox.h

@@ -51 +51 @@
 private:
     class FlexibleBoxIterator;
+    typedef WTF::HashMap<const RenderBox*, LayoutUnit> InflexibleFlexItemSize;
 
     void layoutHorizontalBlock(bool relayoutChildren);
 
-    void computePreferredSize(bool relayoutChildren, FlexibleBoxIterator&, LayoutUnit&, float& totalPositiveFlexibility, float& totalNegativeFlexibility);
+    void computePreferredSizeHorizontal(bool relayoutChildren, FlexibleBoxIterator&, LayoutUnit&, float& totalPositiveFlexibility, float& totalNegativeFlexibility);
+    bool runFreeSpaceAllocationAlgorithmHorizontal(LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize&);
 };