Unreviewed Win build fix after r158855; wrap shapeInfoForFloat() in an ENABLE(CSS_SHA...
[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     LayoutUnit offset() const { return m_offset; }
122     LayoutUnit shapeOffset() const;
123     LayoutUnit heightRemaining() const;
124
125 private:
126     bool updateOffsetIfNeeded(const FloatingObject*);
127
128     const RenderBlockFlow* m_renderer;
129     int m_lineTop;
130     int m_lineBottom;
131     LayoutUnit m_offset;
132     const FloatingObject* m_outermostFloat;
133 };
134
135 FloatingObjects::FloatingObjects(const RenderBlockFlow* renderer, bool horizontalWritingMode)
136     : m_placedFloatsTree(UninitializedTree)
137     , m_leftObjectsCount(0)
138     , m_rightObjectsCount(0)
139     , m_horizontalWritingMode(horizontalWritingMode)
140     , m_renderer(renderer)
141 {
142 }
143
144 FloatingObjects::~FloatingObjects()
145 {
146 }
147
148 void FloatingObjects::clearLineBoxTreePointers()
149 {
150     // Clear references to originating lines, since the lines are being deleted
151     for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
152         ASSERT(!((*it)->originatingLine()) || &((*it)->originatingLine()->renderer()) == m_renderer);
153         (*it)->setOriginatingLine(0);
154     }
155 }
156
157 void FloatingObjects::clear()
158 {
159     m_set.clear();
160     m_placedFloatsTree.clear();
161     m_leftObjectsCount = 0;
162     m_rightObjectsCount = 0;
163 }
164
165 void FloatingObjects::moveAllToFloatInfoMap(RendererToFloatInfoMap& map)
166 {
167     for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
168         auto& renderer = it->get()->renderer();
169         // FIXME: The only reason it is safe to move these out of the set is that
170         // we are about to clear it. Otherwise it would break the hash table invariant.
171         // A clean way to do this would be to add a takeAll function to HashSet.
172         map.add(&renderer, std::move(*it));
173     }
174     clear();
175 }
176
177 void FloatingObjects::increaseObjectsCount(FloatingObject::Type type)
178 {
179     if (type == FloatingObject::FloatLeft)
180         m_leftObjectsCount++;
181     else
182         m_rightObjectsCount++;
183 }
184
185 void FloatingObjects::decreaseObjectsCount(FloatingObject::Type type)
186 {
187     if (type == FloatingObject::FloatLeft)
188         m_leftObjectsCount--;
189     else
190         m_rightObjectsCount--;
191 }
192
193 FloatingObjectInterval FloatingObjects::intervalForFloatingObject(FloatingObject* floatingObject)
194 {
195     if (m_horizontalWritingMode)
196         return FloatingObjectInterval(floatingObject->frameRect().y(), floatingObject->frameRect().maxY(), floatingObject);
197     return FloatingObjectInterval(floatingObject->frameRect().x(), floatingObject->frameRect().maxX(), floatingObject);
198 }
199
200 void FloatingObjects::addPlacedObject(FloatingObject* floatingObject)
201 {
202     ASSERT(!floatingObject->isInPlacedTree());
203
204     floatingObject->setIsPlaced(true);
205     if (m_placedFloatsTree.isInitialized())
206         m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
207
208 #ifndef NDEBUG
209     floatingObject->setIsInPlacedTree(true);
210 #endif
211 }
212
213 void FloatingObjects::removePlacedObject(FloatingObject* floatingObject)
214 {
215     ASSERT(floatingObject->isPlaced() && floatingObject->isInPlacedTree());
216
217     if (m_placedFloatsTree.isInitialized()) {
218         bool removed = m_placedFloatsTree.remove(intervalForFloatingObject(floatingObject));
219         ASSERT_UNUSED(removed, removed);
220     }
221
222     floatingObject->setIsPlaced(false);
223 #ifndef NDEBUG
224     floatingObject->setIsInPlacedTree(false);
225 #endif
226 }
227
228 FloatingObject* FloatingObjects::add(std::unique_ptr<FloatingObject> floatingObject)
229 {
230     increaseObjectsCount(floatingObject->type());
231     if (floatingObject->isPlaced())
232         addPlacedObject(floatingObject.get());
233     return m_set.add(std::move(floatingObject)).iterator->get();
234 }
235
236 void FloatingObjects::remove(FloatingObject* floatingObject)
237 {
238     ASSERT((m_set.contains<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject)));
239     decreaseObjectsCount(floatingObject->type());
240     ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
241     if (floatingObject->isPlaced())
242         removePlacedObject(floatingObject);
243     ASSERT(!floatingObject->originatingLine());
244     auto it = m_set.find<FloatingObject&, FloatingObjectHashTranslator>(*floatingObject);
245     if (it == m_set.end())
246         return;
247     m_set.remove(it);
248 }
249
250 void FloatingObjects::computePlacedFloatsTree()
251 {
252     ASSERT(!m_placedFloatsTree.isInitialized());
253     if (m_set.isEmpty())
254         return;
255     m_placedFloatsTree.initIfNeeded(m_renderer->view().intervalArena());
256     for (auto it = m_set.begin(), end = m_set.end(); it != end; ++it) {
257         FloatingObject* floatingObject = it->get();
258         if (floatingObject->isPlaced())
259             m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
260     }
261 }
262
263 inline const FloatingObjectTree& FloatingObjects::placedFloatsTree()
264 {
265     if (!m_placedFloatsTree.isInitialized())
266         computePlacedFloatsTree();
267     return m_placedFloatsTree;
268 }
269
270 #if ENABLE(CSS_SHAPES)
271 static inline ShapeOutsideInfo* shapeInfoForFloat(const FloatingObject* floatingObject, const RenderBlockFlow* containingBlock, LayoutUnit lineTop, LayoutUnit lineBottom)
272 {
273     if (floatingObject) {
274         if (ShapeOutsideInfo* shapeOutside = floatingObject->renderer().shapeOutsideInfo()) {
275             shapeOutside->updateDeltasForContainingBlockLine(containingBlock, floatingObject, lineTop, lineBottom - lineTop);
276             return shapeOutside;
277         }
278     }
279
280     return 0;
281 }
282 #endif
283
284 template<>
285 inline LayoutUnit ComputeFloatOffsetAdapter<FloatingObject::FloatLeft>::shapeOffset() const
286 {
287 #if ENABLE(CSS_SHAPES)
288     if (ShapeOutsideInfo* shapeOutside = shapeInfoForFloat(m_outermostFloat, m_renderer, m_lineTop, m_lineBottom))
289         return m_offset + shapeOutside->rightMarginBoxDelta();
290 #endif
291
292     return m_offset;
293 }
294
295 template<>
296 inline LayoutUnit ComputeFloatOffsetAdapter<FloatingObject::FloatRight>::shapeOffset() const
297 {
298 #if ENABLE(CSS_SHAPES)
299     if (ShapeOutsideInfo* shapeOutside = shapeInfoForFloat(m_outermostFloat, m_renderer, m_lineTop, m_lineBottom))
300         return m_offset + shapeOutside->leftMarginBoxDelta();
301 #endif
302
303     return m_offset;
304 }
305
306 LayoutUnit FloatingObjects::logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit *heightRemaining)
307 {
308     int logicalTopAsInt = roundToInt(logicalTop);
309     ComputeFloatOffsetAdapter<FloatingObject::FloatLeft> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
310     placedFloatsTree().allOverlapsWithAdapter(adapter);
311
312     if (heightRemaining)
313         *heightRemaining = adapter.heightRemaining();
314
315     return adapter.offset();
316 }
317
318 LayoutUnit FloatingObjects::logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit *heightRemaining)
319 {
320     int logicalTopAsInt = roundToInt(logicalTop);
321     ComputeFloatOffsetAdapter<FloatingObject::FloatRight> adapter(m_renderer, logicalTopAsInt, logicalTopAsInt, fixedOffset);
322     placedFloatsTree().allOverlapsWithAdapter(adapter);
323
324     if (heightRemaining)
325         *heightRemaining = adapter.heightRemaining();
326
327     return min(fixedOffset, adapter.offset());
328 }
329
330 LayoutUnit FloatingObjects::logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight)
331 {
332     ComputeFloatOffsetAdapter<FloatingObject::FloatLeft> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
333     placedFloatsTree().allOverlapsWithAdapter(adapter);
334
335     return adapter.shapeOffset();
336 }
337
338 LayoutUnit FloatingObjects::logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight)
339 {
340     ComputeFloatOffsetAdapter<FloatingObject::FloatRight> adapter(m_renderer, roundToInt(logicalTop), roundToInt(logicalTop + logicalHeight), fixedOffset);
341     placedFloatsTree().allOverlapsWithAdapter(adapter);
342
343     return min(fixedOffset, adapter.shapeOffset());
344 }
345
346 inline static bool rangesIntersect(int floatTop, int floatBottom, int objectTop, int objectBottom)
347 {
348     if (objectTop >= floatBottom || objectBottom < floatTop)
349         return false;
350
351     // The top of the object overlaps the float
352     if (objectTop >= floatTop)
353         return true;
354
355     // The object encloses the float
356     if (objectTop < floatTop && objectBottom > floatBottom)
357         return true;
358
359     // The bottom of the object overlaps the float
360     if (objectBottom > objectTop && objectBottom > floatTop && objectBottom <= floatBottom)
361         return true;
362
363     return false;
364 }
365
366 template<>
367 inline bool ComputeFloatOffsetAdapter<FloatingObject::FloatLeft>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
368 {
369     LayoutUnit logicalRight = m_renderer->logicalRightForFloat(floatingObject);
370     if (logicalRight > m_offset) {
371         m_offset = logicalRight;
372         return true;
373     }
374     return false;
375 }
376
377 template<>
378 inline bool ComputeFloatOffsetAdapter<FloatingObject::FloatRight>::updateOffsetIfNeeded(const FloatingObject* floatingObject)
379 {
380     LayoutUnit logicalLeft = m_renderer->logicalLeftForFloat(floatingObject);
381     if (logicalLeft < m_offset) {
382         m_offset = logicalLeft;
383         return true;
384     }
385     return false;
386 }
387
388 template <FloatingObject::Type FloatTypeValue>
389 inline void ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded(const IntervalType& interval)
390 {
391     const FloatingObject* floatingObject = interval.data();
392     if (floatingObject->type() != FloatTypeValue || !rangesIntersect(interval.low(), interval.high(), m_lineTop, m_lineBottom))
393         return;
394
395     // All the objects returned from the tree should be already placed.
396     ASSERT(floatingObject->isPlaced());
397     ASSERT(rangesIntersect(m_renderer->pixelSnappedLogicalTopForFloat(floatingObject), m_renderer->pixelSnappedLogicalBottomForFloat(floatingObject), m_lineTop, m_lineBottom));
398
399     bool floatIsNewExtreme = updateOffsetIfNeeded(floatingObject);
400     if (floatIsNewExtreme)
401         m_outermostFloat = floatingObject;
402 }
403
404 template <FloatingObject::Type FloatTypeValue>
405 LayoutUnit ComputeFloatOffsetAdapter<FloatTypeValue>::heightRemaining() const
406 {
407     return m_outermostFloat ? m_renderer->logicalBottomForFloat(m_outermostFloat) - m_lineTop : LayoutUnit(1);
408 }
409
410 #ifndef NDEBUG
411 // These helpers are only used by the PODIntervalTree for debugging purposes.
412 String ValueToString<int>::string(const int value)
413 {
414     return String::number(value);
415 }
416
417 String ValueToString<FloatingObject*>::string(const FloatingObject* floatingObject)
418 {
419     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());
420 }
421 #endif
422
423
424 } // namespace WebCore