Changeset 118600 in webkit


Ignore:
Timestamp:
May 25, 2012 7:07:18 PM (12 years ago)
Author:
tony@chromium.org
Message:

implement new negative flexing algorithm
​https://bugs.webkit.org/show_bug.cgi?id=86528

Reviewed by Ojan Vafai.

Source/WebCore:

Rather than just scale by the negative flexibility, we also take the
flex-basis (preferred size) into consideration. That means items with
a larger preferred size will shrink faster.

Test: css3/flexbox/flex-algorithm.html (new test cases added)

  • rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::preferredMainAxisContentExtentForChild): Handle overflow.
(WebCore::RenderFlexibleBox::layoutFlexItems):
(WebCore::RenderFlexibleBox::computeNextFlexLine): Sum weighted negative flex.
(WebCore::RenderFlexibleBox::freezeViolations):
(WebCore::RenderFlexibleBox::resolveFlexibleLengths): Shrink by weighted amount.
Also handle large values by making sure the flex values are finite.

  • rendering/RenderFlexibleBox.h:

LayoutTests:

  • css3/flexbox/flex-algorithm-expected.txt:
  • css3/flexbox/flex-algorithm.html:
Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r118599 r118600  
     12012-05-25  Tony Chang  <tony@chromium.org>
     2
     3        implement new negative flexing algorithm
     4        https://bugs.webkit.org/show_bug.cgi?id=86528
     5
     6        Reviewed by Ojan Vafai.
     7
     8        * css3/flexbox/flex-algorithm-expected.txt:
     9        * css3/flexbox/flex-algorithm.html:
     10
    1112012-05-25  Mihai Parparita  <mihaip@chromium.org>
    212

  • trunk/LayoutTests/css3/flexbox/flex-algorithm-expected.txt

    r110253 r118600  
     1PASS
     2PASS
     3PASS
     4PASS
     5PASS
     6PASS
    17PASS
    28PASS

  • trunk/LayoutTests/css3/flexbox/flex-algorithm.html

    r117385 r118600  
    8787</div>
    8888
     89<div style="display: -webkit-flex" class="flexbox">
     90  <div data-expected-width="50" style="-webkit-flex: 1 1 100px"></div>
     91  <div data-expected-width="250" style="-webkit-flex: 1 1 500px"></div>
     92  <div data-expected-width="300" style="width: 300px"></div>
     93</div>
     94
     95<div style="display: -webkit-flex" class="flexbox">
     96  <div data-expected-width="50" style="-webkit-flex: 1 1 100px"></div>
     97  <div data-expected-width="250" style="-webkit-flex: 1 1 500px; margin-right: 300px;"></div>
     98</div>
     99
     100<div style="display: -webkit-flex" class="flexbox">
     101  <div data-expected-width="50" style="-webkit-flex: 1 1 100px"></div>
     102  <div data-expected-width="550" style="-webkit-flex: 1 1 500px; padding-left: 300px;"></div>
     103</div>
     104
     105<div style="display: -webkit-flex" class="flexbox">
     106  <div data-expected-width="50" style="-webkit-flex: 1 1 100px"></div>
     107  <div data-expected-width="550" style="-webkit-flex: 1 1 500px; border-left: 200px dashed orange; border-right: 100px dashed orange;"></div>
     108</div>
     109
     110<!-- Test some overflow cases. -->
     111<div style="display: -webkit-flex" class="flexbox">
     112  <div data-expected-width="600" style="-webkit-flex: 0 100000000000000000000000000000000000000 600px"></div>
     113  <div data-expected-width="600" style="-webkit-flex: 0 100000000000000000000000000000000000000 600px"></div>
     114</div>
     115
     116<div style="display: -webkit-flex" class="flexbox">
     117  <div data-expected-width="600" style="-webkit-flex: 100000000000000000000000000000000000000 0 600px"></div>
     118  <div data-expected-width="600" style="-webkit-flex: 0 100000000000000000000000000000000000000 600px"></div>
     119  <div data-expected-width="0" style="-webkit-flex: 1 1 100000000000000000000000000000000000000px"></div>
     120</div>
     121
    89122<!-- Test flexitem borders. -->
    90123<div style="display: -webkit-flex" class="flexbox">

  • trunk/Source/WebCore/ChangeLog

    r118599 r118600  
     12012-05-25  Tony Chang  <tony@chromium.org>
     2
     3        implement new negative flexing algorithm
     4        https://bugs.webkit.org/show_bug.cgi?id=86528
     5
     6        Reviewed by Ojan Vafai.
     7
     8        Rather than just scale by the negative flexibility, we also take the
     9        flex-basis (preferred size) into consideration.  That means items with
     10        a larger preferred size will shrink faster.
     11
     12        Test: css3/flexbox/flex-algorithm.html (new test cases added)
     13
     14        * rendering/RenderFlexibleBox.cpp:
     15        (WebCore::RenderFlexibleBox::preferredMainAxisContentExtentForChild): Handle overflow.
     16        (WebCore::RenderFlexibleBox::layoutFlexItems):
     17        (WebCore::RenderFlexibleBox::computeNextFlexLine): Sum weighted negative flex.
     18        (WebCore::RenderFlexibleBox::freezeViolations):
     19        (WebCore::RenderFlexibleBox::resolveFlexibleLengths): Shrink by weighted amount.
     20        Also handle large values by making sure the flex values are finite.
     21        * rendering/RenderFlexibleBox.h:
     22
    1232012-05-25  Mihai Parparita  <mihaip@chromium.org>
    224

  • trunk/Source/WebCore/rendering/RenderFlexibleBox.cpp

    r118279 r118600  
    3636#include "RenderView.h"
    3737#include <limits>
     38#include <wtf/MathExtras.h>
    3839
    3940namespace WebCore {
    … …  
    594595        return mainAxisExtent - mainAxisBorderAndPaddingExtentForChild(child);
    595596    }
    596     return minimumValueForLength(mainAxisLength, mainAxisContentExtent(), view());
     597    return std::max(LayoutUnit(0), minimumValueForLength(mainAxisLength, mainAxisContentExtent(), view()));
    597598}
    598599
    … …  
    625626    LayoutUnit preferredMainAxisExtent;
    626627    float totalPositiveFlexibility;
    627     float totalNegativeFlexibility;
     628    float totalWeightedNegativeFlexibility;
    628629    LayoutUnit minMaxAppliedMainAxisExtent;
    629630
    630631    LayoutUnit crossAxisOffset = flowAwareBorderBefore() + flowAwarePaddingBefore();
    631     while (computeNextFlexLine(iterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalNegativeFlexibility, minMaxAppliedMainAxisExtent)) {
     632    while (computeNextFlexLine(iterator, orderedChildren, preferredMainAxisExtent, totalPositiveFlexibility, totalWeightedNegativeFlexibility, minMaxAppliedMainAxisExtent)) {
    632633        LayoutUnit availableFreeSpace = computeAvailableFreeSpace(preferredMainAxisExtent);
    633634        FlexSign flexSign = (minMaxAppliedMainAxisExtent < preferredMainAxisExtent + availableFreeSpace) ? PositiveFlexibility : NegativeFlexibility;
    634635        InflexibleFlexItemSize inflexibleItems;
    635636        WTF::Vector<LayoutUnit> childSizes;
    636         while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems, childSizes)) {
    637             ASSERT(totalPositiveFlexibility >= 0 && totalNegativeFlexibility >= 0);
     637        while (!resolveFlexibleLengths(flexSign, orderedChildren, availableFreeSpace, totalPositiveFlexibility, totalWeightedNegativeFlexibility, inflexibleItems, childSizes)) {
     638            ASSERT(totalPositiveFlexibility >= 0 && totalWeightedNegativeFlexibility >= 0);
    638639            ASSERT(inflexibleItems.size() > 0);
    639640        }
    … …  
    801802}
    802803
    803 bool RenderFlexibleBox::computeNextFlexLine(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent)
     804bool RenderFlexibleBox::computeNextFlexLine(FlexOrderIterator& iterator, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalWeightedNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent)
    804805{
    805806    orderedChildren.clear();
    806807    preferredMainAxisExtent = 0;
    807     totalPositiveFlexibility = totalNegativeFlexibility = 0;
     808    totalPositiveFlexibility = totalWeightedNegativeFlexibility = 0;
    808809    minMaxAppliedMainAxisExtent = 0;
    809810
    … …  
    829830        preferredMainAxisExtent += childMainAxisMarginBoxExtent;
    830831        totalPositiveFlexibility += child->style()->positiveFlex();
    831         totalNegativeFlexibility += child->style()->negativeFlex();
     832        totalWeightedNegativeFlexibility += child->style()->negativeFlex() * childMainAxisExtent;
    832833
    833834        LayoutUnit childMinMaxAppliedMainAxisExtent = adjustChildSizeForMinAndMax(child, childMainAxisExtent, flexboxAvailableContentExtent);
    … …  
    837838}
    838839
    839 void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems)
     840void RenderFlexibleBox::freezeViolations(const WTF::Vector<Violation>& violations, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalWeightedNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems)
    840841{
    841842    for (size_t i = 0; i < violations.size(); ++i) {
    842843        RenderBox* child = violations[i].child;
    843844        LayoutUnit childSize = violations[i].childSize;
    844         availableFreeSpace -= childSize - preferredMainAxisContentExtentForChild(child);
     845        LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
     846        availableFreeSpace -= childSize - preferredChildSize;
    845847        totalPositiveFlexibility -= child->style()->positiveFlex();
    846         totalNegativeFlexibility -= child->style()->negativeFlex();
     848        totalWeightedNegativeFlexibility -= child->style()->negativeFlex() * preferredChildSize;
    847849        inflexibleItems.set(child, childSize);
    848850    }
    … …  
    850852
    851853// Returns true if we successfully ran the algorithm and sized the flex items.
    852 bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
     854bool RenderFlexibleBox::resolveFlexibleLengths(FlexSign flexSign, const OrderedFlexItemList& children, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalWeightedNegativeFlexibility, InflexibleFlexItemSize& inflexibleItems, WTF::Vector<LayoutUnit>& childSizes)
    853855{
    854856    childSizes.clear();
    … …  
    870872            LayoutUnit preferredChildSize = preferredMainAxisContentExtentForChild(child);
    871873            LayoutUnit childSize = preferredChildSize;
    872             if (availableFreeSpace > 0 && totalPositiveFlexibility > 0 && flexSign == PositiveFlexibility)
     874            if (availableFreeSpace > 0 && totalPositiveFlexibility > 0 && flexSign == PositiveFlexibility && isfinite(totalPositiveFlexibility))
    873875                childSize += lroundf(availableFreeSpace * child->style()->positiveFlex() / totalPositiveFlexibility);
    874             else if (availableFreeSpace < 0 && totalNegativeFlexibility > 0  && flexSign == NegativeFlexibility)
    875                 childSize += lroundf(availableFreeSpace * child->style()->negativeFlex() / totalNegativeFlexibility);
     876            else if (availableFreeSpace < 0 && totalWeightedNegativeFlexibility > 0 && flexSign == NegativeFlexibility && isfinite(totalWeightedNegativeFlexibility))
     877                childSize += lroundf(availableFreeSpace * child->style()->negativeFlex() * preferredChildSize / totalWeightedNegativeFlexibility);
    876878
    877879            LayoutUnit adjustedChildSize = adjustChildSizeForMinAndMax(child, childSize, flexboxAvailableContentExtent);
    … …  
    889891
    890892    if (totalViolation)
    891         freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalPositiveFlexibility, totalNegativeFlexibility, inflexibleItems);
     893        freezeViolations(totalViolation < 0 ? maxViolations : minViolations, availableFreeSpace, totalPositiveFlexibility, totalWeightedNegativeFlexibility, inflexibleItems);
    892894    else
    893895        availableFreeSpace -= usedFreeSpace;

  • trunk/Source/WebCore/rendering/RenderFlexibleBox.h

    r118279 r118600  
    114114    LayoutUnit lineBreakLength();
    115115    LayoutUnit adjustChildSizeForMinAndMax(RenderBox*, LayoutUnit childSize, LayoutUnit flexboxAvailableContentExtent);
    116     bool computeNextFlexLine(FlexOrderIterator&, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent);
     116    bool computeNextFlexLine(FlexOrderIterator&, OrderedFlexItemList& orderedChildren, LayoutUnit& preferredMainAxisExtent, float& totalPositiveFlexibility, float& totalWeightedNegativeFlexibility, LayoutUnit& minMaxAppliedMainAxisExtent);
    117117    LayoutUnit computeAvailableFreeSpace(LayoutUnit preferredMainAxisExtent);
    118118
    119     bool resolveFlexibleLengths(FlexSign, const OrderedFlexItemList&, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize&, WTF::Vector<LayoutUnit>& childSizes);
    120     void freezeViolations(const WTF::Vector<Violation>&, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalNegativeFlexibility, InflexibleFlexItemSize&);
     119    bool resolveFlexibleLengths(FlexSign, const OrderedFlexItemList&, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalWeightedNegativeFlexibility, InflexibleFlexItemSize&, WTF::Vector<LayoutUnit>& childSizes);
     120    void freezeViolations(const WTF::Vector<Violation>&, LayoutUnit& availableFreeSpace, float& totalPositiveFlexibility, float& totalWeightedNegativeFlexibility, InflexibleFlexItemSize&);
    121121
    122122    void setLogicalOverrideSize(RenderBox* child, LayoutUnit childPreferredSize);
Note: See TracChangeset for help on using the changeset viewer.