Changeset 190484 in webkit


Ignore:
Timestamp:
Oct 2, 2015 5:14:49 AM (9 years ago)
Author:
jfernandez@igalia.com
Message:

[CSS Grid Layout] Support for Content Alignment in grid layout
​https://bugs.webkit.org/show_bug.cgi?id=145520

Reviewed by Darin Adler.

Source/WebCore:

According to CSS Box Alignment specification, Content Distribution
alignment controls alignment of the box's content within the box. The
alignment container is the grid container's content box. The alignment
subjects are the grid tracks.

This patch implements Grid Layout support for Content Distribution
alignment along both block/column and inline/row axis, which are handled
by align-content and justify-content properties respectively.

This patch provides support for overflow handling, similar to what
Self Alignment provides with grid items, and both <content-position>
and <content-distribution> values.

Baseline Alignment is still missing because it requires some additional
behavior to be supported on grids before considering its implementation.

Tests: css3/overwrite-content-alignment.html

css3/overwrite-self-alignment.html
fast/css-grid-layout/grid-align-content-distribution-vertical-lr.html
fast/css-grid-layout/grid-align-content-distribution-vertical-rl.html
fast/css-grid-layout/grid-align-content-distribution.html
fast/css-grid-layout/grid-align-content-vertical-lr.html
fast/css-grid-layout/grid-align-content-vertical-rl.html
fast/css-grid-layout/grid-align-content.html
fast/css-grid-layout/grid-content-alignment-overflow.html
fast/css-grid-layout/grid-content-alignment-with-different-sized-tracks.html
fast/css-grid-layout/grid-content-alignment-with-span-vertical-lr.html
fast/css-grid-layout/grid-content-alignment-with-span-vertical-rl.html
fast/css-grid-layout/grid-content-alignment-with-span.html
fast/css-grid-layout/grid-justify-content-distribution-vertical-lr.html
fast/css-grid-layout/grid-justify-content-distribution-vertical-rl.html
fast/css-grid-layout/grid-justify-content-distribution.html
fast/css-grid-layout/grid-justify-content-vertical-lr.html
fast/css-grid-layout/grid-justify-content-vertical-rl.html
fast/css-grid-layout/grid-justify-content.html

  • rendering/RenderFlexibleBox.cpp:

(WebCore::RenderFlexibleBox::layoutAndPlaceChildren):
(WebCore::RenderFlexibleBox::layoutColumnReverse):
(WebCore::RenderFlexibleBox::alignFlexLines):

  • rendering/RenderGrid.cpp:

(WebCore::ContentAlignmentData::ContentAlignmentData):
(WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
(WebCore::RenderGrid::layoutGridItems):
(WebCore::RenderGrid::gridAreaBreadthForChild):
(WebCore::RenderGrid::populateGridPositions):
(WebCore::resolveContentDistributionFallback):
(WebCore::offsetToStartEdge):
(WebCore::offsetToEndEdge):
(WebCore::contentDistributionOffset):
(WebCore::RenderGrid::computeContentPositionAndDistributionColumnOffset):
(WebCore::RenderGrid::computeContentPositionAndDistributionRowOffset):
(WebCore::RenderGrid::findChildLogicalPosition):
(WebCore::RenderGrid::computePreferredLogicalWidths): Deleted.
(WebCore::RenderGrid::autoPlacementMajorAxisDirection): Deleted.
(WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
(WebCore::RenderGrid::cachedGridCoordinate): Deleted.
(WebCore::RenderGrid::rowPositionForChild): Deleted.

  • rendering/RenderGrid.h:
  • rendering/style/RenderStyle.cpp:

(WebCore::RenderStyle::resolvedAlignContentPosition):
(WebCore::RenderStyle::resolvedAlignContentDistribution):
(WebCore::RenderStyle::resolvedJustifyContentPosition):
(WebCore::RenderStyle::resolvedJustifyContentDistribution):

  • rendering/style/RenderStyle.h:

LayoutTests:

Content Distribution alignment controls alignment of the box's
content within the box. The alignment container is the grid
container's content box. The alignment subjects are the grid
tracks.

In addition to the tests to verify the new functionality, I've
added some tests to check out that the new complex values are
overwritten properly.

I had to modify the grid-item-margin-auto-columns-rows-horizontal-rtl
test because when using RTL direction the whole grid must flow form
right to left, not only its items, so I rebaselined text expectations
to adapt it to the new behavior.

  • css3/overwrite-content-alignment-expected.txt: Added.
  • css3/overwrite-content-alignment.html: Added.
  • css3/overwrite-self-alignment-expected.txt: Added.
  • css3/overwrite-self-alignment.html: Added.
  • fast/css-grid-layout/grid-align-content-distribution-expected.txt: Added.
  • fast/css-grid-layout/grid-align-content-distribution-vertical-lr-expected.txt: Added.
  • fast/css-grid-layout/grid-align-content-distribution-vertical-lr.html: Added.
  • fast/css-grid-layout/grid-align-content-distribution-vertical-rl-expected.txt: Added.
  • fast/css-grid-layout/grid-align-content-distribution-vertical-rl.html: Added.
  • fast/css-grid-layout/grid-align-content-distribution.html: Added.
  • fast/css-grid-layout/grid-align-content-expected.txt: Added.
  • fast/css-grid-layout/grid-align-content-vertical-lr-expected.txt: Added.
  • fast/css-grid-layout/grid-align-content-vertical-lr.html: Added.
  • fast/css-grid-layout/grid-align-content-vertical-rl-expected.txt: Added.
  • fast/css-grid-layout/grid-align-content-vertical-rl.html: Added.
  • fast/css-grid-layout/grid-align-content.html: Added.
  • fast/css-grid-layout/grid-content-alignment-overflow-expected.txt: Added.
  • fast/css-grid-layout/grid-content-alignment-overflow.html: Added.
  • fast/css-grid-layout/grid-content-alignment-with-different-sized-tracks.html: Added.
  • fast/css-grid-layout/grid-content-alignment-with-different-sized-tracks-expected.txt: Added.
  • fast/css-grid-layout/grid-content-alignment-with-span-expected.txt: Added.
  • fast/css-grid-layout/grid-content-alignment-with-span-vertical-lr-expected.txt: Added.
  • fast/css-grid-layout/grid-content-alignment-with-span-vertical-lr.html: Added.
  • fast/css-grid-layout/grid-content-alignment-with-span-vertical-rl-expected.txt: Added.
  • fast/css-grid-layout/grid-content-alignment-with-span-vertical-rl.html: Added.
  • fast/css-grid-layout/grid-content-alignment-with-span.html: Added.
  • fast/css-grid-layout/grid-item-margin-auto-columns-rows-horizontal-rtl-expected.html:
  • fast/css-grid-layout/grid-justify-content-distribution-expected.txt: Added.
  • fast/css-grid-layout/grid-justify-content-distribution-vertical-lr-expected.txt: Added.
  • fast/css-grid-layout/grid-justify-content-distribution-vertical-lr.html: Added.
  • fast/css-grid-layout/grid-justify-content-distribution-vertical-rl-expected.txt: Added.
  • fast/css-grid-layout/grid-justify-content-distribution-vertical-rl.html: Added.
  • fast/css-grid-layout/grid-justify-content-distribution.html: Added.
  • fast/css-grid-layout/grid-justify-content-expected.txt: Added.
  • fast/css-grid-layout/grid-justify-content-vertical-lr-expected.txt: Added.
  • fast/css-grid-layout/grid-justify-content-vertical-lr.html: Added.
  • fast/css-grid-layout/grid-justify-content-vertical-rl-expected.txt: Added.
  • fast/css-grid-layout/grid-justify-content-vertical-rl.html: Added.
  • fast/css-grid-layout/grid-justify-content.html: Added.
  • fast/css-grid-layout/resources/grid.css:

(.firstRowThirdColumn):
(.firstRowFourthColumn):
(.secondRowThirdColumn):
(.secondRowFourthColumn):
(.thirdRowFirstColumn):
(.thirdRowSecondColumn):
(.fourthRowFirstColumn):
(.fourthRowSecondColumn):

Location:
trunk
Files:
42 added
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r190481 r190484  
     12015-10-02  Javier Fernandez  <jfernandez@igalia.com>
     2
     3        [CSS Grid Layout] Support for Content Alignment in grid layout
     4        https://bugs.webkit.org/show_bug.cgi?id=145520
     5
     6        Reviewed by Darin Adler.
     7
     8        Content Distribution alignment controls alignment of the box's
     9        content within the box. The alignment container is the grid
     10        container's content box. The alignment subjects are the grid
     11        tracks.
     12
     13        In addition to the tests to verify the new functionality, I've
     14        added some tests to check out that the new complex values are
     15        overwritten properly.
     16
     17        I had to modify the grid-item-margin-auto-columns-rows-horizontal-rtl
     18        test because when using RTL direction the whole grid must flow form
     19        right to left, not only its items, so I rebaselined text expectations
     20        to adapt it to the new behavior.
     21
     22        * css3/overwrite-content-alignment-expected.txt: Added.
     23        * css3/overwrite-content-alignment.html: Added.
     24        * css3/overwrite-self-alignment-expected.txt: Added.
     25        * css3/overwrite-self-alignment.html: Added.
     26        * fast/css-grid-layout/grid-align-content-distribution-expected.txt: Added.
     27        * fast/css-grid-layout/grid-align-content-distribution-vertical-lr-expected.txt: Added.
     28        * fast/css-grid-layout/grid-align-content-distribution-vertical-lr.html: Added.
     29        * fast/css-grid-layout/grid-align-content-distribution-vertical-rl-expected.txt: Added.
     30        * fast/css-grid-layout/grid-align-content-distribution-vertical-rl.html: Added.
     31        * fast/css-grid-layout/grid-align-content-distribution.html: Added.
     32        * fast/css-grid-layout/grid-align-content-expected.txt: Added.
     33        * fast/css-grid-layout/grid-align-content-vertical-lr-expected.txt: Added.
     34        * fast/css-grid-layout/grid-align-content-vertical-lr.html: Added.
     35        * fast/css-grid-layout/grid-align-content-vertical-rl-expected.txt: Added.
     36        * fast/css-grid-layout/grid-align-content-vertical-rl.html: Added.
     37        * fast/css-grid-layout/grid-align-content.html: Added.
     38        * fast/css-grid-layout/grid-content-alignment-overflow-expected.txt: Added.
     39        * fast/css-grid-layout/grid-content-alignment-overflow.html: Added.
     40        * fast/css-grid-layout/grid-content-alignment-with-different-sized-tracks.html: Added.
     41        * fast/css-grid-layout/grid-content-alignment-with-different-sized-tracks-expected.txt: Added.
     42        * fast/css-grid-layout/grid-content-alignment-with-span-expected.txt: Added.
     43        * fast/css-grid-layout/grid-content-alignment-with-span-vertical-lr-expected.txt: Added.
     44        * fast/css-grid-layout/grid-content-alignment-with-span-vertical-lr.html: Added.
     45        * fast/css-grid-layout/grid-content-alignment-with-span-vertical-rl-expected.txt: Added.
     46        * fast/css-grid-layout/grid-content-alignment-with-span-vertical-rl.html: Added.
     47        * fast/css-grid-layout/grid-content-alignment-with-span.html: Added.
     48        * fast/css-grid-layout/grid-item-margin-auto-columns-rows-horizontal-rtl-expected.html:
     49        * fast/css-grid-layout/grid-justify-content-distribution-expected.txt: Added.
     50        * fast/css-grid-layout/grid-justify-content-distribution-vertical-lr-expected.txt: Added.
     51        * fast/css-grid-layout/grid-justify-content-distribution-vertical-lr.html: Added.
     52        * fast/css-grid-layout/grid-justify-content-distribution-vertical-rl-expected.txt: Added.
     53        * fast/css-grid-layout/grid-justify-content-distribution-vertical-rl.html: Added.
     54        * fast/css-grid-layout/grid-justify-content-distribution.html: Added.
     55        * fast/css-grid-layout/grid-justify-content-expected.txt: Added.
     56        * fast/css-grid-layout/grid-justify-content-vertical-lr-expected.txt: Added.
     57        * fast/css-grid-layout/grid-justify-content-vertical-lr.html: Added.
     58        * fast/css-grid-layout/grid-justify-content-vertical-rl-expected.txt: Added.
     59        * fast/css-grid-layout/grid-justify-content-vertical-rl.html: Added.
     60        * fast/css-grid-layout/grid-justify-content.html: Added.
     61        * fast/css-grid-layout/resources/grid.css:
     62        (.firstRowThirdColumn):
     63        (.firstRowFourthColumn):
     64        (.secondRowThirdColumn):
     65        (.secondRowFourthColumn):
     66        (.thirdRowFirstColumn):
     67        (.thirdRowSecondColumn):
     68        (.fourthRowFirstColumn):
     69        (.fourthRowSecondColumn):
     70
    1712015-10-01  Dean Jackson  <dino@apple.com>
    272

  • trunk/LayoutTests/fast/css-grid-layout/grid-item-margin-auto-columns-rows-horizontal-rtl-expected.html

    r183370 r190484  
    5454<div class="testContainer">
    5555    <div class="grid gridLong">
    56         <div class="gridItem firstRowFirstColumn"   style="left: 20px; top: 20px;"></div>
    57         <div class="gridItem firstRowSecondColumn"  style="left: 0px"></div>
    58         <div class="gridItem secondRowFirstColumn"  style="left: 20px; top: 60px;"></div>
    59         <div class="gridItem secondRowSecondColumn" style="left: 0px; top: 60px;"></div>
     56        <div class="gridItem firstRowFirstColumn"   style="left: 180px; top: 20px;"></div>
     57        <div class="gridItem firstRowSecondColumn"  style="left: 160px"></div>
     58        <div class="gridItem secondRowFirstColumn"  style="left: 180px; top: 60px;"></div>
     59        <div class="gridItem secondRowSecondColumn" style="left: 160px; top: 60px;"></div>
    6060    </div>
    6161</div>
    … …  
    6363<div class="testContainer">
    6464    <div class="grid gridShort">
    65         <div class="gridItem firstRowFirstColumn"   style="left: 20px; top: 20px;"></div>
    66         <div class="gridItem firstRowSecondColumn"  style="left: 0px;"></div>
    67         <div class="gridItem secondRowFirstColumn"  style="left: 20px; top: 60px;"></div>
    68         <div class="gridItem secondRowSecondColumn" style="left: 0px; top: 60px;"></div>
     65        <div class="gridItem firstRowFirstColumn"   style="left: 180px; top: 20px;"></div>
     66        <div class="gridItem firstRowSecondColumn"  style="left: 160px;"></div>
     67        <div class="gridItem secondRowFirstColumn"  style="left: 180px; top: 60px;"></div>
     68        <div class="gridItem secondRowSecondColumn" style="left: 160px; top: 60px;"></div>
    6969    </div>
    7070</div>
    … …  
    7272<div class="testContainer">
    7373    <div class="grid gridLong">
    74         <div class="gridItem firstRowFirstColumn"   style="left: 20px; top: 80px;"></div>
    75         <div class="gridItem firstRowSecondColumn"  style="left: 0px; top: 80px;"></div>
    76         <div class="gridItem secondRowFirstColumn"  style="left: 20px;"></div>
    77         <div class="gridItem secondRowSecondColumn" style="left: 0px; top: 20px;"></div>
     74        <div class="gridItem firstRowFirstColumn"   style="left: 180px; top: 80px;"></div>
     75        <div class="gridItem firstRowSecondColumn"  style="left: 160px; top: 80px;"></div>
     76        <div class="gridItem secondRowFirstColumn"  style="left: 180px;"></div>
     77        <div class="gridItem secondRowSecondColumn" style="left: 160px; top: 20px;"></div>
    7878    </div>
    7979</div>
    … …  
    8181<div class="testContainer">
    8282    <div class="grid gridShort">
    83         <div class="gridItem firstRowFirstColumn"   style="left: 20px; top: 60px;"></div>
    84         <div class="gridItem firstRowSecondColumn"  style="left: 0px; top: 40px;"></div>
    85         <div class="gridItem secondRowFirstColumn"  style="left: 20px;"></div>
    86         <div class="gridItem secondRowSecondColumn" style="left: 0px;"></div>
     83        <div class="gridItem firstRowFirstColumn"   style="left: 180px; top: 60px;"></div>
     84        <div class="gridItem firstRowSecondColumn"  style="left: 160px; top: 40px;"></div>
     85        <div class="gridItem secondRowFirstColumn"  style="left: 180px;"></div>
     86        <div class="gridItem secondRowSecondColumn" style="left: 160px;"></div>
    8787    </div>
    8888</div>

  • trunk/LayoutTests/fast/css-grid-layout/resources/grid.css

    r183399 r190484  
    2828}
    2929
     30.firstRowThirdColumn {
     31    background-color: magenta;
     32    -webkit-grid-column: 3;
     33    -webkit-grid-row: 1;
     34}
     35
     36.firstRowFourthColumn {
     37    background-color: green;
     38    -webkit-grid-column: 4;
     39    -webkit-grid-row: 1;
     40}
     41
    3042.secondRowFirstColumn {
    3143    background-color: purple;
    … …  
    3850    -webkit-grid-column: 2;
    3951    -webkit-grid-row: 2;
     52}
     53
     54.secondRowThirdColumn {
     55    background-color: navy;
     56    -webkit-grid-column: 3;
     57    -webkit-grid-row: 2;
     58}
     59
     60.secondRowFourthColumn {
     61    background-color: pink;
     62    -webkit-grid-column: 4;
     63    -webkitgrid-row: 2;
     64}
     65
     66.thirdRowFirstColumn {
     67    background-color: olive;
     68    -webkit-grid-column: 1;
     69    -webkit-grid-row: 3;
     70}
     71
     72.thirdRowSecondColumn {
     73    background-color: maroon;
     74    -webkit-grid-column: 2;
     75    -webkit-grid-row: 3;
     76}
     77
     78.thirdRowThirdColumn {
     79    background-color: yellow;
     80    -webkit-grid-column: 3;
     81    -webkit-grid-row: 3;
     82}
     83
     84.fourthRowFirstColumn {
     85    background-color: red;
     86    -webkit-grid-column: 1;
     87    -webkit-grid-row: 4;
     88}
     89
     90.fourthRowSecondColumn {
     91    background-color: aqua;
     92    -webkit-grid-column: 2;
     93    -webkit-grid-row: 4;
    4094}
    4195

  • trunk/Source/WebCore/ChangeLog

    r190482 r190484  
     12015-10-02  Javier Fernandez  <jfernandez@igalia.com>
     2
     3        [CSS Grid Layout] Support for Content Alignment in grid layout
     4        https://bugs.webkit.org/show_bug.cgi?id=145520
     5
     6        Reviewed by Darin Adler.
     7
     8        According to CSS Box Alignment specification, Content Distribution
     9        alignment controls alignment of the box's content within the box. The
     10        alignment container is the grid container's content box. The alignment
     11        subjects are the grid tracks.
     12
     13        This patch implements Grid Layout support for Content Distribution
     14        alignment along both block/column and inline/row axis, which are handled
     15        by align-content and justify-content properties respectively.
     16
     17        This patch provides support for overflow handling, similar to what
     18        Self Alignment provides with grid items, and both <content-position>
     19        and <content-distribution> values.
     20
     21        Baseline Alignment is still missing because it requires some additional
     22        behavior to be supported on grids before considering its implementation.
     23
     24        Tests: css3/overwrite-content-alignment.html
     25               css3/overwrite-self-alignment.html
     26               fast/css-grid-layout/grid-align-content-distribution-vertical-lr.html
     27               fast/css-grid-layout/grid-align-content-distribution-vertical-rl.html
     28               fast/css-grid-layout/grid-align-content-distribution.html
     29               fast/css-grid-layout/grid-align-content-vertical-lr.html
     30               fast/css-grid-layout/grid-align-content-vertical-rl.html
     31               fast/css-grid-layout/grid-align-content.html
     32               fast/css-grid-layout/grid-content-alignment-overflow.html
     33               fast/css-grid-layout/grid-content-alignment-with-different-sized-tracks.html
     34               fast/css-grid-layout/grid-content-alignment-with-span-vertical-lr.html
     35               fast/css-grid-layout/grid-content-alignment-with-span-vertical-rl.html
     36               fast/css-grid-layout/grid-content-alignment-with-span.html
     37               fast/css-grid-layout/grid-justify-content-distribution-vertical-lr.html
     38               fast/css-grid-layout/grid-justify-content-distribution-vertical-rl.html
     39               fast/css-grid-layout/grid-justify-content-distribution.html
     40               fast/css-grid-layout/grid-justify-content-vertical-lr.html
     41               fast/css-grid-layout/grid-justify-content-vertical-rl.html
     42               fast/css-grid-layout/grid-justify-content.html
     43
     44        * rendering/RenderFlexibleBox.cpp:
     45        (WebCore::RenderFlexibleBox::layoutAndPlaceChildren):
     46        (WebCore::RenderFlexibleBox::layoutColumnReverse):
     47        (WebCore::RenderFlexibleBox::alignFlexLines):
     48        * rendering/RenderGrid.cpp:
     49        (WebCore::ContentAlignmentData::ContentAlignmentData):
     50        (WebCore::RenderGrid::computeUsedBreadthOfGridTracks):
     51        (WebCore::RenderGrid::layoutGridItems):
     52        (WebCore::RenderGrid::gridAreaBreadthForChild):
     53        (WebCore::RenderGrid::populateGridPositions):
     54        (WebCore::resolveContentDistributionFallback):
     55        (WebCore::offsetToStartEdge):
     56        (WebCore::offsetToEndEdge):
     57        (WebCore::contentDistributionOffset):
     58        (WebCore::RenderGrid::computeContentPositionAndDistributionColumnOffset):
     59        (WebCore::RenderGrid::computeContentPositionAndDistributionRowOffset):
     60        (WebCore::RenderGrid::findChildLogicalPosition):
     61        (WebCore::RenderGrid::computePreferredLogicalWidths): Deleted.
     62        (WebCore::RenderGrid::autoPlacementMajorAxisDirection): Deleted.
     63        (WebCore::RenderGrid::autoPlacementMinorAxisDirection): Deleted.
     64        (WebCore::RenderGrid::cachedGridCoordinate): Deleted.
     65        (WebCore::RenderGrid::rowPositionForChild): Deleted.
     66        * rendering/RenderGrid.h:
     67        * rendering/style/RenderStyle.cpp:
     68        (WebCore::RenderStyle::resolvedAlignContentPosition):
     69        (WebCore::RenderStyle::resolvedAlignContentDistribution):
     70        (WebCore::RenderStyle::resolvedJustifyContentPosition):
     71        (WebCore::RenderStyle::resolvedJustifyContentDistribution):
     72        * rendering/style/RenderStyle.h:
     73
    1742015-10-02  Dean Jackson  <dino@apple.com>
    275

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

    r189567 r190484  
    10941094    ASSERT(childSizes.size() == children.size());
    10951095
    1096     ContentPosition position = style().justifyContentPosition();
    1097     ContentDistributionType distribution = style().justifyContentDistribution();
    1098     RenderStyle::resolveContentJustification(style(), position);
     1096    ContentPosition position = style().resolvedJustifyContentPosition();
     1097    ContentDistributionType distribution = style().resolvedJustifyContentDistribution();
    10991098
    11001099    size_t numberOfChildrenForJustifyContent = numberOfInFlowPositionedChildren(children);
    … …  
    11791178void RenderFlexibleBox::layoutColumnReverse(const OrderedFlexItemList& children, LayoutUnit crossAxisOffset, LayoutUnit availableFreeSpace)
    11801179{
    1181     ContentPosition position = style().justifyContentPosition();
    1182     ContentDistributionType distribution = style().justifyContentDistribution();
    1183     RenderStyle::resolveContentJustification(style(), position);
     1180    ContentPosition position = style().resolvedJustifyContentPosition();
     1181    ContentDistributionType distribution = style().resolvedJustifyContentDistribution();
    11841182
    11851183    // This is similar to the logic in layoutAndPlaceChildren, except we place the children
    … …  
    12381236void RenderFlexibleBox::alignFlexLines(Vector<LineContext>& lineContexts)
    12391237{
    1240     ContentPosition position = style().alignContentPosition();
    1241     ContentDistributionType distribution = style().alignContentDistribution();
    1242     RenderStyle::resolveContentAlignment(style(), position, distribution);
     1238    ContentPosition position = style().resolvedAlignContentPosition();
     1239    ContentDistributionType distribution = style().resolvedAlignContentDistribution();
    12431240
    12441241    if (!isMultiline() || position == ContentPositionFlexStart)

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

    r190308 r190484  
    117117};
    118118
     119struct ContentAlignmentData {
     120    WTF_MAKE_FAST_ALLOCATED;
     121public:
     122    bool isValid() { return positionOffset >= 0 && distributionOffset >= 0; }
     123    static ContentAlignmentData defaultOffsets() { return {-1, -1}; }
     124
     125    LayoutUnit positionOffset;
     126    LayoutUnit distributionOffset;
     127};
     128
    119129class RenderGrid::GridIterator {
    120130    WTF_MAKE_NONCOPYABLE(GridIterator);
    … …  
    346356}
    347357
    348 void RenderGrid::computeUsedBreadthOfGridTracks(GridTrackSizingDirection direction, GridSizingData& sizingData)
    349 {
    350     LayoutUnit availableLogicalSpace = (direction == ForColumns) ? availableLogicalWidth() : availableLogicalHeight(IncludeMarginBorderPadding);
    351     computeUsedBreadthOfGridTracks(direction, sizingData, availableLogicalSpace);
    352 }
    353 
    354358bool RenderGrid::gridElementIsShrinkToFit()
    355359{
    … …  
    490494}
    491495
    492 double RenderGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<size_t, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const
     496double RenderGrid::computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, GridTrackSizingDirection direction, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible) const
    493497{
    494498    // We want to avoid the effect of flex factors sum below 1 making the factor unit size to grow exponentially.
    … …  
    523527
    524528    double flexFactorSum = 0;
    525     Vector<size_t, 8> flexibleTracksIndexes;
     529    Vector<unsigned, 8> flexibleTracksIndexes;
    526530    for (const auto& resolvedPosition : tracksSpan) {
    527         size_t trackIndex = resolvedPosition.toInt();
     531        unsigned trackIndex = resolvedPosition.toInt();
    528532        GridTrackSize trackSize = gridTrackSize(direction, trackIndex);
    529533        if (!trackSize.maxTrackBreadth().isFlex())
    … …  
    12111215}
    12121216
     1217void RenderGrid::applyStretchAlignmentToTracksIfNeeded(GridTrackSizingDirection direction, GridSizingData& sizingData, LayoutUnit availableSpace)
     1218{
     1219    if (availableSpace <= 0
     1220        || (direction == ForColumns && style().resolvedJustifyContentDistribution() != ContentDistributionStretch)
     1221        || (direction == ForRows && style().resolvedAlignContentDistribution() != ContentDistributionStretch))
     1222        return;
     1223
     1224    // Spec defines auto-sized tracks as the ones with an 'auto' max-sizing function.
     1225    Vector<GridTrack>& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
     1226    Vector<unsigned> autoSizedTracksIndex;
     1227    for (unsigned i = 0; i < tracks.size(); ++i) {
     1228        const GridTrackSize& trackSize = gridTrackSize(direction, i);
     1229        if (trackSize.hasAutoMaxTrackBreadth())
     1230            autoSizedTracksIndex.append(i);
     1231    }
     1232
     1233    unsigned numberOfAutoSizedTracks = autoSizedTracksIndex.size();
     1234    if (numberOfAutoSizedTracks < 1)
     1235        return;
     1236
     1237    LayoutUnit sizeToIncrease = availableSpace / numberOfAutoSizedTracks;
     1238    for (const auto& trackIndex : autoSizedTracksIndex) {
     1239        auto& track = tracks[trackIndex];
     1240        track.setBaseSize(track.baseSize() + sizeToIncrease);
     1241    }
     1242}
     1243
    12131244void RenderGrid::layoutGridItems()
    12141245{
    12151246    placeItemsOnGrid();
    12161247
     1248    LayoutUnit availableSpaceForColumns = availableLogicalWidth();
     1249    LayoutUnit availableSpaceForRows = availableLogicalHeight(IncludeMarginBorderPadding);
    12171250    GridSizingData sizingData(gridColumnCount(), gridRowCount());
    1218     computeUsedBreadthOfGridTracks(ForColumns, sizingData);
     1251    computeUsedBreadthOfGridTracks(ForColumns, sizingData, availableSpaceForColumns);
    12191252    ASSERT(tracksAreWiderThanMinTrackBreadth(ForColumns, sizingData.columnTracks));
    1220     computeUsedBreadthOfGridTracks(ForRows, sizingData);
     1253    computeUsedBreadthOfGridTracks(ForRows, sizingData, availableSpaceForRows);
    12211254    ASSERT(tracksAreWiderThanMinTrackBreadth(ForRows, sizingData.rowTracks));
    12221255
    1223     populateGridPositions(sizingData);
     1256    applyStretchAlignmentToTracksIfNeeded(ForColumns, sizingData, availableSpaceForColumns);
     1257    applyStretchAlignmentToTracksIfNeeded(ForRows, sizingData, availableSpaceForRows);
     1258
     1259    populateGridPositions(sizingData, availableSpaceForColumns, availableSpaceForRows);
    12241260
    12251261    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
    … …  
    12291265        Optional<LayoutUnit> oldOverrideContainingBlockContentLogicalHeight = child->hasOverrideContainingBlockLogicalHeight() ? child->overrideContainingBlockContentLogicalHeight() : LayoutUnit();
    12301266
    1231         LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForChild(*child, ForColumns, sizingData.columnTracks);
    1232         LayoutUnit overrideContainingBlockContentLogicalHeight = gridAreaBreadthForChild(*child, ForRows, sizingData.rowTracks);
     1267        LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForChildIncludingAlignmentOffsets(*child, ForColumns, sizingData);
     1268        LayoutUnit overrideContainingBlockContentLogicalHeight = gridAreaBreadthForChildIncludingAlignmentOffsets(*child, ForRows, sizingData);
    12331269        if (!oldOverrideContainingBlockContentLogicalWidth || oldOverrideContainingBlockContentLogicalWidth.value() != overrideContainingBlockContentLogicalWidth
    12341270            || ((!oldOverrideContainingBlockContentLogicalHeight || oldOverrideContainingBlockContentLogicalHeight.value() != overrideContainingBlockContentLogicalHeight)
    … …  
    12951331}
    12961332
    1297 void RenderGrid::populateGridPositions(const GridSizingData& sizingData)
    1298 {
    1299     m_columnPositions.resizeToFit(sizingData.columnTracks.size() + 1);
    1300     m_columnPositions[0] = borderAndPaddingStart();
    1301     for (unsigned i = 0; i < m_columnPositions.size() - 1; ++i)
    1302         m_columnPositions[i + 1] = m_columnPositions[i] + sizingData.columnTracks[i].baseSize();
    1303 
    1304     m_rowPositions.resizeToFit(sizingData.rowTracks.size() + 1);
    1305     m_rowPositions[0] = borderAndPaddingBefore();
    1306     for (unsigned i = 0; i < m_rowPositions.size() - 1; ++i)
    1307         m_rowPositions[i + 1] = m_rowPositions[i] + sizingData.rowTracks[i].baseSize();
     1333LayoutUnit RenderGrid::gridAreaBreadthForChildIncludingAlignmentOffsets(const RenderBox& child, GridTrackSizingDirection direction, const GridSizingData& sizingData) const
     1334{
     1335    // We need the cached value when available because Content Distribution alignment properties
     1336    // may have some influence in the final grid area breadth.
     1337    const auto& tracks = (direction == ForColumns) ? sizingData.columnTracks : sizingData.rowTracks;
     1338    const auto& coordinate = cachedGridCoordinate(child);
     1339    const auto& span = (direction == ForColumns) ? coordinate.columns : coordinate.rows;
     1340    const auto& linePositions = (direction == ForColumns) ? m_columnPositions : m_rowPositions;
     1341
     1342    LayoutUnit initialTrackPosition = linePositions[span.resolvedInitialPosition.toInt()];
     1343    LayoutUnit finalTrackPosition = linePositions[span.resolvedFinalPosition.toInt()];
     1344
     1345    // Track Positions vector stores the 'start' grid line of each track, so we have to add last track's baseSize.
     1346    return finalTrackPosition - initialTrackPosition + tracks[span.resolvedFinalPosition.toInt()].baseSize();
     1347}
     1348
     1349void RenderGrid::populateGridPositions(GridSizingData& sizingData, LayoutUnit availableSpaceForColumns, LayoutUnit availableSpaceForRows)
     1350{
     1351    // Since we add alignment offsets, grid lines are not always adjacent. Hence we will have to
     1352    // assume from now on that we just store positions of the initial grid lines of each track,
     1353    // except the last one, which is the only one considered as a final grid line of a track.
     1354    // FIXME: This will affect the computed style value of grid tracks size, since we are
     1355    // using these positions to compute them.
     1356
     1357    unsigned numberOfTracks = sizingData.columnTracks.size();
     1358    unsigned numberOfLines = numberOfTracks + 1;
     1359    unsigned lastLine = numberOfLines - 1;
     1360    unsigned nextToLastLine = numberOfLines - 2;
     1361    ContentAlignmentData offset = computeContentPositionAndDistributionOffset(ForColumns, availableSpaceForColumns, numberOfTracks);
     1362    m_columnPositions.resize(numberOfLines);
     1363    m_columnPositions[0] = borderAndPaddingStart() + offset.positionOffset;
     1364    for (unsigned i = 0; i < lastLine; ++i)
     1365        m_columnPositions[i + 1] = m_columnPositions[i] + offset.distributionOffset + sizingData.columnTracks[i].baseSize();
     1366    m_columnPositions[lastLine] = m_columnPositions[nextToLastLine] + sizingData.columnTracks[nextToLastLine].baseSize();
     1367
     1368    numberOfTracks = sizingData.rowTracks.size();
     1369    numberOfLines = numberOfTracks + 1;
     1370    lastLine = numberOfLines - 1;
     1371    nextToLastLine = numberOfLines - 2;
     1372    offset = computeContentPositionAndDistributionOffset(ForRows, availableSpaceForRows, numberOfTracks);
     1373    m_rowPositions.resize(numberOfLines);
     1374    m_rowPositions[0] = borderAndPaddingBefore() + offset.positionOffset;
     1375    for (unsigned i = 0; i < lastLine; ++i)
     1376        m_rowPositions[i + 1] = m_rowPositions[i] + offset.distributionOffset + sizingData.rowTracks[i].baseSize();
     1377    m_rowPositions[lastLine] = m_rowPositions[nextToLastLine] + sizingData.rowTracks[nextToLastLine].baseSize();
    13081378}
    13091379
    … …  
    15901660}
    15911661
     1662static inline LayoutUnit offsetBetweenTracks(ContentDistributionType distribution, const Vector<LayoutUnit>& trackPositions, const LayoutUnit& childBreadth)
     1663{
     1664    return (distribution == ContentDistributionStretch || ContentDistributionStretch == ContentDistributionDefault) ? LayoutUnit() : trackPositions[1] - trackPositions[0] - childBreadth;
     1665}
     1666
    15921667LayoutUnit RenderGrid::columnAxisOffsetForChild(const RenderBox& child) const
    15931668{
    15941669    const GridCoordinate& coordinate = cachedGridCoordinate(child);
    1595     LayoutUnit startOfRow = m_rowPositions[coordinate.rows.resolvedInitialPosition.toInt()];
     1670    unsigned childStartLine = coordinate.rows.resolvedInitialPosition.toInt();
     1671    LayoutUnit startOfRow = m_rowPositions[childStartLine];
    15961672    LayoutUnit startPosition = startOfRow + marginBeforeForChild(child);
    15971673    if (hasAutoMarginsInColumnAxis(child))
    … …  
    16031679    case GridAxisEnd:
    16041680    case GridAxisCenter: {
    1605         LayoutUnit endOfRow = m_rowPositions[coordinate.rows.resolvedFinalPosition.next().toInt()];
    1606         LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(RenderStyle::resolveAlignmentOverflow(style(), child.style()), endOfRow - startOfRow, child.logicalHeight() + child.marginLogicalHeight());
     1681        unsigned childEndLine = coordinate.rows.resolvedFinalPosition.next().toInt();
     1682        LayoutUnit endOfRow = m_rowPositions[childEndLine];
     1683        LayoutUnit childBreadth = child.logicalHeight() + child.marginLogicalHeight();
     1684        if (childEndLine - childStartLine > 1 && childEndLine < m_rowPositions.size() - 1)
     1685            endOfRow -= offsetBetweenTracks(style().resolvedAlignContentDistribution(), m_rowPositions, childBreadth);
     1686        LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(RenderStyle::resolveAlignmentOverflow(style(), child.style()), endOfRow - startOfRow, childBreadth);
    16071687        return startPosition + (axisPosition == GridAxisEnd ? offsetFromStartPosition : offsetFromStartPosition / 2);
    16081688    }
    … …  
    16171697{
    16181698    const GridCoordinate& coordinate = cachedGridCoordinate(child);
    1619     LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.resolvedInitialPosition.toInt()];
     1699    unsigned childStartLine = coordinate.columns.resolvedInitialPosition.toInt();
     1700    LayoutUnit startOfColumn = m_columnPositions[childStartLine];
    16201701    LayoutUnit startPosition = startOfColumn + marginStartForChild(child);
    16211702    if (hasAutoMarginsInRowAxis(child))
    … …  
    16271708    case GridAxisEnd:
    16281709    case GridAxisCenter: {
    1629         LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.resolvedFinalPosition.next().toInt()];
    1630         LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(RenderStyle::resolveJustificationOverflow(style(), child.style()), endOfColumn - startOfColumn, child.logicalWidth() + child.marginLogicalWidth());
     1710        unsigned childEndLine = coordinate.columns.resolvedFinalPosition.next().toInt();
     1711        LayoutUnit endOfColumn = m_columnPositions[childEndLine];
     1712        LayoutUnit childBreadth = child.logicalWidth() + child.marginLogicalWidth();
     1713        if (childEndLine - childStartLine > 1 && childEndLine < m_columnPositions.size() - 1)
     1714            endOfColumn -= offsetBetweenTracks(style().resolvedJustifyContentDistribution(), m_columnPositions, childBreadth);
     1715        LayoutUnit offsetFromStartPosition = computeOverflowAlignmentOffset(RenderStyle::resolveJustificationOverflow(style(), child.style()), endOfColumn - startOfColumn, childBreadth);
    16311716        return startPosition + (axisPosition == GridAxisEnd ? offsetFromStartPosition : offsetFromStartPosition / 2);
    16321717    }
    … …  
    16351720    ASSERT_NOT_REACHED();
    16361721    return 0;
     1722}
     1723
     1724ContentPosition static resolveContentDistributionFallback(ContentDistributionType distribution)
     1725{
     1726    switch (distribution) {
     1727    case ContentDistributionSpaceBetween:
     1728        return ContentPositionStart;
     1729    case ContentDistributionSpaceAround:
     1730        return ContentPositionCenter;
     1731    case ContentDistributionSpaceEvenly:
     1732        return ContentPositionCenter;
     1733    case ContentDistributionStretch:
     1734        return ContentPositionStart;
     1735    case ContentDistributionDefault:
     1736        return ContentPositionAuto;
     1737    }
     1738
     1739    ASSERT_NOT_REACHED();
     1740    return ContentPositionAuto;
     1741}
     1742
     1743static inline LayoutUnit offsetToStartEdge(bool isLeftToRight, LayoutUnit availableSpace)
     1744{
     1745    return isLeftToRight ? LayoutUnit() : availableSpace;
     1746}
     1747
     1748static inline LayoutUnit offsetToEndEdge(bool isLeftToRight, LayoutUnit availableSpace)
     1749{
     1750    return !isLeftToRight ? LayoutUnit() : availableSpace;
     1751}
     1752
     1753static ContentAlignmentData contentDistributionOffset(LayoutUnit availableFreeSpace, ContentPosition& fallbackPosition, ContentDistributionType distribution, unsigned numberOfGridTracks)
     1754{
     1755    if (distribution != ContentDistributionDefault && fallbackPosition == ContentPositionAuto)
     1756        fallbackPosition = resolveContentDistributionFallback(distribution);
     1757
     1758    if (availableFreeSpace <= 0)
     1759        return ContentAlignmentData::defaultOffsets();
     1760
     1761    LayoutUnit distributionOffset;
     1762    switch (distribution) {
     1763    case ContentDistributionSpaceBetween:
     1764        if (numberOfGridTracks < 2)
     1765            return ContentAlignmentData::defaultOffsets();
     1766        return {0, availableFreeSpace / (numberOfGridTracks - 1)};
     1767    case ContentDistributionSpaceAround:
     1768        if (numberOfGridTracks < 1)
     1769            return ContentAlignmentData::defaultOffsets();
     1770        distributionOffset = availableFreeSpace / numberOfGridTracks;
     1771        return {distributionOffset / 2, distributionOffset};
     1772    case ContentDistributionSpaceEvenly:
     1773        distributionOffset = availableFreeSpace / (numberOfGridTracks + 1);
     1774        return {distributionOffset, distributionOffset};
     1775    case ContentDistributionStretch:
     1776        return {0, 0};
     1777    case ContentDistributionDefault:
     1778        return ContentAlignmentData::defaultOffsets();
     1779    }
     1780
     1781    ASSERT_NOT_REACHED();
     1782    return ContentAlignmentData::defaultOffsets();
     1783}
     1784
     1785ContentAlignmentData RenderGrid::computeContentPositionAndDistributionOffset(GridTrackSizingDirection direction, LayoutUnit availableFreeSpace, unsigned numberOfGridTracks) const
     1786{
     1787    bool isRowAxis = direction == ForColumns;
     1788    ContentPosition position = isRowAxis ? style().resolvedJustifyContentPosition() : style().resolvedAlignContentPosition();
     1789    ContentDistributionType distribution = isRowAxis ? style().resolvedJustifyContentDistribution() : style().resolvedAlignContentDistribution();
     1790    // If <content-distribution> value can't be applied, 'position' will become the associated
     1791    // <content-position> fallback value.
     1792    ContentAlignmentData contentAlignment = contentDistributionOffset(availableFreeSpace, position, distribution, numberOfGridTracks);
     1793    if (contentAlignment.isValid())
     1794        return contentAlignment;
     1795
     1796    OverflowAlignment overflow = isRowAxis ? style().justifyContentOverflowAlignment() : style().alignContentOverflowAlignment();
     1797    if (availableFreeSpace <= 0 && overflow == OverflowAlignmentSafe)
     1798        return {0, 0};
     1799
     1800    switch (position) {
     1801    case ContentPositionLeft:
     1802        // The align-content's axis is always orthogonal to the inline-axis.
     1803        return {0, 0};
     1804    case ContentPositionRight:
     1805        if (isRowAxis)
     1806            return {availableFreeSpace, 0};
     1807        // The align-content's axis is always orthogonal to the inline-axis.
     1808        return {0, 0};
     1809    case ContentPositionCenter:
     1810        return {availableFreeSpace / 2, 0};
     1811    case ContentPositionFlexEnd: // Only used in flex layout, for other layout, it's equivalent to 'end'.
     1812    case ContentPositionEnd:
     1813        if (isRowAxis)
     1814            return {offsetToEndEdge(style().isLeftToRightDirection(), availableFreeSpace), 0};
     1815        return {availableFreeSpace, 0};
     1816    case ContentPositionFlexStart: // Only used in flex layout, for other layout, it's equivalent to 'start'.
     1817    case ContentPositionStart:
     1818        if (isRowAxis)
     1819            return {offsetToStartEdge(style().isLeftToRightDirection(), availableFreeSpace), 0};
     1820        return {0, 0};
     1821    case ContentPositionBaseline:
     1822    case ContentPositionLastBaseline:
     1823        // FIXME: Implement the previous values. For now, we always 'start' align.
     1824        // http://webkit.org/b/145566
     1825        if (isRowAxis)
     1826            return {offsetToStartEdge(style().isLeftToRightDirection(), availableFreeSpace), 0};
     1827        return {0, 0};
     1828    case ContentPositionAuto:
     1829        break;
     1830    }
     1831
     1832    ASSERT_NOT_REACHED();
     1833    return {0, 0};
    16371834}
    16381835
    … …  
    16481845    }
    16491846
    1650     // The grid items should be inside the grid container's border box, that's why they need to be shifted.
    16511847    return LayoutPoint(rowAxisOffset, columnAxisOffsetForChild(child));
    16521848}

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

    r190308 r190484  
    4141class GridItemWithSpan;
    4242
     43struct ContentAlignmentData;
     44
    4345enum GridAxisPosition {GridAxisStart, GridAxisEnd, GridAxisCenter};
    4446
    … …  
    6668    class GridIterator;
    6769    class GridSizingData;
    68     void computeUsedBreadthOfGridTracks(GridTrackSizingDirection, GridSizingData&);
    6970    void computeUsedBreadthOfGridTracks(GridTrackSizingDirection, GridSizingData&, LayoutUnit& availableLogicalSpace);
    7071    bool gridElementIsShrinkToFit();
    … …  
    8788
    8889    void layoutGridItems();
    89     void populateGridPositions(const GridSizingData&);
     90    void populateGridPositions(GridSizingData&, LayoutUnit availableSpaceForColumns, LayoutUnit availableSpaceForRows);
    9091    void clearGrid();
    9192
    … …  
    115116
    116117    typedef HashSet<unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> TrackIndexSet;
    117     double computeFlexFactorUnitSize(const Vector<GridTrack>&, GridTrackSizingDirection, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<size_t, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible = nullptr) const;
     118    double computeFlexFactorUnitSize(const Vector<GridTrack>&, GridTrackSizingDirection, double flexFactorSum, LayoutUnit leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible = nullptr) const;
    118119    double findFlexFactorUnitSize(const Vector<GridTrack>&, const GridSpan&, GridTrackSizingDirection, LayoutUnit spaceToFill) const;
    119120
    … …  
    128129    LayoutUnit columnAxisOffsetForChild(const RenderBox&) const;
    129130    LayoutUnit rowAxisOffsetForChild(const RenderBox&) const;
     131    ContentAlignmentData computeContentPositionAndDistributionOffset(GridTrackSizingDirection, LayoutUnit availableFreeSpace, unsigned numberOfGridTracks) const;
    130132    LayoutPoint findChildLogicalPosition(const RenderBox&) const;
    131133    GridCoordinate cachedGridCoordinate(const RenderBox&) const;
    … …  
    133135
    134136    LayoutUnit gridAreaBreadthForChild(const RenderBox& child, GridTrackSizingDirection, const Vector<GridTrack>&) const;
     137    LayoutUnit gridAreaBreadthForChildIncludingAlignmentOffsets(const RenderBox&, GridTrackSizingDirection, const GridSizingData&) const;
     138
     139    void applyStretchAlignmentToTracksIfNeeded(GridTrackSizingDirection, GridSizingData&, LayoutUnit availableSpace);
    135140
    136141    virtual void paintChildren(PaintInfo& forSelf, const LayoutPoint& paintOffset, PaintInfo& forChild, bool usePrintRect) override;

  • trunk/Source/WebCore/rendering/style/RenderStyle.cpp

    r189910 r190484  
    210210}
    211211
    212 void RenderStyle::resolveContentAlignment(const RenderStyle& style, ContentPosition& position, ContentDistributionType& distribution)
    213 {
    214     if (position != ContentPositionAuto || distribution != ContentDistributionDefault)
    215         return;
    216 
    217     if (style.isDisplayFlexibleBox())
    218         distribution = ContentDistributionStretch;
    219     else
    220         position = ContentPositionStart;
    221 }
    222 
    223 void RenderStyle::resolveContentJustification(const RenderStyle& style, ContentPosition& position)
    224 {
    225     if (position != ContentPositionAuto || style.justifyContentDistribution() != ContentDistributionDefault)
    226         return;
    227 
    228     if (style.isDisplayFlexibleBox())
    229         position = ContentPositionFlexStart;
    230     else
    231         position = ContentPositionStart;
     212ContentPosition RenderStyle::resolvedAlignContentPosition() const
     213{
     214    const StyleContentAlignmentData& align = alignContent();
     215    if (align.position() != ContentPositionAuto || align.distribution() != ContentDistributionDefault)
     216        return align.position();
     217    // 'auto' computes to 'stretch' for flexbox, hence it's managed by distribution().
     218    return isDisplayFlexibleBox() ? ContentPositionAuto : ContentPositionStart;
     219}
     220
     221ContentDistributionType RenderStyle::resolvedAlignContentDistribution() const
     222{
     223    const StyleContentAlignmentData& align = alignContent();
     224    if (align.position() != ContentPositionAuto || align.distribution() != ContentDistributionDefault)
     225        return align.distribution();
     226    return isDisplayFlexibleBox() ? ContentDistributionStretch : ContentDistributionDefault;
     227}
     228
     229ContentPosition RenderStyle::resolvedJustifyContentPosition() const
     230{
     231    const StyleContentAlignmentData& justify = justifyContent();
     232    if (justify.position() != ContentPositionAuto || justify.distribution() != ContentDistributionDefault)
     233        return justify.position();
     234    // 'auto' computes to 'stretch' for flexbox, but since flexing in the main axis is controlled by flex, it behaves as flex-start.
     235    return isDisplayFlexibleBox() ? ContentPositionFlexStart : ContentPositionStart;
     236}
     237
     238ContentDistributionType RenderStyle::resolvedJustifyContentDistribution() const
     239{
     240    // even that 'auto' computes to 'stretch' for flexbox it behaves as flex-start, hence it's managed by position().
     241    return justifyContentDistribution();
    232242}
    233243

  • trunk/Source/WebCore/rendering/style/RenderStyle.h

    r190231 r190484  
    490490    static Ref<RenderStyle> createStyleInheritingFromPseudoStyle(const RenderStyle& pseudoStyle);
    491491
    492     static void resolveContentAlignment(const RenderStyle&, ContentPosition&, ContentDistributionType&);
    493     static void resolveContentJustification(const RenderStyle&, ContentPosition&);
     492    ContentPosition resolvedAlignContentPosition() const;
     493    ContentDistributionType resolvedAlignContentDistribution() const;
     494    ContentPosition resolvedJustifyContentPosition() const;
     495    ContentDistributionType resolvedJustifyContentDistribution() const;
    494496    static ItemPosition resolveAlignment(const RenderStyle& parentStyle, const RenderStyle& childStyle, ItemPosition resolvedAutoPositionForRenderer);
    495497    static OverflowAlignment resolveAlignmentOverflow(const RenderStyle& parentStyle, const RenderStyle& childStyle);
Note: See TracChangeset for help on using the changeset viewer.