#ifndef render_layer_h
#define render_layer_h
#include "RenderObject.h"
#include "Timer.h"
#include "WidgetClient.h"
namespace WebCore {
class CachedResource;
class RenderView;
class RenderFrameSet;
class RenderObject;
class RenderStyle;
class RenderTable;
class RenderText;
class ScrollBar;
class ClipRects
{
public:
ClipRects(const IntRect& r) :m_overflowClipRect(r), m_fixedClipRect(r), m_posClipRect(r), m_refCnt(0) {}
ClipRects(const IntRect& o, const IntRect& f, const IntRect& p)
:m_overflowClipRect(o), m_fixedClipRect(f), m_posClipRect(p), m_refCnt(0) {}
const IntRect& overflowClipRect() { return m_overflowClipRect; }
const IntRect& fixedClipRect() { return m_fixedClipRect; }
const IntRect& posClipRect() { return m_posClipRect; }
void ref() { m_refCnt++; }
void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }
void destroy(RenderArena* renderArena);
void* operator new(size_t sz, RenderArena* renderArena) throw();
void operator delete(void* ptr, size_t sz);
private:
void* operator new(size_t sz) throw();
private:
IntRect m_overflowClipRect;
IntRect m_fixedClipRect;
IntRect m_posClipRect;
unsigned m_refCnt;
};
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 dir, 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 : WidgetClient {
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; }
static ScrollBar* gScrollBar;
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 styleChanged();
Marquee* marquee() const { return m_marquee; }
void suspendMarquees();
bool isOverflowOnly() const { return m_isOverflowOnly; }
bool isTransparent() const;
RenderLayer* transparentAncestor();
void beginTransparencyLayers(GraphicsContext*, const IntRect&);
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; }
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 setPos( int xPos, int yPos ) {
m_x = xPos;
m_y = yPos;
}
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 &r, 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 hasScrollbar);
void setHasVerticalScrollbar(bool hasScrollbar);
ScrollBar* horizontalScrollbar() { return m_hBar; }
ScrollBar* verticalScrollbar() { return m_vBar; }
int verticalScrollbarWidth();
int horizontalScrollbarHeight();
void positionScrollbars(const IntRect& absBounds);
void positionResizeControl();
bool isPointInResizeControl(const IntPoint&);
IntSize offsetFromResizeCorner(const IntPoint&) const;
void paintScrollbars(GraphicsContext*, const IntRect& damageRect);
void paintResizeControl(GraphicsContext*);
void updateScrollInfoAfterLayout();
void slotValueChanged(int);
bool scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier=1.0);
void autoscroll();
bool shouldAutoscroll();
IntRect resizeControlRect() { return m_resizeControlRect; }
void setResizeControlRect(const IntRect& r) { m_resizeControlRect = r; }
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 checkForRepaintOnResize();
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();
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; }
RenderLayer* enclosingPositionedAncestor() 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(RenderObject::NodeInfo&, const IntPoint&);
void calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,
IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect);
void calculateClipRects(const RenderLayer* rootLayer);
ClipRects* clipRects() const { return m_clipRects; }
bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect) const;
IntRect absoluteBoundingBox() const;
void updateHoverActiveState(RenderObject::NodeInfo& info);
IntRect repaintRect() const { return m_repaintRect; }
bool adjustForPurpleCaretWhenScrolling() const { return m_adjustForPurpleCaretWhenScrolling; }
void setAdjustForPurpleCaretWhenScrolling(bool b) { m_adjustForPurpleCaretWhenScrolling = b; }
void destroy(RenderArena* renderArena);
void* operator new(size_t sz, RenderArena* renderArena) throw();
void operator delete(void* ptr, size_t sz);
private:
void* operator new(size_t sz) throw();
private:
void setNextSibling(RenderLayer* next) { m_next = next; }
void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
void setParent(RenderLayer* parent) { m_parent = parent; }
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, RenderObject::NodeInfo&, const IntPoint&, const IntRect& hitTestRect);
void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
bool shouldBeOverflowOnly() const;
virtual void valueChanged(Widget*);
void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
protected:
RenderObject* m_object;
RenderLayer* m_parent;
RenderLayer* m_previous;
RenderLayer* m_next;
RenderLayer* m_first;
RenderLayer* m_last;
IntRect m_repaintRect; IntRect m_fullRepaintRect;
int m_repaintX;
int m_repaintY;
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;
ScrollBar* m_hBar;
ScrollBar* m_vBar;
IntRect m_resizeControlRect;
bool m_inResizeMode;
Image* m_resizeCornerImage;
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_repaintOverflowOnResize : 1;
bool m_overflowStatusDirty : 1;
bool m_horizontalOverflow : 1;
bool m_verticalOverflow : 1;
bool m_adjustForPurpleCaretWhenScrolling : 1;
Marquee* m_marquee; };
}
#endif