#ifndef FloatingObjects_h
#define FloatingObjects_h
#include "core/rendering/RootInlineBox.h"
#include "platform/PODFreeListArena.h"
#include "platform/PODIntervalTree.h"
#include "wtf/ListHashSet.h"
#include "wtf/OwnPtr.h"
namespace WebCore {
class RenderBlockFlow;
class RenderBox;
enum ShapeOutsideFloatOffsetMode { ShapeOutsideFloatShapeOffset, ShapeOutsideFloatMarginBoxOffset };
class FloatingObject {
WTF_MAKE_NONCOPYABLE(FloatingObject); WTF_MAKE_FAST_ALLOCATED;
public:
#ifndef NDEBUG
template <class> friend struct ValueToString;
#endif
enum Type { FloatLeft = 1, FloatRight = 2, FloatLeftRight = 3 };
static PassOwnPtr<FloatingObject> create(RenderBox*);
PassOwnPtr<FloatingObject> copyToNewContainer(LayoutSize, bool shouldPaint = false, bool isDescendant = false) const;
PassOwnPtr<FloatingObject> unsafeClone() const;
Type type() const { return static_cast<Type>(m_type); }
RenderBox* renderer() const { return m_renderer; }
bool isPlaced() const { return m_isPlaced; }
void setIsPlaced(bool placed = true) { m_isPlaced = placed; }
LayoutUnit x() const { ASSERT(isPlaced()); return m_frameRect.x(); }
LayoutUnit maxX() const { ASSERT(isPlaced()); return m_frameRect.maxX(); }
LayoutUnit y() const { ASSERT(isPlaced()); return m_frameRect.y(); }
LayoutUnit maxY() const { ASSERT(isPlaced()); return m_frameRect.maxY(); }
LayoutUnit width() const { return m_frameRect.width(); }
LayoutUnit height() const { return m_frameRect.height(); }
void setX(LayoutUnit x) { ASSERT(!isInPlacedTree()); m_frameRect.setX(x); }
void setY(LayoutUnit y) { ASSERT(!isInPlacedTree()); m_frameRect.setY(y); }
void setWidth(LayoutUnit width) { ASSERT(!isInPlacedTree()); m_frameRect.setWidth(width); }
void setHeight(LayoutUnit height) { ASSERT(!isInPlacedTree()); m_frameRect.setHeight(height); }
const LayoutRect& frameRect() const { ASSERT(isPlaced()); return m_frameRect; }
void setFrameRect(const LayoutRect& frameRect) { ASSERT(!isInPlacedTree()); m_frameRect = frameRect; }
int paginationStrut() const { return m_paginationStrut; }
void setPaginationStrut(int strut) { m_paginationStrut = strut; }
#ifndef NDEBUG
bool isInPlacedTree() const { return m_isInPlacedTree; }
void setIsInPlacedTree(bool value) { m_isInPlacedTree = value; }
#endif
bool shouldPaint() const { return m_shouldPaint; }
void setShouldPaint(bool shouldPaint) { m_shouldPaint = shouldPaint; }
bool isDescendant() const { return m_isDescendant; }
void setIsDescendant(bool isDescendant) { m_isDescendant = isDescendant; }
RootInlineBox* originatingLine() const { return m_originatingLine; }
void setOriginatingLine(RootInlineBox* line) { m_originatingLine = line; }
private:
explicit FloatingObject(RenderBox*);
FloatingObject(RenderBox*, Type, const LayoutRect&, bool shouldPaint, bool isDescendant);
RenderBox* m_renderer;
RootInlineBox* m_originatingLine;
LayoutRect m_frameRect;
int m_paginationStrut;
unsigned m_type : 2;
unsigned m_shouldPaint : 1;
unsigned m_isDescendant : 1;
unsigned m_isPlaced : 1;
#ifndef NDEBUG
unsigned m_isInPlacedTree : 1;
#endif
};
struct FloatingObjectHashFunctions {
static unsigned hash(FloatingObject* key) { return DefaultHash<RenderBox*>::Hash::hash(key->renderer()); }
static bool equal(FloatingObject* a, FloatingObject* b) { return a->renderer() == b->renderer(); }
static const bool safeToCompareToEmptyOrDeleted = true;
};
struct FloatingObjectHashTranslator {
static unsigned hash(RenderBox* key) { return DefaultHash<RenderBox*>::Hash::hash(key); }
static bool equal(FloatingObject* a, RenderBox* b) { return a->renderer() == b; }
};
typedef ListHashSet<FloatingObject*, 4, FloatingObjectHashFunctions> FloatingObjectSet;
typedef FloatingObjectSet::const_iterator FloatingObjectSetIterator;
typedef PODInterval<int, FloatingObject*> FloatingObjectInterval;
typedef PODIntervalTree<int, FloatingObject*> FloatingObjectTree;
typedef PODFreeListArena<PODRedBlackTree<FloatingObjectInterval>::Node> IntervalArena;
typedef HashMap<RenderBox*, FloatingObject*> RendererToFloatInfoMap;
class FloatingObjects {
WTF_MAKE_NONCOPYABLE(FloatingObjects); WTF_MAKE_FAST_ALLOCATED;
public:
FloatingObjects(const RenderBlockFlow*, bool horizontalWritingMode);
~FloatingObjects();
void clear();
void moveAllToFloatInfoMap(RendererToFloatInfoMap&);
FloatingObject* add(PassOwnPtr<FloatingObject>);
void remove(FloatingObject*);
void addPlacedObject(FloatingObject*);
void removePlacedObject(FloatingObject*);
void setHorizontalWritingMode(bool b = true) { m_horizontalWritingMode = b; }
bool hasLeftObjects() const { return m_leftObjectsCount > 0; }
bool hasRightObjects() const { return m_rightObjectsCount > 0; }
const FloatingObjectSet& set() const { return m_set; }
void clearLineBoxTreePointers();
LayoutUnit logicalLeftOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
LayoutUnit logicalRightOffset(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit logicalHeight);
LayoutUnit logicalLeftOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
LayoutUnit logicalRightOffsetForPositioningFloat(LayoutUnit fixedOffset, LayoutUnit logicalTop, LayoutUnit* heightRemaining);
LayoutUnit lowestFloatLogicalBottom(FloatingObject::Type);
private:
bool hasLowestFloatLogicalBottomCached(bool isHorizontal, FloatingObject::Type floatType) const;
LayoutUnit getCachedlowestFloatLogicalBottom(FloatingObject::Type floatType) const;
void setCachedLowestFloatLogicalBottom(bool isHorizontal, FloatingObject::Type floatType, LayoutUnit value);
void markLowestFloatLogicalBottomCacheAsDirty();
void computePlacedFloatsTree();
const FloatingObjectTree& placedFloatsTree()
{
if (!m_placedFloatsTree.isInitialized())
computePlacedFloatsTree();
return m_placedFloatsTree;
}
void increaseObjectsCount(FloatingObject::Type);
void decreaseObjectsCount(FloatingObject::Type);
FloatingObjectInterval intervalForFloatingObject(FloatingObject*);
FloatingObjectSet m_set;
FloatingObjectTree m_placedFloatsTree;
unsigned m_leftObjectsCount;
unsigned m_rightObjectsCount;
bool m_horizontalWritingMode;
const RenderBlockFlow* m_renderer;
struct FloatBottomCachedValue {
FloatBottomCachedValue();
LayoutUnit value;
bool dirty;
};
FloatBottomCachedValue m_lowestFloatBottomCache[2];
bool m_cachedHorizontalWritingMode;
};
#ifndef NDEBUG
template <> struct ValueToString<int> {
static String string(const int value);
};
template<> struct ValueToString<FloatingObject*> {
static String string(const FloatingObject*);
};
#endif
}
#endif