#ifndef RenderLayer_h
#define RenderLayer_h
#include "PaintInfo.h"
#include "RenderBox.h"
#include "ScrollableArea.h"
#include <wtf/OwnPtr.h>
#if ENABLE(CSS_FILTERS)
#include "RenderLayerFilterInfo.h"
#endif
namespace WebCore {
#if ENABLE(CSS_FILTERS)
class FilterEffectRenderer;
#endif
class HitTestRequest;
class HitTestResult;
class HitTestingTransformState;
class RenderMarquee;
class RenderReplica;
class RenderScrollbarPart;
class RenderStyle;
class RenderView;
class Scrollbar;
class TransformationMatrix;
#if USE(ACCELERATED_COMPOSITING)
class RenderLayerBacking;
class RenderLayerCompositor;
#endif
enum BorderRadiusClippingRule { IncludeSelfForBorderRadius, DoNotIncludeSelfForBorderRadius };
enum RepaintStatus {
NeedsNormalRepaint = 0,
NeedsFullRepaint = 1 << 0,
NeedsFullRepaintForPositionedMovementLayout = 1 << 1
};
class ClipRect {
public:
ClipRect()
: m_hasRadius(false)
{ }
ClipRect(const LayoutRect& rect)
: m_rect(rect)
, m_hasRadius(false)
{ }
const LayoutRect& rect() const { return m_rect; }
void setRect(const LayoutRect& rect) { m_rect = rect; }
bool hasRadius() const { return m_hasRadius; }
void setHasRadius(bool hasRadius) { m_hasRadius = hasRadius; }
bool operator==(const ClipRect& other) const { return rect() == other.rect() && hasRadius() == other.hasRadius(); }
bool operator!=(const ClipRect& other) const { return rect() != other.rect() || hasRadius() != other.hasRadius(); }
void intersect(const LayoutRect& other) { m_rect.intersect(other); }
void intersect(const ClipRect& other)
{
m_rect.intersect(other.rect());
if (other.hasRadius())
m_hasRadius = true;
}
void move(LayoutUnit x, LayoutUnit y) { m_rect.move(x, y); }
bool isEmpty() const { return m_rect.isEmpty(); }
bool intersects(const LayoutRect& rect) { return m_rect.intersects(rect); }
private:
LayoutRect m_rect;
bool m_hasRadius;
};
inline ClipRect intersection(const ClipRect& a, const ClipRect& b)
{
ClipRect c = a;
c.intersect(b);
return c;
}
class ClipRects {
public:
ClipRects()
: m_refCnt(0)
, m_fixed(false)
{
}
ClipRects(const LayoutRect& r)
: m_overflowClipRect(r)
, m_fixedClipRect(r)
, m_posClipRect(r)
, m_refCnt(0)
, m_fixed(false)
{
}
ClipRects(const ClipRects& other)
: m_overflowClipRect(other.overflowClipRect())
, m_fixedClipRect(other.fixedClipRect())
, m_posClipRect(other.posClipRect())
, m_refCnt(0)
, m_fixed(other.fixed())
{
}
void reset(const LayoutRect& r)
{
m_overflowClipRect = r;
m_fixedClipRect = r;
m_posClipRect = r;
m_fixed = false;
}
const ClipRect& overflowClipRect() const { return m_overflowClipRect; }
void setOverflowClipRect(const ClipRect& r) { m_overflowClipRect = r; }
const ClipRect& fixedClipRect() const { return m_fixedClipRect; }
void setFixedClipRect(const ClipRect&r) { m_fixedClipRect = r; }
const ClipRect& posClipRect() const { return m_posClipRect; }
void setPosClipRect(const ClipRect& r) { m_posClipRect = r; }
bool fixed() const { return m_fixed; }
void setFixed(bool fixed) { m_fixed = fixed; }
void ref() { m_refCnt++; }
void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }
void destroy(RenderArena*);
void* operator new(size_t, RenderArena*);
void operator delete(void*, size_t);
bool operator==(const ClipRects& other) const
{
return m_overflowClipRect == other.overflowClipRect() &&
m_fixedClipRect == other.fixedClipRect() &&
m_posClipRect == other.posClipRect() &&
m_fixed == other.fixed();
}
ClipRects& operator=(const ClipRects& other)
{
m_overflowClipRect = other.overflowClipRect();
m_fixedClipRect = other.fixedClipRect();
m_posClipRect = other.posClipRect();
m_fixed = other.fixed();
return *this;
}
private:
void* operator new(size_t) throw();
private:
ClipRect m_overflowClipRect;
ClipRect m_fixedClipRect;
ClipRect m_posClipRect;
unsigned m_refCnt : 31;
bool m_fixed : 1;
};
class RenderLayer : public ScrollableArea {
public:
friend class RenderReplica;
RenderLayer(RenderBoxModelObject*);
~RenderLayer();
RenderBoxModelObject* renderer() const { return m_renderer; }
RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }
RenderLayer* parent() const { return m_parent; }
RenderLayer* previousSibling() const { return m_previous; }
RenderLayer* nextSibling() const { return m_next; }
RenderLayer* firstChild() const { return m_first; }
RenderLayer* lastChild() const { return m_last; }
void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);
RenderLayer* removeChild(RenderLayer*);
void removeOnlyThisLayer();
void insertOnlyThisLayer();
void repaintIncludingDescendants();
#if USE(ACCELERATED_COMPOSITING)
void setBackingNeedsRepaint();
void setBackingNeedsRepaintInRect(const LayoutRect&); void repaintIncludingNonCompositingDescendants(RenderBoxModelObject* repaintContainer);
#endif
void styleChanged(StyleDifference, const RenderStyle* oldStyle);
RenderMarquee* marquee() const { return m_marquee; }
bool isNormalFlowOnly() const { return m_isNormalFlowOnly; }
bool isSelfPaintingLayer() const;
bool cannotBlitToWindow() const;
bool isTransparent() const;
RenderLayer* transparentPaintingAncestor();
void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, PaintBehavior);
bool hasReflection() const { return renderer()->hasReflection(); }
bool isReflection() const { return renderer()->isReplica(); }
RenderReplica* reflection() const { return m_reflection; }
RenderLayer* reflectionLayer() const;
const RenderLayer* root() const
{
const RenderLayer* curr = this;
while (curr->parent())
curr = curr->parent();
return curr;
}
const LayoutPoint& location() const { return m_topLeft; }
void setLocation(LayoutUnit x, LayoutUnit y) { m_topLeft = LayoutPoint(x, y); }
const IntSize& size() const { return m_layerSize; }
void setSize(const IntSize& size) { m_layerSize = size; }
LayoutRect rect() const { return LayoutRect(location(), size()); }
int scrollWidth() const;
int scrollHeight() const;
void panScrollFromPoint(const LayoutPoint&);
enum ScrollOffsetClamping {
ScrollOffsetUnclamped,
ScrollOffsetClamped
};
void scrollByRecursively(int xDelta, int yDelta, ScrollOffsetClamping = ScrollOffsetUnclamped);
int scrollXOffset() const { return m_scrollOffset.width() + scrollOrigin().x(); }
int scrollYOffset() const { return m_scrollOffset.height() + scrollOrigin().y(); }
IntSize scrollOffset() const { return IntSize(scrollXOffset(), scrollYOffset()); }
void scrollToOffset(int, int, ScrollOffsetClamping = ScrollOffsetUnclamped);
void scrollToXOffset(int x, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(x, scrollYOffset(), clamp); }
void scrollToYOffset(int y, ScrollOffsetClamping clamp = ScrollOffsetUnclamped) { scrollToOffset(scrollXOffset(), y, clamp); }
void scrollRectToVisible(const LayoutRect&, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
LayoutRect getRectToExpose(const LayoutRect& visibleRect, const LayoutRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
bool scrollsOverflow() const;
bool allowsScrolling() const; bool hasScrollbars() const { return m_hBar || m_vBar; }
void setHasHorizontalScrollbar(bool);
void setHasVerticalScrollbar(bool);
PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
void destroyScrollbar(ScrollbarOrientation);
bool hasHorizontalScrollbar() const { return horizontalScrollbar(); }
bool hasVerticalScrollbar() const { return verticalScrollbar(); }
virtual Scrollbar* horizontalScrollbar() const { return m_hBar.get(); }
virtual Scrollbar* verticalScrollbar() const { return m_vBar.get(); }
virtual ScrollableArea* enclosingScrollableArea() const;
int verticalScrollbarWidth(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
int horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
bool hasOverflowControls() const;
bool isPointInResizeControl(const IntPoint& absolutePoint) const;
bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint);
IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const;
void paintOverflowControls(GraphicsContext*, const IntPoint&, const IntRect& damageRect, bool paintingOverlayControls = false);
void paintScrollCorner(GraphicsContext*, const IntPoint&, const IntRect& damageRect);
void paintResizer(GraphicsContext*, const IntPoint&, const IntRect& damageRect);
void updateScrollInfoAfterLayout();
bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1);
void autoscroll();
void resize(const PlatformMouseEvent&, const LayoutSize&);
bool inResizeMode() const { return m_inResizeMode; }
void setInResizeMode(bool b) { m_inResizeMode = b; }
bool isRootLayer() const { return renderer()->isRenderView(); }
#if USE(ACCELERATED_COMPOSITING)
RenderLayerCompositor* compositor() const;
void contentChanged(ContentChangeType);
#endif
bool canRender3DTransforms() const;
void updateLayerPosition();
enum UpdateLayerPositionsFlag {
CheckForRepaint = 1,
IsCompositingUpdateRoot = 1 << 1,
UpdateCompositingLayers = 1 << 2,
UpdatePagination = 1 << 3
};
typedef unsigned UpdateLayerPositionsFlags;
static const UpdateLayerPositionsFlags defaultFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers;
void updateLayerPositions(LayoutPoint* offsetFromRoot, UpdateLayerPositionsFlags = defaultFlags);
void updateTransform();
void relativePositionOffset(LayoutUnit& relX, LayoutUnit& relY) const { relX += m_relativeOffset.width(); relY += m_relativeOffset.height(); }
const LayoutSize& relativePositionOffset() const { return m_relativeOffset; }
void clearClipRectsIncludingDescendants();
void clearClipRects();
void addBlockSelectionGapsBounds(const LayoutRect&);
void clearBlockSelectionGapsBounds();
void repaintBlockSelectionGaps();
RenderLayer* stackingContext() const;
bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }
void dirtyZOrderLists();
void dirtyStackingContextZOrderLists();
Vector<RenderLayer*>* posZOrderList() const
{
ASSERT(!m_zOrderListsDirty);
ASSERT(isStackingContext() || !m_posZOrderList);
return m_posZOrderList;
}
Vector<RenderLayer*>* negZOrderList() const
{
ASSERT(!m_zOrderListsDirty);
ASSERT(isStackingContext() || !m_negZOrderList);
return m_negZOrderList;
}
void dirtyNormalFlowList();
Vector<RenderLayer*>* normalFlowList() const { ASSERT(!m_normalFlowListDirty); return m_normalFlowList; }
void updateLayerListsIfNeeded();
bool hasVisibleContent() const { return m_hasVisibleContent; }
bool hasVisibleDescendant() const { return m_hasVisibleDescendant; }
void setHasVisibleContent(bool);
void dirtyVisibleContentStatus();
RenderLayer* enclosingPositionedAncestor() const;
RenderLayer* enclosingScrollableLayer() const;
RenderLayer* clippingRoot() const;
#if USE(ACCELERATED_COMPOSITING)
RenderLayer* enclosingCompositingLayer(bool includeSelf = true) const;
RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(false); }
#endif
#if ENABLE(CSS_FILTERS)
RenderLayer* enclosingFilterLayer(bool includeSelf = true) const;
RenderLayer* enclosingFilterRepaintLayer() const;
void setFilterBackendNeedsRepaintingInRect(const LayoutRect&, bool immediate);
#endif
void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntPoint& location) const;
void convertToPixelSnappedLayerCoords(const RenderLayer* ancestorLayer, IntRect&) const;
void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutPoint& location) const;
void convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect&) const;
bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
int zIndex() const { return renderer()->style()->zIndex(); }
enum PaintLayerFlag {
PaintLayerHaveTransparency = 1,
PaintLayerAppliedTransform = 1 << 1,
PaintLayerTemporaryClipRects = 1 << 2,
PaintLayerPaintingReflection = 1 << 3,
PaintLayerPaintingOverlayScrollbars = 1 << 4,
PaintLayerPaintingCompositingBackgroundPhase = 1 << 5,
PaintLayerPaintingCompositingForegroundPhase = 1 << 6,
PaintLayerPaintingCompositingMaskPhase = 1 << 7,
PaintLayerPaintingCompositingAllPhases = (PaintLayerPaintingCompositingBackgroundPhase | PaintLayerPaintingCompositingForegroundPhase | PaintLayerPaintingCompositingMaskPhase)
};
typedef unsigned PaintLayerFlags;
void paint(GraphicsContext*, const LayoutRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0,
RenderRegion* = 0, PaintLayerFlags = 0);
bool hitTest(const HitTestRequest&, HitTestResult&);
void paintOverlayScrollbars(GraphicsContext*, const LayoutRect& damageRect, PaintBehavior, RenderObject* paintingRoot);
void calculateRects(const RenderLayer* rootLayer, RenderRegion*, const LayoutRect& paintDirtyRect, LayoutRect& layerBounds,
ClipRect& backgroundRect, ClipRect& foregroundRect, ClipRect& outlineRect,
bool temporaryClipRects = false, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
void updateClipRects(const RenderLayer* rootLayer, RenderRegion*, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize);
void calculateClipRects(const RenderLayer* rootLayer, RenderRegion*, ClipRects&, bool useCached = false, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
ClipRects* clipRects() const { return m_clipRects; }
LayoutRect childrenClipRect() const; LayoutRect selfClipRect() const; LayoutRect localClipRect() const;
bool intersectsDamageRect(const LayoutRect& layerBounds, const LayoutRect& damageRect, const RenderLayer* rootLayer) const;
LayoutRect boundingBox(const RenderLayer* rootLayer) const;
LayoutRect localBoundingBox() const;
IntRect absoluteBoundingBox() const;
enum CalculateLayerBoundsFlag {
IncludeSelfTransform = 1 << 0,
UseLocalClipRectIfPossible = 1 << 1,
IncludeLayerFilterOutsets = 1 << 2,
DefaultCalculateLayerBoundsFlags = IncludeSelfTransform | UseLocalClipRectIfPossible | IncludeLayerFilterOutsets
};
typedef unsigned CalculateLayerBoundsFlags;
static IntRect calculateLayerBounds(const RenderLayer*, const RenderLayer* ancestorLayer, CalculateLayerBoundsFlags = DefaultCalculateLayerBoundsFlags);
void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
LayoutPoint computeOffsetFromRoot(bool& hasLayerOffset) const;
LayoutRect repaintRect() const { return m_repaintRect; }
LayoutRect repaintRectIncludingNonCompositingDescendants() const;
enum UpdateLayerPositionsAfterScrollFlag {
NoFlag = 0,
HasSeenFixedPositionedAncestor = 1 << 0,
HasSeenAncestorWithOverflowClip = 1 << 1
};
typedef unsigned UpdateLayerPositionsAfterScrollFlags;
void updateLayerPositionsAfterScroll(UpdateLayerPositionsAfterScrollFlags = NoFlag);
void setRepaintStatus(RepaintStatus status) { m_repaintStatus = status; }
LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
void setStaticInlinePosition(LayoutUnit position) { m_staticInlinePosition = position; }
void setStaticBlockPosition(LayoutUnit position) { m_staticBlockPosition = position; }
bool hasTransform() const { return renderer()->hasTransform(); }
TransformationMatrix* transform() const { return m_transform.get(); }
TransformationMatrix currentTransform() const;
TransformationMatrix renderableTransform(PaintBehavior) const;
TransformationMatrix perspectiveTransform() const;
FloatPoint perspectiveOrigin() const;
bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
bool has3DTransform() const { return m_transform && !m_transform->isAffine(); }
#if ENABLE(CSS_FILTERS)
virtual void filterNeedsRepaint();
bool hasFilter() const { return renderer()->hasFilter(); }
#else
bool hasFilter() const { return false; }
#endif
void* operator new(size_t, RenderArena*);
void operator delete(void*, size_t);
#if USE(ACCELERATED_COMPOSITING)
bool isComposited() const { return m_backing != 0; }
bool hasCompositedMask() const;
RenderLayerBacking* backing() const { return m_backing.get(); }
RenderLayerBacking* ensureBacking();
void clearBacking(bool layerBeingDestroyed = false);
virtual GraphicsLayer* layerForHorizontalScrollbar() const;
virtual GraphicsLayer* layerForVerticalScrollbar() const;
virtual GraphicsLayer* layerForScrollCorner() const;
#else
bool isComposited() const { return false; }
bool hasCompositedMask() const { return false; }
#endif
bool paintsWithTransparency(PaintBehavior paintBehavior) const
{
return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited());
}
bool paintsWithTransform(PaintBehavior) const;
bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
#if ENABLE(CSS_FILTERS)
bool paintsWithFilters() const;
bool requiresFullLayerImageForFilters() const;
FilterEffectRenderer* filterRenderer() const
{
RenderLayerFilterInfo* filterInfo = this->filterInfo();
return filterInfo ? filterInfo->renderer() : 0;
}
RenderLayerFilterInfo* filterInfo() const { return hasFilterInfo() ? RenderLayerFilterInfo::filterInfoForRenderLayer(this) : 0; }
RenderLayerFilterInfo* ensureFilterInfo() { return RenderLayerFilterInfo::createFilterInfoForRenderLayerIfNeeded(this); }
void removeFilterInfoIfNeeded()
{
if (hasFilterInfo())
RenderLayerFilterInfo::removeFilterInfoForRenderLayer(this);
}
bool hasFilterInfo() const { return m_hasFilterInfo; }
void setHasFilterInfo(bool hasFilterInfo) { m_hasFilterInfo = hasFilterInfo; }
#endif
#if !ASSERT_DISABLED
bool layerListMutationAllowed() const { return m_layerListMutationAllowed; }
void setLayerListMutationAllowed(bool flag) { m_layerListMutationAllowed = flag; }
#endif
private:
void updateZOrderLists();
void rebuildZOrderLists();
void clearZOrderLists();
void updateNormalFlowList();
bool isDirtyStackingContext() const { return m_zOrderListsDirty && isStackingContext(); }
void computeRepaintRects(LayoutPoint* offsetFromRoot = 0);
void clearRepaintRects();
void clipToRect(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&,
BorderRadiusClippingRule = IncludeSelfForBorderRadius);
void restoreClip(GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&);
bool shouldRepaintAfterLayout() const;
void updateScrollbarsAfterStyleChange(const RenderStyle* oldStyle);
void updateScrollbarsAfterLayout();
friend IntSize RenderBox::scrolledContentOffset() const;
IntSize scrolledContentOffset() const { return scrollOffset() + m_scrollOverflow; }
void* operator new(size_t) throw();
void setNextSibling(RenderLayer* next) { m_next = next; }
void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
void setParent(RenderLayer* parent);
void setFirstChild(RenderLayer* first) { m_first = first; }
void setLastChild(RenderLayer* last) { m_last = last; }
LayoutPoint renderBoxLocation() const { return renderer()->isBox() ? toRenderBox(renderer())->location() : LayoutPoint(); }
LayoutUnit renderBoxX() const { return renderBoxLocation().x(); }
LayoutUnit renderBoxY() const { return renderBoxLocation().y(); }
void collectLayers(bool includeHiddenLayers, Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);
void updateCompositingAndLayerListsIfNeeded();
void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,
PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
PaintLayerFlags = 0);
void paintLayerContentsAndReflection(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,
PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
PaintLayerFlags = 0);
void paintLayerContents(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect,
PaintBehavior, RenderObject* paintingRoot, RenderRegion* = 0, OverlapTestRequestMap* = 0,
PaintLayerFlags = 0);
void paintList(Vector<RenderLayer*>*, RenderLayer* rootLayer, GraphicsContext* p,
const LayoutRect& paintDirtyRect, PaintBehavior,
RenderObject* paintingRoot, RenderRegion*, OverlapTestRequestMap*,
PaintLayerFlags);
void paintPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*,
const LayoutRect& paintDirtyRect, PaintBehavior,
RenderObject* paintingRoot, RenderRegion*, OverlapTestRequestMap*,
PaintLayerFlags);
void paintChildLayerIntoColumns(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*,
const LayoutRect& paintDirtyRect, PaintBehavior,
RenderObject* paintingRoot, RenderRegion*, OverlapTestRequestMap*,
PaintLayerFlags, const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
const LayoutRect& hitTestRect, const LayoutPoint& hitTestPoint, bool appliedTransform,
const HitTestingTransformState* transformState = 0, double* zOffset = 0);
RenderLayer* hitTestList(Vector<RenderLayer*>*, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
const LayoutRect& hitTestRect, const LayoutPoint& hitTestPoint,
const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset,
const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
RenderLayer* hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
const LayoutRect& hitTestRect, const LayoutPoint& hitTestPoint,
const HitTestingTransformState* transformState, double* zOffset);
RenderLayer* hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result,
const LayoutRect& hitTestRect, const LayoutPoint& hitTestPoint,
const HitTestingTransformState* transformState, double* zOffset,
const Vector<RenderLayer*>& columnLayers, size_t columnIndex);
PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
const LayoutRect& hitTestRect, const LayoutPoint& hitTestPoint,
const HitTestingTransformState* containerTransformState) const;
bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const LayoutPoint& hitTestPoint, HitTestFilter) const;
void computeScrollDimensions();
bool hasHorizontalOverflow() const;
bool hasVerticalOverflow() const;
bool shouldBeNormalFlowOnly() const;
int scrollPosition(Scrollbar*) const;
virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&);
virtual void invalidateScrollCornerRect(const IntRect&);
virtual bool isActive() const;
virtual bool isScrollCornerVisible() const;
virtual IntRect scrollCornerRect() const;
virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const;
virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const;
virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const;
virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const;
virtual int scrollSize(ScrollbarOrientation) const;
virtual void setScrollOffset(const IntPoint&);
virtual IntPoint scrollPosition() const;
virtual IntPoint minimumScrollPosition() const;
virtual IntPoint maximumScrollPosition() const;
virtual IntRect visibleContentRect(bool includeScrollbars) const;
virtual int visibleHeight() const;
virtual int visibleWidth() const;
virtual IntSize contentsSize() const;
virtual IntSize overhangAmount() const;
virtual IntPoint currentMousePosition() const;
virtual bool shouldSuspendScrollAnimations() const;
virtual bool isOnActivePage() const;
virtual IntRect scrollableAreaBoundingBox() const OVERRIDE;
IntRect scrollCornerAndResizerRect() const;
void scrollTo(int, int);
void updateCompositingLayersAfterScroll();
IntSize scrollbarOffset(const Scrollbar*) const;
void updateScrollableAreaSet(bool hasOverflow);
void childVisibilityChanged(bool newVisibility);
void dirtyVisibleDescendantStatus();
void updateVisibilityStatus();
void setHas3DTransformedDescendant(bool b) { m_has3DTransformedDescendant = b; }
bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; }
void dirty3DTransformedDescendantStatus();
bool update3DTransformedDescendantStatus();
Node* enclosingElement() const;
void createReflection();
void removeReflection();
void updateReflectionStyle();
bool paintingInsideReflection() const { return m_paintingInsideReflection; }
void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; }
#if ENABLE(CSS_FILTERS)
void updateOrRemoveFilterEffect();
#endif
void parentClipRects(const RenderLayer* rootLayer, RenderRegion*, ClipRects&, bool temporaryClipRects = false, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
ClipRect backgroundClipRect(const RenderLayer* rootLayer, RenderRegion*, bool temporaryClipRects, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const;
LayoutRect paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, PaintBehavior);
RenderLayer* enclosingTransformedAncestor() const;
LayoutPoint absoluteToContents(const LayoutPoint&) const;
void positionOverflowControls(const IntSize&);
void updateScrollCornerStyle();
void updateResizerStyle();
void drawPlatformResizerImage(GraphicsContext*, IntRect resizerCornerRect);
void updatePagination();
bool isPaginated() const { return m_isPaginated; }
#if USE(ACCELERATED_COMPOSITING)
bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
void setHasCompositingDescendant(bool b) { m_hasCompositingDescendant = b; }
bool mustOverlapCompositedLayers() const { return m_mustOverlapCompositedLayers; }
void setMustOverlapCompositedLayers(bool b) { m_mustOverlapCompositedLayers = b; }
#endif
friend class RenderLayerBacking;
friend class RenderLayerCompositor;
friend class RenderBoxModelObject;
void destroy(RenderArena*);
LayoutUnit overflowTop() const;
LayoutUnit overflowBottom() const;
LayoutUnit overflowLeft() const;
LayoutUnit overflowRight() const;
bool canUseConvertToLayerCoords() const
{
return !renderer()->hasColumns() && !renderer()->hasTransform() && !isComposited()
#if ENABLE(SVG)
&& !renderer()->isSVGRoot()
#endif
;
}
LayoutUnit verticalScrollbarStart(int minX, int maxX) const;
LayoutUnit horizontalScrollbarStart(int minX) const;
protected:
bool m_inResizeMode : 1;
bool m_scrollDimensionsDirty : 1;
bool m_zOrderListsDirty : 1;
bool m_normalFlowListDirty: 1;
bool m_isNormalFlowOnly : 1;
bool m_usedTransparency : 1; bool m_paintingInsideReflection : 1; bool m_inOverflowRelayout : 1;
unsigned m_repaintStatus : 2;
bool m_visibleContentStatusDirty : 1;
bool m_hasVisibleContent : 1;
bool m_visibleDescendantStatusDirty : 1;
bool m_hasVisibleDescendant : 1;
bool m_isPaginated : 1;
bool m_3DTransformedDescendantStatusDirty : 1;
bool m_has3DTransformedDescendant : 1; #if USE(ACCELERATED_COMPOSITING)
bool m_hasCompositingDescendant : 1; bool m_mustOverlapCompositedLayers : 1;
#endif
bool m_containsDirtyOverlayScrollbars : 1;
#if !ASSERT_DISABLED
bool m_layerListMutationAllowed : 1;
#endif
bool m_canSkipRepaintRectsUpdateOnScroll : 1;
#if ENABLE(CSS_FILTERS)
bool m_hasFilterInfo : 1;
#endif
RenderBoxModelObject* m_renderer;
RenderLayer* m_parent;
RenderLayer* m_previous;
RenderLayer* m_next;
RenderLayer* m_first;
RenderLayer* m_last;
LayoutRect m_repaintRect; LayoutRect m_outlineBox;
LayoutSize m_relativeOffset;
LayoutPoint m_topLeft;
IntSize m_layerSize;
IntSize m_scrollOffset;
IntSize m_scrollOverflow;
LayoutSize m_scrollSize;
RefPtr<Scrollbar> m_hBar;
RefPtr<Scrollbar> m_vBar;
Vector<RenderLayer*>* m_posZOrderList;
Vector<RenderLayer*>* m_negZOrderList;
Vector<RenderLayer*>* m_normalFlowList;
ClipRects* m_clipRects; #ifndef NDEBUG
const RenderLayer* m_clipRectsRoot; #endif
IntPoint m_cachedOverlayScrollbarOffset;
RenderMarquee* m_marquee;
LayoutUnit m_staticInlinePosition;
LayoutUnit m_staticBlockPosition;
OwnPtr<TransformationMatrix> m_transform;
RenderReplica* m_reflection;
RenderScrollbarPart* m_scrollCorner;
RenderScrollbarPart* m_resizer;
private:
LayoutRect m_blockSelectionGapsBounds;
#if USE(ACCELERATED_COMPOSITING)
OwnPtr<RenderLayerBacking> m_backing;
#endif
};
inline void RenderLayer::clearZOrderLists()
{
if (m_posZOrderList) {
delete m_posZOrderList;
m_posZOrderList = 0;
}
if (m_negZOrderList) {
delete m_negZOrderList;
m_negZOrderList = 0;
}
}
inline void RenderLayer::updateZOrderLists()
{
if (!m_zOrderListsDirty)
return;
if (!isStackingContext()) {
clearZOrderLists();
m_zOrderListsDirty = false;
return;
}
rebuildZOrderLists();
}
#if !ASSERT_DISABLED
class LayerListMutationDetector {
public:
LayerListMutationDetector(RenderLayer* layer)
: m_layer(layer)
, m_previousMutationAllowedState(layer->layerListMutationAllowed())
{
m_layer->setLayerListMutationAllowed(false);
}
~LayerListMutationDetector()
{
m_layer->setLayerListMutationAllowed(m_previousMutationAllowedState);
}
private:
RenderLayer* m_layer;
bool m_previousMutationAllowedState;
};
#endif
}
#ifndef NDEBUG
void showLayerTree(const WebCore::RenderLayer*);
void showLayerTree(const WebCore::RenderObject*);
#endif
#endif // RenderLayer_h