RenderFlowThread.h [plain text]
#ifndef RenderFlowThread_h
#define RenderFlowThread_h
#include "RenderBlockFlow.h"
#include <wtf/HashCountedSet.h>
#include <wtf/ListHashSet.h>
#include <wtf/PassRefPtr.h>
namespace WebCore {
class CurrentRenderRegionMaintainer;
struct LayerFragment;
typedef Vector<LayerFragment, 1> LayerFragments;
class RenderFlowThread;
class RenderNamedFlowFragment;
class RenderStyle;
class RenderRegion;
class RootInlineBox;
typedef ListHashSet<RenderRegion*> RenderRegionList;
typedef Vector<RenderLayer*> RenderLayerList;
typedef HashMap<RenderNamedFlowFragment*, RenderLayerList> RegionToLayerListMap;
typedef HashMap<RenderLayer*, RenderNamedFlowFragment*> LayerToRegionMap;
typedef HashMap<const RootInlineBox*, RenderRegion*> ContainingRegionMap;
class RenderFlowThread: public RenderBlockFlow {
public:
virtual ~RenderFlowThread() { }
virtual void removeFlowChildInfo(RenderObject*);
#ifndef NDEBUG
bool hasChildInfo(RenderObject* child) const { return child && child->isBox() && m_regionRangeMap.contains(toRenderBox(child)); }
#endif
#if !ASSERT_WITH_SECURITY_IMPLICATION_DISABLED
bool checkLinesConsistency(const RenderBlockFlow*) const;
#endif
virtual void deleteLines() override;
virtual void addRegionToThread(RenderRegion*) = 0;
virtual void removeRegionFromThread(RenderRegion*);
const RenderRegionList& renderRegionList() const { return m_regionList; }
virtual void updateLogicalWidth() override final;
virtual void computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues&) const override;
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction) override;
bool hasRegions() const { return m_regionList.size(); }
virtual void regionChangedWritingMode(RenderRegion*) { }
void validateRegions();
void invalidateRegions();
bool hasValidRegionInfo() const { return !m_regionsInvalidated && !m_regionList.isEmpty(); }
virtual RenderObject* resolveMovedChild(RenderObject* child) const { return child; }
virtual void flowThreadDescendantInserted(RenderObject*) { }
virtual void flowThreadRelativeWillBeRemoved(RenderObject*) { }
virtual void flowThreadDescendantBoxLaidOut(RenderBox*) { }
static PassRef<RenderStyle> createFlowThreadStyle(RenderStyle* parentStyle);
virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle) override;
void repaintRectangleInRegions(const LayoutRect&) const;
LayoutPoint adjustedPositionRelativeToOffsetParent(const RenderBoxModelObject&, const LayoutPoint&);
LayoutUnit pageLogicalTopForOffset(LayoutUnit);
LayoutUnit pageLogicalWidthForOffset(LayoutUnit);
LayoutUnit pageLogicalHeightForOffset(LayoutUnit);
LayoutUnit pageRemainingLogicalHeightForOffset(LayoutUnit, PageBoundaryRule = IncludePageBoundary);
virtual void setPageBreak(const RenderBlock*, LayoutUnit , LayoutUnit ) { }
virtual void updateMinimumPageHeight(const RenderBlock*, LayoutUnit , LayoutUnit ) { }
enum RegionAutoGenerationPolicy {
AllowRegionAutoGeneration,
DisallowRegionAutoGeneration,
};
virtual RenderRegion* regionAtBlockOffset(const RenderBox*, LayoutUnit, bool extendLastRegion = false, RegionAutoGenerationPolicy = AllowRegionAutoGeneration);
bool regionsHaveUniformLogicalWidth() const { return m_regionsHaveUniformLogicalWidth; }
bool regionsHaveUniformLogicalHeight() const { return m_regionsHaveUniformLogicalHeight; }
virtual RenderRegion* mapFromFlowToRegion(TransformState&) const;
void logicalWidthChangedInRegionsForBlock(const RenderBlock*, bool&);
LayoutUnit contentLogicalWidthOfFirstRegion() const;
LayoutUnit contentLogicalHeightOfFirstRegion() const;
LayoutUnit contentLogicalLeftOfFirstRegion() const;
RenderRegion* firstRegion() const;
RenderRegion* lastRegion() const;
bool previousRegionCountChanged() const { return m_previousRegionCount != m_regionList.size(); };
void updatePreviousRegionCount() { m_previousRegionCount = m_regionList.size(); };
virtual void setRegionRangeForBox(const RenderBox*, RenderRegion*, RenderRegion*);
bool getRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
bool computedRegionRangeForBox(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
bool hasCachedRegionRangeForBox(const RenderBox*) const;
bool objectInFlowRegion(const RenderObject*, const RenderRegion*) const;
bool objectShouldFragmentInFlowRegion(const RenderObject*, const RenderRegion*) const;
void markAutoLogicalHeightRegionsForLayout();
void markRegionsForOverflowLayoutIfNeeded();
virtual bool addForcedRegionBreak(const RenderBlock*, LayoutUnit, RenderBox* breakChild, bool isBefore, LayoutUnit* offsetBreakAdjustment = 0);
virtual void applyBreakAfterContent(LayoutUnit) { }
virtual bool isPageLogicalHeightKnown() const { return true; }
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);
enum LayoutPhase {
LayoutPhaseMeasureContent = 0, LayoutPhaseConstrained, LayoutPhaseOverflow, LayoutPhaseFinal };
bool inMeasureContentLayoutPhase() const { return m_layoutPhase == LayoutPhaseMeasureContent; }
bool inConstrainedLayoutPhase() const { return m_layoutPhase == LayoutPhaseConstrained; }
bool inOverflowLayoutPhase() const { return m_layoutPhase == LayoutPhaseOverflow; }
bool inFinalLayoutPhase() const { return m_layoutPhase == LayoutPhaseFinal; }
void setLayoutPhase(LayoutPhase phase) { m_layoutPhase = phase; }
bool needsTwoPhasesLayout() const { return m_needsTwoPhasesLayout; }
void clearNeedsTwoPhasesLayout() { m_needsTwoPhasesLayout = false; }
bool hasCompositingRegionDescendant() const;
void setNeedsLayerToRegionMappingsUpdate() { m_layersToRegionMappingsDirty = true; }
void updateAllLayerToRegionMappingsIfNeeded()
{
if (m_layersToRegionMappingsDirty)
updateAllLayerToRegionMappings();
}
const RenderLayerList* getLayerListForRegion(RenderNamedFlowFragment*) const;
RenderNamedFlowFragment* regionForCompositedLayer(RenderLayer&); RenderNamedFlowFragment* cachedRegionForCompositedLayer(RenderLayer&) const;
virtual bool collectsGraphicsLayersUnderRegions() const;
void pushFlowThreadLayoutState(const RenderObject&);
void popFlowThreadLayoutState();
LayoutUnit offsetFromLogicalTopOfFirstRegion(const RenderBlock*) const;
void clearRenderBoxRegionInfoAndCustomStyle(const RenderBox*, const RenderRegion*, const RenderRegion*, const RenderRegion*, const RenderRegion*);
void addRegionsVisualEffectOverflow(const RenderBox*);
void addRegionsVisualOverflowFromTheme(const RenderBlock*);
void addRegionsOverflowFromChild(const RenderBox*, const RenderBox*, const LayoutSize&);
void addRegionsLayoutOverflow(const RenderBox*, const LayoutRect&);
void addRegionsVisualOverflow(const RenderBox*, const LayoutRect&);
void clearRegionsOverflow(const RenderBox*);
LayoutRect mapFromFlowThreadToLocal(const RenderBox*, const LayoutRect&) const;
LayoutRect mapFromLocalToFlowThread(const RenderBox*, const LayoutRect&) const;
void flipForWritingModeLocalCoordinates(LayoutRect&) const;
static LayoutUnit maxLogicalHeight() { return LayoutUnit::max() / 2; }
bool regionInRange(const RenderRegion* targetRegion, const RenderRegion* startRegion, const RenderRegion* endRegion) const;
virtual bool absoluteQuadsForBox(Vector<FloatQuad>&, bool*, const RenderBox*, float, float) const { return false; }
virtual void layout() override;
void setCurrentRegionMaintainer(CurrentRenderRegionMaintainer* currentRegionMaintainer) { m_currentRegionMaintainer = currentRegionMaintainer; }
RenderRegion* currentRegion() const;
ContainingRegionMap& containingRegionMap();
virtual bool shouldCheckColumnBreaks() const { return false; }
private:
virtual bool isRenderFlowThread() const override final { return true; }
virtual bool requiresLayer() const override final { return true; }
protected:
RenderFlowThread(Document&, PassRef<RenderStyle>);
virtual const char* renderName() const = 0;
virtual LayoutUnit initialLogicalWidth() const { return 0; };
void clearLinesToRegionMap();
virtual void willBeDestroyed() override;
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 updateAllLayerToRegionMappings();
void updateLayerToRegionMappings(RenderLayer&, LayerToRegionMap&, RegionToLayerListMap&, bool& needsLayerUpdate);
void updateRegionForRenderLayer(RenderLayer*, LayerToRegionMap&, RegionToLayerListMap&, bool& needsLayerUpdate);
void initializeRegionsComputedAutoHeight(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;
bool getRegionRangeForBoxFromCachedInfo(const RenderBox*, RenderRegion*& startRegion, RenderRegion*& endRegion) const;
void removeRenderBoxRegionInfo(RenderBox*);
void removeLineRegionInfo(const RenderBlockFlow*);
RenderRegionList m_regionList;
unsigned short m_previousRegionCount;
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;
m_rangeInvalidated = true;
}
RenderRegion* startRegion() const { return m_startRegion; }
RenderRegion* endRegion() const { return m_endRegion; }
bool rangeInvalidated() const { return m_rangeInvalidated; }
void clearRangeInvalidated() { m_rangeInvalidated = false; }
private:
RenderRegion* m_startRegion;
RenderRegion* m_endRegion;
bool m_rangeInvalidated;
};
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;
};
std::unique_ptr<LayerToRegionMap> m_layerToRegionMap;
std::unique_ptr<RegionToLayerListMap> m_regionToLayerListMap;
std::unique_ptr<ContainingRegionMap> m_lineToRegionMap;
typedef HashMap<const RenderBox*, RenderRegionRange> RenderRegionRangeMap;
RenderRegionRangeMap m_regionRangeMap;
typedef HashMap<RenderBox*, RenderRegion*> RenderBoxToRegionMap;
RenderBoxToRegionMap m_breakBeforeToRegionMap;
RenderBoxToRegionMap 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;
CurrentRenderRegionMaintainer* m_currentRegionMaintainer;
bool m_regionsInvalidated : 1;
bool m_regionsHaveUniformLogicalWidth : 1;
bool m_regionsHaveUniformLogicalHeight : 1;
bool m_pageLogicalSizeChanged : 1;
unsigned m_layoutPhase : 2;
bool m_needsTwoPhasesLayout : 1;
bool m_layersToRegionMappingsDirty : 1;
};
RENDER_OBJECT_TYPE_CASTS(RenderFlowThread, isRenderFlowThread())
class CurrentRenderFlowThreadMaintainer {
WTF_MAKE_NONCOPYABLE(CurrentRenderFlowThreadMaintainer);
public:
CurrentRenderFlowThreadMaintainer(RenderFlowThread*);
~CurrentRenderFlowThreadMaintainer();
private:
RenderFlowThread* m_renderFlowThread;
RenderFlowThread* m_previousRenderFlowThread;
};
class CurrentRenderFlowThreadDisabler {
WTF_MAKE_NONCOPYABLE(CurrentRenderFlowThreadDisabler);
public:
CurrentRenderFlowThreadDisabler(RenderView*);
~CurrentRenderFlowThreadDisabler();
private:
RenderView* m_view;
RenderFlowThread* m_renderFlowThread;
};
#ifndef NDEBUG
template <> struct ValueToString<RenderRegion*> {
static String string(const RenderRegion* value) { return String::format("%p", value); }
};
#endif
}
#endif // RenderFlowThread_h