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
|
/*
* Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
*
* 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 THE COPYRIGHT HOLDER "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 THE COPYRIGHT HOLDER 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.
*/
#ifndef LayoutFlowThread_h
#define LayoutFlowThread_h
#include "core/CoreExport.h"
#include "core/layout/LayoutBlockFlow.h"
#include "core/paint/PaintLayerFragment.h"
#include "wtf/ListHashSet.h"
namespace blink {
class LayoutMultiColumnSet;
typedef ListHashSet<LayoutMultiColumnSet*> LayoutMultiColumnSetList;
// LayoutFlowThread is used to collect all the layout objects that participate in a flow thread. It
// will also help in doing the layout. However, it will not layout directly to screen. Instead,
// LayoutMultiColumnSet objects will redirect their paint and nodeAtPoint methods to this
// object. Each LayoutMultiColumnSet will actually be a viewPort of the LayoutFlowThread.
class CORE_EXPORT LayoutFlowThread: public LayoutBlockFlow {
public:
LayoutFlowThread();
~LayoutFlowThread() override { }
bool isLayoutFlowThread() const final { return true; }
virtual bool isLayoutMultiColumnFlowThread() const { return false; }
virtual bool isLayoutPagedFlowThread() const { return false; }
static LayoutFlowThread* locateFlowThreadContainingBlockOf(const LayoutObject&);
void layout() override;
// Always create a Layer for the LayoutFlowThread so that we
// can easily avoid drawing the children directly.
PaintLayerType layerTypeRequired() const final { return NormalPaintLayer; }
virtual void flowThreadDescendantWasInserted(LayoutObject*) { }
virtual void flowThreadDescendantWillBeRemoved(LayoutObject*) { }
virtual void flowThreadDescendantStyleWillChange(LayoutBox*, StyleDifference, const ComputedStyle& newStyle) { }
virtual void flowThreadDescendantStyleDidChange(LayoutBox*, StyleDifference, const ComputedStyle& oldStyle) { }
bool nodeAtPoint(HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) final;
virtual void addColumnSetToThread(LayoutMultiColumnSet*) = 0;
virtual void removeColumnSetFromThread(LayoutMultiColumnSet*);
void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const override;
bool hasColumnSets() const { return m_multiColumnSetList.size(); }
void validateColumnSets();
void invalidateColumnSets();
bool hasValidColumnSetInfo() const { return !m_columnSetsInvalidated && !m_multiColumnSetList.isEmpty(); }
bool mapToVisibleRectInAncestorSpace(const LayoutBoxModelObject* ancestor, LayoutRect&, VisibleRectFlags = DefaultVisibleRectFlags) const override;
LayoutUnit pageLogicalHeightForOffset(LayoutUnit);
LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit, PageBoundaryRule);
virtual void contentWasLaidOut(LayoutUnit logicalBottomInFlowThreadAfterPagination) = 0;
virtual bool canSkipLayout(const LayoutBox&) const = 0;
// Find and return the next logical top after |flowThreadOffset| that can fit unbreakable
// content as tall as |contentLogicalHeight|. |flowThreadOffset| is expected to be at the exact
// top of a column that's known to not have enough space for |contentLogicalHeight|. This method
// is called when the current column is too short to fit the content, in the hope that there
// exists one that's tall enough further ahead. If no such column can be found,
// |flowThreadOffset| will be returned.
LayoutUnit nextLogicalTopForUnbreakableContent(LayoutUnit flowThreadOffset, LayoutUnit contentLogicalHeight) const;
virtual bool isPageLogicalHeightKnown() const { return true; }
bool pageLogicalSizeChanged() const { return m_pageLogicalSizeChanged; }
void collectLayerFragments(PaintLayerFragments&, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRectInFlowThread);
// Return the visual bounding box based on the supplied flow-thread bounding box. Both
// rectangles are completely physical in terms of writing mode.
LayoutRect fragmentsBoundingBox(const LayoutRect& layerBoundingBox) const;
LayoutPoint flowThreadPointToVisualPoint(const LayoutPoint& flowThreadPoint) const
{
return flowThreadPoint + columnOffset(flowThreadPoint);
}
virtual LayoutPoint visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const = 0;
virtual LayoutMultiColumnSet* columnSetAtBlockOffset(LayoutUnit) const = 0;
virtual const char* name() const = 0;
protected:
void generateColumnSetIntervalTree();
LayoutMultiColumnSetList m_multiColumnSetList;
typedef PODInterval<LayoutUnit, LayoutMultiColumnSet*> MultiColumnSetInterval;
typedef PODIntervalTree<LayoutUnit, LayoutMultiColumnSet*> MultiColumnSetIntervalTree;
class MultiColumnSetSearchAdapter {
public:
MultiColumnSetSearchAdapter(LayoutUnit offset)
: m_offset(offset)
, m_result(nullptr)
{
}
const LayoutUnit& lowValue() const { return m_offset; }
const LayoutUnit& highValue() const { return m_offset; }
void collectIfNeeded(const MultiColumnSetInterval&);
LayoutMultiColumnSet* result() const { return m_result; }
private:
LayoutUnit m_offset;
LayoutMultiColumnSet* m_result;
};
MultiColumnSetIntervalTree m_multiColumnSetIntervalTree;
bool m_columnSetsInvalidated : 1;
bool m_pageLogicalSizeChanged : 1;
};
DEFINE_LAYOUT_OBJECT_TYPE_CASTS(LayoutFlowThread, isLayoutFlowThread());
// These structures are used by PODIntervalTree for debugging.
#ifndef NDEBUG
template <> struct ValueToString<LayoutMultiColumnSet*> {
static String toString(const LayoutMultiColumnSet* value) { return String::format("%p", value); }
};
#endif
} // namespace blink
#endif // LayoutFlowThread_h
|
