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 174 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
185 | 185 |
186 if (gridIsDirty()) | 186 if (gridIsDirty()) |
187 return; | 187 return; |
188 | 188 |
189 if (!newChild->isBox()) { | 189 if (!newChild->isBox()) { |
190 dirtyGrid(); | 190 dirtyGrid(); |
191 return; | 191 return; |
192 } | 192 } |
193 | 193 |
194 RenderBox* newChildBox = toRenderBox(newChild); | 194 RenderBox* newChildBox = toRenderBox(newChild); |
195 OwnPtr<GridSpan> rowPositions = resolveGridPositionsFromStyle(newChildBox, F orRows); | 195 OwnPtr<GridSpan> rowPositions = GridResolvedPosition::resolveGridPositionsFr omStyle(*style(), newChildBox, ForRows); |
196 OwnPtr<GridSpan> columnPositions = resolveGridPositionsFromStyle(newChildBox , ForColumns); | 196 OwnPtr<GridSpan> columnPositions = GridResolvedPosition::resolveGridPosition sFromStyle(*style(), newChildBox, ForColumns); |
197 if (!rowPositions || !columnPositions) { | 197 if (!rowPositions || !columnPositions) { |
198 // The new child requires the auto-placement algorithm to run so we need to recompute the grid fully. | 198 // The new child requires the auto-placement algorithm to run so we need to recompute the grid fully. |
199 dirtyGrid(); | 199 dirtyGrid(); |
200 } else { | 200 } else { |
201 if (gridRowCount() <= rowPositions->finalPositionIndex || gridColumnCoun t() <= columnPositions->finalPositionIndex) { | 201 if (gridRowCount() <= rowPositions->resolvedFinalPosition || gridColumnC ount() <= columnPositions->resolvedFinalPosition) { |
202 // FIXME: We could just insert the new child provided we had a primi tive to arbitrarily grow the grid. | 202 // FIXME: We could just insert the new child provided we had a primi tive to arbitrarily grow the grid. |
203 dirtyGrid(); | 203 dirtyGrid(); |
204 } else { | 204 } else { |
205 insertItemIntoGrid(newChildBox, GridCoordinate(*rowPositions, *colum nPositions)); | 205 insertItemIntoGrid(newChildBox, GridCoordinate(*rowPositions, *colum nPositions)); |
206 } | 206 } |
207 } | 207 } |
208 } | 208 } |
209 | 209 |
210 void RenderGrid::removeChild(RenderObject* child) | 210 void RenderGrid::removeChild(RenderObject* child) |
211 { | 211 { |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
412 normalizedFractionBreadth = std::max(normalizedFractionBreadth, trac ks[trackIndex].m_usedBreadth / trackSize.maxTrackBreadth().flex()); | 412 normalizedFractionBreadth = std::max(normalizedFractionBreadth, trac ks[trackIndex].m_usedBreadth / trackSize.maxTrackBreadth().flex()); |
413 } | 413 } |
414 | 414 |
415 for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) { | 415 for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) { |
416 GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i] ); | 416 GridIterator iterator(m_grid, direction, flexibleSizedTracksIndex[i] ); |
417 while (RenderBox* gridItem = iterator.nextGridItem()) { | 417 while (RenderBox* gridItem = iterator.nextGridItem()) { |
418 const GridCoordinate coordinate = cachedGridCoordinate(gridItem) ; | 418 const GridCoordinate coordinate = cachedGridCoordinate(gridItem) ; |
419 const GridSpan span = (direction == ForColumns) ? coordinate.col umns : coordinate.rows; | 419 const GridSpan span = (direction == ForColumns) ? coordinate.col umns : coordinate.rows; |
420 | 420 |
421 // Do not include already processed items. | 421 // Do not include already processed items. |
422 if (i > 0 && span.initialPositionIndex <= flexibleSizedTracksInd ex[i - 1]) | 422 if (i > 0 && span.resolvedInitialPosition <= flexibleSizedTracks Index[i - 1]) |
423 continue; | 423 continue; |
424 | 424 |
425 double itemNormalizedFlexBreadth = computeNormalizedFractionBrea dth(tracks, span, direction, maxContentForChild(gridItem, direction, sizingData. columnTracks)); | 425 double itemNormalizedFlexBreadth = computeNormalizedFractionBrea dth(tracks, span, direction, maxContentForChild(gridItem, direction, sizingData. columnTracks)); |
426 normalizedFractionBreadth = std::max(normalizedFractionBreadth, itemNormalizedFlexBreadth); | 426 normalizedFractionBreadth = std::max(normalizedFractionBreadth, itemNormalizedFlexBreadth); |
427 } | 427 } |
428 } | 428 } |
429 } | 429 } |
430 | 430 |
431 for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) { | 431 for (size_t i = 0; i < flexibleSizedTracksIndex.size(); ++i) { |
432 const size_t trackIndex = flexibleSizedTracksIndex[i]; | 432 const size_t trackIndex = flexibleSizedTracksIndex[i]; |
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
477 static bool sortByGridNormalizedFlexValue(const GridTrackForNormalization& track 1, const GridTrackForNormalization& track2) | 477 static bool sortByGridNormalizedFlexValue(const GridTrackForNormalization& track 1, const GridTrackForNormalization& track2) |
478 { | 478 { |
479 return track1.m_normalizedFlexValue < track2.m_normalizedFlexValue; | 479 return track1.m_normalizedFlexValue < track2.m_normalizedFlexValue; |
480 } | 480 } |
481 | 481 |
482 double RenderGrid::computeNormalizedFractionBreadth(Vector<GridTrack>& tracks, c onst GridSpan& tracksSpan, GridTrackSizingDirection direction, LayoutUnit availa bleLogicalSpace) const | 482 double RenderGrid::computeNormalizedFractionBreadth(Vector<GridTrack>& tracks, c onst GridSpan& tracksSpan, GridTrackSizingDirection direction, LayoutUnit availa bleLogicalSpace) const |
483 { | 483 { |
484 // |availableLogicalSpace| already accounts for the used breadths so no need to remove it here. | 484 // |availableLogicalSpace| already accounts for the used breadths so no need to remove it here. |
485 | 485 |
486 Vector<GridTrackForNormalization> tracksForNormalization; | 486 Vector<GridTrackForNormalization> tracksForNormalization; |
487 for (size_t i = tracksSpan.initialPositionIndex; i <= tracksSpan.finalPositi onIndex; ++i) { | 487 for (GridResolvedPosition resolvedPosition = tracksSpan.resolvedInitialPosit ion; resolvedPosition <= tracksSpan.resolvedFinalPosition; ++resolvedPosition) { |
488 const GridTrackSize& trackSize = gridTrackSize(direction, i); | 488 const GridTrackSize& trackSize = gridTrackSize(direction, resolvedPositi on); |
489 if (!trackSize.maxTrackBreadth().isFlex()) | 489 if (!trackSize.maxTrackBreadth().isFlex()) |
490 continue; | 490 continue; |
491 | 491 |
492 tracksForNormalization.append(GridTrackForNormalization(tracks[i], track Size.maxTrackBreadth().flex())); | 492 tracksForNormalization.append(GridTrackForNormalization(tracks[resolvedP osition], trackSize.maxTrackBreadth().flex())); |
493 } | 493 } |
494 | 494 |
495 // The function is not called if we don't have <flex> grid tracks | 495 // The function is not called if we don't have <flex> grid tracks |
496 ASSERT(!tracksForNormalization.isEmpty()); | 496 ASSERT(!tracksForNormalization.isEmpty()); |
497 | 497 |
498 std::sort(tracksForNormalization.begin(), tracksForNormalization.end(), sort ByGridNormalizedFlexValue); | 498 std::sort(tracksForNormalization.begin(), tracksForNormalization.end(), sort ByGridNormalizedFlexValue); |
499 | 499 |
500 // These values work together: as we walk over our grid tracks, we increase fractionValueBasedOnGridItemsRatio | 500 // These values work together: as we walk over our grid tracks, we increase fractionValueBasedOnGridItemsRatio |
501 // to match a grid track's usedBreadth to <flex> ratio until the total fract ions sized grid tracks wouldn't | 501 // to match a grid track's usedBreadth to <flex> ratio until the total fract ions sized grid tracks wouldn't |
502 // fit into availableLogicalSpaceIgnoringFractionTracks. | 502 // fit into availableLogicalSpaceIgnoringFractionTracks. |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
535 Length logicalSize = direction == ForColumns ? style()->logicalWidth() : style()->logicalHeight(); | 535 Length logicalSize = direction == ForColumns ? style()->logicalWidth() : style()->logicalHeight(); |
536 if (logicalSize.isIntrinsicOrAuto()) { | 536 if (logicalSize.isIntrinsicOrAuto()) { |
537 DEFINE_STATIC_LOCAL(GridTrackSize, autoTrackSize, (Length(Auto))); | 537 DEFINE_STATIC_LOCAL(GridTrackSize, autoTrackSize, (Length(Auto))); |
538 return autoTrackSize; | 538 return autoTrackSize; |
539 } | 539 } |
540 } | 540 } |
541 | 541 |
542 return trackSize; | 542 return trackSize; |
543 } | 543 } |
544 | 544 |
545 size_t RenderGrid::explicitGridColumnCount() const | |
546 { | |
547 return style()->gridTemplateColumns().size(); | |
548 } | |
549 | |
550 size_t RenderGrid::explicitGridRowCount() const | |
551 { | |
552 return style()->gridTemplateRows().size(); | |
553 } | |
554 | |
555 size_t RenderGrid::explicitGridSizeForSide(GridPositionSide side) const | |
556 { | |
557 return (side == ColumnStartSide || side == ColumnEndSide) ? explicitGridColu mnCount() : explicitGridRowCount(); | |
558 } | |
559 | |
560 LayoutUnit RenderGrid::logicalContentHeightForChild(RenderBox* child, Vector<Gri dTrack>& columnTracks) | 545 LayoutUnit RenderGrid::logicalContentHeightForChild(RenderBox* child, Vector<Gri dTrack>& columnTracks) |
561 { | 546 { |
562 SubtreeLayoutScope layoutScope(child); | 547 SubtreeLayoutScope layoutScope(child); |
563 LayoutUnit oldOverrideContainingBlockContentLogicalWidth = child->hasOverrid eContainingBlockLogicalWidth() ? child->overrideContainingBlockContentLogicalWid th() : LayoutUnit(); | 548 LayoutUnit oldOverrideContainingBlockContentLogicalWidth = child->hasOverrid eContainingBlockLogicalWidth() ? child->overrideContainingBlockContentLogicalWid th() : LayoutUnit(); |
564 LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForCh ild(child, ForColumns, columnTracks); | 549 LayoutUnit overrideContainingBlockContentLogicalWidth = gridAreaBreadthForCh ild(child, ForColumns, columnTracks); |
565 if (child->style()->logicalHeight().isPercent() || oldOverrideContainingBloc kContentLogicalWidth != overrideContainingBlockContentLogicalWidth) | 550 if (child->style()->logicalHeight().isPercent() || oldOverrideContainingBloc kContentLogicalWidth != overrideContainingBlockContentLogicalWidth) |
566 layoutScope.setNeedsLayout(child); | 551 layoutScope.setNeedsLayout(child); |
567 | 552 |
568 child->setOverrideContainingBlockContentLogicalWidth(overrideContainingBlock ContentLogicalWidth); | 553 child->setOverrideContainingBlockContentLogicalWidth(overrideContainingBlock ContentLogicalWidth); |
569 // If |child| has a percentage logical height, we shouldn't let it override its intrinsic height, which is | 554 // If |child| has a percentage logical height, we shouldn't let it override its intrinsic height, which is |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
622 | 607 |
623 GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[i ] : sizingData.rowTracks[i]; | 608 GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[i ] : sizingData.rowTracks[i]; |
624 if (track.m_maxBreadth == infinity) | 609 if (track.m_maxBreadth == infinity) |
625 track.m_maxBreadth = track.m_usedBreadth; | 610 track.m_maxBreadth = track.m_usedBreadth; |
626 } | 611 } |
627 } | 612 } |
628 | 613 |
629 void RenderGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizing Direction direction, GridSizingData& sizingData, RenderBox* gridItem, FilterFunc tion filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGette r, AccumulatorGrowFunction trackGrowthFunction) | 614 void RenderGrid::resolveContentBasedTrackSizingFunctionsForItems(GridTrackSizing Direction direction, GridSizingData& sizingData, RenderBox* gridItem, FilterFunc tion filterFunction, SizingFunction sizingFunction, AccumulatorGetter trackGette r, AccumulatorGrowFunction trackGrowthFunction) |
630 { | 615 { |
631 const GridCoordinate coordinate = cachedGridCoordinate(gridItem); | 616 const GridCoordinate coordinate = cachedGridCoordinate(gridItem); |
632 const size_t initialTrackIndex = (direction == ForColumns) ? coordinate.colu mns.initialPositionIndex : coordinate.rows.initialPositionIndex; | 617 const GridResolvedPosition initialTrackPosition = (direction == ForColumns) ? coordinate.columns.resolvedInitialPosition : coordinate.rows.resolvedInitialPo sition; |
633 const size_t finalTrackIndex = (direction == ForColumns) ? coordinate.column s.finalPositionIndex : coordinate.rows.finalPositionIndex; | 618 const GridResolvedPosition finalTrackPosition = (direction == ForColumns) ? coordinate.columns.resolvedFinalPosition : coordinate.rows.resolvedFinalPosition ; |
634 | 619 |
635 sizingData.filteredTracks.shrink(0); | 620 sizingData.filteredTracks.shrink(0); |
636 for (size_t trackIndex = initialTrackIndex; trackIndex <= finalTrackIndex; + +trackIndex) { | 621 for (GridResolvedPosition trackPosition = initialTrackPosition; trackPositio n <= finalTrackPosition; ++trackPosition) { |
637 const GridTrackSize& trackSize = gridTrackSize(direction, trackIndex); | 622 const GridTrackSize& trackSize = gridTrackSize(direction, trackPosition) ; |
638 if (!(trackSize.*filterFunction)()) | 623 if (!(trackSize.*filterFunction)()) |
639 continue; | 624 continue; |
640 | 625 |
641 GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[t rackIndex] : sizingData.rowTracks[trackIndex]; | 626 GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[t rackPosition] : sizingData.rowTracks[trackPosition]; |
642 sizingData.filteredTracks.append(&track); | 627 sizingData.filteredTracks.append(&track); |
643 } | 628 } |
644 | 629 |
645 if (sizingData.filteredTracks.isEmpty()) | 630 if (sizingData.filteredTracks.isEmpty()) |
646 return; | 631 return; |
647 | 632 |
648 LayoutUnit additionalBreadthSpace = (this->*sizingFunction)(gridItem, direct ion, sizingData.columnTracks); | 633 LayoutUnit additionalBreadthSpace = (this->*sizingFunction)(gridItem, direct ion, sizingData.columnTracks); |
649 for (size_t trackIndexForSpace = initialTrackIndex; trackIndexForSpace <= fi nalTrackIndex; ++trackIndexForSpace) { | 634 for (size_t trackIndexForSpace = initialTrackPosition; trackIndexForSpace <= finalTrackPosition; ++trackIndexForSpace) { |
650 GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[t rackIndexForSpace] : sizingData.rowTracks[trackIndexForSpace]; | 635 GridTrack& track = (direction == ForColumns) ? sizingData.columnTracks[t rackIndexForSpace] : sizingData.rowTracks[trackIndexForSpace]; |
651 additionalBreadthSpace -= (track.*trackGetter)(); | 636 additionalBreadthSpace -= (track.*trackGetter)(); |
652 } | 637 } |
653 | 638 |
654 // FIXME: We should pass different values for |tracksForGrowthAboveMaxBreadt h|. | 639 // FIXME: We should pass different values for |tracksForGrowthAboveMaxBreadt h|. |
655 distributeSpaceToTracks(sizingData.filteredTracks, &sizingData.filteredTrack s, trackGetter, trackGrowthFunction, sizingData, additionalBreadthSpace); | 640 distributeSpaceToTracks(sizingData.filteredTracks, &sizingData.filteredTrack s, trackGetter, trackGrowthFunction, sizingData, additionalBreadthSpace); |
656 } | 641 } |
657 | 642 |
658 static bool sortByGridTrackGrowthPotential(const GridTrack* track1, const GridTr ack* track2) | 643 static bool sortByGridTrackGrowthPotential(const GridTrack* track1, const GridTr ack* track2) |
659 { | 644 { |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
717 m_grid[row].grow(oldColumnSize + 1); | 702 m_grid[row].grow(oldColumnSize + 1); |
718 } else { | 703 } else { |
719 const size_t oldRowSize = m_grid.size(); | 704 const size_t oldRowSize = m_grid.size(); |
720 m_grid.grow(oldRowSize + 1); | 705 m_grid.grow(oldRowSize + 1); |
721 m_grid[oldRowSize].grow(m_grid[0].size()); | 706 m_grid[oldRowSize].grow(m_grid[0].size()); |
722 } | 707 } |
723 } | 708 } |
724 | 709 |
725 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridCoordinate& coor dinate) | 710 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridCoordinate& coor dinate) |
726 { | 711 { |
727 for (size_t row = coordinate.rows.initialPositionIndex; row <= coordinate.ro ws.finalPositionIndex; ++row) { | 712 for (GridResolvedPosition row = coordinate.rows.resolvedInitialPosition; row <= coordinate.rows.resolvedFinalPosition; ++row) { |
728 for (size_t column = coordinate.columns.initialPositionIndex; column <= coordinate.columns.finalPositionIndex; ++column) | 713 for (GridResolvedPosition column = coordinate.columns.resolvedInitialPos ition; column <= coordinate.columns.resolvedFinalPosition; ++column) |
729 m_grid[row][column].append(child); | 714 m_grid[row][column].append(child); |
730 } | 715 } |
731 | 716 |
732 m_gridItemCoordinate.set(child, coordinate); | 717 m_gridItemCoordinate.set(child, coordinate); |
733 } | 718 } |
734 | 719 |
735 void RenderGrid::insertItemIntoGrid(RenderBox* child, size_t rowTrack, size_t co lumnTrack) | 720 void RenderGrid::insertItemIntoGrid(RenderBox* child, const GridResolvedPosition & rowTrack, const GridResolvedPosition& columnTrack) |
736 { | 721 { |
737 const GridSpan& rowSpan = resolveGridPositionsFromAutoPlacementPosition(chil d, ForRows, rowTrack); | 722 const GridSpan& rowSpan = GridResolvedPosition::resolveGridPositionsFromAuto PlacementPosition(child, ForRows, rowTrack); |
738 const GridSpan& columnSpan = resolveGridPositionsFromAutoPlacementPosition(c hild, ForColumns, columnTrack); | 723 const GridSpan& columnSpan = GridResolvedPosition::resolveGridPositionsFromA utoPlacementPosition(child, ForColumns, columnTrack); |
739 insertItemIntoGrid(child, GridCoordinate(rowSpan, columnSpan)); | 724 insertItemIntoGrid(child, GridCoordinate(rowSpan, columnSpan)); |
740 } | 725 } |
741 | 726 |
742 void RenderGrid::placeItemsOnGrid() | 727 void RenderGrid::placeItemsOnGrid() |
743 { | 728 { |
744 if (!gridIsDirty()) | 729 if (!gridIsDirty()) |
745 return; | 730 return; |
746 | 731 |
747 ASSERT(m_gridItemCoordinate.isEmpty()); | 732 ASSERT(m_gridItemCoordinate.isEmpty()); |
748 | 733 |
749 populateExplicitGridAndOrderIterator(); | 734 populateExplicitGridAndOrderIterator(); |
750 | 735 |
751 // We clear the dirty bit here as the grid sizes have been updated, this mea ns | 736 // We clear the dirty bit here as the grid sizes have been updated, this mea ns |
752 // that we can safely call gridRowCount() / gridColumnCount(). | 737 // that we can safely call gridRowCount() / gridColumnCount(). |
753 m_gridIsDirty = false; | 738 m_gridIsDirty = false; |
754 | 739 |
755 Vector<RenderBox*> autoMajorAxisAutoGridItems; | 740 Vector<RenderBox*> autoMajorAxisAutoGridItems; |
756 Vector<RenderBox*> specifiedMajorAxisAutoGridItems; | 741 Vector<RenderBox*> specifiedMajorAxisAutoGridItems; |
757 GridAutoFlow autoFlow = style()->gridAutoFlow(); | 742 GridAutoFlow autoFlow = style()->gridAutoFlow(); |
758 for (RenderBox* child = m_orderIterator.first(); child; child = m_orderItera tor.next()) { | 743 for (RenderBox* child = m_orderIterator.first(); child; child = m_orderItera tor.next()) { |
759 // FIXME: We never re-resolve positions if the grid is grown during auto -placement which may lead auto / <integer> | 744 // FIXME: We never re-resolve positions if the grid is grown during auto -placement which may lead auto / <integer> |
760 // positions to not match the author's intent. The specification is uncl ear on what should be done in this case. | 745 // positions to not match the author's intent. The specification is uncl ear on what should be done in this case. |
761 OwnPtr<GridSpan> rowPositions = resolveGridPositionsFromStyle(child, For Rows); | 746 OwnPtr<GridSpan> rowPositions = GridResolvedPosition::resolveGridPositio nsFromStyle(*style(), child, ForRows); |
762 OwnPtr<GridSpan> columnPositions = resolveGridPositionsFromStyle(child, ForColumns); | 747 OwnPtr<GridSpan> columnPositions = GridResolvedPosition::resolveGridPosi tionsFromStyle(*style(), child, ForColumns); |
763 if (!rowPositions || !columnPositions) { | 748 if (!rowPositions || !columnPositions) { |
764 GridSpan* majorAxisPositions = (autoPlacementMajorAxisDirection() == ForColumns) ? columnPositions.get() : rowPositions.get(); | 749 GridSpan* majorAxisPositions = (autoPlacementMajorAxisDirection() == ForColumns) ? columnPositions.get() : rowPositions.get(); |
765 if (!majorAxisPositions) | 750 if (!majorAxisPositions) |
766 autoMajorAxisAutoGridItems.append(child); | 751 autoMajorAxisAutoGridItems.append(child); |
767 else | 752 else |
768 specifiedMajorAxisAutoGridItems.append(child); | 753 specifiedMajorAxisAutoGridItems.append(child); |
769 continue; | 754 continue; |
770 } | 755 } |
771 insertItemIntoGrid(child, GridCoordinate(*rowPositions, *columnPositions )); | 756 insertItemIntoGrid(child, GridCoordinate(*rowPositions, *columnPositions )); |
772 } | 757 } |
(...skipping 11 matching lines...) Expand all Loading... | |
784 placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems); | 769 placeSpecifiedMajorAxisItemsOnGrid(specifiedMajorAxisAutoGridItems); |
785 placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems); | 770 placeAutoMajorAxisItemsOnGrid(autoMajorAxisAutoGridItems); |
786 | 771 |
787 m_grid.shrinkToFit(); | 772 m_grid.shrinkToFit(); |
788 } | 773 } |
789 | 774 |
790 void RenderGrid::populateExplicitGridAndOrderIterator() | 775 void RenderGrid::populateExplicitGridAndOrderIterator() |
791 { | 776 { |
792 OrderIteratorPopulator populator(m_orderIterator); | 777 OrderIteratorPopulator populator(m_orderIterator); |
793 | 778 |
794 size_t maximumRowIndex = std::max<size_t>(1, explicitGridRowCount()); | 779 size_t maximumRowIndex = std::max<size_t>(1, GridResolvedPosition::explicitG ridRowCount(*style())); |
795 size_t maximumColumnIndex = std::max<size_t>(1, explicitGridColumnCount()); | 780 size_t maximumColumnIndex = std::max<size_t>(1, GridResolvedPosition::explic itGridColumnCount(*style())); |
796 | 781 |
797 for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBo x()) { | 782 for (RenderBox* child = firstChildBox(); child; child = child->nextSiblingBo x()) { |
798 populator.collectChild(child); | 783 populator.collectChild(child); |
799 | 784 |
800 // This function bypasses the cache (cachedGridCoordinate()) as it is us ed to build it. | 785 // This function bypasses the cache (cachedGridCoordinate()) as it is us ed to build it. |
801 OwnPtr<GridSpan> rowPositions = resolveGridPositionsFromStyle(child, For Rows); | 786 OwnPtr<GridSpan> rowPositions = GridResolvedPosition::resolveGridPositio nsFromStyle(*style(), child, ForRows); |
802 OwnPtr<GridSpan> columnPositions = resolveGridPositionsFromStyle(child, ForColumns); | 787 OwnPtr<GridSpan> columnPositions = GridResolvedPosition::resolveGridPosi tionsFromStyle(*style(), child, ForColumns); |
803 | 788 |
804 // |positions| is 0 if we need to run the auto-placement algorithm. Our estimation ignores | 789 // |positions| is 0 if we need to run the auto-placement algorithm. Our estimation ignores |
805 // this case as the auto-placement algorithm will grow the grid as neede d. | 790 // this case as the auto-placement algorithm will grow the grid as neede d. |
806 if (rowPositions) | 791 if (rowPositions) |
807 maximumRowIndex = std::max(maximumRowIndex, rowPositions->finalPosit ionIndex + 1); | 792 maximumRowIndex = std::max<size_t>(maximumRowIndex, rowPositions->re solvedFinalPosition.next()); |
808 if (columnPositions) | 793 if (columnPositions) |
809 maximumColumnIndex = std::max(maximumColumnIndex, columnPositions->f inalPositionIndex + 1); | 794 maximumColumnIndex = std::max<size_t>(maximumColumnIndex, columnPosi tions->resolvedFinalPosition.next()); |
Julien - ping for review
2014/03/21 23:49:27
Do we need GridResolvedPosition::next() or would t
| |
810 } | 795 } |
811 | 796 |
812 m_grid.grow(maximumRowIndex); | 797 m_grid.grow(maximumRowIndex); |
813 for (size_t i = 0; i < m_grid.size(); ++i) | 798 for (size_t i = 0; i < m_grid.size(); ++i) |
814 m_grid[i].grow(maximumColumnIndex); | 799 m_grid[i].grow(maximumColumnIndex); |
815 } | 800 } |
816 | 801 |
817 void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& au toGridItems) | 802 void RenderGrid::placeSpecifiedMajorAxisItemsOnGrid(const Vector<RenderBox*>& au toGridItems) |
818 { | 803 { |
819 for (size_t i = 0; i < autoGridItems.size(); ++i) { | 804 for (size_t i = 0; i < autoGridItems.size(); ++i) { |
820 OwnPtr<GridSpan> majorAxisPositions = resolveGridPositionsFromStyle(auto GridItems[i], autoPlacementMajorAxisDirection()); | 805 OwnPtr<GridSpan> majorAxisPositions = GridResolvedPosition::resolveGridP ositionsFromStyle(*style(), autoGridItems[i], autoPlacementMajorAxisDirection()) ; |
821 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAx isPositions->initialPositionIndex); | 806 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), majorAx isPositions->resolvedInitialPosition); |
822 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) { | 807 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) { |
823 insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPosi tionIndex, emptyGridArea->columns.initialPositionIndex); | 808 insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.resolvedIni tialPosition, emptyGridArea->columns.resolvedInitialPosition); |
824 continue; | 809 continue; |
825 } | 810 } |
826 | 811 |
827 growGrid(autoPlacementMinorAxisDirection()); | 812 growGrid(autoPlacementMinorAxisDirection()); |
828 OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(); | 813 OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea(); |
829 ASSERT(emptyGridArea); | 814 ASSERT(emptyGridArea); |
830 insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.initialPosition Index, emptyGridArea->columns.initialPositionIndex); | 815 insertItemIntoGrid(autoGridItems[i], emptyGridArea->rows.resolvedInitial Position, emptyGridArea->columns.resolvedInitialPosition); |
831 } | 816 } |
832 } | 817 } |
833 | 818 |
834 void RenderGrid::placeAutoMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGri dItems) | 819 void RenderGrid::placeAutoMajorAxisItemsOnGrid(const Vector<RenderBox*>& autoGri dItems) |
835 { | 820 { |
836 for (size_t i = 0; i < autoGridItems.size(); ++i) | 821 for (size_t i = 0; i < autoGridItems.size(); ++i) |
837 placeAutoMajorAxisItemOnGrid(autoGridItems[i]); | 822 placeAutoMajorAxisItemOnGrid(autoGridItems[i]); |
838 } | 823 } |
839 | 824 |
840 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem) | 825 void RenderGrid::placeAutoMajorAxisItemOnGrid(RenderBox* gridItem) |
841 { | 826 { |
842 OwnPtr<GridSpan> minorAxisPositions = resolveGridPositionsFromStyle(gridItem , autoPlacementMinorAxisDirection()); | 827 OwnPtr<GridSpan> minorAxisPositions = GridResolvedPosition::resolveGridPosit ionsFromStyle(*style(), gridItem, autoPlacementMinorAxisDirection()); |
843 ASSERT(!resolveGridPositionsFromStyle(gridItem, autoPlacementMajorAxisDirect ion())); | 828 ASSERT(!GridResolvedPosition::resolveGridPositionsFromStyle(*style(), gridIt em, autoPlacementMajorAxisDirection())); |
844 size_t minorAxisIndex = 0; | 829 size_t minorAxisIndex = 0; |
845 if (minorAxisPositions) { | 830 if (minorAxisPositions) { |
846 minorAxisIndex = minorAxisPositions->initialPositionIndex; | 831 minorAxisIndex = minorAxisPositions->resolvedInitialPosition; |
847 GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAx isIndex); | 832 GridIterator iterator(m_grid, autoPlacementMinorAxisDirection(), minorAx isIndex); |
848 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) { | 833 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridArea()) { |
849 insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPositionInde x, emptyGridArea->columns.initialPositionIndex); | 834 insertItemIntoGrid(gridItem, emptyGridArea->rows.resolvedInitialPosi tion, emptyGridArea->columns.resolvedInitialPosition); |
850 return; | 835 return; |
851 } | 836 } |
852 } else { | 837 } else { |
853 const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForC olumns) ? gridColumnCount() : gridRowCount(); | 838 const size_t endOfMajorAxis = (autoPlacementMajorAxisDirection() == ForC olumns) ? gridColumnCount() : gridRowCount(); |
854 for (size_t majorAxisIndex = 0; majorAxisIndex < endOfMajorAxis; ++major AxisIndex) { | 839 for (size_t majorAxisIndex = 0; majorAxisIndex < endOfMajorAxis; ++major AxisIndex) { |
855 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), maj orAxisIndex); | 840 GridIterator iterator(m_grid, autoPlacementMajorAxisDirection(), maj orAxisIndex); |
856 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridAre a()) { | 841 if (OwnPtr<GridCoordinate> emptyGridArea = iterator.nextEmptyGridAre a()) { |
857 insertItemIntoGrid(gridItem, emptyGridArea->rows.initialPosition Index, emptyGridArea->columns.initialPositionIndex); | 842 insertItemIntoGrid(gridItem, emptyGridArea->rows.resolvedInitial Position, emptyGridArea->columns.resolvedInitialPosition); |
858 return; | 843 return; |
859 } | 844 } |
860 } | 845 } |
861 } | 846 } |
862 | 847 |
863 // 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. | 848 // 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. |
864 const size_t columnIndex = (autoPlacementMajorAxisDirection() == ForColumns) ? m_grid[0].size() : minorAxisIndex; | 849 const size_t columnIndex = (autoPlacementMajorAxisDirection() == ForColumns) ? m_grid[0].size() : minorAxisIndex; |
865 const size_t rowIndex = (autoPlacementMajorAxisDirection() == ForColumns) ? minorAxisIndex : m_grid.size(); | 850 const size_t rowIndex = (autoPlacementMajorAxisDirection() == ForColumns) ? minorAxisIndex : m_grid.size(); |
866 growGrid(autoPlacementMajorAxisDirection()); | 851 growGrid(autoPlacementMajorAxisDirection()); |
867 insertItemIntoGrid(gridItem, rowIndex, columnIndex); | 852 insertItemIntoGrid(gridItem, rowIndex, columnIndex); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
922 | 907 |
923 LayoutRect oldChildRect = child->frameRect(); | 908 LayoutRect oldChildRect = child->frameRect(); |
924 | 909 |
925 // FIXME: Grid items should stretch to fill their cells. Once we | 910 // FIXME: Grid items should stretch to fill their cells. Once we |
926 // implement grid-{column,row}-align, we can also shrink to fit. For | 911 // implement grid-{column,row}-align, we can also shrink to fit. For |
927 // now, just size as if we were a regular child. | 912 // now, just size as if we were a regular child. |
928 child->layoutIfNeeded(); | 913 child->layoutIfNeeded(); |
929 | 914 |
930 #ifndef NDEBUG | 915 #ifndef NDEBUG |
931 const GridCoordinate& coordinate = cachedGridCoordinate(child); | 916 const GridCoordinate& coordinate = cachedGridCoordinate(child); |
932 ASSERT(coordinate.columns.initialPositionIndex < sizingData.columnTracks .size()); | 917 ASSERT(coordinate.columns.resolvedInitialPosition < sizingData.columnTra cks.size()); |
933 ASSERT(coordinate.rows.initialPositionIndex < sizingData.rowTracks.size( )); | 918 ASSERT(coordinate.rows.resolvedInitialPosition < sizingData.rowTracks.si ze()); |
934 #endif | 919 #endif |
935 child->setLogicalLocation(findChildLogicalPosition(child)); | 920 child->setLogicalLocation(findChildLogicalPosition(child)); |
936 | 921 |
937 // Keep track of children overflowing their grid area as we might need t o paint them even if the grid-area is | 922 // Keep track of children overflowing their grid area as we might need t o paint them even if the grid-area is |
938 // not visible | 923 // not visible |
939 if (child->logicalHeight() > overrideContainingBlockContentLogicalHeight | 924 if (child->logicalHeight() > overrideContainingBlockContentLogicalHeight |
940 || child->logicalWidth() > overrideContainingBlockContentLogicalWidt h) | 925 || child->logicalWidth() > overrideContainingBlockContentLogicalWidt h) |
941 m_gridItemsOverflowingGridArea.append(child); | 926 m_gridItemsOverflowingGridArea.append(child); |
942 | 927 |
943 // If the child moved, we have to repaint it as well as any floating/pos itioned | 928 // If the child moved, we have to repaint it as well as any floating/pos itioned |
(...skipping 10 matching lines...) Expand all Loading... | |
954 | 939 |
955 setLogicalHeight(logicalHeight() + borderAndPaddingLogicalHeight()); | 940 setLogicalHeight(logicalHeight() + borderAndPaddingLogicalHeight()); |
956 } | 941 } |
957 | 942 |
958 GridCoordinate RenderGrid::cachedGridCoordinate(const RenderBox* gridItem) const | 943 GridCoordinate RenderGrid::cachedGridCoordinate(const RenderBox* gridItem) const |
959 { | 944 { |
960 ASSERT(m_gridItemCoordinate.contains(gridItem)); | 945 ASSERT(m_gridItemCoordinate.contains(gridItem)); |
961 return m_gridItemCoordinate.get(gridItem); | 946 return m_gridItemCoordinate.get(gridItem); |
962 } | 947 } |
963 | 948 |
964 GridSpan RenderGrid::resolveGridPositionsFromAutoPlacementPosition(const RenderB ox*, GridTrackSizingDirection, size_t initialPosition) const | |
965 { | |
966 // FIXME: We don't support spanning with auto positions yet. Once we do, thi s is wrong. Also we should make | |
967 // sure the grid can accomodate the new item as we only grow 1 position in a given direction. | |
968 return GridSpan(initialPosition, initialPosition); | |
969 } | |
970 | |
971 PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionsFromStyle(const RenderBox* gridItem, GridTrackSizingDirection direction) const | |
972 { | |
973 const GridPosition& initialPosition = (direction == ForColumns) ? gridItem-> style()->gridColumnStart() : gridItem->style()->gridRowStart(); | |
974 const GridPositionSide initialPositionSide = (direction == ForColumns) ? Col umnStartSide : RowStartSide; | |
975 const GridPosition& finalPosition = (direction == ForColumns) ? gridItem->st yle()->gridColumnEnd() : gridItem->style()->gridRowEnd(); | |
976 const GridPositionSide finalPositionSide = (direction == ForColumns) ? Colum nEndSide : RowEndSide; | |
977 | |
978 // We should NEVER see both spans as they should have been handled during st yle resolve. | |
979 ASSERT(!initialPosition.isSpan() || !finalPosition.isSpan()); | |
980 | |
981 if (initialPosition.shouldBeResolvedAgainstOppositePosition() && finalPositi on.shouldBeResolvedAgainstOppositePosition()) { | |
982 if (style()->gridAutoFlow() == AutoFlowNone) | |
983 return adoptPtr(new GridSpan(0, 0)); | |
984 | |
985 // We can't get our grid positions without running the auto placement al gorithm. | |
986 return nullptr; | |
987 } | |
988 | |
989 if (initialPosition.shouldBeResolvedAgainstOppositePosition()) { | |
990 // Infer the position from the final position ('auto / 1' or 'span 2 / 3 ' case). | |
991 const size_t finalResolvedPosition = resolveGridPositionFromStyle(finalP osition, finalPositionSide); | |
992 return resolveGridPositionAgainstOppositePosition(finalResolvedPosition, initialPosition, initialPositionSide); | |
993 } | |
994 | |
995 if (finalPosition.shouldBeResolvedAgainstOppositePosition()) { | |
996 // Infer our position from the initial position ('1 / auto' or '3 / span 2' case). | |
997 const size_t initialResolvedPosition = resolveGridPositionFromStyle(init ialPosition, initialPositionSide); | |
998 return resolveGridPositionAgainstOppositePosition(initialResolvedPositio n, finalPosition, finalPositionSide); | |
999 } | |
1000 | |
1001 size_t resolvedInitialPosition = resolveGridPositionFromStyle(initialPositio n, initialPositionSide); | |
1002 size_t resolvedFinalPosition = resolveGridPositionFromStyle(finalPosition, f inalPositionSide); | |
1003 | |
1004 // If 'grid-after' specifies a line at or before that specified by 'grid-bef ore', it computes to 'span 1'. | |
1005 if (resolvedFinalPosition < resolvedInitialPosition) | |
1006 resolvedFinalPosition = resolvedInitialPosition; | |
1007 | |
1008 return adoptPtr(new GridSpan(resolvedInitialPosition, resolvedFinalPosition) ); | |
1009 } | |
1010 | |
1011 size_t RenderGrid::resolveNamedGridLinePositionFromStyle(const GridPosition& pos ition, GridPositionSide side) const | |
1012 { | |
1013 ASSERT(!position.namedGridLine().isNull()); | |
1014 | |
1015 const NamedGridLinesMap& gridLinesNames = (side == ColumnStartSide || side = = ColumnEndSide) ? style()->namedGridColumnLines() : style()->namedGridRowLines( ); | |
1016 NamedGridLinesMap::const_iterator it = gridLinesNames.find(position.namedGri dLine()); | |
1017 if (it == gridLinesNames.end()) { | |
1018 if (position.isPositive()) | |
1019 return 0; | |
1020 const size_t lastLine = explicitGridSizeForSide(side); | |
1021 return GridPosition::adjustGridPositionForSide(lastLine, side); | |
1022 } | |
1023 | |
1024 size_t namedGridLineIndex; | |
1025 if (position.isPositive()) | |
1026 namedGridLineIndex = std::min<size_t>(position.integerPosition(), it->va lue.size()) - 1; | |
1027 else | |
1028 namedGridLineIndex = std::max<int>(it->value.size() - abs(position.integ erPosition()), 0); | |
1029 return GridPosition::adjustGridPositionForSide(it->value[namedGridLineIndex] , side); | |
1030 } | |
1031 | |
1032 size_t RenderGrid::resolveGridPositionFromStyle(const GridPosition& position, Gr idPositionSide side) const | |
1033 { | |
1034 switch (position.type()) { | |
1035 case ExplicitPosition: { | |
1036 ASSERT(position.integerPosition()); | |
1037 | |
1038 if (!position.namedGridLine().isNull()) | |
1039 return resolveNamedGridLinePositionFromStyle(position, side); | |
1040 | |
1041 // Handle <integer> explicit position. | |
1042 if (position.isPositive()) | |
1043 return GridPosition::adjustGridPositionForSide(position.integerPosit ion() - 1, side); | |
1044 | |
1045 size_t resolvedPosition = abs(position.integerPosition()) - 1; | |
1046 const size_t endOfTrack = explicitGridSizeForSide(side); | |
1047 | |
1048 // Per http://lists.w3.org/Archives/Public/www-style/2013Mar/0589.html, we clamp negative value to the first line. | |
1049 if (endOfTrack < resolvedPosition) | |
1050 return 0; | |
1051 | |
1052 return GridPosition::adjustGridPositionForSide(endOfTrack - resolvedPosi tion, side); | |
1053 } | |
1054 case NamedGridAreaPosition: | |
1055 { | |
1056 NamedGridAreaMap::const_iterator it = style()->namedGridArea().find(posi tion.namedGridLine()); | |
1057 // Unknown grid area should have been computed to 'auto' by now. | |
1058 ASSERT_WITH_SECURITY_IMPLICATION(it != style()->namedGridArea().end()); | |
1059 const GridCoordinate& gridAreaCoordinate = it->value; | |
1060 switch (side) { | |
1061 case ColumnStartSide: | |
1062 return gridAreaCoordinate.columns.initialPositionIndex; | |
1063 case ColumnEndSide: | |
1064 return gridAreaCoordinate.columns.finalPositionIndex; | |
1065 case RowStartSide: | |
1066 return gridAreaCoordinate.rows.initialPositionIndex; | |
1067 case RowEndSide: | |
1068 return gridAreaCoordinate.rows.finalPositionIndex; | |
1069 } | |
1070 ASSERT_NOT_REACHED(); | |
1071 return 0; | |
1072 } | |
1073 case AutoPosition: | |
1074 case SpanPosition: | |
1075 // 'auto' and span depend on the opposite position for resolution (e.g. grid-row: auto / 1 or grid-column: span 3 / "myHeader"). | |
1076 ASSERT_NOT_REACHED(); | |
1077 return 0; | |
1078 } | |
1079 ASSERT_NOT_REACHED(); | |
1080 return 0; | |
1081 } | |
1082 | |
1083 PassOwnPtr<GridSpan> RenderGrid::resolveGridPositionAgainstOppositePosition(size _t resolvedOppositePosition, const GridPosition& position, GridPositionSide side ) const | |
1084 { | |
1085 if (position.isAuto()) | |
1086 return GridSpan::create(resolvedOppositePosition, resolvedOppositePositi on); | |
1087 | |
1088 ASSERT(position.isSpan()); | |
1089 ASSERT(position.spanPosition() > 0); | |
1090 | |
1091 if (!position.namedGridLine().isNull()) { | |
1092 // span 2 'c' -> we need to find the appropriate grid line before / afte r our opposite position. | |
1093 return resolveNamedGridLinePositionAgainstOppositePosition(resolvedOppos itePosition, position, side); | |
1094 } | |
1095 | |
1096 return GridSpan::createWithSpanAgainstOpposite(resolvedOppositePosition, pos ition, side); | |
1097 } | |
1098 | |
1099 PassOwnPtr<GridSpan> RenderGrid::resolveNamedGridLinePositionAgainstOppositePosi tion(size_t resolvedOppositePosition, const GridPosition& position, GridPosition Side side) const | |
1100 { | |
1101 ASSERT(position.isSpan()); | |
1102 ASSERT(!position.namedGridLine().isNull()); | |
1103 // Negative positions are not allowed per the specification and should have been handled during parsing. | |
1104 ASSERT(position.spanPosition() > 0); | |
1105 | |
1106 const NamedGridLinesMap& gridLinesNames = (side == ColumnStartSide || side = = ColumnEndSide) ? style()->namedGridColumnLines() : style()->namedGridRowLines( ); | |
1107 NamedGridLinesMap::const_iterator it = gridLinesNames.find(position.namedGri dLine()); | |
1108 | |
1109 // If there is no named grid line of that name, we resolve the position to ' auto' (which is equivalent to 'span 1' in this case). | |
1110 // See http://lists.w3.org/Archives/Public/www-style/2013Jun/0394.html. | |
1111 if (it == gridLinesNames.end()) | |
1112 return GridSpan::create(resolvedOppositePosition, resolvedOppositePositi on); | |
1113 | |
1114 return GridSpan::createWithNamedSpanAgainstOpposite(resolvedOppositePosition , position, side, it->value); | |
1115 } | |
1116 | |
1117 LayoutUnit RenderGrid::gridAreaBreadthForChild(const RenderBox* child, GridTrack SizingDirection direction, const Vector<GridTrack>& tracks) const | 949 LayoutUnit RenderGrid::gridAreaBreadthForChild(const RenderBox* child, GridTrack SizingDirection direction, const Vector<GridTrack>& tracks) const |
1118 { | 950 { |
1119 const GridCoordinate& coordinate = cachedGridCoordinate(child); | 951 const GridCoordinate& coordinate = cachedGridCoordinate(child); |
1120 const GridSpan& span = (direction == ForColumns) ? coordinate.columns : coor dinate.rows; | 952 const GridSpan& span = (direction == ForColumns) ? coordinate.columns : coor dinate.rows; |
1121 LayoutUnit gridAreaBreadth = 0; | 953 LayoutUnit gridAreaBreadth = 0; |
1122 for (size_t trackIndex = span.initialPositionIndex; trackIndex <= span.final PositionIndex; ++trackIndex) | 954 for (GridResolvedPosition trackPosition = span.resolvedInitialPosition; trac kPosition <= span.resolvedFinalPosition; ++trackPosition) |
Julien - ping for review
2014/03/21 23:49:27
FWIW this seems to be repeated a lot, maybe it wou
| |
1123 gridAreaBreadth += tracks[trackIndex].m_usedBreadth; | 955 gridAreaBreadth += tracks[trackPosition].m_usedBreadth; |
1124 return gridAreaBreadth; | 956 return gridAreaBreadth; |
1125 } | 957 } |
1126 | 958 |
1127 void RenderGrid::populateGridPositions(const GridSizingData& sizingData) | 959 void RenderGrid::populateGridPositions(const GridSizingData& sizingData) |
1128 { | 960 { |
1129 m_columnPositions.resize(sizingData.columnTracks.size() + 1); | 961 m_columnPositions.resize(sizingData.columnTracks.size() + 1); |
1130 m_columnPositions[0] = borderAndPaddingStart(); | 962 m_columnPositions[0] = borderAndPaddingStart(); |
1131 for (size_t i = 0; i < m_columnPositions.size() - 1; ++i) | 963 for (size_t i = 0; i < m_columnPositions.size() - 1; ++i) |
1132 m_columnPositions[i + 1] = m_columnPositions[i] + sizingData.columnTrack s[i].m_usedBreadth; | 964 m_columnPositions[i + 1] = m_columnPositions[i] + sizingData.columnTrack s[i].m_usedBreadth; |
1133 | 965 |
1134 m_rowPositions.resize(sizingData.rowTracks.size() + 1); | 966 m_rowPositions.resize(sizingData.rowTracks.size() + 1); |
1135 m_rowPositions[0] = borderAndPaddingBefore(); | 967 m_rowPositions[0] = borderAndPaddingBefore(); |
1136 for (size_t i = 0; i < m_rowPositions.size() - 1; ++i) | 968 for (size_t i = 0; i < m_rowPositions.size() - 1; ++i) |
1137 m_rowPositions[i + 1] = m_rowPositions[i] + sizingData.rowTracks[i].m_us edBreadth; | 969 m_rowPositions[i + 1] = m_rowPositions[i] + sizingData.rowTracks[i].m_us edBreadth; |
1138 } | 970 } |
1139 | 971 |
1140 LayoutUnit RenderGrid::startOfColumnForChild(const RenderBox* child) const | 972 LayoutUnit RenderGrid::startOfColumnForChild(const RenderBox* child) const |
1141 { | 973 { |
1142 const GridCoordinate& coordinate = cachedGridCoordinate(child); | 974 const GridCoordinate& coordinate = cachedGridCoordinate(child); |
1143 LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPosit ionIndex]; | 975 LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.resolvedInit ialPosition]; |
1144 // The grid items should be inside the grid container's border box, that's w hy they need to be shifted. | 976 // The grid items should be inside the grid container's border box, that's w hy they need to be shifted. |
1145 // FIXME: This should account for the grid item's <overflow-position>. | 977 // FIXME: This should account for the grid item's <overflow-position>. |
1146 return startOfColumn + marginStartForChild(child); | 978 return startOfColumn + marginStartForChild(child); |
1147 } | 979 } |
1148 | 980 |
1149 LayoutUnit RenderGrid::endOfColumnForChild(const RenderBox* child) const | 981 LayoutUnit RenderGrid::endOfColumnForChild(const RenderBox* child) const |
1150 { | 982 { |
1151 const GridCoordinate& coordinate = cachedGridCoordinate(child); | 983 const GridCoordinate& coordinate = cachedGridCoordinate(child); |
1152 LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPosit ionIndex]; | 984 LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.resolvedInit ialPosition]; |
1153 // The grid items should be inside the grid container's border box, that's w hy they need to be shifted. | 985 // The grid items should be inside the grid container's border box, that's w hy they need to be shifted. |
1154 LayoutUnit columnPosition = startOfColumn + marginStartForChild(child); | 986 LayoutUnit columnPosition = startOfColumn + marginStartForChild(child); |
1155 | 987 |
1156 LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.finalPositionI ndex + 1]; | 988 LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.resolvedFinalP osition.next()]; |
1157 // FIXME: This should account for the grid item's <overflow-position>. | 989 // FIXME: This should account for the grid item's <overflow-position>. |
1158 return columnPosition + std::max<LayoutUnit>(0, endOfColumn - m_columnPositi ons[coordinate.columns.initialPositionIndex] - child->logicalWidth()); | 990 return columnPosition + std::max<LayoutUnit>(0, endOfColumn - m_columnPositi ons[coordinate.columns.resolvedInitialPosition] - child->logicalWidth()); |
1159 } | 991 } |
1160 | 992 |
1161 LayoutUnit RenderGrid::columnPositionAlignedWithGridContainerStart(const RenderB ox* child) const | 993 LayoutUnit RenderGrid::columnPositionAlignedWithGridContainerStart(const RenderB ox* child) const |
1162 { | 994 { |
1163 if (style()->isLeftToRightDirection()) | 995 if (style()->isLeftToRightDirection()) |
1164 return startOfColumnForChild(child); | 996 return startOfColumnForChild(child); |
1165 | 997 |
1166 return endOfColumnForChild(child); | 998 return endOfColumnForChild(child); |
1167 } | 999 } |
1168 | 1000 |
1169 LayoutUnit RenderGrid::columnPositionAlignedWithGridContainerEnd(const RenderBox * child) const | 1001 LayoutUnit RenderGrid::columnPositionAlignedWithGridContainerEnd(const RenderBox * child) const |
1170 { | 1002 { |
1171 if (!style()->isLeftToRightDirection()) | 1003 if (!style()->isLeftToRightDirection()) |
1172 return startOfColumnForChild(child); | 1004 return startOfColumnForChild(child); |
1173 | 1005 |
1174 return endOfColumnForChild(child); | 1006 return endOfColumnForChild(child); |
1175 } | 1007 } |
1176 | 1008 |
1177 LayoutUnit RenderGrid::centeredColumnPositionForChild(const RenderBox* child) co nst | 1009 LayoutUnit RenderGrid::centeredColumnPositionForChild(const RenderBox* child) co nst |
1178 { | 1010 { |
1179 const GridCoordinate& coordinate = cachedGridCoordinate(child); | 1011 const GridCoordinate& coordinate = cachedGridCoordinate(child); |
1180 LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.initialPosit ionIndex]; | 1012 LayoutUnit startOfColumn = m_columnPositions[coordinate.columns.resolvedInit ialPosition]; |
1181 LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.finalPositionI ndex + 1]; | 1013 LayoutUnit endOfColumn = m_columnPositions[coordinate.columns.resolvedFinalP osition.next()]; |
1182 LayoutUnit columnPosition = startOfColumn + marginStartForChild(child); | 1014 LayoutUnit columnPosition = startOfColumn + marginStartForChild(child); |
1183 return columnPosition + std::max<LayoutUnit>(0, endOfColumn - startOfColumn - child->logicalWidth()) / 2; | 1015 return columnPosition + std::max<LayoutUnit>(0, endOfColumn - startOfColumn - child->logicalWidth()) / 2; |
1184 } | 1016 } |
1185 | 1017 |
1186 LayoutUnit RenderGrid::columnPositionForChild(const RenderBox* child) const | 1018 LayoutUnit RenderGrid::columnPositionForChild(const RenderBox* child) const |
1187 { | 1019 { |
1188 ItemPosition childJustifySelf = child->style()->justifySelf(); | 1020 ItemPosition childJustifySelf = child->style()->justifySelf(); |
1189 switch (childJustifySelf) { | 1021 switch (childJustifySelf) { |
1190 case ItemPositionSelfStart: | 1022 case ItemPositionSelfStart: |
1191 // self-start is based on the child's direction. That's why we need to c heck against the grid container's direction. | 1023 // self-start is based on the child's direction. That's why we need to c heck against the grid container's direction. |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1240 | 1072 |
1241 ASSERT_NOT_REACHED(); | 1073 ASSERT_NOT_REACHED(); |
1242 return 0; | 1074 return 0; |
1243 } | 1075 } |
1244 | 1076 |
1245 LayoutUnit RenderGrid::rowPositionForChild(const RenderBox* child) const | 1077 LayoutUnit RenderGrid::rowPositionForChild(const RenderBox* child) const |
1246 { | 1078 { |
1247 const GridCoordinate& coordinate = cachedGridCoordinate(child); | 1079 const GridCoordinate& coordinate = cachedGridCoordinate(child); |
1248 | 1080 |
1249 // The grid items should be inside the grid container's border box, that's w hy they need to be shifted. | 1081 // The grid items should be inside the grid container's border box, that's w hy they need to be shifted. |
1250 LayoutUnit startOfRow = m_rowPositions[coordinate.rows.initialPositionIndex] ; | 1082 LayoutUnit startOfRow = m_rowPositions[coordinate.rows.resolvedInitialPositi on]; |
1251 LayoutUnit rowPosition = startOfRow + marginBeforeForChild(child); | 1083 LayoutUnit rowPosition = startOfRow + marginBeforeForChild(child); |
1252 | 1084 |
1253 // FIXME: This function should account for 'align-self'. | 1085 // FIXME: This function should account for 'align-self'. |
1254 | 1086 |
1255 return rowPosition; | 1087 return rowPosition; |
1256 } | 1088 } |
1257 | 1089 |
1258 LayoutPoint RenderGrid::findChildLogicalPosition(const RenderBox* child) const | 1090 LayoutPoint RenderGrid::findChildLogicalPosition(const RenderBox* child) const |
1259 { | 1091 { |
1260 return LayoutPoint(columnPositionForChild(child), rowPositionForChild(child) ); | 1092 return LayoutPoint(columnPositionForChild(child), rowPositionForChild(child) ); |
(...skipping 14 matching lines...) Expand all Loading... | |
1275 | 1107 |
1276 class GridCoordinateSorter { | 1108 class GridCoordinateSorter { |
1277 public: | 1109 public: |
1278 GridCoordinateSorter(RenderGrid* renderer) : m_renderer(renderer) { } | 1110 GridCoordinateSorter(RenderGrid* renderer) : m_renderer(renderer) { } |
1279 | 1111 |
1280 bool operator()(const RenderBox* firstItem, const RenderBox* secondItem) con st | 1112 bool operator()(const RenderBox* firstItem, const RenderBox* secondItem) con st |
1281 { | 1113 { |
1282 GridCoordinate first = m_renderer->cachedGridCoordinate(firstItem); | 1114 GridCoordinate first = m_renderer->cachedGridCoordinate(firstItem); |
1283 GridCoordinate second = m_renderer->cachedGridCoordinate(secondItem); | 1115 GridCoordinate second = m_renderer->cachedGridCoordinate(secondItem); |
1284 | 1116 |
1285 if (first.rows.initialPositionIndex < second.rows.initialPositionIndex) | 1117 if (first.rows.resolvedInitialPosition < second.rows.resolvedInitialPosi tion) |
1286 return true; | 1118 return true; |
1287 if (first.rows.initialPositionIndex > second.rows.initialPositionIndex) | 1119 if (first.rows.resolvedInitialPosition > second.rows.resolvedInitialPosi tion) |
1288 return false; | 1120 return false; |
1289 return first.columns.finalPositionIndex < second.columns.finalPositionIn dex; | 1121 return first.columns.resolvedFinalPosition < second.columns.resolvedFina lPosition; |
1290 } | 1122 } |
1291 private: | 1123 private: |
1292 RenderGrid* m_renderer; | 1124 RenderGrid* m_renderer; |
1293 }; | 1125 }; |
1294 | 1126 |
1295 static inline bool isInSameRowBeforeDirtyArea(const GridCoordinate& coordinate, size_t row, const GridSpan& dirtiedColumns) | 1127 static inline bool isInSameRowBeforeDirtyArea(const GridCoordinate& coordinate, GridResolvedPosition row, const GridSpan& dirtiedColumns) |
Julien - ping for review
2014/03/21 23:49:27
const GridResolvedPosition& to avoid the copy.
| |
1296 { | 1128 { |
1297 return coordinate.rows.initialPositionIndex == row && coordinate.columns.ini tialPositionIndex < dirtiedColumns.initialPositionIndex; | 1129 return coordinate.rows.resolvedInitialPosition == row && coordinate.columns. resolvedInitialPosition < dirtiedColumns.resolvedInitialPosition; |
1298 } | 1130 } |
1299 | 1131 |
1300 static inline bool isInSameRowAfterDirtyArea(const GridCoordinate& coordinate, s ize_t row, const GridSpan& dirtiedColumns) | 1132 static inline bool isInSameRowAfterDirtyArea(const GridCoordinate& coordinate, G ridResolvedPosition row, const GridSpan& dirtiedColumns) |
Julien - ping for review
2014/03/21 23:49:27
Same comment.
| |
1301 { | 1133 { |
1302 return coordinate.rows.initialPositionIndex == row && coordinate.columns.ini tialPositionIndex >= dirtiedColumns.finalPositionIndex; | 1134 return coordinate.rows.resolvedInitialPosition == row && coordinate.columns. resolvedInitialPosition >= dirtiedColumns.resolvedFinalPosition; |
1303 } | 1135 } |
1304 | 1136 |
1305 static inline bool rowIsBeforeDirtyArea(const GridCoordinate& coordinate, const GridSpan& dirtiedRows) | 1137 static inline bool rowIsBeforeDirtyArea(const GridCoordinate& coordinate, const GridSpan& dirtiedRows) |
1306 { | 1138 { |
1307 return coordinate.rows.initialPositionIndex < dirtiedRows.initialPositionInd ex; | 1139 return coordinate.rows.resolvedInitialPosition < dirtiedRows.resolvedInitial Position; |
1308 } | 1140 } |
1309 | 1141 |
1310 void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOff set) | 1142 void RenderGrid::paintChildren(PaintInfo& paintInfo, const LayoutPoint& paintOff set) |
1311 { | 1143 { |
1312 ASSERT_WITH_SECURITY_IMPLICATION(!gridIsDirty()); | 1144 ASSERT_WITH_SECURITY_IMPLICATION(!gridIsDirty()); |
1313 | 1145 |
1314 LayoutRect localRepaintRect = paintInfo.rect; | 1146 LayoutRect localRepaintRect = paintInfo.rect; |
1315 localRepaintRect.moveBy(-paintOffset); | 1147 localRepaintRect.moveBy(-paintOffset); |
1316 | 1148 |
1317 GridSpan dirtiedColumns = dirtiedGridAreas(m_columnPositions, localRepaintRe ct.x(), localRepaintRect.maxX()); | 1149 GridSpan dirtiedColumns = dirtiedGridAreas(m_columnPositions, localRepaintRe ct.x(), localRepaintRect.maxX()); |
1318 GridSpan dirtiedRows = dirtiedGridAreas(m_rowPositions, localRepaintRect.y() , localRepaintRect.maxY()); | 1150 GridSpan dirtiedRows = dirtiedGridAreas(m_rowPositions, localRepaintRect.y() , localRepaintRect.maxY()); |
1319 | 1151 |
1320 // Sort the overflowing grid items according to their positions in the grid. We collect items during the layout | 1152 // Sort the overflowing grid items according to their positions in the grid. We collect items during the layout |
1321 // process following DOM's order but we have to paint following grid's. | 1153 // process following DOM's order but we have to paint following grid's. |
1322 std::stable_sort(m_gridItemsOverflowingGridArea.begin(), m_gridItemsOverflow ingGridArea.end(), GridCoordinateSorter(this)); | 1154 std::stable_sort(m_gridItemsOverflowingGridArea.begin(), m_gridItemsOverflow ingGridArea.end(), GridCoordinateSorter(this)); |
1323 | 1155 |
1324 OrderIterator paintIterator(this); | 1156 OrderIterator paintIterator(this); |
1325 { | 1157 { |
1326 OrderIteratorPopulator populator(paintIterator); | 1158 OrderIteratorPopulator populator(paintIterator); |
1327 Vector<RenderBox*>::const_iterator overflowIterator = m_gridItemsOverflo wingGridArea.begin(); | 1159 Vector<RenderBox*>::const_iterator overflowIterator = m_gridItemsOverflo wingGridArea.begin(); |
1328 Vector<RenderBox*>::const_iterator end = m_gridItemsOverflowingGridArea. end(); | 1160 Vector<RenderBox*>::const_iterator end = m_gridItemsOverflowingGridArea. end(); |
1329 | 1161 |
1330 for (; overflowIterator != end && rowIsBeforeDirtyArea(cachedGridCoordin ate(*overflowIterator), dirtiedRows); ++overflowIterator) { | 1162 for (; overflowIterator != end && rowIsBeforeDirtyArea(cachedGridCoordin ate(*overflowIterator), dirtiedRows); ++overflowIterator) { |
1331 if ((*overflowIterator)->frameRect().intersects(localRepaintRect)) | 1163 if ((*overflowIterator)->frameRect().intersects(localRepaintRect)) |
1332 populator.storeChild(*overflowIterator); | 1164 populator.storeChild(*overflowIterator); |
1333 } | 1165 } |
1334 | 1166 |
1335 for (size_t row = dirtiedRows.initialPositionIndex; row < dirtiedRows.fi nalPositionIndex; ++row) { | 1167 for (GridResolvedPosition row = dirtiedRows.resolvedInitialPosition; row < dirtiedRows.resolvedFinalPosition; ++row) { |
1336 | 1168 |
1337 for (; overflowIterator != end && isInSameRowBeforeDirtyArea(cachedG ridCoordinate(*overflowIterator), row, dirtiedColumns); ++overflowIterator) { | 1169 for (; overflowIterator != end && isInSameRowBeforeDirtyArea(cachedG ridCoordinate(*overflowIterator), row, dirtiedColumns); ++overflowIterator) { |
1338 if ((*overflowIterator)->frameRect().intersects(localRepaintRect )) | 1170 if ((*overflowIterator)->frameRect().intersects(localRepaintRect )) |
1339 populator.storeChild(*overflowIterator); | 1171 populator.storeChild(*overflowIterator); |
1340 } | 1172 } |
1341 | 1173 |
1342 for (size_t column = dirtiedColumns.initialPositionIndex; column < d irtiedColumns.finalPositionIndex; ++column) { | 1174 for (GridResolvedPosition column = dirtiedColumns.resolvedInitialPos ition; column < dirtiedColumns.resolvedFinalPosition; ++column) { |
1343 const Vector<RenderBox*, 1>& children = m_grid[row][column]; | 1175 const Vector<RenderBox*, 1>& children = m_grid[row][column]; |
1344 // FIXME: If we start adding spanning children in all grid areas they span, this | 1176 // FIXME: If we start adding spanning children in all grid areas they span, this |
1345 // would make us paint them several times, which is wrong! | 1177 // would make us paint them several times, which is wrong! |
1346 for (size_t j = 0; j < children.size(); ++j) { | 1178 for (size_t j = 0; j < children.size(); ++j) { |
1347 populator.storeChild(children[j]); | 1179 populator.storeChild(children[j]); |
1348 // Do not paint overflowing grid items twice. | 1180 // Do not paint overflowing grid items twice. |
1349 if (overflowIterator != end && *overflowIterator == children [j]) | 1181 if (overflowIterator != end && *overflowIterator == children [j]) |
1350 ++overflowIterator; | 1182 ++overflowIterator; |
1351 } | 1183 } |
1352 } | 1184 } |
(...skipping 21 matching lines...) Expand all Loading... | |
1374 if (isOutOfFlowPositioned()) | 1206 if (isOutOfFlowPositioned()) |
1375 return "RenderGrid (positioned)"; | 1207 return "RenderGrid (positioned)"; |
1376 if (isAnonymous()) | 1208 if (isAnonymous()) |
1377 return "RenderGrid (generated)"; | 1209 return "RenderGrid (generated)"; |
1378 if (isRelPositioned()) | 1210 if (isRelPositioned()) |
1379 return "RenderGrid (relative positioned)"; | 1211 return "RenderGrid (relative positioned)"; |
1380 return "RenderGrid"; | 1212 return "RenderGrid"; |
1381 } | 1213 } |
1382 | 1214 |
1383 } // namespace WebCore | 1215 } // namespace WebCore |
OLD | NEW |