OLD | NEW |
1 /* | 1 /* |
2 * Copyright (C) 2011 Apple Inc. All rights reserved. | 2 * Copyright (C) 2011 Apple Inc. All rights reserved. |
3 * | 3 * |
4 * Redistribution and use in source and binary forms, with or without | 4 * Redistribution and use in source and binary forms, with or without |
5 * modification, are permitted provided that the following conditions | 5 * modification, are permitted provided that the following conditions |
6 * are met: | 6 * are met: |
7 * 1. Redistributions of source code must retain the above copyright | 7 * 1. Redistributions of source code must retain the above copyright |
8 * notice, this list of conditions and the following disclaimer. | 8 * notice, this list of conditions and the following disclaimer. |
9 * 2. Redistributions in binary form must reproduce the above copyright | 9 * 2. Redistributions in binary form must reproduce the above copyright |
10 * notice, this list of conditions and the following disclaimer in the | 10 * notice, this list of conditions and the following disclaimer in the |
(...skipping 12 matching lines...) Expand all Loading... |
23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | 23 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
24 */ | 24 */ |
25 | 25 |
26 #include "core/layout/LayoutGrid.h" | 26 #include "core/layout/LayoutGrid.h" |
27 | 27 |
28 #include "core/layout/LayoutView.h" | 28 #include "core/layout/LayoutView.h" |
29 #include "core/layout/TextAutosizer.h" | 29 #include "core/layout/TextAutosizer.h" |
30 #include "core/paint/GridPainter.h" | 30 #include "core/paint/GridPainter.h" |
31 #include "core/paint/PaintLayer.h" | 31 #include "core/paint/PaintLayer.h" |
32 #include "core/style/ComputedStyle.h" | 32 #include "core/style/ComputedStyle.h" |
33 #include "core/style/GridCoordinate.h" | 33 #include "core/style/GridArea.h" |
34 #include "platform/LengthFunctions.h" | 34 #include "platform/LengthFunctions.h" |
35 #include <algorithm> | 35 #include <algorithm> |
36 | 36 |
37 namespace blink { | 37 namespace blink { |
38 | 38 |
39 static const int infinity = -1; | 39 static const int infinity = -1; |
40 | 40 |
41 class GridItemWithSpan; | 41 class GridItemWithSpan; |
42 | 42 |
43 class GridTrack { | 43 class GridTrack { |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
190 for (size_t column = m_columnIndex; column < maxColumns; ++column) { | 190 for (size_t column = m_columnIndex; column < maxColumns; ++column) { |
191 const GridCell& children = m_grid[row][column]; | 191 const GridCell& children = m_grid[row][column]; |
192 if (!children.isEmpty()) | 192 if (!children.isEmpty()) |
193 return false; | 193 return false; |
194 } | 194 } |
195 } | 195 } |
196 | 196 |
197 return true; | 197 return true; |
198 } | 198 } |
199 | 199 |
200 PassOwnPtr<GridCoordinate> nextEmptyGridArea(size_t fixedTrackSpan, size_t v
aryingTrackSpan) | 200 PassOwnPtr<GridArea> nextEmptyGridArea(size_t fixedTrackSpan, size_t varying
TrackSpan) |
201 { | 201 { |
202 ASSERT(!m_grid.isEmpty()); | 202 ASSERT(!m_grid.isEmpty()); |
203 ASSERT(fixedTrackSpan >= 1 && varyingTrackSpan >= 1); | 203 ASSERT(fixedTrackSpan >= 1 && varyingTrackSpan >= 1); |
204 | 204 |
205 size_t rowSpan = (m_direction == ForColumns) ? varyingTrackSpan : fixedT
rackSpan; | 205 size_t rowSpan = (m_direction == ForColumns) ? varyingTrackSpan : fixedT
rackSpan; |
206 size_t columnSpan = (m_direction == ForColumns) ? fixedTrackSpan : varyi
ngTrackSpan; | 206 size_t columnSpan = (m_direction == ForColumns) ? fixedTrackSpan : varyi
ngTrackSpan; |
207 | 207 |
208 size_t& varyingTrackIndex = (m_direction == ForColumns) ? m_rowIndex : m
_columnIndex; | 208 size_t& varyingTrackIndex = (m_direction == ForColumns) ? m_rowIndex : m
_columnIndex; |
209 const size_t endOfVaryingTrackIndex = (m_direction == ForColumns) ? m_gr
id.size() : m_grid[0].size(); | 209 const size_t endOfVaryingTrackIndex = (m_direction == ForColumns) ? m_gr
id.size() : m_grid[0].size(); |
210 for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex)
{ | 210 for (; varyingTrackIndex < endOfVaryingTrackIndex; ++varyingTrackIndex)
{ |
211 if (checkEmptyCells(rowSpan, columnSpan)) { | 211 if (checkEmptyCells(rowSpan, columnSpan)) { |
212 OwnPtr<GridCoordinate> result = adoptPtr(new GridCoordinate(Grid
Span::translatedDefiniteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::tr
anslatedDefiniteGridSpan(m_columnIndex, m_columnIndex + columnSpan))); | 212 OwnPtr<GridArea> result = adoptPtr(new GridArea(GridSpan::transl
atedDefiniteGridSpan(m_rowIndex, m_rowIndex + rowSpan), GridSpan::translatedDefi
niteGridSpan(m_columnIndex, m_columnIndex + columnSpan))); |
213 // Advance the iterator to avoid an infinite loop where we would
return the same grid area over and over. | 213 // Advance the iterator to avoid an infinite loop where we would
return the same grid area over and over. |
214 ++varyingTrackIndex; | 214 ++varyingTrackIndex; |
215 return result.release(); | 215 return result.release(); |
216 } | 216 } |
217 } | 217 } |
218 return nullptr; | 218 return nullptr; |
219 } | 219 } |
220 | 220 |
221 private: | 221 private: |
222 const GridRepresentation& m_grid; | 222 const GridRepresentation& m_grid; |
(...skipping 874 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1097 for (size_t row = oldRowSize; row < gridRowCount(); ++row) | 1097 for (size_t row = oldRowSize; row < gridRowCount(); ++row) |
1098 m_grid[row].grow(gridColumnCount()); | 1098 m_grid[row].grow(gridColumnCount()); |
1099 } | 1099 } |
1100 | 1100 |
1101 if (maximumColumnSize > gridColumnCount()) { | 1101 if (maximumColumnSize > gridColumnCount()) { |
1102 for (size_t row = 0; row < gridRowCount(); ++row) | 1102 for (size_t row = 0; row < gridRowCount(); ++row) |
1103 m_grid[row].grow(maximumColumnSize); | 1103 m_grid[row].grow(maximumColumnSize); |
1104 } | 1104 } |
1105 } | 1105 } |
1106 | 1106 |
1107 void LayoutGrid::insertItemIntoGrid(LayoutBox& child, const GridCoordinate& coor
dinate) | 1107 void LayoutGrid::insertItemIntoGrid(LayoutBox& child, const GridArea& area) |
1108 { | 1108 { |
1109 RELEASE_ASSERT(coordinate.rows.isTranslatedDefinite() && coordinate.columns.
isTranslatedDefinite()); | 1109 RELEASE_ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslated
Definite()); |
1110 ensureGridSize(coordinate.rows.resolvedFinalPosition(), coordinate.columns.r
esolvedFinalPosition()); | 1110 ensureGridSize(area.rows.resolvedFinalPosition(), area.columns.resolvedFinal
Position()); |
1111 | 1111 |
1112 for (const auto& row : coordinate.rows) { | 1112 for (const auto& row : area.rows) { |
1113 for (const auto& column: coordinate.columns) | 1113 for (const auto& column: area.columns) |
1114 m_grid[row][column].append(&child); | 1114 m_grid[row][column].append(&child); |
1115 } | 1115 } |
1116 } | 1116 } |
1117 | 1117 |
1118 void LayoutGrid::placeItemsOnGrid() | 1118 void LayoutGrid::placeItemsOnGrid() |
1119 { | 1119 { |
1120 if (!m_gridIsDirty) | 1120 if (!m_gridIsDirty) |
1121 return; | 1121 return; |
1122 | 1122 |
1123 ASSERT(m_gridItemCoordinate.isEmpty()); | 1123 ASSERT(m_gridItemArea.isEmpty()); |
1124 | 1124 |
1125 populateExplicitGridAndOrderIterator(); | 1125 populateExplicitGridAndOrderIterator(); |
1126 | 1126 |
1127 // We clear the dirty bit here as the grid sizes have been updated. | 1127 // We clear the dirty bit here as the grid sizes have been updated. |
1128 m_gridIsDirty = false; | 1128 m_gridIsDirty = false; |
1129 | 1129 |
1130 Vector<LayoutBox*> autoMajorAxisAutoGridItems; | 1130 Vector<LayoutBox*> autoMajorAxisAutoGridItems; |
1131 Vector<LayoutBox*> specifiedMajorAxisAutoGridItems; | 1131 Vector<LayoutBox*> specifiedMajorAxisAutoGridItems; |
1132 for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderItera
tor.next()) { | 1132 for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderItera
tor.next()) { |
1133 if (child->isOutOfFlowPositioned()) | 1133 if (child->isOutOfFlowPositioned()) |
1134 continue; | 1134 continue; |
1135 | 1135 |
1136 GridCoordinate coordinate = cachedGridCoordinate(*child); | 1136 GridArea area = cachedGridArea(*child); |
1137 if (!coordinate.rows.isIndefinite()) | 1137 if (!area.rows.isIndefinite()) |
1138 coordinate.rows.translate(abs(m_smallestRowStart)); | 1138 area.rows.translate(abs(m_smallestRowStart)); |
1139 if (!coordinate.columns.isIndefinite()) | 1139 if (!area.columns.isIndefinite()) |
1140 coordinate.columns.translate(abs(m_smallestColumnStart)); | 1140 area.columns.translate(abs(m_smallestColumnStart)); |
1141 m_gridItemCoordinate.set(child, coordinate); | 1141 m_gridItemArea.set(child, area); |
1142 | 1142 |
1143 if (coordinate.rows.isIndefinite() || coordinate.columns.isIndefinite())
{ | 1143 if (area.rows.isIndefinite() || area.columns.isIndefinite()) { |
1144 GridSpan majorAxisPositions = (autoPlacementMajorAxisDirection() ==
ForColumns) ? coordinate.columns : coordinate.rows; | 1144 GridSpan majorAxisPositions = (autoPlacementMajorAxisDirection() ==
ForColumns) ? area.columns : area.rows; |
1145 if (majorAxisPositions.isIndefinite()) | 1145 if (majorAxisPositions.isIndefinite()) |
1146 autoMajorAxisAutoGridItems.append(child); | 1146 autoMajorAxisAutoGridItems.append(child); |
1147 else | 1147 else |
1148 specifiedMajorAxisAutoGridItems.append(child); | 1148 specifiedMajorAxisAutoGridItems.append(child); |
1149 continue; | 1149 continue; |
1150 } | 1150 } |
1151 insertItemIntoGrid(*child, coordinate); | 1151 insertItemIntoGrid(*child, area); |
1152 } | 1152 } |
1153 | 1153 |
1154 ASSERT(gridRowCount() >= GridPositionsResolver::explicitGridRowCount(*style(
))); | 1154 ASSERT(gridRowCount() >= GridPositionsResolver::explicitGridRowCount(*style(
))); |
1155 ASSERT(gridColumnCount() >= GridPositionsResolver::explicitGridColumnCount(*
style())); | 1155 ASSERT(gridColumnCount() >= GridPositionsResolver::explicitGridColumnCount(*
style())); |
1156 | 1156 |
1157 placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems); | 1157 placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems); |
1158 placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems); | 1158 placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems); |
1159 | 1159 |
1160 m_grid.shrinkToFit(); | 1160 m_grid.shrinkToFit(); |
1161 | 1161 |
1162 #if ENABLE(ASSERT) | 1162 #if ENABLE(ASSERT) |
1163 for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderItera
tor.next()) { | 1163 for (LayoutBox* child = m_orderIterator.first(); child; child = m_orderItera
tor.next()) { |
1164 if (child->isOutOfFlowPositioned()) | 1164 if (child->isOutOfFlowPositioned()) |
1165 continue; | 1165 continue; |
1166 | 1166 |
1167 GridCoordinate coordinate = cachedGridCoordinate(*child); | 1167 GridArea area = cachedGridArea(*child); |
1168 ASSERT(coordinate.rows.isTranslatedDefinite() && coordinate.columns.isTr
anslatedDefinite()); | 1168 ASSERT(area.rows.isTranslatedDefinite() && area.columns.isTranslatedDefi
nite()); |
1169 } | 1169 } |
1170 #endif | 1170 #endif |
1171 } | 1171 } |
1172 | 1172 |
1173 void LayoutGrid::populateExplicitGridAndOrderIterator() | 1173 void LayoutGrid::populateExplicitGridAndOrderIterator() |
1174 { | 1174 { |
1175 OrderIteratorPopulator populator(m_orderIterator); | 1175 OrderIteratorPopulator populator(m_orderIterator); |
1176 | 1176 |
1177 m_smallestRowStart = m_smallestColumnStart = 0; | 1177 m_smallestRowStart = m_smallestColumnStart = 0; |
1178 | 1178 |
1179 size_t maximumRowIndex = std::max<size_t>(1, GridPositionsResolver::explicit
GridRowCount(*style())); | 1179 size_t maximumRowIndex = std::max<size_t>(1, GridPositionsResolver::explicit
GridRowCount(*style())); |
1180 size_t maximumColumnIndex = std::max<size_t>(1, GridPositionsResolver::expli
citGridColumnCount(*style())); | 1180 size_t maximumColumnIndex = std::max<size_t>(1, GridPositionsResolver::expli
citGridColumnCount(*style())); |
1181 | 1181 |
1182 ASSERT(m_gridItemsIndexesMap.isEmpty()); | 1182 ASSERT(m_gridItemsIndexesMap.isEmpty()); |
1183 size_t childIndex = 0; | 1183 size_t childIndex = 0; |
1184 for (LayoutBox* child = firstChildBox(); child; child = child->nextInFlowSib
lingBox()) { | 1184 for (LayoutBox* child = firstChildBox(); child; child = child->nextInFlowSib
lingBox()) { |
1185 if (child->isOutOfFlowPositioned()) | 1185 if (child->isOutOfFlowPositioned()) |
1186 continue; | 1186 continue; |
1187 | 1187 |
1188 populator.collectChild(child); | 1188 populator.collectChild(child); |
1189 m_gridItemsIndexesMap.set(child, childIndex++); | 1189 m_gridItemsIndexesMap.set(child, childIndex++); |
1190 | 1190 |
1191 // This function bypasses the cache (cachedGridCoordinate()) as it is us
ed to build it. | 1191 // This function bypasses the cache (cachedGridArea()) as it is used to
build it. |
1192 GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromS
tyle(*style(), *child, ForRows); | 1192 GridSpan rowPositions = GridPositionsResolver::resolveGridPositionsFromS
tyle(*style(), *child, ForRows); |
1193 GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFr
omStyle(*style(), *child, ForColumns); | 1193 GridSpan columnPositions = GridPositionsResolver::resolveGridPositionsFr
omStyle(*style(), *child, ForColumns); |
1194 m_gridItemCoordinate.set(child, GridCoordinate(rowPositions, columnPosit
ions)); | 1194 m_gridItemArea.set(child, GridArea(rowPositions, columnPositions)); |
1195 | 1195 |
1196 // |positions| is 0 if we need to run the auto-placement algorithm. | 1196 // |positions| is 0 if we need to run the auto-placement algorithm. |
1197 if (!rowPositions.isIndefinite()) { | 1197 if (!rowPositions.isIndefinite()) { |
1198 m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untra
nslatedResolvedInitialPosition()); | 1198 m_smallestRowStart = std::min(m_smallestRowStart, rowPositions.untra
nslatedResolvedInitialPosition()); |
1199 maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untran
slatedResolvedFinalPosition()); | 1199 maximumRowIndex = std::max<int>(maximumRowIndex, rowPositions.untran
slatedResolvedFinalPosition()); |
1200 } else { | 1200 } else { |
1201 // Grow the grid for items with a definite row span, getting the lar
gest such span. | 1201 // Grow the grid for items with a definite row span, getting the lar
gest such span. |
1202 size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*
style(), *child, ForRows); | 1202 size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*
style(), *child, ForRows); |
1203 maximumRowIndex = std::max(maximumRowIndex, spanSize); | 1203 maximumRowIndex = std::max(maximumRowIndex, spanSize); |
1204 } | 1204 } |
1205 | 1205 |
1206 if (!columnPositions.isIndefinite()) { | 1206 if (!columnPositions.isIndefinite()) { |
1207 m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositi
ons.untranslatedResolvedInitialPosition()); | 1207 m_smallestColumnStart = std::min(m_smallestColumnStart, columnPositi
ons.untranslatedResolvedInitialPosition()); |
1208 maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositio
ns.untranslatedResolvedFinalPosition()); | 1208 maximumColumnIndex = std::max<int>(maximumColumnIndex, columnPositio
ns.untranslatedResolvedFinalPosition()); |
1209 } else { | 1209 } else { |
1210 // Grow the grid for items with a definite column span, getting the
largest such span. | 1210 // Grow the grid for items with a definite column span, getting the
largest such span. |
1211 size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*
style(), *child, ForColumns); | 1211 size_t spanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(*
style(), *child, ForColumns); |
1212 maximumColumnIndex = std::max(maximumColumnIndex, spanSize); | 1212 maximumColumnIndex = std::max(maximumColumnIndex, spanSize); |
1213 } | 1213 } |
1214 } | 1214 } |
1215 | 1215 |
1216 m_grid.grow(maximumRowIndex + abs(m_smallestRowStart)); | 1216 m_grid.grow(maximumRowIndex + abs(m_smallestRowStart)); |
1217 for (auto& column : m_grid) | 1217 for (auto& column : m_grid) |
1218 column.grow(maximumColumnIndex + abs(m_smallestColumnStart)); | 1218 column.grow(maximumColumnIndex + abs(m_smallestColumnStart)); |
1219 } | 1219 } |
1220 | 1220 |
1221 PassOwnPtr<GridCoordinate> LayoutGrid::createEmptyGridAreaAtSpecifiedPositionsOu
tsideGrid(const LayoutBox& gridItem, GridTrackSizingDirection specifiedDirection
, const GridSpan& specifiedPositions) const | 1221 PassOwnPtr<GridArea> LayoutGrid::createEmptyGridAreaAtSpecifiedPositionsOutsideG
rid(const LayoutBox& gridItem, GridTrackSizingDirection specifiedDirection, cons
t GridSpan& specifiedPositions) const |
1222 { | 1222 { |
1223 GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ?
ForRows : ForColumns; | 1223 GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ?
ForRows : ForColumns; |
1224 const size_t endOfCrossDirection = crossDirection == ForColumns ? gridColumn
Count() : gridRowCount(); | 1224 const size_t endOfCrossDirection = crossDirection == ForColumns ? gridColumn
Count() : gridRowCount(); |
1225 size_t crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlaced
Item(*style(), gridItem, crossDirection); | 1225 size_t crossDirectionSpanSize = GridPositionsResolver::spanSizeForAutoPlaced
Item(*style(), gridItem, crossDirection); |
1226 GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endO
fCrossDirection, endOfCrossDirection + crossDirectionSpanSize); | 1226 GridSpan crossDirectionPositions = GridSpan::translatedDefiniteGridSpan(endO
fCrossDirection, endOfCrossDirection + crossDirectionSpanSize); |
1227 return adoptPtr(new GridCoordinate(specifiedDirection == ForColumns ? crossD
irectionPositions : specifiedPositions, specifiedDirection == ForColumns ? speci
fiedPositions : crossDirectionPositions)); | 1227 return adoptPtr(new GridArea(specifiedDirection == ForColumns ? crossDirecti
onPositions : specifiedPositions, specifiedDirection == ForColumns ? specifiedPo
sitions : crossDirectionPositions)); |
1228 } | 1228 } |
1229 | 1229 |
1230 void LayoutGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<LayoutBox*>& au
toGridItems) | 1230 void LayoutGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<LayoutBox*>& au
toGridItems) |
1231 { | 1231 { |
1232 bool isForColumns = autoPlacementMajorAxisDirection() == ForColumns; | 1232 bool isForColumns = autoPlacementMajorAxisDirection() == ForColumns; |
1233 bool isGridAutoFlowDense = style()->isGridAutoFlowAlgorithmDense(); | 1233 bool isGridAutoFlowDense = style()->isGridAutoFlowAlgorithmDense(); |
1234 | 1234 |
1235 // Mapping between the major axis tracks (rows or columns) and the last auto
-placed item's position inserted on | 1235 // Mapping between the major axis tracks (rows or columns) and the last auto
-placed item's position inserted on |
1236 // that track. This is needed to implement "sparse" packing for items locked
to a given track. | 1236 // that track. This is needed to implement "sparse" packing for items locked
to a given track. |
1237 // See http://dev.w3.org/csswg/css-grid/#auto-placement-algo | 1237 // See http://dev.w3.org/csswg/css-grid/#auto-placement-algo |
1238 HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZe
roKeyHashTraits<unsigned>> minorAxisCursors; | 1238 HashMap<unsigned, unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZe
roKeyHashTraits<unsigned>> minorAxisCursors; |
1239 | 1239 |
1240 for (const auto& autoGridItem : autoGridItems) { | 1240 for (const auto& autoGridItem : autoGridItems) { |
1241 GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacemen
tMajorAxisDirection()); | 1241 GridSpan majorAxisPositions = cachedGridSpan(*autoGridItem, autoPlacemen
tMajorAxisDirection()); |
1242 ASSERT(majorAxisPositions.isTranslatedDefinite()); | 1242 ASSERT(majorAxisPositions.isTranslatedDefinite()); |
1243 ASSERT(!cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection())
.isTranslatedDefinite()); | 1243 ASSERT(!cachedGridSpan(*autoGridItem, autoPlacementMinorAxisDirection())
.isTranslatedDefinite()); |
1244 size_t minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedI
tem(*style(), *autoGridItem, autoPlacementMinorAxisDirection()); | 1244 size_t minorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedI
tem(*style(), *autoGridItem, autoPlacementMinorAxisDirection()); |
1245 unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPo
sition(); | 1245 unsigned majorAxisInitialPosition = majorAxisPositions.resolvedInitialPo
sition(); |
1246 | 1246 |
1247 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAx
isPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursor
s.get(majorAxisInitialPosition)); | 1247 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAx
isPositions.resolvedInitialPosition(), isGridAutoFlowDense ? 0 : minorAxisCursor
s.get(majorAxisInitialPosition)); |
1248 OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(majorA
xisPositions.integerSpan(), minorAxisSpanSize); | 1248 OwnPtr<GridArea> emptyGridArea = iterator.nextEmptyGridArea(majorAxisPos
itions.integerSpan(), minorAxisSpanSize); |
1249 if (!emptyGridArea) | 1249 if (!emptyGridArea) |
1250 emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*
autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions); | 1250 emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(*
autoGridItem, autoPlacementMajorAxisDirection(), majorAxisPositions); |
1251 | 1251 |
1252 m_gridItemCoordinate.set(autoGridItem, *emptyGridArea); | 1252 m_gridItemArea.set(autoGridItem, *emptyGridArea); |
1253 insertItemIntoGrid(*autoGridItem, *emptyGridArea); | 1253 insertItemIntoGrid(*autoGridItem, *emptyGridArea); |
1254 | 1254 |
1255 if (!isGridAutoFlowDense) | 1255 if (!isGridAutoFlowDense) |
1256 minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyG
ridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitial
Position()); | 1256 minorAxisCursors.set(majorAxisInitialPosition, isForColumns ? emptyG
ridArea->rows.resolvedInitialPosition() : emptyGridArea->columns.resolvedInitial
Position()); |
1257 } | 1257 } |
1258 } | 1258 } |
1259 | 1259 |
1260 void LayoutGrid::placeAutoMajorAxisItemsOnGrid(const Vector<LayoutBox*>& autoGri
dItems) | 1260 void LayoutGrid::placeAutoMajorAxisItemsOnGrid(const Vector<LayoutBox*>& autoGri
dItems) |
1261 { | 1261 { |
1262 std::pair<size_t, size_t> autoPlacementCursor = std::make_pair(0, 0); | 1262 std::pair<size_t, size_t> autoPlacementCursor = std::make_pair(0, 0); |
(...skipping 13 matching lines...) Expand all Loading... |
1276 void LayoutGrid::placeAutoMajorAxisItemOnGrid(LayoutBox& gridItem, std::pair<siz
e_t, size_t>& autoPlacementCursor) | 1276 void LayoutGrid::placeAutoMajorAxisItemOnGrid(LayoutBox& gridItem, std::pair<siz
e_t, size_t>& autoPlacementCursor) |
1277 { | 1277 { |
1278 GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxi
sDirection()); | 1278 GridSpan minorAxisPositions = cachedGridSpan(gridItem, autoPlacementMinorAxi
sDirection()); |
1279 ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isTransl
atedDefinite()); | 1279 ASSERT(!cachedGridSpan(gridItem, autoPlacementMajorAxisDirection()).isTransl
atedDefinite()); |
1280 size_t majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
*style(), gridItem, autoPlacementMajorAxisDirection()); | 1280 size_t majorAxisSpanSize = GridPositionsResolver::spanSizeForAutoPlacedItem(
*style(), gridItem, autoPlacementMajorAxisDirection()); |
1281 | 1281 |
1282 const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColum
ns) ? gridColumnCount() : gridRowCount(); | 1282 const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForColum
ns) ? gridColumnCount() : gridRowCount(); |
1283 size_t majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == F
orColumns ? autoPlacementCursor.second : autoPlacementCursor.first; | 1283 size_t majorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == F
orColumns ? autoPlacementCursor.second : autoPlacementCursor.first; |
1284 size_t minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == F
orColumns ? autoPlacementCursor.first : autoPlacementCursor.second; | 1284 size_t minorAxisAutoPlacementCursor = autoPlacementMajorAxisDirection() == F
orColumns ? autoPlacementCursor.first : autoPlacementCursor.second; |
1285 | 1285 |
1286 OwnPtr<GridCoordinate> emptyGridArea; | 1286 OwnPtr<GridArea> emptyGridArea; |
1287 if (minorAxisPositions.isTranslatedDefinite()) { | 1287 if (minorAxisPositions.isTranslatedDefinite()) { |
1288 // Move to the next track in major axis if initial position in minor axi
s is before auto-placement cursor. | 1288 // Move to the next track in major axis if initial position in minor axi
s is before auto-placement cursor. |
1289 if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacemen
tCursor) | 1289 if (minorAxisPositions.resolvedInitialPosition() < minorAxisAutoPlacemen
tCursor) |
1290 majorAxisAutoPlacementCursor++; | 1290 majorAxisAutoPlacementCursor++; |
1291 | 1291 |
1292 if (majorAxisAutoPlacementCursor < endOfMajorAxis) { | 1292 if (majorAxisAutoPlacementCursor < endOfMajorAxis) { |
1293 GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), min
orAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor); | 1293 GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), min
orAxisPositions.resolvedInitialPosition(), majorAxisAutoPlacementCursor); |
1294 emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.intege
rSpan(), majorAxisSpanSize); | 1294 emptyGridArea = iterator.nextEmptyGridArea(minorAxisPositions.intege
rSpan(), majorAxisSpanSize); |
1295 } | 1295 } |
1296 | 1296 |
(...skipping 19 matching lines...) Expand all Loading... |
1316 } | 1316 } |
1317 | 1317 |
1318 // As we're moving to the next track in the major axis we should res
et the auto-placement cursor in the minor axis. | 1318 // As we're moving to the next track in the major axis we should res
et the auto-placement cursor in the minor axis. |
1319 minorAxisAutoPlacementCursor = 0; | 1319 minorAxisAutoPlacementCursor = 0; |
1320 } | 1320 } |
1321 | 1321 |
1322 if (!emptyGridArea) | 1322 if (!emptyGridArea) |
1323 emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(g
ridItem, autoPlacementMinorAxisDirection(), GridSpan::translatedDefiniteGridSpan
(0, minorAxisSpanSize)); | 1323 emptyGridArea = createEmptyGridAreaAtSpecifiedPositionsOutsideGrid(g
ridItem, autoPlacementMinorAxisDirection(), GridSpan::translatedDefiniteGridSpan
(0, minorAxisSpanSize)); |
1324 } | 1324 } |
1325 | 1325 |
1326 m_gridItemCoordinate.set(&gridItem, *emptyGridArea); | 1326 m_gridItemArea.set(&gridItem, *emptyGridArea); |
1327 insertItemIntoGrid(gridItem, *emptyGridArea); | 1327 insertItemIntoGrid(gridItem, *emptyGridArea); |
1328 // Move auto-placement cursor to the new position. | 1328 // Move auto-placement cursor to the new position. |
1329 autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition(); | 1329 autoPlacementCursor.first = emptyGridArea->rows.resolvedInitialPosition(); |
1330 autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition(
); | 1330 autoPlacementCursor.second = emptyGridArea->columns.resolvedInitialPosition(
); |
1331 } | 1331 } |
1332 | 1332 |
1333 GridTrackSizingDirection LayoutGrid::autoPlacementMajorAxisDirection() const | 1333 GridTrackSizingDirection LayoutGrid::autoPlacementMajorAxisDirection() const |
1334 { | 1334 { |
1335 return style()->isGridAutoFlowDirectionColumn() ? ForColumns : ForRows; | 1335 return style()->isGridAutoFlowDirectionColumn() ? ForColumns : ForRows; |
1336 } | 1336 } |
1337 | 1337 |
1338 GridTrackSizingDirection LayoutGrid::autoPlacementMinorAxisDirection() const | 1338 GridTrackSizingDirection LayoutGrid::autoPlacementMinorAxisDirection() const |
1339 { | 1339 { |
1340 return style()->isGridAutoFlowDirectionColumn() ? ForRows : ForColumns; | 1340 return style()->isGridAutoFlowDirectionColumn() ? ForRows : ForColumns; |
1341 } | 1341 } |
1342 | 1342 |
1343 void LayoutGrid::dirtyGrid() | 1343 void LayoutGrid::dirtyGrid() |
1344 { | 1344 { |
1345 if (m_gridIsDirty) | 1345 if (m_gridIsDirty) |
1346 return; | 1346 return; |
1347 | 1347 |
1348 // Even if this could be redundant, it could be seen as a defensive strategy
against | 1348 // Even if this could be redundant, it could be seen as a defensive strategy
against |
1349 // style changes events happening during the layout phase or even while the
painting process | 1349 // style changes events happening during the layout phase or even while the
painting process |
1350 // is still ongoing. | 1350 // is still ongoing. |
1351 // Forcing a new layout for the Grid layout would cancel any ongoing paintin
g and ensure | 1351 // Forcing a new layout for the Grid layout would cancel any ongoing paintin
g and ensure |
1352 // the grid and its children are correctly laid out according to the new sty
le rules. | 1352 // the grid and its children are correctly laid out according to the new sty
le rules. |
1353 setNeedsLayout(LayoutInvalidationReason::GridChanged); | 1353 setNeedsLayout(LayoutInvalidationReason::GridChanged); |
1354 | 1354 |
1355 m_grid.resize(0); | 1355 m_grid.resize(0); |
1356 m_gridItemCoordinate.clear(); | 1356 m_gridItemArea.clear(); |
1357 m_gridItemsOverflowingGridArea.resize(0); | 1357 m_gridItemsOverflowingGridArea.resize(0); |
1358 m_gridItemsIndexesMap.clear(); | 1358 m_gridItemsIndexesMap.clear(); |
1359 m_gridIsDirty = true; | 1359 m_gridIsDirty = true; |
1360 } | 1360 } |
1361 | 1361 |
1362 void LayoutGrid::applyStretchAlignmentToTracksIfNeeded(GridTrackSizingDirection
direction, GridSizingData& sizingData) | 1362 void LayoutGrid::applyStretchAlignmentToTracksIfNeeded(GridTrackSizingDirection
direction, GridSizingData& sizingData) |
1363 { | 1363 { |
1364 LayoutUnit& availableSpace = sizingData.freeSpaceForDirection(direction); | 1364 LayoutUnit& availableSpace = sizingData.freeSpaceForDirection(direction); |
1365 if (availableSpace <= 0 | 1365 if (availableSpace <= 0 |
1366 || (direction == ForColumns && styleRef().justifyContentDistribution() !
= ContentDistributionStretch) | 1366 || (direction == ForColumns && styleRef().justifyContentDistribution() !
= ContentDistributionStretch) |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1422 // determine the available space before stretching, are not set yet. | 1422 // determine the available space before stretching, are not set yet. |
1423 applyStretchAlignmentToChildIfNeeded(*child); | 1423 applyStretchAlignmentToChildIfNeeded(*child); |
1424 | 1424 |
1425 child->layoutIfNeeded(); | 1425 child->layoutIfNeeded(); |
1426 | 1426 |
1427 // We need pending layouts to be done in order to compute auto-margins p
roperly. | 1427 // We need pending layouts to be done in order to compute auto-margins p
roperly. |
1428 updateAutoMarginsInColumnAxisIfNeeded(*child); | 1428 updateAutoMarginsInColumnAxisIfNeeded(*child); |
1429 updateAutoMarginsInRowAxisIfNeeded(*child); | 1429 updateAutoMarginsInRowAxisIfNeeded(*child); |
1430 | 1430 |
1431 #if ENABLE(ASSERT) | 1431 #if ENABLE(ASSERT) |
1432 const GridCoordinate& coordinate = cachedGridCoordinate(*child); | 1432 const GridArea& area = cachedGridArea(*child); |
1433 ASSERT(coordinate.columns.resolvedInitialPosition() < sizingData.columnT
racks.size()); | 1433 ASSERT(area.columns.resolvedInitialPosition() < sizingData.columnTracks.
size()); |
1434 ASSERT(coordinate.rows.resolvedInitialPosition() < sizingData.rowTracks.
size()); | 1434 ASSERT(area.rows.resolvedInitialPosition() < sizingData.rowTracks.size()
); |
1435 #endif | 1435 #endif |
1436 child->setLogicalLocation(findChildLogicalPosition(*child, sizingData)); | 1436 child->setLogicalLocation(findChildLogicalPosition(*child, sizingData)); |
1437 | 1437 |
1438 // Keep track of children overflowing their grid area as we might need t
o paint them even if the grid-area is | 1438 // Keep track of children overflowing their grid area as we might need t
o paint them even if the grid-area is |
1439 // not visible | 1439 // not visible |
1440 if (child->logicalHeight() > overrideContainingBlockContentLogicalHeight | 1440 if (child->logicalHeight() > overrideContainingBlockContentLogicalHeight |
1441 || child->logicalWidth() > overrideContainingBlockContentLogicalWidt
h) | 1441 || child->logicalWidth() > overrideContainingBlockContentLogicalWidt
h) |
1442 m_gridItemsOverflowingGridArea.append(child); | 1442 m_gridItemsOverflowingGridArea.append(child); |
1443 } | 1443 } |
1444 } | 1444 } |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1537 if (child.parent() == this && !startIsAuto) { | 1537 if (child.parent() == this && !startIsAuto) { |
1538 // If column/row start is "auto" the static position has been already se
t in prepareChildForPositionedLayout(). | 1538 // If column/row start is "auto" the static position has been already se
t in prepareChildForPositionedLayout(). |
1539 PaintLayer* childLayer = child.layer(); | 1539 PaintLayer* childLayer = child.layer(); |
1540 if (isForColumns) | 1540 if (isForColumns) |
1541 childLayer->setStaticInlinePosition(borderStart() + offset); | 1541 childLayer->setStaticInlinePosition(borderStart() + offset); |
1542 else | 1542 else |
1543 childLayer->setStaticBlockPosition(borderBefore() + offset); | 1543 childLayer->setStaticBlockPosition(borderBefore() + offset); |
1544 } | 1544 } |
1545 } | 1545 } |
1546 | 1546 |
1547 GridCoordinate LayoutGrid::cachedGridCoordinate(const LayoutBox& gridItem) const | 1547 GridArea LayoutGrid::cachedGridArea(const LayoutBox& gridItem) const |
1548 { | 1548 { |
1549 ASSERT(m_gridItemCoordinate.contains(&gridItem)); | 1549 ASSERT(m_gridItemArea.contains(&gridItem)); |
1550 return m_gridItemCoordinate.get(&gridItem); | 1550 return m_gridItemArea.get(&gridItem); |
1551 } | 1551 } |
1552 | 1552 |
1553 GridSpan LayoutGrid::cachedGridSpan(const LayoutBox& gridItem, GridTrackSizingDi
rection direction) const | 1553 GridSpan LayoutGrid::cachedGridSpan(const LayoutBox& gridItem, GridTrackSizingDi
rection direction) const |
1554 { | 1554 { |
1555 GridCoordinate coordinate = cachedGridCoordinate(gridItem); | 1555 GridArea area = cachedGridArea(gridItem); |
1556 return direction == ForColumns ? coordinate.columns : coordinate.rows; | 1556 return direction == ForColumns ? area.columns : area.rows; |
1557 } | 1557 } |
1558 | 1558 |
1559 LayoutUnit LayoutGrid::gridAreaBreadthForChild(const LayoutBox& child, GridTrack
SizingDirection direction, const Vector<GridTrack>& tracks) const | 1559 LayoutUnit LayoutGrid::gridAreaBreadthForChild(const LayoutBox& child, GridTrack
SizingDirection direction, const Vector<GridTrack>& tracks) const |
1560 { | 1560 { |
1561 const GridSpan& span = cachedGridSpan(child, direction); | 1561 const GridSpan& span = cachedGridSpan(child, direction); |
1562 LayoutUnit gridAreaBreadth = 0; | 1562 LayoutUnit gridAreaBreadth = 0; |
1563 for (const auto& trackPosition : span) | 1563 for (const auto& trackPosition : span) |
1564 gridAreaBreadth += tracks[trackPosition].baseSize(); | 1564 gridAreaBreadth += tracks[trackPosition].baseSize(); |
1565 | 1565 |
1566 gridAreaBreadth += guttersSize(direction, span.integerSpan()); | 1566 gridAreaBreadth += guttersSize(direction, span.integerSpan()); |
(...skipping 505 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2072 | 2072 |
2073 return LayoutPoint(rowAxisOffset, columnAxisOffsetForChild(child)); | 2073 return LayoutPoint(rowAxisOffset, columnAxisOffsetForChild(child)); |
2074 } | 2074 } |
2075 | 2075 |
2076 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& pa
intOffset) const | 2076 void LayoutGrid::paintChildren(const PaintInfo& paintInfo, const LayoutPoint& pa
intOffset) const |
2077 { | 2077 { |
2078 GridPainter(*this).paintChildren(paintInfo, paintOffset); | 2078 GridPainter(*this).paintChildren(paintInfo, paintOffset); |
2079 } | 2079 } |
2080 | 2080 |
2081 } // namespace blink | 2081 } // namespace blink |
OLD | NEW |