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.
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.
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.
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.
24 #ifndef FloatingObjects_h
25 #define FloatingObjects_h
27 #include "core/rendering/RootInlineBox.h"
28 #include "platform/PODFreeListArena.h"
29 #include "platform/PODIntervalTree.h"
30 #include "wtf/ListHashSet.h"
31 #include "wtf/OwnPtr.h"
35 class RenderBlockFlow;
38 // FIXME this should be removed once RenderBlockFlow::nextFloatLogicalBottomBelow doesn't need it anymore. (Bug 123931)
39 enum ShapeOutsideFloatOffsetMode { ShapeOutsideFloatShapeOffset, ShapeOutsideFloatMarginBoxOffset };
41 class FloatingObject {
42 WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
45 // Used by the PODIntervalTree for debugging the FloatingObject.
46 template <class> friend struct ValueToString;
49 // Note that Type uses bits so you can use FloatLeftRight as a mask to query for both left and right.
50 enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
52 static PassOwnPtr<FloatingObject> create(RenderBox*);
54 PassOwnPtr<FloatingObject> copyToNewContainer(LayoutSize, bool shouldPaint = false, bool isDescendant = false) const;
56 PassOwnPtr<FloatingObject> unsafeClone() const;
58 Type type() const { return static_cast<Type>(m_type); }
59 RenderBox* renderer() const { return m_renderer; }
61 bool isPlaced() const { return m_isPlaced; }
62 void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
64 LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }
65 LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }
66 LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }
67 LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }
68 LayoutUnit width() const { return m_frameRect.width(); }
69 LayoutUnit height() const { return m_frameRect.height(); }
71 void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
72 void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
73 void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
74 void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
76 const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
78 int paginationStrut() const { return m_paginationStrut; }
79 void setPaginationStrut(int strut) { m_paginationStrut = strut; }
82 bool isInPlacedTree() const { return m_isInPlacedTree; }
83 void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
86 bool shouldPaint() const { return m_shouldPaint; }
87 void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
88 bool isDescendant() const { return m_isDescendant; }
89 void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
91 // FIXME: Callers of these methods are dangerous and should be whitelisted explicitly or removed.
92 RootInlineBox* originatingLine() const { return m_originatingLine; }
93 void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
96 explicit FloatingObject(RenderBox*);
97 FloatingObject(RenderBox*, Type, const LayoutRect&, bool shouldPaint, bool isDescendant);
99 RenderBox* m_renderer;
100 RootInlineBox* m_originatingLine;
101 LayoutRect m_frameRect;
102 int m_paginationStrut; // FIXME: Is this class size-sensitive? Does this need 32-bits?
104 unsigned m_type : 2; // Type (left or right aligned)
105 unsigned m_shouldPaint : 1;
106 unsigned m_isDescendant : 1;
107 unsigned m_isPlaced : 1;
109 unsigned m_isInPlacedTree : 1;
113 struct FloatingObjectHashFunctions {
114 static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->renderer()); }
115 static unsigned hash(const OwnPtr<FloatingObject>& key) { return hash(key.get()); }
116 static unsigned hash(const PassOwnPtr<FloatingObject>& key) { return hash(key.get()); }
117 static bool equal(OwnPtr<FloatingObject>& a, FloatingObject* b) { return a->renderer() == b->renderer(); }
118 static bool equal(OwnPtr<FloatingObject>& a, const OwnPtr<FloatingObject>& b) { return equal(a, b.get()); }
119 static bool equal(OwnPtr<FloatingObject>& a, const PassOwnPtr<FloatingObject>& b) { return equal(a, b.get()); }
121 static const bool safeToCompareToEmptyOrDeleted = true;
123 struct FloatingObjectHashTranslator {
124 static unsigned hash(RenderBox* key) { return DefaultHash<RenderBox*>::Hash::hash(key); }
125 static bool equal(FloatingObject* a, RenderBox* b) { return a->renderer() == b; }
126 static bool equal(const OwnPtr<FloatingObject>& a, RenderBox* b) { return a->renderer() == b; }
128 typedef ListHashSet<OwnPtr<FloatingObject>, 4, FloatingObjectHashFunctions> FloatingObjectSet;
129 typedef FloatingObjectSet::const_iterator FloatingObjectSetIterator;
130 typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;
131 typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;
132 typedef PODFreeListArena<PODRedBlackTree<FloatingObjectInterval>::Node> IntervalArena;
133 typedef HashMap<RenderBox*, OwnPtr<FloatingObject> > RendererToFloatInfoMap;
135 class FloatingObjects {
136 WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
138 FloatingObjects(const RenderBlockFlow*, bool horizontalWritingMode);
142 void moveAllToFloatInfoMap(RendererToFloatInfoMap&);
143 FloatingObject* add(PassOwnPtr<FloatingObject>);
144 void remove(FloatingObject*);
145 void addPlacedObject(FloatingObject*);
146 void removePlacedObject(FloatingObject*);
147 void setHorizontalWritingMode(bool b = true) { m_horizontalWritingMode = b; }
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();
154 LayoutUnit logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
155 LayoutUnit logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
157 LayoutUnit logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
158 LayoutUnit logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
160 LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type);
163 bool hasLowestFloatLogicalBottomCached(bool isHorizontal, FloatingObject::Type floatType) const;
164 LayoutUnit getCachedlowestFloatLogicalBottom(FloatingObject::Type floatType) const;
165 void setCachedLowestFloatLogicalBottom(bool isHorizontal, FloatingObject::Type floatType, LayoutUnit value);
166 void markLowestFloatLogicalBottomCacheAsDirty();
168 void computePlacedFloatsTree();
169 const FloatingObjectTree& placedFloatsTree()
171 if (!m_placedFloatsTree.isInitialized())
172 computePlacedFloatsTree();
173 return m_placedFloatsTree;
175 void increaseObjectsCount(FloatingObject::Type);
176 void decreaseObjectsCount(FloatingObject::Type);
177 FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
179 FloatingObjectSet m_set;
180 FloatingObjectTree m_placedFloatsTree;
181 unsigned m_leftObjectsCount;
182 unsigned m_rightObjectsCount;
183 bool m_horizontalWritingMode;
184 const RenderBlockFlow* m_renderer;
186 struct FloatBottomCachedValue {
187 FloatBottomCachedValue();
191 FloatBottomCachedValue m_lowestFloatBottomCache[2];
192 bool m_cachedHorizontalWritingMode;
196 // These structures are used by PODIntervalTree for debugging purposes.
197 template <> struct ValueToString<int> {
198 static String string(const int value);
200 template<> struct ValueToString<FloatingObject*> {
201 static String string(const FloatingObject*);
207 #endif // FloatingObjects_h