RenderElement::style() should return a reference.
[WebKit-https.git] / Source / WebCore / rendering / FloatingObjects.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2007 David Smith (catfish.man@gmail.com)
5  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
6  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  */
23
24 #include "config.h"
25 #include "FloatingObjects.h"
26
27 #include "RenderBlockFlow.h"
28 #include "RenderBox.h"
29 #include "RenderView.h"
30
31 using namespace std;
32 using namespace WTF;
33
34 namespace WebCore {
35
36 struct SameSizeAsFloatingObject {
37     void* pointers[2];
38     LayoutRect rect;
39     int paginationStrut;
40     uint32_t bitfields : 8;
41 };
42
43 COMPILE_ASSERT(sizeof(FloatingObject) == sizeof(SameSizeAsFloatingObject), FloatingObject_should_stay_small);
44
45 FloatingObject::FloatingObject(RenderBox& renderer)
46     : m_renderer(renderer)
47     , m_originatingLine(nullptr)
48     , m_paginationStrut(0)
49     , m_shouldPaint(true)
50     , m_isDescendant(false)
51     , m_isPlaced(false)
52 #ifndef NDEBUG
53     , m_isInPlacedTree(false)
54 #endif
55 {
56     EFloat type = renderer.style().floating();
57     ASSERT(type != NoFloat);
58     if (type == LeftFloat)
59         m_type = FloatLeft;
60     else if (type == RightFloat)
61         m_type = FloatRight;
62 }
63
64 FloatingObject::FloatingObject(RenderBox& renderer, Type type, const LayoutRect& frameRect, bool shouldPaint, bool isDescendant)
65     : m_renderer(renderer)
66     , m_originatingLine(nullptr)
67     , m_frameRect(frameRect)
68     , m_paginationStrut(0)
69     , m_type(type)
70     , m_shouldPaint(shouldPaint)
71     , m_isDescendant(isDescendant)
72     , m_isPlaced(true)
73 #ifndef NDEBUG
74     , m_isInPlacedTree(false)
75 #endif
76 {
77 }
78
79 std::unique_ptr<FloatingObject> FloatingObject::create(RenderBox& renderer)
80 {
81     auto object = std::make_unique<FloatingObject>(renderer);
82     object->setShouldPaint(!renderer.hasSelfPaintingLayer()); // If a layer exists, the float will paint itself. Otherwise someone else will.
83     object->setIsDescendant(true);
84     return object;
85 }
86
87 std::unique_ptr<FloatingObject> FloatingObject::copyToNewContainer(LayoutSize offset, bool shouldPaint, bool isDescendant) const
88 {
89     // FIXME: Use make_unique here, once we can get it to compile on all platforms we support.
90     return std::unique_ptr<FloatingObject>(new FloatingObject(renderer(), type(), LayoutRect(frameRect().location() - offset, frameRect().size()), shouldPaint, isDescendant));
91 }
92
93 std::unique_ptr<FloatingObject> FloatingObject::unsafeClone() const
94 {
95     // FIXME: Use make_unique here, once we can get it to compile on all platforms we support.
96     std::unique_ptr<FloatingObject> cloneObject(new FloatingObject(renderer(), type(), m_frameRect, m_shouldPaint, m_isDescendant));
97     cloneObject->m_originatingLine = m_originatingLine;
98     cloneObject->m_paginationStrut = m_paginationStrut;
99     cloneObject->m_isPlaced = m_isPlaced;
100     return cloneObject;
101 }
102
103 template <FloatingObject::Type FloatTypeValue>
104 class ComputeFloatOffsetAdapter {
105 public:
106     typedef FloatingObjectInterval IntervalType;
107
108     ComputeFloatOffsetAdapter(const RenderBlockFlow* renderer, int lineTop, int lineBottom, LayoutUnit& offset)
109         : m_renderer(renderer)
110         , m_lineTop(lineTop)
111         , m_lineBottom(lineBottom)
112         , m_offset(offset)
113         , m_outermostFloat(0)
114     {
115     }
116
117     int lowValue() const { return m_lineTop; }
118     int highValue() const { return m_lineBottom; }
119     void collectIfNeeded(const IntervalType&);
120
121 #if ENABLE(CSS_SHAPES)
122     // When computing the offset caused by the floats on a given line, if
123     // the outermost float on that line has a shape-outside, the inline
124     // content that butts up against that float must be positioned using
125     // the contours of the shape, not the margin box of the float.
126     const FloatingObject* outermostFloat() const { return m_outermostFloat; }
127 #endif
128
129     LayoutUnit getHeightRemaining() const;
130
131 private:
132     bool updateOffsetIfNeeded(const FloatingObject*);
133
134     const RenderBlockFlow* m_renderer;
135     int m_lineTop;
136     int m_lineBottom;
137     LayoutUnit& m_offset;
138     const FloatingObject* m_outermostFloat;
139 };
140
141 FloatingObjects::FloatingObjects(const RenderBlockFlow* renderer, bool horizontalWritingMode)
142     : m_placedFloatsTree(UninitializedTree)
143     , m_leftObjectsCount(0)
144     , m_rightObjectsCount(0)
145     , m_horizontalWritingMode(horizontalWritingMode)
146     , m_renderer(renderer)
147 {
148 }
149
150 FloatingObjects::~FloatingObjects()
151 {
152 }
153
154 void FloatingObjects::clearLineBoxTreePointers()
155 {
156     // Clear references to originating lines, since the lines are being deleted
157     for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
158         ASSERT(!((*it)->originatingLine()) || &((*it)->originatingLine()->renderer()) == m_renderer);
159         (*it)->setOriginatingLine(0);
160     }
161 }
162
163 void FloatingObjects::clear()
164 {
165     m_set.clear();
166     m_placedFloatsTree.clear();
167     m_leftObjectsCount = 0;
168     m_rightObjectsCount = 0;
169 }
170
171 void FloatingObjects::moveAllToFloatInfoMap(RendererToFloatInfoMap& map)
172 {
173     for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
174         auto& renderer = it->get()->renderer();
175         // FIXME: The only reason it is safe to move these out of the set is that
176         // we are about to clear it. Otherwise it would break the hash table invariant.
177         // A clean way to do this would be to add a takeAll function to HashSet.
178         map.add(&renderer, std::move(*it));
179     }
180     clear();
181 }
182
183 void FloatingObjects::increaseObjectsCount(FloatingObject::Type type)
184 {
185     if (type == FloatingObject::FloatLeft)
186         m_leftObjectsCount++;
187     else
188         m_rightObjectsCount++;
189 }
190
191 void FloatingObjects::decreaseObjectsCount(FloatingObject::Type type)
192 {
193     if (type == FloatingObject::FloatLeft)
194         m_leftObjectsCount--;
195     else
196         m_rightObjectsCount--;
197 }
198
199 FloatingObjectInterval FloatingObjects::intervalForFloatingObject(FloatingObject* floatingObject)
200 {
201     if (m_horizontalWritingMode)
202         return FloatingObjectInterval(floatingObject->frameRect().y(), floatingObject->frameRect().maxY(), floatingObject);
203     return FloatingObjectInterval(floatingObject->frameRect().x(), floatingObject->frameRect().maxX(), floatingObject);
204 }
205
206 void FloatingObjects::addPlacedObject(FloatingObject* floatingObject)
207 {
208     ASSERT(!floatingObject->isInPlacedTree());
209
210     floatingObject->setIsPlaced(true);
211     if (m_placedFloatsTree.isInitialized())
212         m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
213
214 #ifndef NDEBUG
215     floatingObject->setIsInPlacedTree(true);
216 #endif
217 }
218
219 void FloatingObjects::removePlacedObject(FloatingObject* floatingObject)
220 {
221     ASSERT(floatingObject->isPlaced() && floatingObject->isInPlacedTree());
222
223     if (m_placedFloatsTree.isInitialized()) {
224         bool removed = m_placedFloatsTree.remove(intervalForFloatingObject(floatingObject));
225         ASSERT_UNUSED(removed, removed);
226     }
227
228     floatingObject->setIsPlaced(false);
229 #ifndef NDEBUG
230     floatingObject->setIsInPlacedTree(false);
231 #endif
232 }
233
234 FloatingObject* FloatingObjects::add(std::unique_ptr<FloatingObject> floatingObject)
235 {
236     increaseObjectsCount(floatingObject->type());
237     if (floatingObject->isPlaced())
238         addPlacedObject(floatingObject.get());
239     return m_set.add(std::move(floatingObject)).iterator->get();
240 }
241
242 void FloatingObjects::remove(FloatingObject* floatingObject)
243 {
244     ASSERT((m_set.contains<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject)));
245     decreaseObjectsCount(floatingObject->type());
246     ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
247     if (floatingObject->isPlaced())
248         removePlacedObject(floatingObject);
249     ASSERT(!floatingObject->originatingLine());
250     auto it = m_set.find<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject);
251     if (it == m_set.end())
252         return;
253     m_set.remove(it);
254 }
255
256 void FloatingObjects::computePlacedFloatsTree()
257 {
258     ASSERT(!m_placedFloatsTree.isInitialized());
259     if (m_set.isEmpty())
260         return;
261     m_placedFloatsTree.initIfNeeded(m_renderer->view().intervalArena());
262     for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
263         FloatingObject* floatingObject = it->get();
264         if (floatingObject->isPlaced())
265             m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
266     }
267 }
268
269 inline const FloatingObjectTree& FloatingObjects::placedFloatsTree()
270 {
271     if (!m_placedFloatsTree.isInitialized())
272         computePlacedFloatsTree();
273     return m_placedFloatsTree;
274 }
275
276 LayoutUnit FloatingObjects::logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode offsetMode, LayoutUnit *heightRemaining)
277 {
278 #if !ENABLE(CSS_SHAPES)
279     UNUSED_PARAM(offsetMode);
280 #endif
281
282     LayoutUnit offset = fixedOffset;
283     ComputeFloatOffsetAdapter<FloatingObject::FloatLeft> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), offset);
284     placedFloatsTree().allOverlapsWithAdapter(adapter);
285
286     if (heightRemaining)
287         *heightRemaining = adapter.getHeightRemaining();
288
289 #if ENABLE(CSS_SHAPES)
290     const FloatingObject* outermostFloat = adapter.outermostFloat();
291     if (offsetMode == ShapeOutsideFloatShapeOffset && outermostFloat) {
292         if (ShapeOutsideInfo* shapeOutside = outermostFloat->renderer().shapeOutsideInfo()) {
293             shapeOutside->updateDeltasForContainingBlockLine(m_renderer, outermostFloat, logicalTop, logicalHeight);
294             offset += shapeOutside->rightMarginBoxDelta();
295         }
296     }
297 #endif
298
299     return offset;
300 }
301
302 LayoutUnit FloatingObjects::logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight, ShapeOutsideFloatOffsetMode offsetMode, LayoutUnit *heightRemaining)
303 {
304 #if !ENABLE(CSS_SHAPES)
305     UNUSED_PARAM(offsetMode);
306 #endif
307
308     LayoutUnit offset = fixedOffset;
309     ComputeFloatOffsetAdapter<FloatingObject::FloatRight> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), offset);
310     placedFloatsTree().allOverlapsWithAdapter(adapter);
311
312     if (heightRemaining)
313         *heightRemaining = adapter.getHeightRemaining();
314
315 #if ENABLE(CSS_SHAPES)
316     const FloatingObject* outermostFloat = adapter.outermostFloat();
317     if (offsetMode == ShapeOutsideFloatShapeOffset && outermostFloat) {
318         if (ShapeOutsideInfo* shapeOutside = outermostFloat->renderer().shapeOutsideInfo()) {
319             shapeOutside->updateDeltasForContainingBlockLine(m_renderer, outermostFloat, logicalTop, logicalHeight);
320             offset += shapeOutside->leftMarginBoxDelta();
321         }
322     }
323 #endif
324
325     return min(fixedOffset, offset);
326 }
327
328 inline static bool rangesIntersect(int floatTop, int floatBottom, int objectTop, int objectBottom)
329 {
330     if (objectTop >= floatBottom || objectBottom < floatTop)
331         return false;
332
333     // The top of the object overlaps the float
334     if (objectTop >= floatTop)
335         return true;
336
337     // The object encloses the float
338     if (objectTop < floatTop && objectBottom > floatBottom)
339         return true;
340
341     // The bottom of the object overlaps the float
342     if (objectBottom > objectTop && objectBottom > floatTop && objectBottom <= floatBottom)
343         return true;
344
345     return false;
346 }
347
348 template<>
349 inline bool ComputeFloatOffsetAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
350 {
351     LayoutUnit logicalRight = m_renderer->logicalRightForFloat(floatingObject);
352     if (logicalRight > m_offset) {
353         m_offset = logicalRight;
354         return true;
355     }
356     return false;
357 }
358
359 template<>
360 inline bool ComputeFloatOffsetAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
361 {
362     LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(floatingObject);
363     if (logicalLeft < m_offset) {
364         m_offset = logicalLeft;
365         return true;
366     }
367     return false;
368 }
369
370 template <FloatingObject::Type FloatTypeValue>
371 inline void ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded(const IntervalType& interval)
372 {
373     const FloatingObject* floatingObject = interval.data();
374     if (floatingObject->type() != FloatTypeValue || !rangesIntersect(interval.low(), interval.high(), m_lineTop, m_lineBottom))
375         return;
376
377     // All the objects returned from the tree should be already placed.
378     ASSERT(floatingObject->isPlaced());
379     ASSERT(rangesIntersect(m_renderer->pixelSnappedLogicalTopForFloat(floatingObject), m_renderer->pixelSnappedLogicalBottomForFloat(floatingObject), m_lineTop, m_lineBottom));
380
381     bool floatIsNewExtreme = updateOffsetIfNeeded(floatingObject);
382     if (floatIsNewExtreme)
383         m_outermostFloat = floatingObject;
384 }
385
386 template <FloatingObject::Type FloatTypeValue>
387 LayoutUnit ComputeFloatOffsetAdapter<FloatTypeValue>::getHeightRemaining() const
388 {
389     return m_outermostFloat ? m_renderer->logicalBottomForFloat(m_outermostFloat) - m_lineTop : LayoutUnit(1);
390 }
391
392 #ifndef NDEBUG
393 // These helpers are only used by the PODIntervalTree for debugging purposes.
394 String ValueToString<int>::string(const int value)
395 {
396     return String::number(value);
397 }
398
399 String ValueToString<FloatingObject*>::string(const FloatingObject* floatingObject)
400 {
401     return String::format("%p (%ix%i %ix%i)", floatingObject, floatingObject->frameRect().x().toInt(), floatingObject->frameRect().y().toInt(), floatingObject->frameRect().maxX().toInt(), floatingObject->frameRect().maxY().toInt());
402 }
403 #endif
404
405
406 } // namespace WebCore