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 717 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
728 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridCoordinate& coor dinate) | 728 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridCoordinate& coor dinate) |
729 { | 729 { |
730 for (GridResolvedPosition row = coordinate.rows.resolvedInitialPosition; row <= coordinate.rows.resolvedFinalPosition; ++row) { | 730 for (GridResolvedPosition row = coordinate.rows.resolvedInitialPosition; row <= coordinate.rows.resolvedFinalPosition; ++row) { |
731 for (GridResolvedPosition column = coordinate.columns.resolvedInitialPos ition; column <= coordinate.columns.resolvedFinalPosition; ++column) | 731 for (GridResolvedPosition column = coordinate.columns.resolvedInitialPos ition; column <= coordinate.columns.resolvedFinalPosition; ++column) |
732 m_grid[row.toInt()][column.toInt()].append(child); | 732 m_grid[row.toInt()][column.toInt()].append(child); |
733 } | 733 } |
734 | 734 |
735 m_gridItemCoordinate.set(child, coordinate); | 735 m_gridItemCoordinate.set(child, coordinate); |
736 } | 736 } |
737 | 737 |
738 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridResolvedPosition & rowTrack, const GridResolvedPosition& columnTrack) | |
739 { | |
740 const GridSpan& rowSpan = GridResolvedPosition::resolveGridPositionsFromAuto PlacementPosition(*child, ForRows, rowTrack); | |
741 const GridSpan& columnSpan = GridResolvedPosition::resolveGridPositionsFromA utoPlacementPosition(*child, ForColumns, columnTrack); | |
742 insertItemIntoGrid(child, GridCoordinate(rowSpan, columnSpan)); | |
743 } | |
744 | |
745 void RenderGrid::placeItemsOnGrid() | 738 void RenderGrid::placeItemsOnGrid() |
746 { | 739 { |
747 if (!gridIsDirty()) | 740 if (!gridIsDirty()) |
748 return; | 741 return; |
749 | 742 |
750 ASSERT(m_gridItemCoordinate.isEmpty()); | 743 ASSERT(m_gridItemCoordinate.isEmpty()); |
751 | 744 |
752 populateExplicitGridAndOrderIterator(); | 745 populateExplicitGridAndOrderIterator(); |
753 | 746 |
754 // We clear the dirty bit here as the grid sizes have been updated, this mea ns | 747 // We clear the dirty bit here as the grid sizes have been updated, this mea ns |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
797 size_t maximumRowIndex = std::max<size_t>(1, GridResolvedPosition::explicitG ridRowCount(*style())); | 790 size_t maximumRowIndex = std::max<size_t>(1, GridResolvedPosition::explicitG ridRowCount(*style())); |
798 size_t maximumColumnIndex = std::max<size_t>(1, GridResolvedPosition::explic itGridColumnCount(*style())); | 791 size_t maximumColumnIndex = std::max<size_t>(1, GridResolvedPosition::explic itGridColumnCount(*style())); |
799 | 792 |
800 for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBo x()) { | 793 for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBo x()) { |
801 populator.collectChild(child); | 794 populator.collectChild(child); |
802 | 795 |
803 // This function bypasses the cache (cachedGridCoordinate()) as it is us ed to build it. | 796 // This function bypasses the cache (cachedGridCoordinate()) as it is us ed to build it. |
804 OwnPtr<GridSpan> rowPositions = GridResolvedPosition::resolveGridPositio nsFromStyle(*style(), *child, ForRows); | 797 OwnPtr<GridSpan> rowPositions = GridResolvedPosition::resolveGridPositio nsFromStyle(*style(), *child, ForRows); |
805 OwnPtr<GridSpan> columnPositions = GridResolvedPosition::resolveGridPosi tionsFromStyle(*style(), *child, ForColumns); | 798 OwnPtr<GridSpan> columnPositions = GridResolvedPosition::resolveGridPosi tionsFromStyle(*style(), *child, ForColumns); |
806 | 799 |
807 // |positions| is 0 if we need to run the auto-placement algorithm. Our estimation ignores | 800 // |positions| is 0 if we need to run the auto-placement algorithm. |
808 // this case as the auto-placement algorithm will grow the grid as neede d. | 801 if (rowPositions) { |
809 if (rowPositions) | 802 maximumRowIndex = std::max(maximumRowIndex, rowPositions->resolvedFi nalPosition.toInt() + 1); |
810 maximumRowIndex = std::max<size_t>(maximumRowIndex, rowPositions->re solvedFinalPosition.toInt() + 1); | 803 } else if (autoPlacementMinorAxisDirection() == ForRows) { |
Julien - ping for review
2014/05/16 10:08:10
It seems to me that we need to make the initial gr
| |
811 if (columnPositions) | 804 // Grow the grid for items with a definite row span, getting the lar gest such span. |
812 maximumColumnIndex = std::max<size_t>(maximumColumnIndex, columnPosi tions->resolvedFinalPosition.toInt() + 1); | 805 OwnPtr<GridSpan> positions = GridResolvedPosition::resolveGridPositi onsFromAutoPlacementPosition(*style(), *child, ForRows, GridResolvedPosition(0)) ; |
806 maximumRowIndex = std::max(maximumRowIndex, positions->resolvedFinal Position.toInt() + 1); | |
807 } | |
808 | |
809 if (columnPositions) { | |
810 maximumColumnIndex = std::max(maximumColumnIndex, columnPositions->r esolvedFinalPosition.toInt() + 1); | |
811 } else if (autoPlacementMinorAxisDirection() == ForColumns) { | |
812 // Grow the grid for items with a definite column span, getting the largest such span. | |
813 OwnPtr<GridSpan> positions = GridResolvedPosition::resolveGridPositi onsFromAutoPlacementPosition(*style(), *child, ForColumns, GridResolvedPosition( 0)); | |
814 maximumColumnIndex = std::max(maximumColumnIndex, positions->resolve dFinalPosition.toInt() + 1); | |
815 } | |
813 } | 816 } |
814 | 817 |
815 m_grid.grow(maximumRowIndex); | 818 m_grid.grow(maximumRowIndex); |
816 for (size_t i = 0; i < m_grid.size(); ++i) | 819 for (size_t i = 0; i < m_grid.size(); ++i) |
817 m_grid[i].grow(maximumColumnIndex); | 820 m_grid[i].grow(maximumColumnIndex); |
818 } | 821 } |
819 | 822 |
823 bool RenderGrid::checkEmptyCells(const GridCoordinate& coordinate) const | |
824 { | |
825 // Ignore cells outside current grid as we will grow it later if needed. | |
826 size_t maxRows = std::min(coordinate.rows.resolvedFinalPosition.toInt() + 1, gridRowCount()); | |
827 size_t maxColumns = std::min(coordinate.columns.resolvedFinalPosition.toInt( ) + 1, gridColumnCount()); | |
828 | |
829 // This adds a O(N^2) behavior that shouldn't be a big deal as we expect spa nning areas to be small. | |
830 for (size_t row = coordinate.rows.resolvedInitialPosition.toInt(); row < max Rows; ++row) { | |
831 for (size_t column = coordinate.columns.resolvedInitialPosition.toInt(); column < maxColumns; ++column) { | |
832 const GridCell& children = m_grid[row][column]; | |
833 if (!children.isEmpty()) | |
834 return false; | |
835 } | |
836 } | |
837 | |
838 return true; | |
839 } | |
840 | |
841 PassOwnPtr<GridCoordinate> RenderGrid::implicitEmptyGridAreaSpecifiedPositions(c onst RenderBox* gridItem, GridTrackSizingDirection specifiedDirection, const Gri dSpan& specifiedPositions) const | |
Julien - ping for review
2014/05/16 10:08:10
What is an implicit empty grid area?
There are 2
| |
842 { | |
843 GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns; | |
844 const size_t endOfCrossDirection = crossDirection == ForColumns ? gridColumn Count() : gridRowCount(); | |
845 OwnPtr<GridSpan> crossDirectionPositions = GridResolvedPosition::resolveGrid PositionsFromAutoPlacementPosition(*style(), *gridItem, crossDirection, GridReso lvedPosition(endOfCrossDirection)); | |
846 return adoptPtr(new GridCoordinate(specifiedDirection == ForColumns ? *cross DirectionPositions : specifiedPositions, specifiedDirection == ForColumns ? spec ifiedPositions : *crossDirectionPositions)); | |
847 } | |
848 | |
849 PassOwnPtr<GridCoordinate> RenderGrid::emptyGridAreaSpecifiedPositions(const Ren derBox* gridItem, GridTrackSizingDirection specifiedDirection, const GridSpan& s pecifiedPositions) const | |
850 { | |
851 GridTrackSizingDirection crossDirection = specifiedDirection == ForColumns ? ForRows : ForColumns; | |
852 | |
853 GridIterator iterator(m_grid, specifiedDirection, specifiedPositions.resolve dInitialPosition.toInt()); | |
854 OwnPtr<GridCoordinate> emptyGridArea; | |
855 for (emptyGridArea = iterator.nextEmptyGridArea(); emptyGridArea; emptyGridA rea = iterator.nextEmptyGridArea()) { | |
856 GridResolvedPosition crossDirectionInitialPositionIndex = crossDirection == ForColumns ? emptyGridArea->columns.resolvedInitialPosition : emptyGridArea- >rows.resolvedInitialPosition; | |
857 OwnPtr<GridSpan> crossDirectionPositions = GridResolvedPosition::resolve GridPositionsFromAutoPlacementPosition(*style(), *gridItem, crossDirection, cros sDirectionInitialPositionIndex); | |
Julien - ping for review
2014/05/16 10:08:10
I think we should explain why we need to resolve t
| |
858 | |
859 emptyGridArea->rows = specifiedDirection == ForColumns ? *crossDirection Positions : specifiedPositions; | |
860 emptyGridArea->columns = specifiedDirection == ForColumns ? specifiedPos itions : *crossDirectionPositions; | |
861 if (checkEmptyCells(*emptyGridArea)) | |
862 break; | |
863 } | |
864 | |
865 return emptyGridArea.release(); | |
866 } | |
867 | |
868 void RenderGrid::insertItemIntoGridGrowingIfNeeded(RenderBox* gridItem, const Gr idCoordinate& coordinate, GridTrackSizingDirection growingDirection) | |
Julien - ping for review
2014/05/16 10:08:10
I don't like this split for several reasons:
* ins
| |
869 { | |
870 GridResolvedPosition growingDirectionFinalPositionIndex = growingDirection = = ForColumns ? coordinate.columns.resolvedFinalPosition : coordinate.rows.resolv edFinalPosition; | |
871 const size_t endOfGrowingDirection = growingDirection == ForColumns ? gridCo lumnCount() : gridRowCount(); | |
872 if (growingDirectionFinalPositionIndex.toInt() >= endOfGrowingDirection) | |
873 growGrid(growingDirection, growingDirectionFinalPositionIndex.toInt()); | |
874 insertItemIntoGrid(gridItem, coordinate); | |
875 } | |
876 | |
820 void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& au toGridItems) | 877 void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& au toGridItems) |
821 { | 878 { |
822 for (size_t i = 0; i < autoGridItems.size(); ++i) { | 879 for (size_t i = 0; i < autoGridItems.size(); ++i) { |
823 OwnPtr<GridSpan> majorAxisPositions = GridResolvedPosition::resolveGridP ositionsFromStyle(*style(), *autoGridItems[i], autoPlacementMajorAxisDirection() ); | 880 OwnPtr<GridSpan> majorAxisPositions = GridResolvedPosition::resolveGridP ositionsFromStyle(*style(), *autoGridItems[i], autoPlacementMajorAxisDirection() ); |
824 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAx isPositions->resolvedInitialPosition.toInt()); | 881 OwnPtr<GridCoordinate> emptyGridArea = emptyGridAreaSpecifiedPositions(a utoGridItems[i], autoPlacementMajorAxisDirection(), *majorAxisPositions); |
825 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) { | 882 if (!emptyGridArea) |
826 insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.resolvedIni tialPosition, emptyGridArea->columns.resolvedInitialPosition); | 883 emptyGridArea = implicitEmptyGridAreaSpecifiedPositions(autoGridItem s[i], autoPlacementMajorAxisDirection(), *majorAxisPositions); |
827 continue; | 884 insertItemIntoGridGrowingIfNeeded(autoGridItems[i], *emptyGridArea, auto PlacementMinorAxisDirection()); |
828 } | |
829 | |
830 growGrid(autoPlacementMinorAxisDirection(), autoPlacementMinorAxisDirect ion() == ForColumns ? m_grid[0].size() : m_grid.size()); | |
831 OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(); | |
832 ASSERT(emptyGridArea); | |
833 insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.resolvedInitial Position, emptyGridArea->columns.resolvedInitialPosition); | |
834 } | 885 } |
835 } | 886 } |
836 | 887 |
837 void RenderGrid::placeAutoMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGri dItems) | 888 void RenderGrid::placeAutoMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGri dItems) |
838 { | 889 { |
839 for (size_t i = 0; i < autoGridItems.size(); ++i) | 890 for (size_t i = 0; i < autoGridItems.size(); ++i) |
840 placeAutoMajorAxisItemOnGrid(autoGridItems[i]); | 891 placeAutoMajorAxisItemOnGrid(autoGridItems[i]); |
841 } | 892 } |
842 | 893 |
843 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem) | 894 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem) |
844 { | 895 { |
845 OwnPtr<GridSpan> minorAxisPositions = GridResolvedPosition::resolveGridPosit ionsFromStyle(*style(), *gridItem, autoPlacementMinorAxisDirection()); | 896 OwnPtr<GridSpan> minorAxisPositions = GridResolvedPosition::resolveGridPosit ionsFromStyle(*style(), *gridItem, autoPlacementMinorAxisDirection()); |
846 ASSERT(!GridResolvedPosition::resolveGridPositionsFromStyle(*style(), *gridI tem, autoPlacementMajorAxisDirection())); | 897 ASSERT(!GridResolvedPosition::resolveGridPositionsFromStyle(*style(), *gridI tem, autoPlacementMajorAxisDirection())); |
847 size_t minorAxisIndex = 0; | |
848 if (minorAxisPositions) { | 898 if (minorAxisPositions) { |
849 minorAxisIndex = minorAxisPositions->resolvedInitialPosition.toInt(); | 899 OwnPtr<GridCoordinate> emptyGridArea = emptyGridAreaSpecifiedPositions(g ridItem, autoPlacementMinorAxisDirection(), *minorAxisPositions); |
850 GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAx isIndex); | 900 if (!emptyGridArea) |
851 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) { | 901 emptyGridArea = implicitEmptyGridAreaSpecifiedPositions(gridItem, au toPlacementMinorAxisDirection(), *minorAxisPositions); |
852 insertItemIntoGrid(gridItem, emptyGridArea->rows.resolvedInitialPosi tion, emptyGridArea->columns.resolvedInitialPosition); | 902 insertItemIntoGridGrowingIfNeeded(gridItem, *emptyGridArea, autoPlacemen tMajorAxisDirection()); |
853 return; | |
854 } | |
855 } else { | 903 } else { |
904 OwnPtr<GridCoordinate> emptyGridArea; | |
905 | |
856 const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForC olumns) ? gridColumnCount() : gridRowCount(); | 906 const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForC olumns) ? gridColumnCount() : gridRowCount(); |
857 for (size_t majorAxisIndex = 0; majorAxisIndex < endOfMajorAxis; ++major AxisIndex) { | 907 for (size_t majorAxisIndex = 0; majorAxisIndex < endOfMajorAxis; ++major AxisIndex) { |
858 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), maj orAxisIndex); | 908 OwnPtr<GridSpan> majorAxisPositions = GridResolvedPosition::resolveG ridPositionsFromAutoPlacementPosition(*style(), *gridItem, autoPlacementMajorAxi sDirection(), majorAxisIndex); |
859 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridAre a()) { | 909 emptyGridArea = emptyGridAreaSpecifiedPositions(gridItem, autoPlacem entMajorAxisDirection(), *majorAxisPositions); |
860 insertItemIntoGrid(gridItem, emptyGridArea->rows.resolvedInitial Position, emptyGridArea->columns.resolvedInitialPosition); | 910 |
861 return; | 911 if (emptyGridArea) { |
912 // Check that it fits in the minor axis direction, as we shouldn 't grow in that direction here (it was already managed in populateExplicitGridAn dOrderIterator()). | |
913 GridResolvedPosition minorAxisFinalPositionIndex = autoPlacement MinorAxisDirection() == ForColumns ? emptyGridArea->columns.resolvedFinalPositio n : emptyGridArea->rows.resolvedFinalPosition; | |
914 const size_t endOfMinorAxis = autoPlacementMinorAxisDirection() == ForColumns ? gridColumnCount() : gridRowCount(); | |
915 if (minorAxisFinalPositionIndex.toInt() < endOfMinorAxis) | |
916 break; | |
862 } | 917 } |
863 } | 918 } |
919 | |
920 if (!emptyGridArea) { | |
921 OwnPtr<GridSpan> majorAxisPositions = GridResolvedPosition::resolveG ridPositionsFromAutoPlacementPosition(*style(), *gridItem, autoPlacementMajorAxi sDirection(), GridResolvedPosition(endOfMajorAxis)); | |
922 OwnPtr<GridSpan> minorAxisPositions = GridResolvedPosition::resolveG ridPositionsFromAutoPlacementPosition(*style(), *gridItem, autoPlacementMinorAxi sDirection(), GridResolvedPosition(0)); | |
923 emptyGridArea = adoptPtr(new GridCoordinate(autoPlacementMajorAxisDi rection() == ForColumns ? *minorAxisPositions : *majorAxisPositions, autoPlaceme ntMajorAxisDirection() == ForColumns ? *majorAxisPositions : *minorAxisPositions )); | |
924 } | |
925 | |
926 insertItemIntoGridGrowingIfNeeded(gridItem, *emptyGridArea, autoPlacemen tMajorAxisDirection()); | |
864 } | 927 } |
865 | |
866 // We didn't find an empty grid area so we need to create an extra major axi s line and insert our gridItem in it. | |
867 const size_t columnIndex = (autoPlacementMajorAxisDirection() == ForColumns) ? m_grid[0].size() : minorAxisIndex; | |
868 const size_t rowIndex = (autoPlacementMajorAxisDirection() == ForColumns) ? minorAxisIndex : m_grid.size(); | |
869 growGrid(autoPlacementMajorAxisDirection(), autoPlacementMajorAxisDirection( ) == ForColumns ? m_grid[0].size() : m_grid.size()); | |
870 insertItemIntoGrid(gridItem, rowIndex, columnIndex); | |
871 } | 928 } |
872 | 929 |
873 GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const | 930 GridTrackSizingDirection RenderGrid::autoPlacementMajorAxisDirection() const |
874 { | 931 { |
875 GridAutoFlow flow = style()->gridAutoFlow(); | 932 GridAutoFlow flow = style()->gridAutoFlow(); |
876 ASSERT(flow != AutoFlowNone); | 933 ASSERT(flow != AutoFlowNone); |
877 return (flow == AutoFlowColumn) ? ForColumns : ForRows; | 934 return (flow == AutoFlowColumn) ? ForColumns : ForRows; |
878 } | 935 } |
879 | 936 |
880 GridTrackSizingDirection RenderGrid::autoPlacementMinorAxisDirection() const | 937 GridTrackSizingDirection RenderGrid::autoPlacementMinorAxisDirection() const |
(...skipping 341 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1222 if (isOutOfFlowPositioned()) | 1279 if (isOutOfFlowPositioned()) |
1223 return "RenderGrid (positioned)"; | 1280 return "RenderGrid (positioned)"; |
1224 if (isAnonymous()) | 1281 if (isAnonymous()) |
1225 return "RenderGrid (generated)"; | 1282 return "RenderGrid (generated)"; |
1226 if (isRelPositioned()) | 1283 if (isRelPositioned()) |
1227 return "RenderGrid (relative positioned)"; | 1284 return "RenderGrid (relative positioned)"; |
1228 return "RenderGrid"; | 1285 return "RenderGrid"; |
1229 } | 1286 } |
1230 | 1287 |
1231 } // namespace WebCore | 1288 } // namespace WebCore |
OLD | NEW |