b67d5166fda98597ddc289f4aa4a698374302589
[WebKit-https.git] / Source / WebCore / rendering / RenderRegion.h
1 /*
2  * Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1. Redistributions of source code must retain the above
9  *    copyright notice, this list of conditions and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above
12  *    copyright notice, this list of conditions and the following
13  *    disclaimer in the documentation and/or other materials
14  *    provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE
20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
21  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
25  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
26  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  */
29
30 #ifndef RenderRegion_h
31 #define RenderRegion_h
32
33 #include "LayerFragment.h"
34 #include "RenderBlockFlow.h"
35 #include "StyleInheritedData.h"
36 #include "VisiblePosition.h"
37 #include <memory>
38
39 namespace WebCore {
40
41 class Element;
42 class RenderBox;
43 class RenderBoxRegionInfo;
44 class RenderFlowThread;
45 class RenderNamedFlowThread;
46
47 class RenderRegion : public RenderBlockFlow {
48 public:
49     void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
50
51     void setFlowThreadPortionRect(const LayoutRect& rect) { m_flowThreadPortionRect = rect; }
52     LayoutRect flowThreadPortionRect() const { return m_flowThreadPortionRect; }
53     LayoutRect flowThreadPortionOverflowRect();
54
55     LayoutPoint flowThreadPortionLocation() const;
56
57     virtual void attachRegion();
58     virtual void detachRegion();
59
60     RenderNamedFlowThread* parentNamedFlowThread() const { return m_parentNamedFlowThread; }
61     RenderFlowThread* flowThread() const { return m_flowThread; }
62
63     // Valid regions do not create circular dependencies with other flows.
64     bool isValid() const { return m_isValid; }
65     void setIsValid(bool valid) { m_isValid = valid; }
66
67     RenderBoxRegionInfo* renderBoxRegionInfo(const RenderBox*) const;
68     RenderBoxRegionInfo* setRenderBoxRegionInfo(const RenderBox*, LayoutUnit logicalLeftInset, LayoutUnit logicalRightInset,
69         bool containingBlockChainIsInset);
70     std::unique_ptr<RenderBoxRegionInfo> takeRenderBoxRegionInfo(const RenderBox*);
71     void removeRenderBoxRegionInfo(const RenderBox&);
72
73     void deleteAllRenderBoxRegionInfo();
74
75     bool isFirstRegion() const;
76     bool isLastRegion() const;
77     virtual bool shouldClipFlowThreadContent() const;
78
79     // These methods represent the width and height of a "page" and for a RenderRegion they are just the
80     // content width and content height of a region. For RenderRegionSets, however, they will be the width and
81     // height of a single column or page in the set.
82     virtual LayoutUnit pageLogicalWidth() const;
83     virtual LayoutUnit pageLogicalHeight() const;
84
85     LayoutUnit logicalTopOfFlowThreadContentRect(const LayoutRect&) const;
86     LayoutUnit logicalBottomOfFlowThreadContentRect(const LayoutRect&) const;
87     LayoutUnit logicalTopForFlowThreadContent() const { return logicalTopOfFlowThreadContentRect(flowThreadPortionRect()); };
88     LayoutUnit logicalBottomForFlowThreadContent() const { return logicalBottomOfFlowThreadContentRect(flowThreadPortionRect()); };
89
90     // This method represents the logical height of the entire flow thread portion used by the region or set.
91     // For RenderRegions it matches logicalPaginationHeight(), but for sets it is the height of all the pages
92     // or columns added together.
93     virtual LayoutUnit logicalHeightOfAllFlowThreadContent() const;
94
95     // The top of the nearest page inside the region. For RenderRegions, this is just the logical top of the
96     // flow thread portion we contain. For sets, we have to figure out the top of the nearest column or
97     // page.
98     virtual LayoutUnit pageLogicalTopForOffset(LayoutUnit offset) const;
99
100     // Whether or not this region is a set.
101     virtual bool isRenderRegionSet() const { return false; }
102     
103     virtual void repaintFlowThreadContent(const LayoutRect& repaintRect);
104
105     virtual void collectLayerFragments(LayerFragments&, const LayoutRect&, const LayoutRect&) { }
106
107     virtual void adjustRegionBoundsFromFlowThreadPortionRect(LayoutRect& regionBounds) const;
108
109     void addLayoutOverflowForBox(const RenderBox*, const LayoutRect&);
110     void addVisualOverflowForBox(const RenderBox*, const LayoutRect&);
111     LayoutRect layoutOverflowRectForBox(const RenderBox*);
112     LayoutRect visualOverflowRectForBox(const RenderBoxModelObject&);
113     LayoutRect layoutOverflowRectForBoxForPropagation(const RenderBox*);
114     LayoutRect visualOverflowRectForBoxForPropagation(const RenderBoxModelObject&);
115
116     LayoutRect rectFlowPortionForBox(const RenderBox*, const LayoutRect&) const;
117     
118     void setRegionObjectsRegionStyle();
119     void restoreRegionObjectsOriginalStyle();
120
121     bool canHaveChildren() const override { return false; }
122     bool canHaveGeneratedChildren() const override { return true; }
123     VisiblePosition positionForPoint(const LayoutPoint&, const RenderRegion*) override;
124
125     virtual bool hasAutoLogicalHeight() const { return false; }
126
127     virtual void absoluteQuadsForBoxInRegion(Vector<FloatQuad>&, bool*, const RenderBox*, float, float) { }
128
129 protected:
130     RenderRegion(Element&, RenderStyle&&, RenderFlowThread*);
131     RenderRegion(Document&, RenderStyle&&, RenderFlowThread*);
132
133     void ensureOverflowForBox(const RenderBox*, RefPtr<RenderOverflow>&, bool);
134
135     void computePreferredLogicalWidths() override;
136     void computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const override;
137
138     enum OverflowType {
139         LayoutOverflow = 0,
140         VisualOverflow
141     };
142
143     LayoutRect overflowRectForFlowThreadPortion(const LayoutRect& flowThreadPortionRect, bool isFirstPortion, bool isLastPortion, OverflowType);
144     void repaintFlowThreadContentRectangle(const LayoutRect& repaintRect, const LayoutRect& flowThreadPortionRect, const LayoutPoint& regionLocation, const LayoutRect* flowThreadPortionClipRect = 0);
145
146     void computeOverflowFromFlowThread();
147
148 private:
149     bool isRenderRegion() const final { return true; }
150     const char* renderName() const override { return "RenderRegion"; }
151
152     void insertedIntoTree() override;
153     void willBeRemovedFromTree() override;
154
155     virtual void installFlowThread();
156
157     LayoutPoint mapRegionPointIntoFlowThreadCoordinates(const LayoutPoint&);
158
159 protected:
160     RenderFlowThread* m_flowThread;
161
162 private:
163     // If this RenderRegion is displayed as part of another named flow,
164     // we need to create a dependency tree, so that layout of the
165     // regions is always done before the regions themselves.
166     RenderNamedFlowThread* m_parentNamedFlowThread;
167     LayoutRect m_flowThreadPortionRect;
168
169     // This map holds unique information about a block that is split across regions.
170     // A RenderBoxRegionInfo* tells us about any layout information for a RenderBox that
171     // is unique to the region. For now it just holds logical width information for RenderBlocks, but eventually
172     // it will also hold a custom style for any box (for region styling).
173     typedef HashMap<const RenderBox*, std::unique_ptr<RenderBoxRegionInfo>> RenderBoxRegionInfoMap;
174     RenderBoxRegionInfoMap m_renderBoxRegionInfo;
175
176     bool m_isValid : 1;
177 };
178
179 class CurrentRenderRegionMaintainer {
180     WTF_MAKE_NONCOPYABLE(CurrentRenderRegionMaintainer);
181 public:
182     CurrentRenderRegionMaintainer(RenderRegion&);
183     ~CurrentRenderRegionMaintainer();
184
185     RenderRegion& region() const { return m_region; }
186 private:
187     RenderRegion& m_region;
188 };
189
190 } // namespace WebCore
191
192 SPECIALIZE_TYPE_TRAITS_RENDER_OBJECT(RenderRegion, isRenderRegion())
193
194 #endif // RenderRegion_h