120b546e8c6af6996e1fe20b706f89683c0932fe
[WebKit-https.git] / WebCore / rendering / RenderLayer.h
1 /*
2  * Copyright (C) 2003 Apple Computer, Inc.
3  *
4  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
5  *
6  * Other contributors:
7  *   Robert O'Callahan <roc+@cs.cmu.edu>
8  *   David Baron <dbaron@fas.harvard.edu>
9  *   Christian Biesinger <cbiesinger@web.de>
10  *   Randall Jesup <rjesup@wgate.com>
11  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
12  *   Josh Soref <timeless@mac.com>
13  *   Boris Zbarsky <bzbarsky@mit.edu>
14  *
15  * This library is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU Lesser General Public
17  * License as published by the Free Software Foundation; either
18  * version 2.1 of the License, or (at your option) any later version.
19  *
20  * This library is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23  * Lesser General Public License for more details.
24  *
25  * You should have received a copy of the GNU Lesser General Public
26  * License along with this library; if not, write to the Free Software
27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
28  *
29  * Alternatively, the contents of this file may be used under the terms
30  * of either the Mozilla Public License Version 1.1, found at
31  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
32  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
33  * (the "GPL"), in which case the provisions of the MPL or the GPL are
34  * applicable instead of those above.  If you wish to allow use of your
35  * version of this file only under the terms of one of those two
36  * licenses (the MPL or the GPL) and not to allow others to use your
37  * version of this file under the LGPL, indicate your decision by
38  * deletingthe provisions above and replace them with the notice and
39  * other provisions required by the MPL or the GPL, as the case may be.
40  * If you do not delete the provisions above, a recipient may use your
41  * version of this file under any of the LGPL, the MPL or the GPL.
42  */
43
44 #ifndef render_layer_h
45 #define render_layer_h
46
47 #include "RenderObject.h"
48 #include "Timer.h"
49 #include "ScrollBar.h"
50
51 namespace WebCore {
52
53 class CachedResource;
54 class HitTestResult;
55 class RenderView;
56 class RenderFrameSet;
57 class RenderObject;
58 class RenderStyle;
59 class RenderTable;
60 class RenderText;
61 class PlatformScrollbar;
62
63 class ClipRects {
64 public:
65     ClipRects(const IntRect& r) :m_overflowClipRect(r), m_fixedClipRect(r), m_posClipRect(r), m_refCnt(0) {}
66     ClipRects(const IntRect& o, const IntRect& f, const IntRect& p)
67       :m_overflowClipRect(o), m_fixedClipRect(f), m_posClipRect(p), m_refCnt(0) {}
68
69     const IntRect& overflowClipRect() { return m_overflowClipRect; }
70     const IntRect& fixedClipRect() { return m_fixedClipRect; }
71     const IntRect& posClipRect() { return m_posClipRect; }
72
73     void ref() { m_refCnt++; }
74     void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); }
75     
76     void destroy(RenderArena* renderArena);
77
78     // Overloaded new operator.
79     void* operator new(size_t sz, RenderArena* renderArena) throw();    
80
81     // Overridden to prevent the normal delete from being called.
82     void operator delete(void* ptr, size_t sz);
83         
84 private:
85     // The normal operator new is disallowed on all render objects.
86     void* operator new(size_t sz) throw();
87
88 private:
89     IntRect m_overflowClipRect;
90     IntRect m_fixedClipRect;
91     IntRect m_posClipRect;
92     unsigned m_refCnt;
93 };
94
95 // This class handles the auto-scrolling of layers with overflow: marquee.
96 class Marquee
97 {
98 public:
99     Marquee(RenderLayer*);
100
101     int speed() const { return m_speed; }
102     int marqueeSpeed() const;
103     EMarqueeDirection reverseDirection() const { return static_cast<EMarqueeDirection>(-direction()); }
104     EMarqueeDirection direction() const;
105
106     bool isHorizontal() const;
107     bool isUnfurlMarquee() const;
108     int unfurlPos() const { return m_unfurlPos; }
109
110     EWhiteSpace whiteSpace() { return static_cast<EWhiteSpace>(m_whiteSpace); }
111     
112     int computePosition(EMarqueeDirection dir, bool stopAtClientEdge);
113
114     void setEnd(int end) { m_end = end; }
115     
116     void start();
117     void suspend();
118     void stop();
119
120     void updateMarqueeStyle();
121     void updateMarqueePosition();
122
123 private:
124     void timerFired(Timer<Marquee>*);
125
126     RenderLayer* m_layer;
127     int m_currentLoop;
128     int m_totalLoops;
129     Timer<Marquee> m_timer;
130     int m_start;
131     int m_end;
132     int m_speed;
133     int m_unfurlPos;
134     Length m_height;
135     bool m_reset: 1;
136     bool m_suspended : 1;
137     bool m_stopped : 1;
138     unsigned m_whiteSpace : 3; // EWhiteSpace
139     EMarqueeDirection m_direction : 4;
140 };
141
142 class RenderLayer : public ScrollbarClient {
143 public:
144     enum ScrollBehavior {
145         noScroll,
146         alignCenter,
147         alignTop,
148         alignBottom, 
149         alignLeft,
150         alignRight,
151         alignToClosestEdge
152     };
153
154     struct ScrollAlignment {
155         ScrollBehavior m_rectVisible;
156         ScrollBehavior m_rectHidden;
157         ScrollBehavior m_rectPartial;
158     };
159
160     static const ScrollAlignment gAlignCenterIfNeeded;
161     static const ScrollAlignment gAlignToEdgeIfNeeded;
162     static const ScrollAlignment gAlignCenterAlways;
163     static const ScrollAlignment gAlignTopAlways;
164     static const ScrollAlignment gAlignBottomAlways;
165     
166     static ScrollBehavior getVisibleBehavior(const ScrollAlignment& s) { return s.m_rectVisible; }
167     static ScrollBehavior getPartialBehavior(const ScrollAlignment& s) { return s.m_rectPartial; }
168     static ScrollBehavior getHiddenBehavior(const ScrollAlignment& s) { return s.m_rectHidden; }
169     
170     RenderLayer(RenderObject*);
171     ~RenderLayer();
172     
173     RenderObject* renderer() const { return m_object; }
174     RenderLayer* parent() const { return m_parent; }
175     RenderLayer* previousSibling() const { return m_previous; }
176     RenderLayer* nextSibling() const { return m_next; }
177
178     RenderLayer* firstChild() const { return m_first; }
179     RenderLayer* lastChild() const { return m_last; }
180
181     void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0);
182     RenderLayer* removeChild(RenderLayer*);
183
184     void removeOnlyThisLayer();
185     void insertOnlyThisLayer();
186
187     void repaintIncludingDescendants();
188     
189     void styleChanged();
190     
191     Marquee* marquee() const { return m_marquee; }
192     void suspendMarquees();
193
194     bool isOverflowOnly() const { return m_isOverflowOnly; }
195     
196     bool isTransparent() const;
197     RenderLayer* transparentAncestor();
198     void beginTransparencyLayers(GraphicsContext*, const IntRect&);
199     
200     const RenderLayer* root() const {
201         const RenderLayer* curr = this;
202         while (curr->parent()) curr = curr->parent();
203         return curr;
204     }
205     
206     int xPos() const { return m_x; }
207     int yPos() const { return m_y; }
208     int width() const { return m_width; }
209     int height() const { return m_height; }
210
211     void setWidth(int w) { m_width = w; }
212     void setHeight(int h) { m_height = h; }
213
214     int scrollWidth();
215     int scrollHeight();
216     
217     void setPos( int xPos, int yPos ) {
218         m_x = xPos;
219         m_y = yPos;
220     }
221
222     // Scrolling methods for layers that can scroll their overflow.
223     void scrollOffset(int& x, int& y);
224     void subtractScrollOffset(int& x, int& y);
225     int scrollXOffset() const { return m_scrollX + m_scrollOriginX; }
226     int scrollYOffset() const { return m_scrollY; }
227     void scrollToOffset(int x, int y, bool updateScrollbars = true, bool repaint = true);
228     void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY); }
229     void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOriginX, y); }
230     void scrollRectToVisible(const IntRect &r, const ScrollAlignment& alignX = gAlignCenterIfNeeded, const ScrollAlignment& alignY = gAlignCenterIfNeeded);
231     IntRect getRectToExpose(const IntRect &visibleRect,  const IntRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY);    
232     void setHasHorizontalScrollbar(bool);
233     void setHasVerticalScrollbar(bool);
234     PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation);
235     void destroyScrollbar(ScrollbarOrientation);
236     Scrollbar* horizontalScrollbar() { return m_hBar.get(); }
237     Scrollbar* verticalScrollbar() { return m_vBar.get(); }
238     PlatformScrollbar* horizontaScrollbarWidget() const;
239     PlatformScrollbar* verticalScrollbarWidget() const;
240     int verticalScrollbarWidth() const;
241     int horizontalScrollbarHeight() const;
242     void positionOverflowControls();
243     bool isPointInResizeControl(const IntPoint&);
244     IntSize offsetFromResizeCorner(const IntPoint&) const;
245     void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect);
246     void updateScrollInfoAfterLayout();
247     bool scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier=1.0);
248     void autoscroll();
249     void resize(const PlatformMouseEvent&, const IntSize&);
250     bool inResizeMode() const { return m_inResizeMode; }
251     void setInResizeMode(bool b) { m_inResizeMode = b; }
252     
253     void updateLayerPosition();
254     void updateLayerPositions(bool doFullRepaint = false, bool checkForRepaint=true);
255     void checkForRepaintOnResize();
256     void relativePositionOffset(int& relX, int& relY) {
257         relX += m_relX; relY += m_relY;
258     }
259      
260     void clearClipRects();
261     void clearClipRect();
262
263     // Get the enclosing stacking context for this layer.  A stacking context is a layer
264     // that has a non-auto z-index.
265     RenderLayer* stackingContext() const;
266     bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView(); }
267
268     void dirtyZOrderLists();
269     void updateZOrderLists();
270     Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; }
271     Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; }
272     
273     void dirtyOverflowList();
274     void updateOverflowList();
275     Vector<RenderLayer*>* overflowList() const { return m_overflowList; }
276     
277     bool hasVisibleContent() const { return m_hasVisibleContent; }
278     void setHasVisibleContent(bool b);
279     void dirtyVisibleContentStatus();
280
281     // Gets the nearest enclosing positioned ancestor layer (also includes
282     // the <html> layer and the root layer).
283     RenderLayer* enclosingPositionedAncestor() const;
284     
285     void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const;
286     
287     bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); }
288     int zIndex() const { return renderer()->style()->zIndex(); }
289
290     // The two main functions that use the layer system.  The paint method
291     // paints the layers that intersect the damage rect from back to
292     // front.  The hitTest method looks for mouse events by walking
293     // layers that intersect the point from front to back.
294     void paint(GraphicsContext*, const IntRect& damageRect, PaintRestriction = PaintRestrictionNone, RenderObject* paintingRoot = 0);
295     bool hitTest(HitTestResult&, const IntPoint&);
296
297     // This method figures out our layerBounds in coordinates relative to
298     // |rootLayer}.  It also computes our background and foreground clip rects
299     // for painting/event handling.
300     void calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,
301                         IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect) const;
302     void calculateClipRects(const RenderLayer* rootLayer);
303     ClipRects* clipRects() const { return m_clipRects; }
304     IntRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space.
305     IntRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space.
306
307     bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect) const;
308
309     // Returns a bounding box for this layer only.
310     IntRect absoluteBoundingBox() const;
311
312     void updateHoverActiveState(HitTestResult&);
313     
314     IntRect repaintRect() const { return m_repaintRect; }
315
316     void destroy(RenderArena* renderArena);
317
318      // Overloaded new operator.  Derived classes must override operator new
319     // in order to allocate out of the RenderArena.
320     void* operator new(size_t sz, RenderArena* renderArena) throw();    
321
322     // Overridden to prevent the normal delete from being called.
323     void operator delete(void* ptr, size_t sz);
324
325 private:
326     // The normal operator new is disallowed on all render objects.
327     void* operator new(size_t sz) throw();
328
329 private:
330     void setNextSibling(RenderLayer* next) { m_next = next; }
331     void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
332     void setParent(RenderLayer* parent) { m_parent = parent; }
333     void setFirstChild(RenderLayer* first) { m_first = first; }
334     void setLastChild(RenderLayer* last) { m_last = last; }
335
336     void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&);
337
338     void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect,
339         bool haveTransparency, PaintRestriction, RenderObject* paintingRoot);
340     RenderLayer* hitTestLayer(RenderLayer* rootLayer, HitTestResult&, const IntPoint&, const IntRect& hitTestRect);
341     void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0);
342
343     bool shouldBeOverflowOnly() const;
344
345     virtual void valueChanged(Scrollbar*);
346     virtual IntRect windowClipRect() const;
347
348     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
349     
350     void childVisibilityChanged(bool newVisibility);
351     void dirtyVisibleDescendantStatus();
352     void updateVisibilityStatus();
353         
354 protected:   
355     RenderObject* m_object;
356     
357     RenderLayer* m_parent;
358     RenderLayer* m_previous;
359     RenderLayer* m_next;
360
361     RenderLayer* m_first;
362     RenderLayer* m_last;
363
364     IntRect m_repaintRect; // Cached repaint rects. Used by layout.
365     IntRect m_fullRepaintRect;
366     int m_repaintX;
367     int m_repaintY;
368
369     // Our current relative position offset.
370     int m_relX;
371     int m_relY;
372
373     // Our (x,y) coordinates are in our parent layer's coordinate space.
374     int m_x;
375     int m_y;
376
377     // The layer's width/height
378     int m_width;
379     int m_height;
380     
381     // Our scroll offsets if the view is scrolled.
382     int m_scrollX;
383     int m_scrollY;
384     int m_scrollOriginX;
385     int m_scrollLeftOverflow;
386     
387     // The width/height of our scrolled area.
388     int m_scrollWidth;
389     int m_scrollHeight;
390     
391     // For layers with overflow, we have a pair of scrollbars.
392     RefPtr<Scrollbar> m_hBar;
393     RefPtr<Scrollbar> m_vBar;
394     
395     // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop.
396     bool m_inResizeMode;
397
398     // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the
399     // descendant layers within the stacking context that have z-indices of 0 or greater
400     // (auto will count as 0).  m_negZOrderList holds descendants within our stacking context with negative
401     // z-indices.
402     Vector<RenderLayer*>* m_posZOrderList;
403     Vector<RenderLayer*>* m_negZOrderList;
404     
405     // This list contains our overflow child layers.
406     Vector<RenderLayer*>* m_overflowList;
407
408     ClipRects* m_clipRects;      // Cached clip rects used when painting and hit testing.
409
410     bool m_scrollDimensionsDirty : 1;
411     bool m_zOrderListsDirty : 1;
412     bool m_overflowListDirty: 1;
413     bool m_isOverflowOnly: 1;
414
415     bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
416                                  // we ended up painting this layer or any descendants (and therefore need to
417                                  // blend).
418     bool m_inOverflowRelayout : 1;
419     bool m_repaintOverflowOnResize : 1;
420
421     bool m_overflowStatusDirty : 1;
422     bool m_horizontalOverflow : 1;
423     bool m_verticalOverflow : 1;
424     bool m_visibleContentStatusDirty : 1;
425     bool m_hasVisibleContent : 1;
426     bool m_visibleDescendantStatusDirty : 1;
427     bool m_hasVisibleDescendant : 1;
428     
429     Marquee* m_marquee; // Used by layers with overflow:marquee
430 };
431
432 } // namespace
433
434 #endif