1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
|
/*
* Copyright (C) 2017 Igalia S.L.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include "Grid.h"
#include "GridTrackSize.h"
#include "LayoutUnit.h"
namespace WebCore {
static const int infinity = -1;
enum SizingOperation { TrackSizing, IntrinsicSizeComputation };
enum TrackSizeComputationPhase {
ResolveIntrinsicMinimums,
ResolveContentBasedMinimums,
ResolveMaxContentMinimums,
ResolveIntrinsicMaximums,
ResolveMaxContentMaximums,
MaximizeTracks,
};
class GridTrackSizingAlgorithmStrategy;
class GridTrack {
public:
GridTrack() { }
const LayoutUnit& baseSize() const;
void setBaseSize(LayoutUnit);
const LayoutUnit& growthLimit() const;
void setGrowthLimit(LayoutUnit);
bool infiniteGrowthPotential() const { return growthLimitIsInfinite() || m_infinitelyGrowable; }
const LayoutUnit& growthLimitIfNotInfinite() const;
const LayoutUnit& plannedSize() const { return m_plannedSize; }
void setPlannedSize(LayoutUnit plannedSize) { m_plannedSize = plannedSize; }
const LayoutUnit& tempSize() const { return m_tempSize; }
void setTempSize(const LayoutUnit&);
void growTempSize(const LayoutUnit&);
bool infinitelyGrowable() const { return m_infinitelyGrowable; }
void setInfinitelyGrowable(bool infinitelyGrowable) { m_infinitelyGrowable = infinitelyGrowable; }
void setGrowthLimitCap(std::optional<LayoutUnit>);
std::optional<LayoutUnit> growthLimitCap() const { return m_growthLimitCap; }
private:
bool growthLimitIsInfinite() const { return m_growthLimit == infinity; }
bool isGrowthLimitBiggerThanBaseSize() const { return growthLimitIsInfinite() || m_growthLimit >= m_baseSize; }
void ensureGrowthLimitIsBiggerThanBaseSize();
LayoutUnit m_baseSize { 0 };
LayoutUnit m_growthLimit { 0 };
LayoutUnit m_plannedSize { 0 };
LayoutUnit m_tempSize { 0 };
std::optional<LayoutUnit> m_growthLimitCap;
bool m_infinitelyGrowable { false };
};
class GridTrackSizingAlgorithm final {
friend class GridTrackSizingAlgorithmStrategy;
public:
GridTrackSizingAlgorithm(const RenderGrid* renderGrid, Grid& grid)
: m_grid(grid)
, m_renderGrid(renderGrid)
, m_sizingState(ColumnSizingFirstIteration)
{
}
void setup(GridTrackSizingDirection, unsigned numTracks, SizingOperation, std::optional<LayoutUnit> availableSpace, std::optional<LayoutUnit> freeSpace);
void run();
void reset();
// Required by RenderGrid. Try to minimize the exposed surface.
const Grid& grid() const { return m_grid; }
GridTrackSize gridTrackSize(GridTrackSizingDirection, unsigned translatedIndex, SizingOperation) const;
LayoutUnit minContentSize() const { return m_minContentSize; };
LayoutUnit maxContentSize() const { return m_maxContentSize; };
Vector<GridTrack>& tracks(GridTrackSizingDirection direction) { return direction == ForColumns ? m_columns : m_rows; }
const Vector<GridTrack>& tracks(GridTrackSizingDirection direction) const { return direction == ForColumns ? m_columns : m_rows; }
std::optional<LayoutUnit> freeSpace(GridTrackSizingDirection direction) const { return direction == ForColumns ? m_freeSpaceColumns : m_freeSpaceRows; }
void setFreeSpace(GridTrackSizingDirection, std::optional<LayoutUnit>);
#ifndef NDEBUG
bool tracksAreWiderThanMinTrackBreadth() const;
#endif
private:
GridTrackSize gridTrackSize(GridTrackSizingDirection direction, unsigned translatedIndex) const { return gridTrackSize(direction, translatedIndex, m_sizingOperation); }
const GridTrackSize& rawGridTrackSize(GridTrackSizingDirection, unsigned translatedIndex) const;
LayoutUnit assumedRowsSizeForOrthogonalChild(const RenderBox&) const;
LayoutUnit computeTrackBasedSize() const;
// Helper methods for step 1. initializeTrackSizes().
LayoutUnit initialBaseSize(const GridTrackSize&) const;
LayoutUnit initialGrowthLimit(const GridTrackSize&, LayoutUnit baseSize) const;
// Helper methods for step 2. resolveIntrinsicTrackSizes().
void sizeTrackToFitNonSpanningItem(const GridSpan&, RenderBox& gridItem, GridTrack&);
bool spanningItemCrossesFlexibleSizedTracks(const GridSpan&) const;
typedef struct GridItemsSpanGroupRange GridItemsSpanGroupRange;
template <TrackSizeComputationPhase phase> void increaseSizesToAccommodateSpanningItems(const GridItemsSpanGroupRange& gridItemsWithSpan);
LayoutUnit itemSizeForTrackSizeComputationPhase(TrackSizeComputationPhase, RenderBox&) const;
template <TrackSizeComputationPhase phase> void distributeSpaceToTracks(Vector<GridTrack*>& tracks, Vector<GridTrack*>* growBeyondGrowthLimitsTracks, LayoutUnit& availableLogicalSpace) const;
LayoutUnit gridAreaBreadthForChild(const RenderBox&, GridTrackSizingDirection) const;
void computeGridContainerIntrinsicSizes();
// Helper methods for step 4. Strech flexible tracks.
typedef HashSet<unsigned, DefaultHash<unsigned>::Hash, WTF::UnsignedWithZeroKeyHashTraits<unsigned>> TrackIndexSet;
double computeFlexFactorUnitSize(const Vector<GridTrack>& tracks, double flexFactorSum, LayoutUnit& leftOverSpace, const Vector<unsigned, 8>& flexibleTracksIndexes, std::unique_ptr<TrackIndexSet> tracksToTreatAsInflexible = nullptr) const;
void computeFlexSizedTracksGrowth(double flexFraction, Vector<LayoutUnit>& increments, LayoutUnit& totalGrowth) const;
double findFrUnitSize(const GridSpan& tracksSpan, LayoutUnit leftOverSpace) const;
// Track sizing algorithm steps. Note that the "Maximize Tracks" step is done
// entirely inside the strategies, that's why we don't need an additional
// method at thise level.
void initializeTrackSizes();
void resolveIntrinsicTrackSizes();
void stretchFlexibleTracks(std::optional<LayoutUnit> freeSpace);
// State machine.
void advanceNextState();
bool isValidTransition() const;
bool m_needsSetup { true };
std::optional<LayoutUnit> m_availableSpace;
std::optional<LayoutUnit> m_freeSpaceColumns;
std::optional<LayoutUnit> m_freeSpaceRows;
// We need to keep both alive in order to properly size grids with orthogonal
// writing modes.
Vector<GridTrack> m_columns;
Vector<GridTrack> m_rows;
Vector<unsigned> m_contentSizedTracksIndex;
Vector<unsigned> m_flexibleSizedTracksIndex;
GridTrackSizingDirection m_direction;
SizingOperation m_sizingOperation;
Grid& m_grid;
const RenderGrid* m_renderGrid;
std::unique_ptr<GridTrackSizingAlgorithmStrategy> m_strategy;
// The track sizing algorithm is used for both layout and intrinsic size
// computation. We're normally just interested in intrinsic inline sizes
// (a.k.a widths in most of the cases) for the computeIntrinsicLogicalWidths()
// computations. That's why we don't need to keep around different values for
// rows/columns.
LayoutUnit m_minContentSize;
LayoutUnit m_maxContentSize;
enum SizingState {
ColumnSizingFirstIteration,
RowSizingFirstIteration,
ColumnSizingSecondIteration,
RowSizingSecondIteration
};
SizingState m_sizingState;
// This is a RAII class used to ensure that the track sizing algorithm is
// executed as it is suppossed to be, i.e., first resolve columns and then
// rows. Only if required a second iteration is run following the same order,
// first columns and then rows.
class StateMachine {
public:
StateMachine(GridTrackSizingAlgorithm&);
~StateMachine();
private:
GridTrackSizingAlgorithm& m_algorithm;
};
};
class GridTrackSizingAlgorithmStrategy {
public:
LayoutUnit minContentForChild(RenderBox&) const;
LayoutUnit maxContentForChild(RenderBox&) const;
LayoutUnit minSizeForChild(RenderBox&) const;
virtual ~GridTrackSizingAlgorithmStrategy() { }
virtual void maximizeTracks(Vector<GridTrack>&, std::optional<LayoutUnit>& freeSpace) = 0;
virtual double findUsedFlexFraction(Vector<unsigned>& flexibleSizedTracksIndex, GridTrackSizingDirection, std::optional<LayoutUnit> initialFreeSpace) const = 0;
virtual bool recomputeUsedFlexFractionIfNeeded(double& flexFraction, LayoutUnit& totalGrowth) const = 0;
protected:
GridTrackSizingAlgorithmStrategy(GridTrackSizingAlgorithm& algorithm)
: m_algorithm(algorithm) { }
virtual LayoutUnit minLogicalWidthForChild(RenderBox&, Length childMinSize, GridTrackSizingDirection) const = 0;
virtual void layoutGridItemForMinSizeComputation(RenderBox&, bool overrideSizeHasChanged) const = 0;
LayoutUnit logicalHeightForChild(RenderBox&) const;
bool updateOverrideContainingBlockContentSizeForChild(RenderBox&, GridTrackSizingDirection) const;
// GridTrackSizingAlgorithm accessors for subclasses.
LayoutUnit computeTrackBasedSize() const { return m_algorithm.computeTrackBasedSize(); }
GridTrackSizingDirection direction() const { return m_algorithm.m_direction; }
double findFrUnitSize(const GridSpan& tracksSpan, LayoutUnit leftOverSpace) const { return m_algorithm.findFrUnitSize(tracksSpan, leftOverSpace); }
void distributeSpaceToTracks(Vector<GridTrack*>& tracks, LayoutUnit& availableLogicalSpace) const { m_algorithm.distributeSpaceToTracks<MaximizeTracks>(tracks, nullptr, availableLogicalSpace); }
const RenderGrid* renderGrid() const { return m_algorithm.m_renderGrid; }
GridTrackSizingAlgorithm& m_algorithm;
};
} // namespace WebCore
|
