1 /* 2 * Copyright (C) 2003, 2009 Apple Inc. All rights reserved. 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 RenderLayer_h 45 #define RenderLayer_h 46 47 #include "PaintInfo.h" 48 #include "RenderBox.h" 49 #include "ScrollBehavior.h" 50 #include "ScrollableArea.h" 51 #include <wtf/OwnPtr.h> 52 53 namespace WebCore { 54 55 class HitTestRequest; 56 class HitTestResult; 57 class HitTestingTransformState; 58 class RenderMarquee; 59 class RenderReplica; 60 class RenderScrollbarPart; 61 class RenderStyle; 62 class RenderView; 63 class Scrollbar; 64 class TransformationMatrix; 65 66 #if USE(ACCELERATED_COMPOSITING) 67 class RenderLayerBacking; 68 class RenderLayerCompositor; 69 #endif 70 71 class ClipRects { 72 public: ClipRects()73 ClipRects() 74 : m_refCnt(0) 75 , m_fixed(false) 76 { 77 } 78 ClipRects(const IntRect & r)79 ClipRects(const IntRect& r) 80 : m_overflowClipRect(r) 81 , m_fixedClipRect(r) 82 , m_posClipRect(r) 83 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 84 , m_hitTestClip(r) 85 #endif 86 , m_refCnt(0) 87 , m_fixed(false) 88 { 89 } 90 ClipRects(const ClipRects & other)91 ClipRects(const ClipRects& other) 92 : m_overflowClipRect(other.overflowClipRect()) 93 , m_fixedClipRect(other.fixedClipRect()) 94 , m_posClipRect(other.posClipRect()) 95 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 96 , m_hitTestClip(other.hitTestClip()) 97 #endif 98 , m_refCnt(0) 99 , m_fixed(other.fixed()) 100 { 101 } 102 reset(const IntRect & r)103 void reset(const IntRect& r) 104 { 105 m_overflowClipRect = r; 106 m_fixedClipRect = r; 107 m_posClipRect = r; 108 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 109 m_hitTestClip = r; 110 #endif 111 m_fixed = false; 112 } 113 overflowClipRect()114 const IntRect& overflowClipRect() const { return m_overflowClipRect; } setOverflowClipRect(const IntRect & r)115 void setOverflowClipRect(const IntRect& r) { m_overflowClipRect = r; } 116 fixedClipRect()117 const IntRect& fixedClipRect() const { return m_fixedClipRect; } setFixedClipRect(const IntRect & r)118 void setFixedClipRect(const IntRect&r) { m_fixedClipRect = r; } 119 posClipRect()120 const IntRect& posClipRect() const { return m_posClipRect; } setPosClipRect(const IntRect & r)121 void setPosClipRect(const IntRect& r) { m_posClipRect = r; } 122 #if ENABLE(ANDROID_OVERFLOW_SCROLL) hitTestClip()123 const IntRect& hitTestClip() const { return m_hitTestClip; } setHitTestClip(const IntRect & r)124 void setHitTestClip(const IntRect& r) { m_hitTestClip = r; } 125 #endif 126 fixed()127 bool fixed() const { return m_fixed; } setFixed(bool fixed)128 void setFixed(bool fixed) { m_fixed = fixed; } 129 ref()130 void ref() { m_refCnt++; } deref(RenderArena * renderArena)131 void deref(RenderArena* renderArena) { if (--m_refCnt == 0) destroy(renderArena); } 132 133 void destroy(RenderArena*); 134 135 // Overloaded new operator. 136 void* operator new(size_t, RenderArena*) throw(); 137 138 // Overridden to prevent the normal delete from being called. 139 void operator delete(void*, size_t); 140 141 bool operator==(const ClipRects& other) const 142 { 143 return m_overflowClipRect == other.overflowClipRect() && 144 m_fixedClipRect == other.fixedClipRect() && 145 m_posClipRect == other.posClipRect() && 146 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 147 m_hitTestClip == other.hitTestClip() && 148 #endif 149 m_fixed == other.fixed(); 150 } 151 152 ClipRects& operator=(const ClipRects& other) 153 { 154 m_overflowClipRect = other.overflowClipRect(); 155 m_fixedClipRect = other.fixedClipRect(); 156 m_posClipRect = other.posClipRect(); 157 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 158 m_hitTestClip = other.hitTestClip(); 159 #endif 160 m_fixed = other.fixed(); 161 return *this; 162 } 163 164 private: 165 // The normal operator new is disallowed on all render objects. 166 void* operator new(size_t) throw(); 167 168 private: 169 IntRect m_overflowClipRect; 170 IntRect m_fixedClipRect; 171 IntRect m_posClipRect; 172 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 173 IntRect m_hitTestClip; 174 #endif 175 unsigned m_refCnt : 31; 176 bool m_fixed : 1; 177 }; 178 179 class RenderLayer : public ScrollableArea { 180 public: 181 friend class RenderReplica; 182 183 RenderLayer(RenderBoxModelObject*); 184 ~RenderLayer(); 185 renderer()186 RenderBoxModelObject* renderer() const { return m_renderer; } renderBox()187 RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; } parent()188 RenderLayer* parent() const { return m_parent; } previousSibling()189 RenderLayer* previousSibling() const { return m_previous; } nextSibling()190 RenderLayer* nextSibling() const { return m_next; } firstChild()191 RenderLayer* firstChild() const { return m_first; } lastChild()192 RenderLayer* lastChild() const { return m_last; } 193 194 void addChild(RenderLayer* newChild, RenderLayer* beforeChild = 0); 195 RenderLayer* removeChild(RenderLayer*); 196 197 void removeOnlyThisLayer(); 198 void insertOnlyThisLayer(); 199 200 void repaintIncludingDescendants(); 201 202 #if USE(ACCELERATED_COMPOSITING) 203 // Indicate that the layer contents need to be repainted. Only has an effect 204 // if layer compositing is being used, 205 void setBackingNeedsRepaint(); 206 void setBackingNeedsRepaintInRect(const IntRect& r); // r is in the coordinate space of the layer's render object 207 void repaintIncludingNonCompositingDescendants(RenderBoxModelObject* repaintContainer); 208 #endif 209 210 void styleChanged(StyleDifference, const RenderStyle* oldStyle); 211 marquee()212 RenderMarquee* marquee() const { return m_marquee; } 213 isNormalFlowOnly()214 bool isNormalFlowOnly() const { return m_isNormalFlowOnly; } 215 bool isSelfPaintingLayer() const; 216 217 bool requiresSlowRepaints() const; 218 219 bool isTransparent() const; 220 RenderLayer* transparentPaintingAncestor(); 221 void beginTransparencyLayers(GraphicsContext*, const RenderLayer* rootLayer, PaintBehavior); 222 hasReflection()223 bool hasReflection() const { return renderer()->hasReflection(); } isReflection()224 bool isReflection() const { return renderer()->isReplica(); } reflection()225 RenderReplica* reflection() const { return m_reflection; } 226 RenderLayer* reflectionLayer() const; 227 root()228 const RenderLayer* root() const 229 { 230 const RenderLayer* curr = this; 231 while (curr->parent()) 232 curr = curr->parent(); 233 return curr; 234 } 235 x()236 int x() const { return m_x; } y()237 int y() const { return m_y; } setLocation(int x,int y)238 void setLocation(int x, int y) 239 { 240 m_x = x; 241 m_y = y; 242 } 243 width()244 int width() const { return m_width; } height()245 int height() const { return m_height; } size()246 IntSize size() const { return IntSize(m_width, m_height); } 247 248 #if PLATFORM(ANDROID) 249 void setWidth(int w); 250 void setHeight(int h); 251 #else setWidth(int w)252 void setWidth(int w) { m_width = w; } setHeight(int h)253 void setHeight(int h) { m_height = h; } 254 #endif 255 256 int scrollWidth(); 257 int scrollHeight(); 258 259 void panScrollFromPoint(const IntPoint&); 260 261 // Scrolling methods for layers that can scroll their overflow. 262 void scrollByRecursively(int xDelta, int yDelta); 263 scrolledContentOffset()264 IntSize scrolledContentOffset() const { return IntSize(scrollXOffset() + m_scrollLeftOverflow, scrollYOffset() + m_scrollTopOverflow); } 265 scrollXOffset()266 int scrollXOffset() const { return m_scrollX + m_scrollOrigin.x(); } scrollYOffset()267 int scrollYOffset() const { return m_scrollY + m_scrollOrigin.y(); } 268 269 void scrollToOffset(int x, int y); scrollToXOffset(int x)270 void scrollToXOffset(int x) { scrollToOffset(x, m_scrollY + m_scrollOrigin.y()); } scrollToYOffset(int y)271 void scrollToYOffset(int y) { scrollToOffset(m_scrollX + m_scrollOrigin.x(), y); } 272 void scrollRectToVisible(const IntRect&, bool scrollToAnchor = false, const ScrollAlignment& alignX = ScrollAlignment::alignCenterIfNeeded, const ScrollAlignment& alignY = ScrollAlignment::alignCenterIfNeeded); 273 274 IntRect getRectToExpose(const IntRect& visibleRect, const IntRect& exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY); 275 276 void setHasHorizontalScrollbar(bool); 277 void setHasVerticalScrollbar(bool); 278 279 PassRefPtr<Scrollbar> createScrollbar(ScrollbarOrientation); 280 void destroyScrollbar(ScrollbarOrientation); 281 282 // ScrollableArea overrides horizontalScrollbar()283 virtual Scrollbar* horizontalScrollbar() const { return m_hBar.get(); } verticalScrollbar()284 virtual Scrollbar* verticalScrollbar() const { return m_vBar.get(); } 285 286 int verticalScrollbarWidth(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const; 287 int horizontalScrollbarHeight(OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const; 288 289 bool hasOverflowControls() const; 290 bool isPointInResizeControl(const IntPoint& absolutePoint) const; 291 bool hitTestOverflowControls(HitTestResult&, const IntPoint& localPoint); 292 IntSize offsetFromResizeCorner(const IntPoint& absolutePoint) const; 293 294 void paintOverflowControls(GraphicsContext*, int tx, int ty, const IntRect& damageRect, bool paintingOverlayControls = false); 295 void paintScrollCorner(GraphicsContext*, int tx, int ty, const IntRect& damageRect); 296 void paintResizer(GraphicsContext*, int tx, int ty, const IntRect& damageRect); 297 298 void updateScrollInfoAfterLayout(); 299 300 bool scroll(ScrollDirection, ScrollGranularity, float multiplier = 1); 301 void autoscroll(); 302 303 void resize(const PlatformMouseEvent&, const IntSize&); inResizeMode()304 bool inResizeMode() const { return m_inResizeMode; } setInResizeMode(bool b)305 void setInResizeMode(bool b) { m_inResizeMode = b; } 306 isRootLayer()307 bool isRootLayer() const { return renderer()->isRenderView(); } 308 309 #if USE(ACCELERATED_COMPOSITING) 310 RenderLayerCompositor* compositor() const; 311 312 // Notification from the renderer that its content changed (e.g. current frame of image changed). 313 // Allows updates of layer content without repainting. 314 enum ContentChangeType { ImageChanged, MaskImageChanged, CanvasChanged, VideoChanged, FullScreenChanged }; 315 void contentChanged(ContentChangeType); 316 #endif 317 318 // Returns true if the accelerated compositing is enabled 319 bool hasAcceleratedCompositing() const; 320 321 bool canRender3DTransforms() const; 322 323 void updateLayerPosition(); 324 325 enum UpdateLayerPositionsFlag { 326 CheckForRepaint = 1, 327 IsCompositingUpdateRoot = 1 << 1, 328 UpdateCompositingLayers = 1 << 2, 329 UpdatePagination = 1 << 3 330 }; 331 typedef unsigned UpdateLayerPositionsFlags; 332 void updateLayerPositions(UpdateLayerPositionsFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers, IntPoint* cachedOffset = 0); 333 334 void updateTransform(); 335 relativePositionOffset(int & relX,int & relY)336 void relativePositionOffset(int& relX, int& relY) const { relX += m_relX; relY += m_relY; } relativePositionOffset()337 IntSize relativePositionOffset() const { return IntSize(m_relX, m_relY); } 338 339 void clearClipRectsIncludingDescendants(); 340 void clearClipRects(); 341 342 void addBlockSelectionGapsBounds(const IntRect&); 343 void clearBlockSelectionGapsBounds(); 344 void repaintBlockSelectionGaps(); 345 346 // Get the enclosing stacking context for this layer. A stacking context is a layer 347 // that has a non-auto z-index. 348 RenderLayer* stackingContext() const; 349 #if ENABLE(COMPOSITED_FIXED_ELEMENTS) isFixed()350 bool isFixed() const { return renderer()->isPositioned() && renderer()->style()->position() == FixedPosition; } 351 // If fixed elements are composited, they will be containing children isStackingContext()352 bool isStackingContext() const { 353 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 354 if (hasOverflowScroll()) 355 return true; 356 #endif 357 return !hasAutoZIndex() || renderer()->isRenderView() || (isComposited() && isFixed()) || m_shouldComposite; 358 } 359 #else 360 #if ENABLE(ANDROID_OVERFLOW_SCROLL) isStackingContext()361 bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView() || hasOverflowScroll(); } 362 #else isStackingContext()363 bool isStackingContext() const { return !hasAutoZIndex() || renderer()->isRenderView() ; } 364 #endif 365 #endif 366 367 void dirtyZOrderLists(); 368 void dirtyStackingContextZOrderLists(); 369 void updateZOrderLists(); posZOrderList()370 Vector<RenderLayer*>* posZOrderList() const { return m_posZOrderList; } negZOrderList()371 Vector<RenderLayer*>* negZOrderList() const { return m_negZOrderList; } 372 373 void dirtyNormalFlowList(); 374 void updateNormalFlowList(); normalFlowList()375 Vector<RenderLayer*>* normalFlowList() const { return m_normalFlowList; } 376 hasVisibleContent()377 bool hasVisibleContent() const { return m_hasVisibleContent; } hasVisibleDescendant()378 bool hasVisibleDescendant() const { return m_hasVisibleDescendant; } 379 void setHasVisibleContent(bool); 380 void dirtyVisibleContentStatus(); 381 382 // Gets the nearest enclosing positioned ancestor layer (also includes 383 // the <html> layer and the root layer). 384 RenderLayer* enclosingPositionedAncestor() const; 385 386 // The layer relative to which clipping rects for this layer are computed. 387 RenderLayer* clippingRoot() const; 388 389 #if USE(ACCELERATED_COMPOSITING) 390 // Enclosing compositing layer; if includeSelf is true, may return this. 391 RenderLayer* enclosingCompositingLayer(bool includeSelf = true) const; 392 // Ancestor compositing layer, excluding this. ancestorCompositingLayer()393 RenderLayer* ancestorCompositingLayer() const { return enclosingCompositingLayer(false); } 394 #endif 395 396 void convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const; 397 hasAutoZIndex()398 bool hasAutoZIndex() const { return renderer()->style()->hasAutoZIndex(); } zIndex()399 int zIndex() const { return renderer()->style()->zIndex(); } 400 401 // The two main functions that use the layer system. The paint method 402 // paints the layers that intersect the damage rect from back to 403 // front. The hitTest method looks for mouse events by walking 404 // layers that intersect the point from front to back. 405 void paint(GraphicsContext*, const IntRect& damageRect, PaintBehavior = PaintBehaviorNormal, RenderObject* paintingRoot = 0); 406 bool hitTest(const HitTestRequest&, HitTestResult&); 407 void paintOverlayScrollbars(GraphicsContext*, const IntRect& damageRect, PaintBehavior, RenderObject* paintingRoot); 408 409 // This method figures out our layerBounds in coordinates relative to 410 // |rootLayer}. It also computes our background and foreground clip rects 411 // for painting/event handling. 412 void calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds, 413 IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect, bool temporaryClipRects = false, 414 OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const; 415 416 // Compute and cache clip rects computed with the given layer as the root 417 void updateClipRects(const RenderLayer* rootLayer, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize); 418 // Compute and return the clip rects. If useCached is true, will used previously computed clip rects on ancestors 419 // (rather than computing them all from scratch up the parent chain). 420 void calculateClipRects(const RenderLayer* rootLayer, ClipRects&, bool useCached = false, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const; clipRects()421 ClipRects* clipRects() const { return m_clipRects; } 422 423 IntRect childrenClipRect() const; // Returns the foreground clip rect of the layer in the document's coordinate space. 424 IntRect selfClipRect() const; // Returns the background clip rect of the layer in the document's coordinate space. 425 426 bool intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect, const RenderLayer* rootLayer) const; 427 428 // Bounding box relative to some ancestor layer. 429 IntRect boundingBox(const RenderLayer* rootLayer) const; 430 // Bounding box in the coordinates of this layer. 431 IntRect localBoundingBox() const; 432 // Bounding box relative to the root. 433 IntRect absoluteBoundingBox() const; 434 435 void updateHoverActiveState(const HitTestRequest&, HitTestResult&); 436 437 // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint. repaintRect()438 IntRect repaintRect() const { return m_repaintRect; } 439 IntRect repaintRectIncludingDescendants() const; 440 void computeRepaintRects(); 441 void updateRepaintRectsAfterScroll(bool fixed = false); 442 void setNeedsFullRepaint(bool f = true) { m_needsFullRepaint = f; } 443 staticInlinePosition()444 int staticInlinePosition() const { return m_staticInlinePosition; } staticBlockPosition()445 int staticBlockPosition() const { return m_staticBlockPosition; } setStaticInlinePosition(int position)446 void setStaticInlinePosition(int position) { m_staticInlinePosition = position; } setStaticBlockPosition(int position)447 void setStaticBlockPosition(int position) { m_staticBlockPosition = position; } 448 hasTransform()449 bool hasTransform() const { return renderer()->hasTransform(); } 450 // Note that this transform has the transform-origin baked in. transform()451 TransformationMatrix* transform() const { return m_transform.get(); } 452 // currentTransform computes a transform which takes accelerated animations into account. The 453 // resulting transform has transform-origin baked in. If the layer does not have a transform, 454 // returns the identity matrix. 455 TransformationMatrix currentTransform() const; 456 TransformationMatrix renderableTransform(PaintBehavior) const; 457 458 // Get the perspective transform, which is applied to transformed sublayers. 459 // Returns true if the layer has a -webkit-perspective. 460 // Note that this transform has the perspective-origin baked in. 461 TransformationMatrix perspectiveTransform() const; 462 FloatPoint perspectiveOrigin() const; preserves3D()463 bool preserves3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; } has3DTransform()464 bool has3DTransform() const { return m_transform && !m_transform->isAffine(); } 465 466 // Overloaded new operator. Derived classes must override operator new 467 // in order to allocate out of the RenderArena. 468 void* operator new(size_t, RenderArena*) throw(); 469 470 // Overridden to prevent the normal delete from being called. 471 void operator delete(void*, size_t); 472 473 #if USE(ACCELERATED_COMPOSITING) isComposited()474 bool isComposited() const { return m_backing != 0; } 475 bool hasCompositedMask() const; backing()476 RenderLayerBacking* backing() const { return m_backing.get(); } 477 RenderLayerBacking* ensureBacking(); 478 void clearBacking(); 479 virtual GraphicsLayer* layerForHorizontalScrollbar() const; 480 virtual GraphicsLayer* layerForVerticalScrollbar() const; 481 virtual GraphicsLayer* layerForScrollCorner() const; 482 #else isComposited()483 bool isComposited() const { return false; } hasCompositedMask()484 bool hasCompositedMask() const { return false; } 485 #endif 486 paintsWithTransparency(PaintBehavior paintBehavior)487 bool paintsWithTransparency(PaintBehavior paintBehavior) const 488 { 489 return isTransparent() && ((paintBehavior & PaintBehaviorFlattenCompositingLayers) || !isComposited()); 490 } 491 492 bool paintsWithTransform(PaintBehavior) const; 493 containsDirtyOverlayScrollbars()494 bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; } setContainsDirtyOverlayScrollbars(bool dirtyScrollbars)495 void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; } 496 497 #if ENABLE(ANDROID_OVERFLOW_SCROLL) hasOverflowScroll()498 bool hasOverflowScroll() const { return m_hasOverflowScroll; } 499 bool hasOverflowParent() const; 500 #endif 501 502 private: 503 // The normal operator new is disallowed on all render objects. 504 void* operator new(size_t) throw(); 505 setNextSibling(RenderLayer * next)506 void setNextSibling(RenderLayer* next) { m_next = next; } setPreviousSibling(RenderLayer * prev)507 void setPreviousSibling(RenderLayer* prev) { m_previous = prev; } 508 void setParent(RenderLayer* parent); setFirstChild(RenderLayer * first)509 void setFirstChild(RenderLayer* first) { m_first = first; } setLastChild(RenderLayer * last)510 void setLastChild(RenderLayer* last) { m_last = last; } 511 renderBoxX()512 int renderBoxX() const { return renderer()->isBox() ? toRenderBox(renderer())->x() : 0; } renderBoxY()513 int renderBoxY() const { return renderer()->isBox() ? toRenderBox(renderer())->y() : 0; } 514 515 void collectLayers(Vector<RenderLayer*>*&, Vector<RenderLayer*>*&); 516 517 void updateLayerListsIfNeeded(); 518 void updateCompositingAndLayerListsIfNeeded(); 519 520 enum PaintLayerFlag { 521 PaintLayerHaveTransparency = 1, 522 PaintLayerAppliedTransform = 1 << 1, 523 PaintLayerTemporaryClipRects = 1 << 2, 524 PaintLayerPaintingReflection = 1 << 3, 525 PaintLayerPaintingOverlayScrollbars = 1 << 4 526 }; 527 528 typedef unsigned PaintLayerFlags; 529 530 void paintLayer(RenderLayer* rootLayer, GraphicsContext*, const IntRect& paintDirtyRect, 531 PaintBehavior, RenderObject* paintingRoot, OverlapTestRequestMap* = 0, 532 PaintLayerFlags = 0); 533 void paintList(Vector<RenderLayer*>*, RenderLayer* rootLayer, GraphicsContext* p, 534 const IntRect& paintDirtyRect, PaintBehavior, 535 RenderObject* paintingRoot, OverlapTestRequestMap*, 536 PaintLayerFlags); 537 void paintPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*, 538 const IntRect& paintDirtyRect, PaintBehavior, 539 RenderObject* paintingRoot, OverlapTestRequestMap*, 540 PaintLayerFlags); 541 void paintChildLayerIntoColumns(RenderLayer* childLayer, RenderLayer* rootLayer, GraphicsContext*, 542 const IntRect& paintDirtyRect, PaintBehavior, 543 RenderObject* paintingRoot, OverlapTestRequestMap*, 544 PaintLayerFlags, const Vector<RenderLayer*>& columnLayers, size_t columnIndex); 545 546 RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result, 547 const IntRect& hitTestRect, const IntPoint& hitTestPoint, bool appliedTransform, 548 const HitTestingTransformState* transformState = 0, double* zOffset = 0); 549 RenderLayer* hitTestList(Vector<RenderLayer*>*, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result, 550 const IntRect& hitTestRect, const IntPoint& hitTestPoint, 551 const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset, 552 const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants); 553 RenderLayer* hitTestPaginatedChildLayer(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result, 554 const IntRect& hitTestRect, const IntPoint& hitTestPoint, 555 const HitTestingTransformState* transformState, double* zOffset); 556 RenderLayer* hitTestChildLayerColumns(RenderLayer* childLayer, RenderLayer* rootLayer, const HitTestRequest& request, HitTestResult& result, 557 const IntRect& hitTestRect, const IntPoint& hitTestPoint, 558 const HitTestingTransformState* transformState, double* zOffset, 559 const Vector<RenderLayer*>& columnLayers, size_t columnIndex); 560 561 PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer, 562 const IntRect& hitTestRect, const IntPoint& hitTestPoint, 563 const HitTestingTransformState* containerTransformState) const; 564 565 bool hitTestContents(const HitTestRequest&, HitTestResult&, const IntRect& layerBounds, const IntPoint& hitTestPoint, HitTestFilter) const; 566 567 void computeScrollDimensions(bool* needHBar = 0, bool* needVBar = 0); 568 569 bool shouldBeNormalFlowOnly() const; 570 571 // ScrollableArea interface 572 virtual int scrollSize(ScrollbarOrientation orientation) const; 573 virtual void setScrollOffset(const IntPoint&); 574 virtual int scrollPosition(Scrollbar*) const; 575 virtual void invalidateScrollbarRect(Scrollbar*, const IntRect&); 576 virtual void invalidateScrollCornerRect(const IntRect&); 577 virtual bool isActive() const; 578 virtual bool isScrollCornerVisible() const; 579 virtual IntRect scrollCornerRect() const; 580 virtual IntRect convertFromScrollbarToContainingView(const Scrollbar*, const IntRect&) const; 581 virtual IntRect convertFromContainingViewToScrollbar(const Scrollbar*, const IntRect&) const; 582 virtual IntPoint convertFromScrollbarToContainingView(const Scrollbar*, const IntPoint&) const; 583 virtual IntPoint convertFromContainingViewToScrollbar(const Scrollbar*, const IntPoint&) const; 584 virtual IntSize contentsSize() const; 585 virtual int visibleHeight() const; 586 virtual int visibleWidth() const; 587 virtual IntPoint currentMousePosition() const; 588 virtual bool shouldSuspendScrollAnimations() const; 589 590 // Rectangle encompassing the scroll corner and resizer rect. 591 IntRect scrollCornerAndResizerRect() const; 592 disconnectFromPage()593 virtual void disconnectFromPage() { m_page = 0; } 594 595 // NOTE: This should only be called by the overriden setScrollOffset from ScrollableArea. 596 void scrollTo(int x, int y); 597 598 IntSize scrollbarOffset(const Scrollbar*) const; 599 600 void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow); 601 602 void childVisibilityChanged(bool newVisibility); 603 void dirtyVisibleDescendantStatus(); 604 void updateVisibilityStatus(); 605 606 // This flag is computed by RenderLayerCompositor, which knows more about 3d hierarchies than we do. setHas3DTransformedDescendant(bool b)607 void setHas3DTransformedDescendant(bool b) { m_has3DTransformedDescendant = b; } has3DTransformedDescendant()608 bool has3DTransformedDescendant() const { return m_has3DTransformedDescendant; } 609 610 void dirty3DTransformedDescendantStatus(); 611 // Both updates the status, and returns true if descendants of this have 3d. 612 bool update3DTransformedDescendantStatus(); 613 614 Node* enclosingElement() const; 615 616 void createReflection(); 617 void removeReflection(); 618 619 void updateReflectionStyle(); paintingInsideReflection()620 bool paintingInsideReflection() const { return m_paintingInsideReflection; } setPaintingInsideReflection(bool b)621 void setPaintingInsideReflection(bool b) { m_paintingInsideReflection = b; } 622 623 void parentClipRects(const RenderLayer* rootLayer, ClipRects&, bool temporaryClipRects = false, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const; 624 IntRect backgroundClipRect(const RenderLayer* rootLayer, bool temporaryClipRects, OverlayScrollbarSizeRelevancy = IgnoreOverlayScrollbarSize) const; 625 626 RenderLayer* enclosingTransformedAncestor() const; 627 628 // Convert a point in absolute coords into layer coords, taking transforms into account 629 IntPoint absoluteToContents(const IntPoint&) const; 630 631 void positionOverflowControls(int tx, int ty); 632 void updateScrollCornerStyle(); 633 void updateResizerStyle(); 634 635 void updatePagination(); isPaginated()636 bool isPaginated() const { return m_isPaginated; } 637 638 #if USE(ACCELERATED_COMPOSITING) hasCompositingDescendant()639 bool hasCompositingDescendant() const { return m_hasCompositingDescendant; } setHasCompositingDescendant(bool b)640 void setHasCompositingDescendant(bool b) { m_hasCompositingDescendant = b; } 641 mustOverlapCompositedLayers()642 bool mustOverlapCompositedLayers() const { return m_mustOverlapCompositedLayers; } setMustOverlapCompositedLayers(bool b)643 void setMustOverlapCompositedLayers(bool b) { m_mustOverlapCompositedLayers = b; } 644 #if ENABLE(COMPOSITED_FIXED_ELEMENTS) shouldComposite()645 bool shouldComposite() { return m_shouldComposite; } setShouldComposite(bool b)646 void setShouldComposite(bool b) { m_shouldComposite = b; } 647 #endif 648 #endif 649 650 void updateContentsScale(float); 651 652 friend class RenderLayerBacking; 653 friend class RenderLayerCompositor; 654 friend class RenderBoxModelObject; 655 656 // Only safe to call from RenderBoxModelObject::destroyLayer(RenderArena*) 657 void destroy(RenderArena*); 658 659 int overflowTop() const; 660 int overflowBottom() const; 661 int overflowLeft() const; 662 int overflowRight() const; 663 664 protected: 665 RenderBoxModelObject* m_renderer; 666 667 RenderLayer* m_parent; 668 RenderLayer* m_previous; 669 RenderLayer* m_next; 670 RenderLayer* m_first; 671 RenderLayer* m_last; 672 673 IntRect m_repaintRect; // Cached repaint rects. Used by layout. 674 IntRect m_outlineBox; 675 676 // Our current relative position offset. 677 int m_relX; 678 int m_relY; 679 680 // Our (x,y) coordinates are in our parent layer's coordinate space. 681 int m_x; 682 int m_y; 683 684 // The layer's width/height 685 int m_width; 686 int m_height; 687 688 // Our scroll offsets if the view is scrolled. 689 int m_scrollX; 690 int m_scrollY; 691 692 int m_scrollLeftOverflow; 693 int m_scrollTopOverflow; 694 695 // The width/height of our scrolled area. 696 int m_scrollWidth; 697 int m_scrollHeight; 698 699 // For layers with overflow, we have a pair of scrollbars. 700 RefPtr<Scrollbar> m_hBar; 701 RefPtr<Scrollbar> m_vBar; 702 703 // Keeps track of whether the layer is currently resizing, so events can cause resizing to start and stop. 704 bool m_inResizeMode; 705 706 // For layers that establish stacking contexts, m_posZOrderList holds a sorted list of all the 707 // descendant layers within the stacking context that have z-indices of 0 or greater 708 // (auto will count as 0). m_negZOrderList holds descendants within our stacking context with negative 709 // z-indices. 710 Vector<RenderLayer*>* m_posZOrderList; 711 Vector<RenderLayer*>* m_negZOrderList; 712 713 // This list contains child layers that cannot create stacking contexts. For now it is just 714 // overflow layers, but that may change in the future. 715 Vector<RenderLayer*>* m_normalFlowList; 716 717 ClipRects* m_clipRects; // Cached clip rects used when painting and hit testing. 718 #ifndef NDEBUG 719 const RenderLayer* m_clipRectsRoot; // Root layer used to compute clip rects. 720 #endif 721 722 bool m_scrollDimensionsDirty : 1; 723 bool m_zOrderListsDirty : 1; 724 bool m_normalFlowListDirty: 1; 725 bool m_isNormalFlowOnly : 1; 726 727 bool m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether 728 // we ended up painting this layer or any descendants (and therefore need to 729 // blend). 730 bool m_paintingInsideReflection : 1; // A state bit tracking if we are painting inside a replica. 731 bool m_inOverflowRelayout : 1; 732 bool m_needsFullRepaint : 1; 733 734 bool m_overflowStatusDirty : 1; 735 bool m_horizontalOverflow : 1; 736 bool m_verticalOverflow : 1; 737 bool m_visibleContentStatusDirty : 1; 738 bool m_hasVisibleContent : 1; 739 bool m_visibleDescendantStatusDirty : 1; 740 bool m_hasVisibleDescendant : 1; 741 742 bool m_isPaginated : 1; // If we think this layer is split by a multi-column ancestor, then this bit will be set. 743 744 bool m_3DTransformedDescendantStatusDirty : 1; 745 bool m_has3DTransformedDescendant : 1; // Set on a stacking context layer that has 3D descendants anywhere 746 // in a preserves3D hierarchy. Hint to do 3D-aware hit testing. 747 #if USE(ACCELERATED_COMPOSITING) 748 bool m_hasCompositingDescendant : 1; // In the z-order tree. 749 bool m_mustOverlapCompositedLayers : 1; 750 #if ENABLE(COMPOSITED_FIXED_ELEMENTS) 751 bool m_shouldComposite : 1; 752 #endif 753 #endif 754 755 bool m_containsDirtyOverlayScrollbars : 1; 756 #if ENABLE(ANDROID_OVERFLOW_SCROLL) 757 bool m_hasOverflowScroll : 1; 758 #endif 759 760 IntPoint m_cachedOverlayScrollbarOffset; 761 762 RenderMarquee* m_marquee; // Used by layers with overflow:marquee 763 764 // Cached normal flow values for absolute positioned elements with static left/top values. 765 int m_staticInlinePosition; 766 int m_staticBlockPosition; 767 768 OwnPtr<TransformationMatrix> m_transform; 769 770 // May ultimately be extended to many replicas (with their own paint order). 771 RenderReplica* m_reflection; 772 773 // Renderers to hold our custom scroll corner and resizer. 774 RenderScrollbarPart* m_scrollCorner; 775 RenderScrollbarPart* m_resizer; 776 777 private: 778 IntRect m_blockSelectionGapsBounds; 779 780 #if USE(ACCELERATED_COMPOSITING) 781 OwnPtr<RenderLayerBacking> m_backing; 782 #endif 783 784 Page* m_page; 785 }; 786 787 } // namespace WebCore 788 789 #ifndef NDEBUG 790 // Outside the WebCore namespace for ease of invocation from gdb. 791 void showLayerTree(const WebCore::RenderLayer*); 792 void showLayerTree(const WebCore::RenderObject*); 793 #endif 794 795 #endif // RenderLayer_h 796