#ifndef RenderLayer_h
#define RenderLayer_h
#include "CSSPropertyNames.h"
#include "RenderObject.h"
#include "ScrollBar.h"
#include "Timer.h"
#include <wtf/OwnPtr.h>
namespace WebCore {
class AffineTransform;
class CachedResource;
class FloatQuad;
class HitTestResult;
#if ENABLE(HW_COMP)
class LCLayer;
class LCRootLayer;
#endif
class PlatformScrollbar;
class RenderFrameSet;
class RenderObject;
class RenderStyle;
class RenderTable;
class RenderText;
class RenderView;
class Scrollbar;
#if ENABLE(HW_COMP)
enum {
RenderLayerCompositeBackgroundMask = (1 << 0),
RenderLayerCompositeForegroundMask = (1 << 1),
RenderLayerCompositeAllMask = (unsigned int)-1
};
typedef unsigned int RenderLayerCompositePhase;
#define PROFILE_LAYER_REBUILD 0
#endif
struct HitTestRequest;
class ClipRects {
public:
ClipRects()
: m_refCnt(0)
, m_fixed(false)
{
}
ClipRects(const IntRect& r)
: m_overflowClipRect(r)
, m_fixedClipRect(r)
, m_posClipRect(r)
, m_refCnt(0)
, m_fixed(false)
{
}
ClipRects(const IntRect& overflowRect, const IntRect& fixedRect, const IntRect& posRect, bool fixed)
: m_overflowClipRect(overflowRect)
, m_fixedClipRect(fixedRect)
, m_posClipRect(posRect)
, m_refCnt(0)
, m_fixed(fixed)
{
}
ClipRects(const ClipRects& inOther)
: m_overflowClipRect(inOther.overflowClipRect())
, m_fixedClipRect(inOther.fixedClipRect())
, m_posClipRect(inOther.posClipRect())
, m_refCnt(0)
, m_fixed(inOther.fixed())
{
}
const IntRect& overflowClipRect() const { return m_overflowClipRect; }
const IntRect& fixedClipRect() const { return m_fixedClipRect; }
const IntRect& posClipRect() const { return m_posClipRect; }
bool fixed() const { return m_fixed; }
IntRect& overflowClipRect() { return m_overflowClipRect; }
IntRect& fixedClipRect() { return m_fixedClipRect; }
IntRect& posClipRect() { return m_posClipRect; }
void setFixed(bool inFixed = true) { m_fixed = inFixed; }
bool operator==(const ClipRects& other) const
{
return m_overflowClipRect == other.overflowClipRect() &&
m_fixedClipRect == other.fixedClipRect() &&
m_posClipRect == other.posClipRect() &&
m_fixed == other.fixed();
}
void ref() { m_refCnt++; }
void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }
void destroy(RenderArena*);
void* operator new(size_t, RenderArena*) throw();
void operator delete(void*, size_t);
private:
void* operator new(size_t) throw();
private:
IntRect m_overflowClipRect;
IntRect m_fixedClipRect;
IntRect m_posClipRect;
unsigned m_refCnt : 31;
bool m_fixed : 1;
};
class Marquee {
public:
Marquee(RenderLayer*);
int speed() const { return m_speed; }
int marqueeSpeed() const;
EMarqueeDirection reverseDirection() const { return static_cast<EMarqueeDirection>(-direction()); }
EMarqueeDirection direction() const;
bool isHorizontal() const;
int computePosition(EMarqueeDirection, bool stopAtClientEdge);
void setEnd(int end) { m_end = end; }
void start();
void suspend();
void stop();
void updateMarqueeStyle();
void updateMarqueePosition();
private:
void timerFired(Timer<Marquee>*);
RenderLayer* m_layer;
int m_currentLoop;
int m_totalLoops;
Timer<Marquee> m_timer;
int m_start;
int m_end;
int m_speed;
Length m_height;
bool m_reset: 1;
bool m_suspended : 1;
bool m_stopped : 1;
EMarqueeDirection m_direction : 4;
};
class RenderLayer : public ScrollbarClient {
public:
enum ScrollBehavior {
noScroll,
alignCenter,
alignTop,
alignBottom,
alignLeft,
alignRight,
alignToClosestEdge
};
struct ScrollAlignment {
ScrollBehavior m_rectVisible;
ScrollBehavior m_rectHidden;
ScrollBehavior m_rectPartial;
};
static const ScrollAlignment gAlignCenterIfNeeded;
static const ScrollAlignment gAlignToEdgeIfNeeded;
static const ScrollAlignment gAlignCenterAlways;
static const ScrollAlignment gAlignTopAlways;
static const ScrollAlignment gAlignBottomAlways;
static ScrollBehavior getVisibleBehavior(const ScrollAlignment& s) { return s.m_rectVisible; }
static ScrollBehavior getPartialBehavior(const ScrollAlignment& s) { return s.m_rectPartial; }
static ScrollBehavior getHiddenBehavior(const ScrollAlignment& s) { return s.m_rectHidden; }
RenderLayer(RenderObject*);
~RenderLayer();
RenderObject* renderer() const { return m_object; }
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();
void repaintAbsoluteRectIncludingDescendants(const IntRect& r);
void setStyleChangePending(bool inPending);
void styleChanged(RenderStyle::Diff inDiff, bool hasOldStyle);
Marquee* marquee() const { return m_marquee; }
void suspendMarquees();
bool isOverflowOnly() const { return m_isOverflowOnly; }
bool isTransparent() const;
bool isTransparentForDrawing() const;
RenderLayer* transparentAncestor();
void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer);
const RenderLayer* root() const
{
const RenderLayer* curr = this;
while (curr->parent())
curr = curr->parent();
return curr;
}
int xPos() const { return m_x; }
int yPos() const { return m_y; }
void setPos(int xPos, int yPos)
{
m_x = xPos;
m_y = yPos;
}
int width() const { return m_width; }
int height() const { return m_height; }
void setWidth(int w) { m_width = w; }
void setHeight(int h) { m_height = h; }
int scrollWidth();
int scrollHeight();
void scrollOffset(int& x, int& y);
void subtractScrollOffset(int& x, int& y);
int scrollXOffset() const { return m_scrollX + m_scrollOriginX; }
int scrollYOffset() const { return m_scrollY; }
void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true);
void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }
void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOriginX, y); }
void scrollRectToVisible(const IntRect&, const ScrollAlignment& alignX = gAlignCenterIfNeeded, const ScrollAlignment& alignY = gAlignCenterIfNeeded);
IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);
void setHasHorizontalScrollbar(bool);
void setHasVerticalScrollbar(bool);
PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
void destroyScrollbar(ScrollbarOrientation);
Scrollbar* horizontalScrollbar() { return m_hBar.get(); }
Scrollbar* verticalScrollbar() { return m_vBar.get(); }
PlatformScrollbar* horizontalScrollbarWidget() const;
PlatformScrollbar* verticalScrollbarWidget() const;
int verticalScrollbarWidth() const;
int horizontalScrollbarHeight() const;
void positionOverflowControls();
bool isPointInResizeControl(const IntPoint&);
bool hitTestOverflowControls(HitTestResult&);
IntSize offsetFromResizeCorner(const IntPoint&) const;
void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
void updateScrollInfoAfterLayout();
bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1.0f);
void autoscroll();
void resize(const PlatformMouseEvent&, const IntSize&);
bool inResizeMode() const { return m_inResizeMode; }
void setInResizeMode(bool b) { m_inResizeMode = b; }
void updateLayerPosition();
void updateLayerPositions(bool doFullRepaint = false, bool checkForRepaint = true);
void updateTransform();
void relativePositionOffset(int& relX, int& relY) { relX += m_relX; relY += m_relY; }
void clearClipRects();
void clearClipRect();
RenderLayer* stackingContext() const;
bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }
void dirtyZOrderLists(bool inScheduleUpdate = true);
void dirtyStackingContextZOrderList(bool inScheduleUpdate = true);
void updateZOrderLists();
Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; }
Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; }
void dirtyOverflowList();
void updateOverflowList();
Vector<RenderLayer*>* overflowList() const { return m_overflowList; }
bool hasVisibleContent() const { return m_hasVisibleContent; }
void setHasVisibleContent(bool);
void dirtyVisibleContentStatus();
RenderLayer* enclosingPositionedAncestor() const;
RenderLayer* enclosingDocumentLayer() const;
void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
int zIndex() const { return renderer()->style()->zIndex(); }
void paint(GraphicsContext*, const IntRect& damageRect, PaintRestriction = PaintRestrictionNone, RenderObject* paintingRoot = 0);
bool hitTest(const HitTestRequest&, HitTestResult&);
void calculateRects(const RenderLayer* rootLayer, const RenderLayer* rootLayerForClipping,
const IntRect& paintDirtyRect, IntRect& layerBounds,
IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect) const;
void calculateClipRects(const RenderLayer* rootLayer);
ClipRects* clipRects() const { return m_clipRects; }
IntRect childrenClipRect() const; IntRect selfClipRect() const;
bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const;
IntRect localBoundingBox() const; IntRect absoluteBoundingBox() const;
IntRect boundingBox(const RenderLayer* rootLayer) const;
void updateHoverActiveState(const HitTestRequest&, HitTestResult&);
IntRect repaintRect() const { return m_repaintRect; }
void setNeedsFullRepaint(bool f = true) { m_needsFullRepaint = f; }
int staticX() const { return m_staticX; }
int staticY() const { return m_staticY; }
void setStaticX(int staticX) { m_staticX = staticX; }
void setStaticY(int staticY) { m_staticY = staticY; }
bool adjustForPurpleCaretWhenScrolling() const { return m_adjustForPurpleCaretWhenScrolling; }
void setAdjustForPurpleCaretWhenScrolling(bool b) { m_adjustForPurpleCaretWhenScrolling = b; }
AffineTransform* transform() const { return m_transform.get(); }
Transform3D currentTransform() const;
float currentOpacity() const;
void destroy(RenderArena*);
void* operator new(size_t, RenderArena*) throw();
void operator delete(void*, size_t);
bool startAnimation(double beginTime, int index);
bool startTransition(double beginTime, int property, RenderStyle* fromStyle, RenderStyle* toStyle);
void setAnimationStartTime(double t);
void setTransitionStartTime(int property, double t);
void animationFinished(const String& name, int index, bool reset);
void transitionFinished(int property);
void suspendAnimations();
void resumeAnimations();
FloatPoint convertToPage(const FloatPoint& inPoint);
FloatPoint convertFromPage(const FloatPoint& inPoint);
void convertQuadToPage(FloatQuad& ioQuad);
private:
void* operator new(size_t) throw();
private:
void setNextSibling(RenderLayer* next) { m_next = next; }
void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
#if !ENABLE(HW_COMP)
void setParent(RenderLayer* parent) { m_parent = parent; }
#endif
void setFirstChild(RenderLayer* first) { m_first = first; }
void setLastChild(RenderLayer* last) { m_last = last; }
void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);
void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
bool haveTransparency, PaintRestriction, RenderObject* paintingRoot);
RenderLayer* hitTestLayer(RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&, const IntRect& hitTestRect, const IntPoint& hitTestPoint);
RenderLayer* hitTestRootLayer(RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result, const IntRect& hitTestRect, const IntPoint& hitTestPoint);
void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
bool shouldBeOverflowOnly() const;
virtual void valueChanged(Scrollbar*);
virtual IntRect windowClipRect() const;
virtual bool isActive() const;
void computeClipRectsFromAncestor(const RenderLayer* inAncestorLayer, ClipRects& outClipRects, bool& outIsClipped, const RenderLayer** outNearestClippingAncestor = 0) const;
void updateClipRectsRelativeToLayer(const RenderLayer* inAncestorLayer, ClipRects& ioClipRects, bool& outHasClip) const;
void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
void childVisibilityChanged(bool newVisibility);
void dirtyVisibleDescendantStatus();
void updateVisibilityStatus();
Node* enclosingElement() const;
#include "RenderLayerCompositing.h"
protected:
RenderObject* m_object;
RenderLayer* m_parent;
RenderLayer* m_previous;
RenderLayer* m_next;
RenderLayer* m_first;
RenderLayer* m_last;
IntRect m_repaintRect; IntRect m_outlineBox;
int m_relX;
int m_relY;
int m_x;
int m_y;
int m_width;
int m_height;
int m_scrollX;
int m_scrollY;
int m_scrollOriginX;
int m_scrollLeftOverflow;
int m_scrollWidth;
int m_scrollHeight;
RefPtr<Scrollbar> m_hBar;
RefPtr<Scrollbar> m_vBar;
bool m_inResizeMode;
Vector<RenderLayer*>* m_posZOrderList;
Vector<RenderLayer*>* m_negZOrderList;
Vector<RenderLayer*>* m_overflowList;
ClipRects* m_clipRects;
bool m_scrollDimensionsDirty : 1;
bool m_zOrderListsDirty : 1;
bool m_overflowListDirty: 1;
bool m_isOverflowOnly: 1;
bool m_usedTransparency : 1; bool m_inOverflowRelayout : 1;
bool m_needsFullRepaint : 1;
bool m_overflowStatusDirty : 1;
bool m_horizontalOverflow : 1;
bool m_verticalOverflow : 1;
bool m_visibleContentStatusDirty : 1;
bool m_hasVisibleContent : 1;
bool m_visibleDescendantStatusDirty : 1;
bool m_hasVisibleDescendant : 1;
bool m_styleChangePending : 1;
bool m_adjustForPurpleCaretWhenScrolling : 1;
#if ENABLE(HW_COMP)
bool m_forceCompositingLayer : 1; bool m_isSimpleContainerCompositingLayer : 1; bool m_simpleCompositingLayerStatusDirty : 1;
bool m_hasCompositingDescendant : 1;
bool m_compositingContentOffsetDirty: 1;
bool m_rebuildingLayerTree : 1;
#endif
Marquee* m_marquee;
int m_staticX;
int m_staticY;
OwnPtr<AffineTransform> m_transform;
#if ENABLE(HW_COMP)
float m_transformOriginX;
float m_transformOriginY;
float m_transformOriginZ;
LCLayer* m_layer;
LCLayer* m_contentsLayer; LCLayer* m_clippingLayer;
IntSize m_compositingContentOffset;
#if PROFILE_LAYER_REBUILD
int m_rootLayerUpdateCount;
#endif
#endif
};
}
#endif // RenderLayer_h