Changeset 289986 in webkit


Ignore:
Timestamp:
Feb 16, 2022 5:31:02 PM (5 months ago)
Author:
commit-queue@webkit.org
Message:

Inherit track count from parent grid for subgridded axes and clamp item placement to that explicit grid.
​https://bugs.webkit.org/show_bug.cgi?id=236122

Patch by Matt Woodrow <Matt Woodrow> on 2022-02-16
Reviewed by Dean Jackson.

LayoutTests/imported/w3c:

Test changes to match latest spec, submitted upstream as ​https://github.com/web-platform-tests/wpt/pull/32629

  • web-platform-tests/css/css-grid/subgrid/line-names-002-expected.html:
  • web-platform-tests/css/css-grid/subgrid/line-names-005-expected.html:

Source/WebCore:

Changes GridPositionsResolver::explicitGrid<>Count to return the number of tracks
spanned in the parent grid, for axes that are a subgrid.

Updates adjustGridPositionsForStyle to use the number of lines specified in the
subgrid property, for grid items that are also a subgrid and have an otherwise
indefinite span.

Adds clamping support to Grid so that we can prevent subgrids from ever adding
new implicit tracks.

  • rendering/Grid.cpp:

(WebCore::Grid::insert):
(WebCore::Grid::setClampingForSubgrid):
(WebCore::Grid::clampAndTranslateToImplicitGrid):
(WebCore::Grid::setNeedsItemsPlacement):

  • rendering/Grid.h:
  • rendering/RenderGrid.cpp:

(WebCore::RenderGrid::computeIntrinsicLogicalWidths const):
(WebCore::RenderGrid::placeItemsOnGrid const):
(WebCore::RenderGrid::populateExplicitGridAndOrderIterator const):
(WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid const):
(WebCore::RenderGrid::isSubgrid const):
(WebCore::RenderGrid::isSubgridRows const):
(WebCore::RenderGrid::isSubgridColumns const):
(WebCore::RenderGrid::gridAreaBreadthForOutOfFlowChild):
(WebCore::RenderGrid::numTracks const):
(WebCore::transposedDirection):
(WebCore::RenderGrid::computeGridSpanForOutOfFlowChild const):
(WebCore::RenderGrid::gridSpanForOutOfFlowChild const):
(WebCore::RenderGrid::gridSpanForChild const):

  • rendering/RenderGrid.h:
  • rendering/style/GridArea.h:

(WebCore::GridSpan::integerSpan const):
(WebCore::GridSpan::translateTo):
(WebCore::GridSpan::clamp):

  • rendering/style/GridPositionsResolver.cpp:

(WebCore::isIndefiniteSpan):
(WebCore::adjustGridPositionsFromStyle):
(WebCore::GridPositionsResolver::explicitGridColumnCount):
(WebCore::GridPositionsResolver::explicitGridRowCount):
(WebCore::explicitGridSizeForSide):
(WebCore::resolveNamedGridLinePositionFromStyle):
(WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
(WebCore::resolveGridPositionAgainstOppositePosition):
(WebCore::resolveGridPositionFromStyle):
(WebCore::GridPositionsResolver::resolveGridPositionsFromStyle):

  • rendering/style/GridPositionsResolver.h:
Location:
trunk
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/imported/w3c/ChangeLog

    r289981 r289986  
     12022-02-16  Matt Woodrow  <mattwoodrow@apple.com>
     2
     3        Inherit track count from parent grid for subgridded axes and clamp item placement to that explicit grid.
     4        https://bugs.webkit.org/show_bug.cgi?id=236122
     5
     6        Reviewed by Dean Jackson.
     7
     8        Test changes to match latest spec, submitted upstream as https://github.com/web-platform-tests/wpt/pull/32629
     9
     10        * web-platform-tests/css/css-grid/subgrid/line-names-002-expected.html:
     11        * web-platform-tests/css/css-grid/subgrid/line-names-005-expected.html:
     12
    1132022-02-16  Said Abou-Hallawa  <said@apple.com>
    214

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-grid/subgrid/line-names-002-expected.html

    r262056 r289986  
    1515.grid {
    1616  display: grid;
    17   grid: auto / [a] 50px 50px [a] 50px 50px [a];
     17  grid: auto / [a] 50px 40px [a] 10px 50px [a];
    1818  padding: 20px 10px;
    1919}
    … …  
    3333<div class="grid">
    3434  <div class="subgrid">
    35     <x style="grid-column: 1 / 3"></x>
     35    <x style="grid-column: 3 / 4"></x>
    3636  </div>
    3737</div>

  • trunk/LayoutTests/imported/w3c/web-platform-tests/css/css-grid/subgrid/line-names-005-expected.html

    r262056 r289986  
    116116<i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i>
    117117  <div class="subgrid2">
    118     <x style="grid-column: span 4 / 11">x</x>
     118    <x style="grid-column: span 3 / 11">x</x>
    119119  </div>
    120120</div>
    … …  
    130130<i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i><i></i>
    131131  <div style="display:grid; grid:auto/subgrid; grid-column: span 10; grid-row:2">
    132     <x style="grid-column: 1 / 11">x</x>
     132    <x style="grid-column: 10 / 11">x</x>
    133133  </div>
    134134</div>

  • trunk/Source/WebCore/ChangeLog

    r289981 r289986  
     12022-02-16  Matt Woodrow  <mattwoodrow@apple.com>
     2
     3        Inherit track count from parent grid for subgridded axes and clamp item placement to that explicit grid.
     4        https://bugs.webkit.org/show_bug.cgi?id=236122
     5
     6        Reviewed by Dean Jackson.
     7
     8        Changes GridPositionsResolver::explicitGrid<>Count to return the number of tracks
     9        spanned in the parent grid, for axes that are a subgrid.
     10
     11        Updates adjustGridPositionsForStyle to use the number of lines specified in the
     12        subgrid property, for grid items that are also a subgrid and have an otherwise
     13        indefinite span.
     14
     15        Adds clamping support to Grid so that we can prevent subgrids from ever adding
     16        new implicit tracks.
     17
     18        * rendering/Grid.cpp:
     19        (WebCore::Grid::insert):
     20        (WebCore::Grid::setClampingForSubgrid):
     21        (WebCore::Grid::clampAndTranslateToImplicitGrid):
     22        (WebCore::Grid::setNeedsItemsPlacement):
     23        * rendering/Grid.h:
     24        * rendering/RenderGrid.cpp:
     25        (WebCore::RenderGrid::computeIntrinsicLogicalWidths const):
     26        (WebCore::RenderGrid::placeItemsOnGrid const):
     27        (WebCore::RenderGrid::populateExplicitGridAndOrderIterator const):
     28        (WebCore::RenderGrid::placeSpecifiedMajorAxisItemsOnGrid const):
     29        (WebCore::RenderGrid::isSubgrid const):
     30        (WebCore::RenderGrid::isSubgridRows const):
     31        (WebCore::RenderGrid::isSubgridColumns const):
     32        (WebCore::RenderGrid::gridAreaBreadthForOutOfFlowChild):
     33        (WebCore::RenderGrid::numTracks const):
     34        (WebCore::transposedDirection):
     35        (WebCore::RenderGrid::computeGridSpanForOutOfFlowChild const):
     36        (WebCore::RenderGrid::gridSpanForOutOfFlowChild const):
     37        (WebCore::RenderGrid::gridSpanForChild const):
     38        * rendering/RenderGrid.h:
     39        * rendering/style/GridArea.h:
     40        (WebCore::GridSpan::integerSpan const):
     41        (WebCore::GridSpan::translateTo):
     42        (WebCore::GridSpan::clamp):
     43        * rendering/style/GridPositionsResolver.cpp:
     44        (WebCore::isIndefiniteSpan):
     45        (WebCore::adjustGridPositionsFromStyle):
     46        (WebCore::GridPositionsResolver::explicitGridColumnCount):
     47        (WebCore::GridPositionsResolver::explicitGridRowCount):
     48        (WebCore::explicitGridSizeForSide):
     49        (WebCore::resolveNamedGridLinePositionFromStyle):
     50        (WebCore::resolveNamedGridLinePositionAgainstOppositePosition):
     51        (WebCore::resolveGridPositionAgainstOppositePosition):
     52        (WebCore::resolveGridPositionFromStyle):
     53        (WebCore::GridPositionsResolver::resolveGridPositionsFromStyle):
     54        * rendering/style/GridPositionsResolver.h:
     55
    1562022-02-16  Said Abou-Hallawa  <said@apple.com>
    257

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

    r284093 r289986  
    6262}
    6363
    64 void Grid::insert(RenderBox& child, const GridArea& area)
    65 {
    66     ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefinite());
    67     ensureGridSize(area.rows.endLine(), area.columns.endLine());
    68 
    69     for (auto row : area.rows) {
    70         for (auto column : area.columns)
     64GridArea Grid::insert(RenderBox& child, const GridArea& area)
     65{
     66    GridArea clampedArea = area;
     67    if (m_maxRows)
     68        clampedArea.rows.clamp(m_maxRows);
     69    if (m_maxColumns)
     70        clampedArea.columns.clamp(m_maxColumns);
     71
     72    ASSERT(clampedArea.rows.isTranslatedDefinite() && clampedArea.columns.isTranslatedDefinite());
     73    ensureGridSize(clampedArea.rows.endLine(), clampedArea.columns.endLine());
     74
     75    for (auto row : clampedArea.rows) {
     76        for (auto column : clampedArea.columns)
    7177            m_grid[row][column].append(child);
    7278    }
    7379
    74     setGridItemArea(child, area);
     80    setGridItemArea(child, clampedArea);
     81    return clampedArea;
    7582}
    7683
    … …  
    8491{
    8592    return direction == ForRows ? m_explicitRowStart : m_explicitColumnStart;
     93}
     94
     95void Grid::setClampingForSubgrid(unsigned maxRows, unsigned maxColumns)
     96{
     97    m_maxRows = maxRows;
     98    m_maxColumns = maxColumns;
     99}
     100
     101void Grid::clampAreaToSubgridIfNeeded(GridArea& area)
     102{
     103    if (!area.rows.isIndefinite()) {
     104        if (m_maxRows)
     105            area.rows.clamp(m_maxRows);
     106    }
     107    if (!area.columns.isIndefinite()) {
     108        if (m_maxColumns)
     109            area.columns.clamp(m_maxColumns);
     110    }
    86111}
    87112
    … …  
    162187    m_autoRepeatColumns = 0;
    163188    m_autoRepeatRows = 0;
     189    m_maxColumns = 0;
     190    m_maxRows = 0;
    164191}
    165192

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

    r270293 r289986  
    4949
    5050    void ensureGridSize(unsigned maximumRowSize, unsigned maximumColumnSize);
    51     void insert(RenderBox&, const GridArea&);
     51    GridArea insert(RenderBox&, const GridArea&);
    5252
    5353    // Note that each in flow child of a grid container becomes a grid item. This means that
    … …  
    6767    unsigned autoRepeatTracks(GridTrackSizingDirection) const;
    6868    void setAutoRepeatTracks(unsigned autoRepeatRows, unsigned autoRepeatColumns);
     69
     70    void setClampingForSubgrid(unsigned maxRows, unsigned maxColumns);
     71
     72    void clampAreaToSubgridIfNeeded(GridArea&);
    6973
    7074    void setAutoRepeatEmptyColumns(std::unique_ptr<OrderedTrackIndexSet>);
    … …  
    9296    unsigned m_autoRepeatColumns { 0 };
    9397    unsigned m_autoRepeatRows { 0 };
     98
     99    unsigned m_maxColumns { 0 };
     100    unsigned m_maxRows { 0 };
    94101
    95102    bool m_needsItemsPlacement { true };

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

    r285987 r289986  
    103103}
    104104
     105bool isFlippedDirection(const RenderGrid& grid, GridTrackSizingDirection direction)
     106{
     107    if (direction == ForColumns)
     108        return !grid.style().isLeftToRightDirection();
     109    return grid.style().isFlippedBlocksWritingMode();
     110}
     111
     112bool isSubgridReversedDirection(const RenderGrid& grid, GridTrackSizingDirection outerDirection, const RenderGrid& subgrid)
     113{
     114    GridTrackSizingDirection childDirection = flowAwareDirectionForChild(grid, subgrid, outerDirection);
     115    ASSERT(subgrid.isSubgrid(childDirection));
     116    return isFlippedDirection(grid, outerDirection) != isFlippedDirection(subgrid, childDirection);
     117}
     118
    105119} // namespace GridLayoutFunctions
    106120

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

    r285497 r289986  
    4646std::optional<LayoutUnit> overridingContainingBlockContentSizeForChild(const RenderBox&, GridTrackSizingDirection);
    4747
     48bool isFlippedDirection(const RenderGrid&, GridTrackSizingDirection);
     49bool isSubgridReversedDirection(const RenderGrid&, GridTrackSizingDirection outerDirection, const RenderGrid& subgrid);
     50
    4851}
    4952

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

    r289437 r289986  
    447447    bool hadExcludedChildren = computePreferredWidthsForExcludedChildren(childMinWidth, childMaxWidth);
    448448
    449     Grid grid(const_cast<RenderGrid&>(*this));
    450     GridTrackSizingAlgorithm algorithm(this, grid);
     449    GridTrackSizingAlgorithm algorithm(this, const_cast<Grid&>(m_grid));
    451450    placeItemsOnGrid(algorithm, std::nullopt);
    452451
    … …  
    642641    unsigned autoRepeatColumns = computeAutoRepeatTracksCount(ForColumns, availableLogicalWidth);
    643642    unsigned autoRepeatRows = computeAutoRepeatTracksCount(ForRows, availableLogicalHeightForPercentageComputation());
    644 
    645643    autoRepeatRows = clampAutoRepeatTracks(ForRows, autoRepeatRows);
    646644    autoRepeatColumns = clampAutoRepeatTracks(ForColumns, autoRepeatColumns);
    … …  
    671669
    672670        GridArea area = grid.gridItemArea(*child);
     671        grid.clampAreaToSubgridIfNeeded(area);
    673672        if (!area.rows.isIndefinite())
    674673            area.rows.translate(grid.explicitGridStart(ForRows));
    … …  
    691690#if ASSERT_ENABLED
    692691    if (grid.hasGridItems()) {
    693         ASSERT(grid.numTracks(ForRows) >= GridPositionsResolver::explicitGridRowCount(style(), grid.autoRepeatTracks(ForRows)));
    694         ASSERT(grid.numTracks(ForColumns) >= GridPositionsResolver::explicitGridColumnCount(style(), grid.autoRepeatTracks(ForColumns)));
     692        ASSERT(grid.numTracks(ForRows) >= GridPositionsResolver::explicitGridRowCount(*this));
     693        ASSERT(grid.numTracks(ForColumns) >= GridPositionsResolver::explicitGridColumnCount(*this));
    695694    }
    696695#endif
    … …  
    746745    unsigned explicitRowStart = 0;
    747746    unsigned explicitColumnStart = 0;
    748     unsigned autoRepeatRows = grid.autoRepeatTracks(ForRows);
    749     unsigned autoRepeatColumns = grid.autoRepeatTracks(ForColumns);
    750     unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(style(), autoRepeatRows);
    751     unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(style(), autoRepeatColumns);
     747    unsigned maximumRowIndex = GridPositionsResolver::explicitGridRowCount(*this);
     748    unsigned maximumColumnIndex = GridPositionsResolver::explicitGridColumnCount(*this);
    752749
    753750    for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBox()) {
    … …  
    755752            continue;
    756753       
    757         GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForRows, autoRepeatRows);
    758         if (!rowPositions.isIndefinite()) {
    759             explicitRowStart = std::max<int>(explicitRowStart, -rowPositions.untranslatedStartLine());
    760             maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
    761         } else {
    762             // Grow the grid for items with a definite row span, getting the largest such span.
    763             unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*child, ForRows);
    764             maximumRowIndex = std::max(maximumRowIndex, spanSize);
    765         }
    766 
    767         GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(style(), *child, ForColumns, autoRepeatColumns);
    768         if (!columnPositions.isIndefinite()) {
    769             explicitColumnStart = std::max<int>(explicitColumnStart, -columnPositions.untranslatedStartLine());
    770             maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
    771         } else {
    772             // Grow the grid for items with a definite column span, getting the largest such span.
    773             unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*child, ForColumns);
    774             maximumColumnIndex = std::max(maximumColumnIndex, spanSize);
     754        GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromStyle(*child, ForRows);
     755        if (!isSubgridRows()) {
     756            if (!rowPositions.isIndefinite()) {
     757                explicitRowStart = std::max<int>(explicitRowStart, -rowPositions.untranslatedStartLine());
     758                maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untranslatedEndLine());
     759            } else {
     760                // Grow the grid for items with a definite row span, getting the largest such span.
     761                unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*child, ForRows);
     762                maximumRowIndex = std::max(maximumRowIndex, spanSize);
     763            }
     764        }
     765
     766        GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFromStyle(*child, ForColumns);
     767        if (!isSubgridColumns()) {
     768            if (!columnPositions.isIndefinite()) {
     769                explicitColumnStart = std::max<int>(explicitColumnStart, -columnPositions.untranslatedStartLine());
     770                maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositions.untranslatedEndLine());
     771            } else {
     772                // Grow the grid for items with a definite column span, getting the largest such span.
     773                unsigned spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*child, ForColumns);
     774                maximumColumnIndex = std::max(maximumColumnIndex, spanSize);
     775            }
    775776        }
    776777
    … …  
    780781    grid.setExplicitGridStart(explicitRowStart, explicitColumnStart);
    781782    grid.ensureGridSize(maximumRowIndex + explicitRowStart, maximumColumnIndex + explicitColumnStart);
     783    grid.setClampingForSubgrid(isSubgridRows() ? maximumRowIndex : 0, isSubgridColumns() ? maximumColumnIndex : 0);
    782784}
    783785
    … …  
    813815            emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(grid, *autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions);
    814816
    815         grid.insert(*autoGridItem, *emptyGridArea);
     817        *emptyGridArea = grid.insert(*autoGridItem, *emptyGridArea);
    816818
    817819        if (!isGridAutoFlowDense)
    … …  
    16111613}
    16121614
     1615bool RenderGrid::isSubgrid(GridTrackSizingDirection direction) const
     1616{
     1617    if (isOutOfFlowPositioned() || isExcludedFromNormalLayout())
     1618        return false;
     1619    if ((direction == ForColumns) ? !style().gridSubgridColumns() : !style().gridSubgridRows())
     1620        return false;
     1621    return is<RenderGrid>(parent());
     1622}
     1623
    16131624LayoutUnit RenderGrid::gridAreaBreadthForOutOfFlowChild(const RenderBox& child, GridTrackSizingDirection direction)
    16141625{
    16151626    ASSERT(child.isOutOfFlowPositioned());
    16161627    bool isRowAxis = direction == ForColumns;
    1617     GridSpan span = GridPositionsResolver::resolveGridPositionsFromStyle(style(), child, direction, autoRepeatCountForDirection(direction));
    1618     if (span.isIndefinite())
     1628    int lastLine = numTracks(direction, m_grid);
     1629
     1630    int startLine, endLine;
     1631    bool startIsAuto, endIsAuto;
     1632    if (!computeGridPositionsForOutOfFlowChild(child, direction, startLine, startIsAuto, endLine, endIsAuto))
    16191633        return isRowAxis ? clientLogicalWidth() : clientLogicalHeight();
    1620 
    1621     unsigned explicitStart = m_grid.explicitGridStart(direction);
    1622     int startLine = span.untranslatedStartLine() + explicitStart;
    1623     int endLine = span.untranslatedEndLine() + explicitStart;
    1624     int lastLine = numTracks(direction, m_grid);
    1625     GridPosition startPosition = direction == ForColumns ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
    1626     GridPosition endPosition = direction == ForColumns ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
    1627 
    1628     bool startIsAuto = startPosition.isAuto() || startLine < 0 || startLine > lastLine;
    1629     bool endIsAuto = endPosition.isAuto() || endLine < 0 || endLine > lastLine;
    16301634
    16311635    if (startIsAuto && endIsAuto)
    … …  
    19211925
    19221926    // FIXME: This still requires knowledge about m_grid internals.
    1923     return grid.numTracks(ForRows) ? grid.numTracks(ForColumns) : GridPositionsResolver::explicitGridColumnCount(style(), grid.autoRepeatTracks(ForColumns));
     1927    return grid.numTracks(ForRows) ? grid.numTracks(ForColumns) : GridPositionsResolver::explicitGridColumnCount(*this);
    19241928}
    19251929
    … …  
    19781982}
    19791983
     1984bool RenderGrid::computeGridPositionsForOutOfFlowChild(const RenderBox& child, GridTrackSizingDirection direction, int& startLine, bool& startIsAuto, int& endLine, bool& endIsAuto) const
     1985{
     1986    ASSERT(child.isOutOfFlowPositioned());
     1987    int lastLine = numTracks(direction, m_grid);
     1988    GridSpan span = GridPositionsResolver::resolveGridPositionsFromStyle(child, direction);
     1989    if (span.isIndefinite())
     1990        return false;
     1991
     1992    unsigned explicitStart = m_grid.explicitGridStart(direction);
     1993    startLine = span.untranslatedStartLine() + explicitStart;
     1994    endLine = span.untranslatedEndLine() + explicitStart;
     1995
     1996    GridPosition startPosition = direction == ForColumns ? child.style().gridItemColumnStart() : child.style().gridItemRowStart();
     1997    GridPosition endPosition = direction == ForColumns ? child.style().gridItemColumnEnd() : child.style().gridItemRowEnd();
     1998
     1999    startIsAuto = startPosition.isAuto() || startLine < 0 || startLine > lastLine;
     2000    endIsAuto = endPosition.isAuto() || endLine < 0 || endLine > lastLine;
     2001    return true;
     2002}
     2003
     2004GridSpan RenderGrid::gridSpanForOutOfFlowChild(const RenderBox& child, GridTrackSizingDirection direction) const
     2005{
     2006    int lastLine = numTracks(direction, m_grid);
     2007    int startLine, endLine;
     2008    bool startIsAuto, endIsAuto;
     2009    if (!computeGridPositionsForOutOfFlowChild(child, direction, startLine, startIsAuto, endLine, endIsAuto))
     2010        return GridSpan::translatedDefiniteGridSpan(0, lastLine);
     2011    return GridSpan::translatedDefiniteGridSpan(startIsAuto ? 0 : startLine, endIsAuto ? lastLine : endLine);
     2012}
     2013
     2014GridSpan RenderGrid::gridSpanForChild(const RenderBox& child, GridTrackSizingDirection direction) const
     2015{
     2016    ASSERT(is<RenderGrid>(child.parent()));
     2017
     2018    RenderGrid* renderGrid = downcast<RenderGrid>(child.parent());
     2019    // |direction| is specified relative to this grid, switch it if |child|'s direct parent grid
     2020    // is using a different writing mode.
     2021    direction = GridLayoutFunctions::flowAwareDirectionForChild(*this, *renderGrid, direction);
     2022    GridSpan span = child.isOutOfFlowPositioned() ? renderGrid->gridSpanForOutOfFlowChild(child, direction) : renderGrid->currentGrid().gridItemSpan(child, direction);
     2023
     2024    while (renderGrid != this) {
     2025        ASSERT(is<RenderGrid>(renderGrid->parent()));
     2026        RenderGrid* parent = downcast<RenderGrid>(renderGrid->parent());
     2027
     2028        bool isSubgrid = renderGrid->isSubgrid(direction);
     2029
     2030        direction = GridLayoutFunctions::flowAwareDirectionForChild(*parent, *renderGrid, direction);
     2031
     2032        GridSpan parentSpan = renderGrid->isOutOfFlowPositioned() ? parent->gridSpanForOutOfFlowChild(*renderGrid, direction) :  parent->currentGrid().gridItemSpan(*renderGrid, direction);
     2033        if (isSubgrid)
     2034            span.translateTo(parentSpan, GridLayoutFunctions::isSubgridReversedDirection(*parent, direction, *renderGrid));
     2035        else
     2036            span = parentSpan;
     2037        renderGrid = parent;
     2038    }
     2039    return span;
     2040}
     2041
    19802042} // namespace WebCore

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

    r289437 r289986  
    8383    StyleContentAlignmentData contentAlignment(GridTrackSizingDirection) const;
    8484
     85    // Computes the span relative to this RenderGrid, even if the RenderBox is a child
     86    // of a descendant subgrid.
     87    GridSpan gridSpanForChild(const RenderBox&, GridTrackSizingDirection) const;
     88
     89    bool isSubgrid(GridTrackSizingDirection) const;
     90    bool isSubgridRows() const
     91    {
     92        return isSubgrid(ForRows);
     93    }
     94    bool isSubgridColumns() const
     95    {
     96        return isSubgrid(ForColumns);
     97    }
     98
     99    const Grid& currentGrid() const
     100    {
     101        return m_grid;
     102    }
     103
    85104private:
    86105    ItemPosition selfAlignmentNormalBehavior(const RenderBox* child = nullptr) const override
    … …  
    151170    void setLogicalOffsetForChild(RenderBox&, GridTrackSizingDirection) const;
    152171    LayoutUnit logicalOffsetForChild(const RenderBox&, GridTrackSizingDirection) const;
    153     GridArea cachedGridArea(const RenderBox&) const;
    154     GridSpan cachedGridSpan(const RenderBox&, GridTrackSizingDirection) const;
    155172
    156173    LayoutUnit gridAreaBreadthForChildIncludingAlignmentOffsets(const RenderBox&, GridTrackSizingDirection) const;
    … …  
    194211    Vector<RenderBox*> computeAspectRatioDependentAndBaselineItems();
    195212
     213    GridSpan gridSpanForOutOfFlowChild(const RenderBox&, GridTrackSizingDirection) const;
     214    bool computeGridPositionsForOutOfFlowChild(const RenderBox&, GridTrackSizingDirection, int&, bool&, int&, bool&) const;
     215
    196216    Grid m_grid;
    197217

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

    r254087 r289986  
    6666    unsigned integerSpan() const
    6767    {
    68         ASSERT(isTranslatedDefinite());
     68        ASSERT(!isIndefinite());
    6969        return m_endLine - m_startLine;
    7070    }
    … …  
    140140        ASSERT(m_startLine >= 0);
    141141        ASSERT(m_endLine > 0);
     142    }
     143
     144    // Moves this span to be in the same coordinate space as |parent|.
     145    // If reverse is specified, then swaps the direction to handle RTL/LTR changes.
     146    void translateTo(const GridSpan& parent, bool reverse)
     147    {
     148        ASSERT(m_type == TranslatedDefinite);
     149        ASSERT(parent.m_type == TranslatedDefinite);
     150        if (reverse) {
     151            int start = m_startLine;
     152            m_startLine = parent.endLine() - m_endLine;
     153            m_endLine = parent.endLine() - start;
     154        } else {
     155            m_startLine += parent.m_startLine;
     156            m_endLine += parent.m_startLine;
     157        }
     158    }
     159
     160    void clamp(int max)
     161    {
     162        ASSERT(m_type != Indefinite);
     163        m_startLine = std::max(m_startLine, 0);
     164        m_endLine = std::max(std::min(m_endLine, max), 1);
     165        if (m_startLine >= m_endLine)
     166            m_startLine = m_endLine - 1;
    142167    }
    143168

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

    r262262 r289986  
    3434#include "GridArea.h"
    3535#include "RenderBox.h"
     36#include "RenderGrid.h"
    3637#include <cstdlib>
    3738
    … …  
    153154}
    154155
     156// https://drafts.csswg.org/css-grid-2/#indefinite-grid-span
     157static bool isIndefiniteSpan(GridPosition& initialPosition, GridPosition& finalPosition)
     158{
     159    if (initialPosition.isAuto())
     160        return !finalPosition.isSpan();
     161    if (finalPosition.isAuto())
     162        return !initialPosition.isSpan();
     163    return false;
     164}
     165
    155166static void adjustGridPositionsFromStyle(const RenderBox& gridItem, GridTrackSizingDirection direction, GridPosition& initialPosition, GridPosition& finalPosition)
    156167{
    … …  
    169180    if (finalPosition.isAuto() && initialPosition.isSpan() && !initialPosition.namedGridLine().isNull())
    170181        initialPosition.setSpanPosition(1, String());
    171 }
    172 
    173 unsigned GridPositionsResolver::explicitGridColumnCount(const RenderStyle& gridContainerStyle, unsigned autoRepeatTracksCount)
    174 {
    175     return std::min<unsigned>(std::max(gridContainerStyle.gridColumns().size() + autoRepeatTracksCount, gridContainerStyle.namedGridAreaColumnCount()), GridPosition::max());
    176 }
    177 
    178 unsigned GridPositionsResolver::explicitGridRowCount(const RenderStyle& gridContainerStyle, unsigned autoRepeatTracksCount)
    179 {
    180     return std::min<unsigned>(std::max(gridContainerStyle.gridRows().size() + autoRepeatTracksCount, gridContainerStyle.namedGridAreaRowCount()), GridPosition::max());
    181 }
    182 
    183 static unsigned explicitGridSizeForSide(const RenderStyle& gridContainerStyle, GridPositionSide side, unsigned autoRepeatTracksCount)
    184 {
    185     return isColumnSide(side) ? GridPositionsResolver::explicitGridColumnCount(gridContainerStyle, autoRepeatTracksCount) : GridPositionsResolver::explicitGridRowCount(gridContainerStyle, autoRepeatTracksCount);
     182
     183    if (isIndefiniteSpan(initialPosition, finalPosition) && is<RenderGrid>(gridItem) && downcast<RenderGrid>(gridItem).isSubgrid(direction)) {
     184        // Indefinite span for an item that is subgridded in this axis.
     185        int lineCount = (isForColumns ? gridItem.style().orderedNamedGridColumnLines() : gridItem.style().orderedNamedGridRowLines()).size();
     186
     187        if (initialPosition.isAuto()) {
     188            // Set initial position to span <line names - 1>
     189            initialPosition.setSpanPosition(std::max(1, lineCount - 1), "");
     190        } else {
     191            // Set final position to span <line names - 1>
     192            finalPosition.setSpanPosition(std::max(1, lineCount - 1), "");
     193        }
     194    }
     195}
     196
     197unsigned GridPositionsResolver::explicitGridColumnCount(const RenderGrid& gridContainer)
     198{
     199    if (gridContainer.isSubgridColumns()) {
     200        const RenderGrid& parent = *downcast<RenderGrid>(gridContainer.parent());
     201        GridTrackSizingDirection direction = GridLayoutFunctions::flowAwareDirectionForChild(parent, gridContainer, ForColumns);
     202        return parent.gridSpanForChild(gridContainer, direction).integerSpan();
     203    }
     204    return std::min<unsigned>(std::max(gridContainer.style().gridColumns().size() + gridContainer.autoRepeatCountForDirection(ForColumns), gridContainer.style().namedGridAreaColumnCount()), GridPosition::max());
     205}
     206
     207unsigned GridPositionsResolver::explicitGridRowCount(const RenderGrid& gridContainer)
     208{
     209    if (gridContainer.isSubgridRows()) {
     210        const RenderGrid& parent = *downcast<RenderGrid>(gridContainer.parent());
     211        GridTrackSizingDirection direction = GridLayoutFunctions::flowAwareDirectionForChild(parent, gridContainer, ForRows);
     212        return parent.gridSpanForChild(gridContainer, direction).integerSpan();
     213    }
     214    return std::min<unsigned>(std::max(gridContainer.style().gridRows().size() + gridContainer.autoRepeatCountForDirection(ForRows), gridContainer.style().namedGridAreaRowCount()), GridPosition::max());
     215}
     216
     217static unsigned explicitGridSizeForSide(const RenderGrid& gridContainer, GridPositionSide side)
     218{
     219    return isColumnSide(side) ? GridPositionsResolver::explicitGridColumnCount(gridContainer) : GridPositionsResolver::explicitGridRowCount(gridContainer);
    186220}
    187221
    … …  
    225259}
    226260
    227 static int resolveNamedGridLinePositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side, unsigned autoRepeatTracksCount)
     261static int resolveNamedGridLinePositionFromStyle(const RenderGrid& gridContainer, const GridPosition& position, GridPositionSide side)
    228262{
    229263    ASSERT(!position.namedGridLine().isNull());
    230264
    231     unsigned lastLine = explicitGridSizeForSide(gridContainerStyle, side, autoRepeatTracksCount);
    232     NamedLineCollection linesCollection(gridContainerStyle, position.namedGridLine(), directionFromSide(side), lastLine, autoRepeatTracksCount);
     265    unsigned lastLine = explicitGridSizeForSide(gridContainer, side);
     266    NamedLineCollection linesCollection(gridContainer.style(), position.namedGridLine(), directionFromSide(side), lastLine, gridContainer.autoRepeatCountForDirection(directionFromSide(side)));
    233267
    234268    if (position.isPositive())
    … …  
    251285}
    252286
    253 static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side, unsigned autoRepeatTracksCount)
     287static GridSpan resolveNamedGridLinePositionAgainstOppositePosition(const RenderGrid& gridContainer, int oppositeLine, const GridPosition& position, GridPositionSide side)
    254288{
    255289    ASSERT(position.isSpan());
    … …  
    258292    ASSERT(position.spanPosition() > 0);
    259293
    260     unsigned lastLine = explicitGridSizeForSide(gridContainerStyle, side, autoRepeatTracksCount);
    261     NamedLineCollection linesCollection(gridContainerStyle, position.namedGridLine(), directionFromSide(side), lastLine, autoRepeatTracksCount);
     294    unsigned lastLine = explicitGridSizeForSide(gridContainer, side);
     295    NamedLineCollection linesCollection(gridContainer.style(), position.namedGridLine(), directionFromSide(side), lastLine, gridContainer.autoRepeatCountForDirection(directionFromSide(side)));
    262296    return definiteGridSpanWithNamedLineSpanAgainstOpposite(oppositeLine, position, side, lastLine, linesCollection);
    263297}
    264298
    265 static GridSpan resolveGridPositionAgainstOppositePosition(const RenderStyle& gridContainerStyle, int oppositeLine, const GridPosition& position, GridPositionSide side, unsigned autoRepeatTracksCount)
     299static GridSpan resolveGridPositionAgainstOppositePosition(const RenderGrid& gridContainer, int oppositeLine, const GridPosition& position, GridPositionSide side)
    266300{
    267301    if (position.isAuto()) {
    … …  
    276310    if (!position.namedGridLine().isNull()) {
    277311        // span 2 'c' -> we need to find the appropriate grid line before / after our opposite position.
    278         return resolveNamedGridLinePositionAgainstOppositePosition(gridContainerStyle, oppositeLine, position, side, autoRepeatTracksCount);
     312        return resolveNamedGridLinePositionAgainstOppositePosition(gridContainer, oppositeLine, position, side);
    279313    }
    280314
    … …  
    316350}
    317351
    318 static int resolveGridPositionFromStyle(const RenderStyle& gridContainerStyle, const GridPosition& position, GridPositionSide side, unsigned autoRepeatTracksCount)
     352static int resolveGridPositionFromStyle(const RenderGrid& gridContainer, const GridPosition& position, GridPositionSide side)
    319353{
    320354    switch (position.type()) {
    … …  
    323357
    324358        if (!position.namedGridLine().isNull())
    325             return resolveNamedGridLinePositionFromStyle(gridContainerStyle, position, side, autoRepeatTracksCount);
     359            return resolveNamedGridLinePositionFromStyle(gridContainer, position, side);
    326360
    327361        // Handle <integer> explicit position.
    … …  
    330364
    331365        unsigned resolvedPosition = std::abs(position.integerPosition()) - 1;
    332         const unsigned endOfTrack = explicitGridSizeForSide(gridContainerStyle, side, autoRepeatTracksCount);
     366        const unsigned endOfTrack = explicitGridSizeForSide(gridContainer, side);
    333367
    334368        return endOfTrack - resolvedPosition;
    … …  
    342376        ASSERT(!position.namedGridLine().isNull());
    343377
    344         unsigned lastLine = explicitGridSizeForSide(gridContainerStyle, side, autoRepeatTracksCount);
    345         NamedLineCollection implicitLines(gridContainerStyle, implicitNamedGridLineForSide(namedGridLine, side), directionFromSide(side), lastLine, autoRepeatTracksCount);
     378        unsigned lastLine = explicitGridSizeForSide(gridContainer, side);
     379        NamedLineCollection implicitLines(gridContainer.style(), implicitNamedGridLineForSide(namedGridLine, side), directionFromSide(side), lastLine, gridContainer.autoRepeatCountForDirection(directionFromSide(side)));
    346380        if (implicitLines.hasNamedLines())
    347381            return implicitLines.firstPosition();
    … …  
    349383        // Otherwise, if there is a named line with the specified name, contributes the first such line to the grid
    350384        // item's placement.
    351         NamedLineCollection explicitLines(gridContainerStyle, namedGridLine, directionFromSide(side), lastLine, autoRepeatTracksCount);
     385        NamedLineCollection explicitLines(gridContainer.style(), namedGridLine, directionFromSide(side), lastLine, gridContainer.autoRepeatCountForDirection(directionFromSide(side)));
    352386        if (explicitLines.hasNamedLines())
    353387            return explicitLines.firstPosition();
    … …  
    366400}
    367401
    368 GridSpan GridPositionsResolver::resolveGridPositionsFromStyle(const RenderStyle& gridContainerStyle, const RenderBox& gridItem, GridTrackSizingDirection direction, unsigned autoRepeatTracksCount)
    369 {
     402GridSpan GridPositionsResolver::resolveGridPositionsFromStyle(const RenderBox& gridItem, GridTrackSizingDirection direction)
     403{
     404    auto* gridContainer = downcast<RenderGrid>(gridItem.containingBlock());
     405    ASSERT(gridContainer);
     406
    370407    GridPosition initialPosition, finalPosition;
    371408    adjustGridPositionsFromStyle(gridItem, direction, initialPosition, finalPosition);
    … …  
    380417    if (initialPosition.shouldBeResolvedAgainstOppositePosition()) {
    381418        // Infer the position from the final position ('auto / 1' or 'span 2 / 3' case).
    382         auto endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide, autoRepeatTracksCount);
    383         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, endLine, initialPosition, initialSide, autoRepeatTracksCount);
     419        auto endLine = resolveGridPositionFromStyle(*gridContainer, finalPosition, finalSide);
     420        return resolveGridPositionAgainstOppositePosition(*gridContainer, endLine, initialPosition, initialSide);
    384421    }
    385422
    386423    if (finalPosition.shouldBeResolvedAgainstOppositePosition()) {
    387424        // Infer our position from the initial position ('1 / auto' or '3 / span 2' case).
    388         auto startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide, autoRepeatTracksCount);
    389         return resolveGridPositionAgainstOppositePosition(gridContainerStyle, startLine, finalPosition, finalSide, autoRepeatTracksCount);
    390     }
    391 
    392     int startLine = resolveGridPositionFromStyle(gridContainerStyle, initialPosition, initialSide, autoRepeatTracksCount);
    393     int endLine = resolveGridPositionFromStyle(gridContainerStyle, finalPosition, finalSide, autoRepeatTracksCount);
     425        auto startLine = resolveGridPositionFromStyle(*gridContainer, initialPosition, initialSide);
     426        return resolveGridPositionAgainstOppositePosition(*gridContainer, startLine, finalPosition, finalSide);
     427    }
     428
     429    int startLine = resolveGridPositionFromStyle(*gridContainer, initialPosition, initialSide);
     430    int endLine = resolveGridPositionFromStyle(*gridContainer, finalPosition, finalSide);
    394431
    395432    if (startLine > endLine)

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

    r262262 r289986  
    3737class GridSpan;
    3838class RenderBox;
     39class RenderGrid;
    3940class RenderStyle;
    4041
    … …  
    7475    static GridPositionSide finalPositionSide(GridTrackSizingDirection);
    7576    static unsigned spanSizeForAutoPlacedItem(const RenderBox&, GridTrackSizingDirection);
    76     static GridSpan resolveGridPositionsFromStyle(const RenderStyle&, const RenderBox&, GridTrackSizingDirection, unsigned autoRepeatTracksCount);
    77     static unsigned explicitGridColumnCount(const RenderStyle&, unsigned autoRepeatColumnsCount);
    78     static unsigned explicitGridRowCount(const RenderStyle&, unsigned autoRepeatRowsCount);
     77    static GridSpan resolveGridPositionsFromStyle(const RenderBox&, GridTrackSizingDirection);
     78    static unsigned explicitGridColumnCount(const RenderGrid&);
     79    static unsigned explicitGridRowCount(const RenderGrid&);
    7980};
    8081
Note: See TracChangeset for help on using the changeset viewer.