RenderFlowThread.h [plain text]
#ifndef RenderFlowThread_h
#define RenderFlowThread_h
#include "RenderBlock.h"
#include <wtf/HashCountedSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/PassRefPtr.h>
namespace WebCore {
struct LayerFragment;
typedef Vector<LayerFragment, 1> LayerFragments;
class RenderFlowThread;
class RenderStyle;
class RenderRegion;
typedef ListHashSet<RenderRegion*> RenderRegionList;
class RenderFlowThread: public RenderBlock {
public:
RenderFlowThread();
virtual ~RenderFlowThread() { };
virtual bool isRenderFlowThread() const { return true; }
virtual void layout();
virtual bool requiresLayer() const { return true; }
void removeFlowChildInfo(RenderObject*);
#ifndef NDEBUG
bool hasChildInfo(RenderObject* child) const { return child && child->isBox() && m_regionRangeMap.contains(toRenderBox(child)); }
#endif
virtual void addRegionToThread(RenderRegion*);
virtual void removeRegionFromThread(RenderRegion*);
const RenderRegionList& renderRegionList() const { return m_regionList; }
virtual void updateLogicalWidth() OVERRIDE;
virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const OVERRIDE;
void paintFlowThreadPortionInRegion(PaintInfo&, RenderRegion*, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const LayoutPoint&) const;
bool hitTestFlowThreadPortionInRegion(RenderRegion*, const LayoutRect& flowThreadPortionRect, const LayoutRect& flowThreadPortionOverflowRect, const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset) const;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) OVERRIDE;
bool hasRegions() const { return m_regionList.size(); }
bool hasRegionsWithStyling() const { return m_hasRegionsWithStyling; }
void checkRegionsWithStyling();
void validateRegions();
void invalidateRegions();
bool hasValidRegionInfo() const { return !m_regionsInvalidated && !m_regionList.isEmpty(); }
static PassRefPtr<RenderStyle> createFlowThreadStyle(RenderStyle* parentStyle);
void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
void repaintRectangleInRegions(const LayoutRect&, bool immediate) const;
LayoutPoint adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject&, const LayoutPoint&);
LayoutUnit pageLogicalTopForOffset(LayoutUnit);
LayoutUnit pageLogicalWidthForOffset(LayoutUnit);
LayoutUnit pageLogicalHeightForOffset(LayoutUnit);
LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit, PageBoundaryRule = IncludePageBoundary);
virtual void setPageBreak(LayoutUnit , LayoutUnit ) { }
virtual void updateMinimumPageHeight(LayoutUnit , LayoutUnit ) { }
enum RegionAutoGenerationPolicy {
AllowRegionAutoGeneration,
DisallowRegionAutoGeneration,
};
RenderRegion* regionAtBlockOffset(LayoutUnit, bool extendLastRegion = false, RegionAutoGenerationPolicy = AllowRegionAutoGeneration);
bool regionsHaveUniformLogicalWidth() const { return m_regionsHaveUniformLogicalWidth; }
bool regionsHaveUniformLogicalHeight() const { return m_regionsHaveUniformLogicalHeight; }
RenderRegion* mapFromFlowToRegion(TransformState&) const;
void removeRenderBoxRegionInfo(RenderBox*);
bool logicalWidthChangedInRegionsForBlock(const RenderBlock*);
LayoutUnit contentLogicalWidthOfFirstRegion() const;
LayoutUnit contentLogicalHeightOfFirstRegion() const;
LayoutUnit contentLogicalLeftOfFirstRegion() const;
RenderRegion* firstRegion() const;
RenderRegion* lastRegion() const;
void setRegionRangeForBox(const RenderBox*, LayoutUnit offsetFromLogicalTopOfFirstPage);
void getRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
void clearRenderObjectCustomStyle(const RenderObject*,
const RenderRegion* oldStartRegion = 0, const RenderRegion* oldEndRegion = 0,
const RenderRegion* newStartRegion = 0, const RenderRegion* newEndRegion = 0);
void computeOverflowStateForRegions(LayoutUnit oldClientAfterEdge);
bool overset() const { return m_overset; }
bool objectInFlowRegion(const RenderObject*, const RenderRegion*) const;
void markAutoLogicalHeightRegionsForLayout();
bool addForcedRegionBreak(LayoutUnit, RenderObject* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment = 0);
void applyBreakAfterContent(LayoutUnit);
bool pageLogicalSizeChanged() const { return m_pageLogicalSizeChanged; }
bool hasAutoLogicalHeightRegions() const { ASSERT(isAutoLogicalHeightRegionsCountConsistent()); return m_autoLogicalHeightRegionsCount; }
void incrementAutoLogicalHeightRegions();
void decrementAutoLogicalHeightRegions();
#ifndef NDEBUG
bool isAutoLogicalHeightRegionsCountConsistent() const;
#endif
void collectLayerFragments(LayerFragments&, const LayoutRect& layerBoundingBox, const LayoutRect& dirtyRect);
LayoutRect fragmentsBoundingBox(const LayoutRect& layerBoundingBox);
void setInConstrainedLayoutPhase(bool value) { m_inConstrainedLayoutPhase = value; }
bool inConstrainedLayoutPhase() const { return m_inConstrainedLayoutPhase; }
bool needsTwoPhasesLayout() const { return m_needsTwoPhasesLayout; }
void clearNeedsTwoPhasesLayout() { m_needsTwoPhasesLayout = false; }
void pushFlowThreadLayoutState(const RenderObject*);
void popFlowThreadLayoutState();
LayoutUnit offsetFromLogicalTopOfFirstRegion(const RenderBlock*) const;
protected:
virtual const char* renderName() const = 0;
virtual LayoutUnit initialLogicalWidth() const { return 0; };
virtual void mapLocalToContainer(const RenderLayerModelObject* repaintContainer, TransformState&, MapCoordinatesFlags = ApplyContainerFlip, bool* wasFixed = 0) const OVERRIDE;
void updateRegionsFlowThreadPortionRect(const RenderRegion* = 0);
bool shouldRepaint(const LayoutRect&) const;
bool regionInRange(const RenderRegion* targetRegion, const RenderRegion* startRegion, const RenderRegion* endRegion) const;
LayoutRect computeRegionClippingRect(const LayoutPoint&, const LayoutRect&, const LayoutRect&) const;
void setDispatchRegionLayoutUpdateEvent(bool value) { m_dispatchRegionLayoutUpdateEvent = value; }
bool shouldDispatchRegionLayoutUpdateEvent() { return m_dispatchRegionLayoutUpdateEvent; }
virtual void dispatchRegionLayoutUpdateEvent() { m_dispatchRegionLayoutUpdateEvent = false; }
void initializeRegionsOverrideLogicalContentHeight(RenderRegion* = 0);
virtual void autoGenerateRegionsToBlockOffset(LayoutUnit) { };
inline bool hasCachedOffsetFromLogicalTopOfFirstRegion(const RenderBox*) const;
inline LayoutUnit cachedOffsetFromLogicalTopOfFirstRegion(const RenderBox*) const;
inline void setOffsetFromLogicalTopOfFirstRegion(const RenderBox*, LayoutUnit);
inline void clearOffsetFromLogicalTopOfFirstRegion(const RenderBox*);
inline const RenderBox* currentActiveRenderBox() const;
RenderRegionList m_regionList;
class RenderRegionRange {
public:
RenderRegionRange()
{
setRange(0, 0);
}
RenderRegionRange(RenderRegion* start, RenderRegion* end)
{
setRange(start, end);
}
void setRange(RenderRegion* start, RenderRegion* end)
{
m_startRegion = start;
m_endRegion = end;
}
RenderRegion* startRegion() const { return m_startRegion; }
RenderRegion* endRegion() const { return m_endRegion; }
private:
RenderRegion* m_startRegion;
RenderRegion* m_endRegion;
};
typedef PODInterval<LayoutUnit, RenderRegion*> RegionInterval;
typedef PODIntervalTree<LayoutUnit, RenderRegion*> RegionIntervalTree;
class RegionSearchAdapter {
public:
RegionSearchAdapter(LayoutUnit offset)
: m_offset(offset)
, m_result(0)
{
}
const LayoutUnit& lowValue() const { return m_offset; }
const LayoutUnit& highValue() const { return m_offset; }
void collectIfNeeded(const RegionInterval&);
RenderRegion* result() const { return m_result; }
private:
LayoutUnit m_offset;
RenderRegion* m_result;
};
typedef HashMap<const RenderBox*, RenderRegionRange> RenderRegionRangeMap;
RenderRegionRangeMap m_regionRangeMap;
typedef HashMap<RenderObject*, RenderRegion*> RenderObjectToRegionMap;
RenderObjectToRegionMap m_breakBeforeToRegionMap;
RenderObjectToRegionMap m_breakAfterToRegionMap;
typedef ListHashSet<const RenderObject*> RenderObjectStack;
RenderObjectStack m_activeObjectsStack;
typedef HashMap<const RenderBox*, LayoutUnit> RenderBoxToOffsetMap;
RenderBoxToOffsetMap m_boxesToOffsetMap;
unsigned m_autoLogicalHeightRegionsCount;
RegionIntervalTree m_regionIntervalTree;
bool m_regionsInvalidated : 1;
bool m_regionsHaveUniformLogicalWidth : 1;
bool m_regionsHaveUniformLogicalHeight : 1;
bool m_overset : 1;
bool m_hasRegionsWithStyling : 1;
bool m_dispatchRegionLayoutUpdateEvent : 1;
bool m_pageLogicalSizeChanged : 1;
bool m_inConstrainedLayoutPhase : 1;
bool m_needsTwoPhasesLayout : 1;
};
inline RenderFlowThread* toRenderFlowThread(RenderObject* object)
{
ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderFlowThread());
return static_cast<RenderFlowThread*>(object);
}
inline const RenderFlowThread* toRenderFlowThread(const RenderObject* object)
{
ASSERT_WITH_SECURITY_IMPLICATION(!object || object->isRenderFlowThread());
return static_cast<const RenderFlowThread*>(object);
}
void toRenderFlowThread(const RenderFlowThread*);
class CurrentRenderFlowThreadMaintainer {
WTF_MAKE_NONCOPYABLE(CurrentRenderFlowThreadMaintainer);
public:
CurrentRenderFlowThreadMaintainer(RenderFlowThread*);
~CurrentRenderFlowThreadMaintainer();
private:
RenderFlowThread* m_renderFlowThread;
RenderFlowThread* m_previousRenderFlowThread;
};
#ifndef NDEBUG
template <> struct ValueToString<LayoutUnit> {
static String string(const LayoutUnit value) { return String::number(value.toFloat()); }
};
template <> struct ValueToString<RenderRegion*> {
static String string(const RenderRegion* value) { return String::format("%p", value); }
};
#endif
}
#endif // RenderFlowThread_h