Unreviewed, rolling out r234489.
[WebKit-https.git] / Source / WebCore / rendering / FloatingObjects.h
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 #pragma once
25
26 #include "PODIntervalTree.h"
27 #include "RootInlineBox.h"
28 #include <wtf/ListHashSet.h>
29 #include <wtf/WeakPtr.h>
30
31 namespace WebCore {
32
33 class RenderBlockFlow;
34 class RenderBox;
35
36 class FloatingObject {
37     WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
38 public:
39     // Note that Type uses bits so you can use FloatLeftRight as a mask to query for both left and right.
40     enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
41
42     static std::unique_ptr<FloatingObject> create(RenderBox&);
43     std::unique_ptr<FloatingObject> copyToNewContainer(LayoutSize, bool shouldPaint = false, bool isDescendant = false) const;
44     std::unique_ptr<FloatingObject> cloneForNewParent() const;
45
46     explicit FloatingObject(RenderBox&);
47     FloatingObject(RenderBox&, Type, const LayoutRect&, const LayoutSize&, bool shouldPaint, bool isDescendant);
48
49     Type type() const { return static_cast<Type>(m_type); }
50     RenderBox& renderer() const { return *m_renderer; }
51
52     bool isPlaced() const { return m_isPlaced; }
53     void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
54
55     LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }
56     LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }
57     LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }
58     LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }
59     LayoutUnit width() const { return m_frameRect.width(); }
60     LayoutUnit height() const { return m_frameRect.height(); }
61
62     void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
63     void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
64     void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
65     void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
66
67     void setMarginOffset(LayoutSize offset) { ASSERT(!isInPlacedTree()); m_marginOffset = offset; }
68
69     const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
70     void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }
71
72     LayoutUnit paginationStrut() const { return m_paginationStrut; }
73     void setPaginationStrut(LayoutUnit strut) { m_paginationStrut = strut; }
74
75 #ifndef NDEBUG
76     bool isInPlacedTree() const { return m_isInPlacedTree; }
77     void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
78 #endif
79
80     bool shouldPaint() const { return m_shouldPaint; }
81     void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
82     bool isDescendant() const { return m_isDescendant; }
83     void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
84
85     // FIXME: Callers of these methods are dangerous and should be whitelisted explicitly or removed.
86     RootInlineBox* originatingLine() const { return m_originatingLine.get(); }
87     void clearOriginatingLine() { m_originatingLine = nullptr; }
88     void setOriginatingLine(RootInlineBox& line) { m_originatingLine = makeWeakPtr(line); }
89
90     LayoutSize locationOffsetOfBorderBox() const
91     {
92         ASSERT(isPlaced());
93         return LayoutSize(m_frameRect.location().x() + m_marginOffset.width(), m_frameRect.location().y() + m_marginOffset.height());
94     }
95     LayoutSize marginOffset() const { ASSERT(isPlaced()); return m_marginOffset; }
96     LayoutSize translationOffsetToAncestor() const;
97
98 private:
99     WeakPtr<RenderBox> m_renderer;
100     WeakPtr<RootInlineBox> m_originatingLine;
101     LayoutRect m_frameRect;
102     LayoutUnit m_paginationStrut;
103     LayoutSize m_marginOffset;
104
105     unsigned m_type : 2; // Type (left or right aligned)
106     unsigned m_shouldPaint : 1;
107     unsigned m_isDescendant : 1;
108     unsigned m_isPlaced : 1;
109 #ifndef NDEBUG
110     unsigned m_isInPlacedTree : 1;
111 #endif
112 };
113
114 struct FloatingObjectHashFunctions {
115     static unsigned hash(const std::unique_ptr<FloatingObject>& key) { return PtrHash<RenderBox*>::hash(&key->renderer()); }
116     static bool equal(const std::unique_ptr<FloatingObject>& a, const std::unique_ptr<FloatingObject>& b) { return &a->renderer() == &b->renderer(); }
117     static const bool safeToCompareToEmptyOrDeleted = true;
118 };
119 struct FloatingObjectHashTranslator {
120     static unsigned hash(const RenderBox& key) { return PtrHash<const RenderBox*>::hash(&key); }
121     static unsigned hash(const FloatingObject& key) { return PtrHash<RenderBox*>::hash(&key.renderer()); }
122     static bool equal(const std::unique_ptr<FloatingObject>& a, const RenderBox& b) { return &a->renderer() == &b; }
123     static bool equal(const std::unique_ptr<FloatingObject>& a, const FloatingObject& b) { return &a->renderer() == &b.renderer(); }
124 };
125
126 typedef ListHashSet<std::unique_ptr<FloatingObject>, FloatingObjectHashFunctions> FloatingObjectSet;
127
128 typedef PODInterval<LayoutUnit, FloatingObject*> FloatingObjectInterval;
129 typedef PODIntervalTree<LayoutUnit, FloatingObject*> FloatingObjectTree;
130
131 // FIXME: This is really the same thing as FloatingObjectSet.
132 // Change clients to use that set directly, and replace the moveAllToFloatInfoMap function with a takeSet function.
133 typedef HashMap<RenderBox*, std::unique_ptr<FloatingObject>> RendererToFloatInfoMap;
134
135 class FloatingObjects {
136     WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
137 public:
138     explicit FloatingObjects(const RenderBlockFlow&);
139     ~FloatingObjects();
140
141     void clear();
142     void moveAllToFloatInfoMap(RendererToFloatInfoMap&);
143     FloatingObject* add(std::unique_ptr<FloatingObject>);
144     void remove(FloatingObject*);
145     void addPlacedObject(FloatingObject*);
146     void removePlacedObject(FloatingObject*);
147     void setHorizontalWritingMode(bool b = true) { m_horizontalWritingMode = b; }
148
149     bool hasLeftObjects() const { return m_leftObjectsCount > 0; }
150     bool hasRightObjects() const { return m_rightObjectsCount > 0; }
151     const FloatingObjectSet& set() const { return m_set; }
152     void clearLineBoxTreePointers();
153
154     LayoutUnit logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
155     LayoutUnit logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
156
157     LayoutUnit logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
158     LayoutUnit logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
159
160     LayoutUnit findNextFloatLogicalBottomBelow(LayoutUnit logicalHeight);
161     LayoutUnit findNextFloatLogicalBottomBelowForBlock(LayoutUnit logicalHeight);
162
163 private:
164     RenderBlockFlow& renderer() const { return *m_renderer; }
165     void computePlacedFloatsTree();
166     const FloatingObjectTree* placedFloatsTree();
167     void increaseObjectsCount(FloatingObject::Type);
168     void decreaseObjectsCount(FloatingObject::Type);
169     FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
170
171     FloatingObjectSet m_set;
172     std::unique_ptr<FloatingObjectTree> m_placedFloatsTree;
173     unsigned m_leftObjectsCount;
174     unsigned m_rightObjectsCount;
175     bool m_horizontalWritingMode;
176     WeakPtr<RenderBlockFlow> m_renderer;
177 };
178
179 } // namespace WebCore
180
181 #ifndef NDEBUG
182 namespace WTF {
183
184 // This helper is used by PODIntervalTree for debugging purposes.
185 template<> struct ValueToString<WebCore::FloatingObject*> {
186     static String string(const WebCore::FloatingObject* floatingObject)
187     {
188         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());
189     }
190 };
191
192 } // namespace WTF
193 #endif