Reviewed by Maciej.
[WebKit-https.git] / WebCore / rendering / RenderLayer.cpp
1 /*
2  * Copyright (C) 2006 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 #include "config.h"
45 #include "RenderLayer.h"
46
47 #include "CSSPropertyNames.h"
48 #include "Document.h"
49 #include "EventHandler.h"
50 #include "EventNames.h"
51 #include "FloatRect.h"
52 #include "Frame.h"
53 #include "FrameView.h"
54 #include "FrameTree.h"
55 #include "GraphicsContext.h"
56 #include "HTMLMarqueeElement.h"
57 #include "HTMLNames.h"
58 #include "HitTestRequest.h"
59 #include "HitTestResult.h"
60 #include "OverflowEvent.h"
61 #include "PlatformMouseEvent.h"
62 #include "PlatformScrollBar.h" 
63 #include "RenderArena.h"
64 #include "RenderInline.h"
65 #include "RenderTheme.h"
66 #include "RenderView.h"
67 #include "SelectionController.h"
68
69 #if ENABLE(SVG)
70 #include "SVGNames.h"
71 #endif
72
73 #define MIN_INTERSECT_FOR_REVEAL 32
74
75 using namespace std;
76
77 namespace WebCore {
78
79 using namespace EventNames;
80 using namespace HTMLNames;
81
82 #ifndef NDEBUG
83 static bool inRenderLayerDestroy;
84 #endif
85
86 const RenderLayer::ScrollAlignment RenderLayer::gAlignCenterIfNeeded = { RenderLayer::noScroll, RenderLayer::alignCenter, RenderLayer::alignToClosestEdge };
87 const RenderLayer::ScrollAlignment RenderLayer::gAlignToEdgeIfNeeded = { RenderLayer::noScroll, RenderLayer::alignToClosestEdge, RenderLayer::alignToClosestEdge };
88 const RenderLayer::ScrollAlignment RenderLayer::gAlignCenterAlways = { RenderLayer::alignCenter, RenderLayer::alignCenter, RenderLayer::alignCenter };
89 const RenderLayer::ScrollAlignment RenderLayer::gAlignTopAlways = { RenderLayer::alignTop, RenderLayer::alignTop, RenderLayer::alignTop };
90 const RenderLayer::ScrollAlignment RenderLayer::gAlignBottomAlways = { RenderLayer::alignBottom, RenderLayer::alignBottom, RenderLayer::alignBottom };
91
92 const int MinimumWidthWhileResizing = 100;
93 const int MinimumHeightWhileResizing = 40;
94
95 void* ClipRects::operator new(size_t sz, RenderArena* renderArena) throw()
96 {
97     return renderArena->allocate(sz);
98 }
99
100 void ClipRects::operator delete(void* ptr, size_t sz)
101 {
102     // Stash size where destroy can find it.
103     *(size_t *)ptr = sz;
104 }
105
106 void ClipRects::destroy(RenderArena* renderArena)
107 {
108     delete this;
109     
110     // Recover the size left there for us by operator delete and free the memory.
111     renderArena->free(*(size_t *)this, this);
112 }
113
114 RenderLayer::RenderLayer(RenderObject* object)
115 : m_object(object),
116 m_parent(0),
117 m_previous(0),
118 m_next(0),
119 m_first(0),
120 m_last(0),
121 m_repaintX(0),
122 m_repaintY(0),
123 m_relX(0),
124 m_relY(0),
125 m_x(0),
126 m_y(0),
127 m_width(0),
128 m_height(0),
129 m_scrollX(0),
130 m_scrollY(0),
131 m_scrollOriginX(0),
132 m_scrollLeftOverflow(0),
133 m_scrollWidth(0),
134 m_scrollHeight(0),
135 m_inResizeMode(false),
136 m_posZOrderList(0),
137 m_negZOrderList(0),
138 m_overflowList(0),
139 m_clipRects(0) ,
140 m_scrollDimensionsDirty(true),
141 m_zOrderListsDirty(true),
142 m_overflowListDirty(true),
143 m_isOverflowOnly(shouldBeOverflowOnly()),
144 m_usedTransparency(false),
145 m_inOverflowRelayout(false),
146 m_repaintOverflowOnResize(false),
147 m_overflowStatusDirty(true),
148 m_visibleContentStatusDirty( true ),
149 m_hasVisibleContent( false ),
150 m_visibleDescendantStatusDirty( false ),
151 m_hasVisibleDescendant( false ),
152 m_marquee(0)
153 {
154     if (!object->firstChild() && object->style()) {
155         m_visibleContentStatusDirty = false;
156         m_hasVisibleContent = object->style()->visibility() == VISIBLE;
157     }
158 }
159
160 RenderLayer::~RenderLayer()
161 {
162     destroyScrollbar(HorizontalScrollbar);
163     destroyScrollbar(VerticalScrollbar);
164
165     // Child layers will be deleted by their corresponding render objects, so
166     // we don't need to delete them ourselves.
167
168     delete m_posZOrderList;
169     delete m_negZOrderList;
170     delete m_overflowList;
171     delete m_marquee;
172     
173     // Make sure we have no lingering clip rects.
174     assert(!m_clipRects);
175 }
176
177 void RenderLayer::checkForRepaintOnResize()
178 {
179     m_repaintOverflowOnResize = m_object->selfNeedsLayout() || m_object->hasOverflowClip() && m_object->normalChildNeedsLayout();
180     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
181         child->checkForRepaintOnResize();
182 }
183
184 void RenderLayer::updateLayerPositions(bool doFullRepaint, bool checkForRepaint)
185 {
186     if (doFullRepaint) {
187         m_object->repaint();
188         checkForRepaint = doFullRepaint = false;
189     }
190     
191     updateLayerPosition(); // For relpositioned layers or non-positioned layers,
192                            // we need to keep in sync, since we may have shifted relative
193                            // to our parent layer.
194
195     positionOverflowControls();
196
197     updateVisibilityStatus();
198         
199     if (m_hasVisibleContent) {
200         int x, y;
201         m_object->absolutePosition(x, y);
202         IntRect newRect = m_object->getAbsoluteRepaintRect();
203         if (checkForRepaint) {
204             RenderView* c = m_object->view();
205             ASSERT(c);
206             if (c && !c->printing()) {
207                 bool didMove = x != m_repaintX || y != m_repaintY;
208                 if (!didMove && !m_repaintOverflowOnResize)
209                     m_object->repaintAfterLayoutIfNeeded(m_repaintRect);
210                 else if (didMove || newRect != m_repaintRect) {
211                     c->repaintViewRectangle(m_repaintRect);
212                     c->repaintViewRectangle(newRect);
213                 }
214             }
215         }
216         m_repaintRect = newRect;
217         m_repaintX = x;
218         m_repaintY = y;
219     } else {
220         m_repaintRect = IntRect();
221     }
222     
223     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
224         child->updateLayerPositions(doFullRepaint, checkForRepaint);
225         
226     // With all our children positioned, now update our marquee if we need to.
227     if (m_marquee)
228         m_marquee->updateMarqueePosition();
229 }
230
231 void RenderLayer::setHasVisibleContent(bool b) 
232
233     if (m_hasVisibleContent == b && !m_visibleContentStatusDirty)
234         return;
235     m_visibleContentStatusDirty = false; 
236     m_hasVisibleContent = b;
237     if (parent())
238         parent()->childVisibilityChanged(m_hasVisibleContent);
239 }
240
241 void RenderLayer::dirtyVisibleContentStatus() 
242
243     m_visibleContentStatusDirty = true; 
244     if (parent())
245         parent()->dirtyVisibleDescendantStatus();
246 }
247
248 void RenderLayer::childVisibilityChanged(bool newVisibility) 
249
250     if (m_hasVisibleDescendant == newVisibility || m_visibleDescendantStatusDirty)
251         return;
252     if (newVisibility) {
253         RenderLayer* l = this;
254         while (l && !l->m_visibleDescendantStatusDirty && !l->m_hasVisibleDescendant) {
255             l->m_hasVisibleDescendant = true;
256             l = l->parent();
257         }
258     } else 
259         dirtyVisibleDescendantStatus();
260 }
261
262 void RenderLayer::dirtyVisibleDescendantStatus()
263 {
264     RenderLayer* l = this;
265     while (l && !l->m_visibleDescendantStatusDirty) {
266         l->m_visibleDescendantStatusDirty = true;
267         l = l->parent();
268     }
269 }
270
271 void RenderLayer::updateVisibilityStatus()
272 {
273     if (m_visibleDescendantStatusDirty) {
274         m_hasVisibleDescendant = false;
275         for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
276             child->updateVisibilityStatus();        
277             if (child->m_hasVisibleContent || child->m_hasVisibleDescendant) {
278                 m_hasVisibleDescendant = true;
279                 break;
280             }
281         }
282         m_visibleDescendantStatusDirty = false;
283     }
284
285     if (m_visibleContentStatusDirty) {
286         if (m_object->style()->visibility() == VISIBLE)
287             m_hasVisibleContent = true;
288         else {
289             // layer may be hidden but still have some visible content, check for this
290             m_hasVisibleContent = false;
291             RenderObject* r = m_object->firstChild();
292             while (r) {
293                 if (r->style()->visibility() == VISIBLE && !r->layer()) {
294                     m_hasVisibleContent = true;
295                     break;
296                 }
297                 if (r->firstChild() && !r->layer())
298                     r = r->firstChild();
299                 else if (r->nextSibling())
300                     r = r->nextSibling();
301                 else {
302                     do {
303                         r = r->parent();
304                         if (r==m_object)
305                             r = 0;
306                     } while (r && !r->nextSibling());
307                     if (r)
308                         r = r->nextSibling();
309                 }
310             }
311         }    
312         m_visibleContentStatusDirty = false; 
313     }
314 }
315
316 void RenderLayer::updateLayerPosition()
317 {
318     // Clear our cached clip rect information.
319     clearClipRect();
320
321     int x = m_object->xPos();
322     int y = m_object->yPos() - m_object->borderTopExtra();
323
324     if (!m_object->isPositioned() && m_object->parent()) {
325         // We must adjust our position by walking up the render tree looking for the
326         // nearest enclosing object with a layer.
327         RenderObject* curr = m_object->parent();
328         while (curr && !curr->layer()) {
329             if (!curr->isTableRow()) {
330                 // Rows and cells share the same coordinate space (that of the section).
331                 // Omit them when computing our xpos/ypos.
332                 x += curr->xPos();
333                 y += curr->yPos();
334             }
335             curr = curr->parent();
336         }
337         y += curr->borderTopExtra();
338         if (curr->isTableRow()) {
339             // Put ourselves into the row coordinate space.
340             x -= curr->xPos();
341             y -= curr->yPos();
342         }
343     }
344
345     m_relX = m_relY = 0;
346     if (m_object->isRelPositioned()) {
347         m_relX = static_cast<RenderBox*>(m_object)->relativePositionOffsetX();
348         m_relY = static_cast<RenderBox*>(m_object)->relativePositionOffsetY();
349         x += m_relX; y += m_relY;
350     }
351     
352     // Subtract our parent's scroll offset.
353     if (m_object->isPositioned() && enclosingPositionedAncestor()) {
354         RenderLayer* positionedParent = enclosingPositionedAncestor();
355
356         // For positioned layers, we subtract out the enclosing positioned layer's scroll offset.
357         positionedParent->subtractScrollOffset(x, y);
358         
359         if (m_object->isPositioned() && positionedParent->renderer()->isRelPositioned() &&
360             positionedParent->renderer()->isInlineFlow()) {
361             // When we have an enclosing relpositioned inline, we need to add in the offset of the first line
362             // box from the rest of the content, but only in the cases where we know we're positioned
363             // relative to the inline itself.
364             RenderFlow* flow = static_cast<RenderFlow*>(positionedParent->renderer());
365             int sx = 0, sy = 0;
366             if (flow->firstLineBox()) {
367                 sx = flow->firstLineBox()->xPos();
368                 sy = flow->firstLineBox()->yPos();
369             }
370             else {
371                 sx = flow->staticX();
372                 sy = flow->staticY();
373             }
374             bool isInlineType = m_object->style()->isOriginalDisplayInlineType();
375             
376             if (!m_object->hasStaticX())
377                 x += sx;
378             
379             // This is not terribly intuitive, but we have to match other browsers.  Despite being a block display type inside
380             // an inline, we still keep our x locked to the left of the relative positioned inline.  Arguably the correct
381             // behavior would be to go flush left to the block that contains the inline, but that isn't what other browsers
382             // do.
383             if (m_object->hasStaticX() && !isInlineType)
384                 // Avoid adding in the left border/padding of the containing block twice.  Subtract it out.
385                 x += sx - (m_object->containingBlock()->borderLeft() + m_object->containingBlock()->paddingLeft());
386             
387             if (!m_object->hasStaticY())
388                 y += sy;
389         }
390     }
391     else if (parent())
392         parent()->subtractScrollOffset(x, y);
393     
394     setPos(x,y);
395
396     setWidth(m_object->width());
397     setHeight(m_object->height() + m_object->borderTopExtra() + m_object->borderBottomExtra());
398
399     if (!m_object->hasOverflowClip()) {
400         if (m_object->overflowWidth() > m_object->width())
401             setWidth(m_object->overflowWidth());
402         if (m_object->overflowHeight() > m_object->height())
403             setHeight(m_object->overflowHeight());
404     }
405 }
406
407 RenderLayer *RenderLayer::stackingContext() const
408 {
409     RenderLayer* curr = parent();
410     for ( ; curr && !curr->m_object->isRenderView() && !curr->m_object->isRoot() &&
411           curr->m_object->style()->hasAutoZIndex();
412           curr = curr->parent());
413     return curr;
414 }
415
416 RenderLayer*
417 RenderLayer::enclosingPositionedAncestor() const
418 {
419     RenderLayer* curr = parent();
420     for ( ; curr && !curr->m_object->isRenderView() && !curr->m_object->isRoot() &&
421          !curr->m_object->isPositioned() && !curr->m_object->isRelPositioned();
422          curr = curr->parent());
423          
424     return curr;
425 }
426
427 bool
428 RenderLayer::isTransparent() const
429 {
430 #if ENABLE(SVG)
431     if (m_object->node()->namespaceURI() == SVGNames::svgNamespaceURI)
432         return false;
433 #endif
434     return m_object->isTransparent();
435 }
436
437 RenderLayer*
438 RenderLayer::transparentAncestor()
439 {
440     RenderLayer* curr = parent();
441     for ( ; curr && !curr->isTransparent(); curr = curr->parent());
442     return curr;
443 }
444
445 static IntRect transparencyClipBox(RenderLayer* l)
446 {
447     // FIXME: Although this completely ignores clipping, we ultimately intersect with the
448     // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
449     // would be better to respect clips.
450     IntRect clipRect = l->absoluteBoundingBox();
451     
452     // Note: we don't have to walk z-order lists since transparent elements always establish
453     // a stacking context.  This means we can just walk the layer tree directly. 
454     for (RenderLayer* curr = l->firstChild(); curr; curr = curr->nextSibling())
455         clipRect.unite(transparencyClipBox(curr));
456     
457     return clipRect;
458 }
459
460 void RenderLayer::beginTransparencyLayers(GraphicsContext* p, const IntRect& paintDirtyRect)
461 {
462     if (p->paintingDisabled() || (isTransparent() && m_usedTransparency))
463         return;
464     
465     RenderLayer* ancestor = transparentAncestor();
466     if (ancestor)
467         ancestor->beginTransparencyLayers(p, paintDirtyRect);
468     
469     if (isTransparent()) {
470         m_usedTransparency = true;
471         IntRect clipRect = transparencyClipBox(this);
472         clipRect.intersect(paintDirtyRect);
473         p->save();
474         p->clip(clipRect);
475         p->beginTransparencyLayer(renderer()->opacity());
476     }
477 }
478
479 void* RenderLayer::operator new(size_t sz, RenderArena* renderArena) throw()
480 {
481     return renderArena->allocate(sz);
482 }
483
484 void RenderLayer::operator delete(void* ptr, size_t sz)
485 {
486     assert(inRenderLayerDestroy);
487     
488     // Stash size where destroy can find it.
489     *(size_t *)ptr = sz;
490 }
491
492 void RenderLayer::destroy(RenderArena* renderArena)
493 {
494 #ifndef NDEBUG
495     inRenderLayerDestroy = true;
496 #endif
497     delete this;
498 #ifndef NDEBUG
499     inRenderLayerDestroy = false;
500 #endif
501     
502     // Recover the size left there for us by operator delete and free the memory.
503     renderArena->free(*(size_t *)this, this);
504 }
505
506 void RenderLayer::addChild(RenderLayer *child, RenderLayer* beforeChild)
507 {
508     RenderLayer* prevSibling = beforeChild ? beforeChild->previousSibling() : lastChild();
509     if (prevSibling) {
510         child->setPreviousSibling(prevSibling);
511         prevSibling->setNextSibling(child);
512     }
513     else
514         setFirstChild(child);
515
516     if (beforeChild) {
517         beforeChild->setPreviousSibling(child);
518         child->setNextSibling(beforeChild);
519     }
520     else
521         setLastChild(child);
522    
523     child->setParent(this);
524
525     if (child->isOverflowOnly())
526         dirtyOverflowList();
527     else {
528         // Dirty the z-order list in which we are contained.  The stackingContext() can be null in the
529         // case where we're building up generated content layers.  This is ok, since the lists will start
530         // off dirty in that case anyway.
531         RenderLayer* stackingContext = child->stackingContext();
532         if (stackingContext)
533             stackingContext->dirtyZOrderLists();
534     }
535     
536     child->updateVisibilityStatus();
537     if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
538         childVisibilityChanged(true);
539 }
540
541 RenderLayer* RenderLayer::removeChild(RenderLayer* oldChild)
542 {
543     // remove the child
544     if (oldChild->previousSibling())
545         oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());
546     if (oldChild->nextSibling())
547         oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());
548
549     if (m_first == oldChild)
550         m_first = oldChild->nextSibling();
551     if (m_last == oldChild)
552         m_last = oldChild->previousSibling();
553
554     if (oldChild->isOverflowOnly())
555         dirtyOverflowList();
556     else { 
557         // Dirty the z-order list in which we are contained.  When called via the
558         // reattachment process in removeOnlyThisLayer, the layer may already be disconnected
559         // from the main layer tree, so we need to null-check the |stackingContext| value.
560         RenderLayer* stackingContext = oldChild->stackingContext();
561         if (stackingContext)
562             stackingContext->dirtyZOrderLists();
563     }
564
565     oldChild->setPreviousSibling(0);
566     oldChild->setNextSibling(0);
567     oldChild->setParent(0);
568     
569     oldChild->updateVisibilityStatus();
570     if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
571         childVisibilityChanged(false);
572     
573     return oldChild;
574 }
575
576 void RenderLayer::removeOnlyThisLayer()
577 {
578     if (!m_parent)
579         return;
580     
581     // Dirty the clip rects.
582     clearClipRects();
583
584     // Remove us from the parent.
585     RenderLayer* parent = m_parent;
586     RenderLayer* nextSib = nextSibling();
587     parent->removeChild(this);
588     
589     // Now walk our kids and reattach them to our parent.
590     RenderLayer* current = m_first;
591     while (current) {
592         RenderLayer* next = current->nextSibling();
593         removeChild(current);
594         parent->addChild(current, nextSib);
595         current->updateLayerPositions();
596         current = next;
597     }
598     
599     destroy(renderer()->renderArena());
600 }
601
602 void RenderLayer::insertOnlyThisLayer()
603 {
604     if (!m_parent && renderer()->parent()) {
605         // We need to connect ourselves when our renderer() has a parent.
606         // Find our enclosingLayer and add ourselves.
607         RenderLayer* parentLayer = renderer()->parent()->enclosingLayer();
608         if (parentLayer)
609             parentLayer->addChild(this, 
610                                   renderer()->parent()->findNextLayer(parentLayer, renderer()));
611     }
612     
613     // Remove all descendant layers from the hierarchy and add them to the new position.
614     for (RenderObject* curr = renderer()->firstChild(); curr; curr = curr->nextSibling())
615         curr->moveLayers(m_parent, this);
616         
617     // Clear out all the clip rects.
618     clearClipRects();
619 }
620
621 void 
622 RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, int& x, int& y) const
623 {
624     if (ancestorLayer == this)
625         return;
626         
627     if (m_object->style()->position() == FixedPosition) {
628         // Add in the offset of the view.  We can obtain this by calling
629         // absolutePosition() on the RenderView.
630         int xOff, yOff;
631         m_object->absolutePosition(xOff, yOff, true);
632         x += xOff;
633         y += yOff;
634         return;
635     }
636  
637     RenderLayer* parentLayer;
638     if (m_object->style()->position() == AbsolutePosition)
639         parentLayer = enclosingPositionedAncestor();
640     else
641         parentLayer = parent();
642     
643     if (!parentLayer) return;
644     
645     parentLayer->convertToLayerCoords(ancestorLayer, x, y);
646
647     x += xPos();
648     y += yPos();
649 }
650
651 void
652 RenderLayer::scrollOffset(int& x, int& y)
653 {
654     x += scrollXOffset() + m_scrollLeftOverflow;
655     y += scrollYOffset();
656 }
657
658 void
659 RenderLayer::subtractScrollOffset(int& x, int& y)
660 {
661     x -= scrollXOffset() + m_scrollLeftOverflow;
662     y -= scrollYOffset();
663 }
664
665 void RenderLayer::scrollToOffset(int x, int y, bool updateScrollbars, bool repaint)
666 {
667     if (renderer()->style()->overflowX() != OMARQUEE) {
668         if (x < 0) x = 0;
669         if (y < 0) y = 0;
670     
671         // Call the scrollWidth/Height functions so that the dimensions will be computed if they need
672         // to be (for overflow:hidden blocks).
673         int maxX = scrollWidth() - m_object->clientWidth();
674         int maxY = scrollHeight() - m_object->clientHeight();
675         
676         if (x > maxX) x = maxX;
677         if (y > maxY) y = maxY;
678     }
679     
680     // FIXME: Eventually, we will want to perform a blit.  For now never
681     // blit, since the check for blitting is going to be very
682     // complicated (since it will involve testing whether our layer
683     // is either occluded by another layer or clipped by an enclosing
684     // layer or contains fixed backgrounds, etc.).
685     m_scrollX = x - m_scrollOriginX;
686     m_scrollY = y;
687
688     // Update the positions of our child layers.
689     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
690         child->updateLayerPositions(false, false);
691     
692     RenderView* view = renderer()->view();
693     
694     // We should have a RenderView if we're trying to scroll.
695     ASSERT(view);
696     if (view) {
697 #if PLATFORM(MAC)
698         // Update dashboard regions, scrolling may change the clip of a
699         // particular region.
700         view->frameView()->updateDashboardRegions();
701 #endif
702
703         view->updateWidgetPositions();
704     }
705
706     // Just schedule a full repaint of our object.
707     if (repaint)
708         m_object->repaint();
709     
710     if (updateScrollbars) {
711         if (m_hBar)
712             m_hBar->setValue(scrollXOffset());
713         if (m_vBar)
714             m_vBar->setValue(m_scrollY);
715     }
716
717     // Schedule the scroll DOM event.
718     if (view)
719         if (FrameView* frameView = view->frameView())
720             frameView->scheduleEvent(new Event(scrollEvent, true, false), EventTargetNodeCast(renderer()->element()), true);
721 }
722
723 void RenderLayer::scrollRectToVisible(const IntRect &rect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
724 {
725     RenderLayer* parentLayer = 0;
726     IntRect newRect = rect;
727     int xOffset = 0, yOffset = 0;
728     
729     if (m_object->hasOverflowClip()) {
730         int x, y;
731         m_object->absolutePosition(x, y);
732         IntRect layerBounds = IntRect(x + scrollXOffset(), y + scrollYOffset(), 
733                                       width() - verticalScrollbarWidth(), height() - horizontalScrollbarHeight());
734         IntRect exposeRect = IntRect(rect.x() + scrollXOffset(), rect.y() + scrollYOffset(), rect.width(), rect.height());
735         IntRect r = getRectToExpose(layerBounds, exposeRect, alignX, alignY);
736         
737         xOffset = r.x() - x;
738         yOffset = r.y() - y;
739         // Adjust offsets if they're outside of the allowable range.
740         xOffset = max(0, min(scrollWidth() - width(), xOffset));
741         yOffset = max(0, min(scrollHeight() - height(), yOffset));
742         
743         if (xOffset != scrollXOffset() || yOffset != scrollYOffset()) {
744             int diffX = scrollXOffset();
745             int diffY = scrollYOffset();
746             scrollToOffset(xOffset, yOffset);
747             diffX = scrollXOffset() - diffX;
748             diffY = scrollYOffset() - diffY;
749             newRect.setX(rect.x() - diffX);
750             newRect.setY(rect.y() - diffY);
751         }
752     
753         if (m_object->parent())
754             parentLayer = m_object->parent()->enclosingLayer();
755     } else {
756         FrameView* view = m_object->document()->view();
757         if (view) {
758             IntRect viewRect = enclosingIntRect(view->visibleContentRect());
759             IntRect r = getRectToExpose(viewRect, rect, alignX, alignY);
760             
761             xOffset = r.x();
762             yOffset = r.y();
763             // Adjust offsets if they're outside of the allowable range.
764             xOffset = max(0, min(view->contentsWidth(), xOffset));
765             yOffset = max(0, min(view->contentsHeight(), yOffset));
766
767             if (m_object->document() && m_object->document()->ownerElement() && m_object->document()->ownerElement()->renderer()) {
768                 view->setContentsPos(xOffset, yOffset);
769                 parentLayer = m_object->document()->ownerElement()->renderer()->enclosingLayer();
770                 newRect.setX(rect.x() - view->contentsX() + view->x());
771                 newRect.setY(rect.y() - view->contentsY() + view->y());
772             } else {
773                 // If this is the outermost view that RenderLayer needs to scroll, then we should scroll the view recursively
774                 // Other apps, like Mail, rely on this feature.
775                 view->scrollPointRecursively(xOffset, yOffset);
776             }
777         }
778     }
779     
780     if (parentLayer)
781         parentLayer->scrollRectToVisible(newRect, alignX, alignY);
782 }
783
784 IntRect RenderLayer::getRectToExpose(const IntRect &visibleRect, const IntRect &exposeRect, const ScrollAlignment& alignX, const ScrollAlignment& alignY)
785 {
786     // Determine the appropriate X behavior.
787     ScrollBehavior scrollX;
788     IntRect exposeRectX(exposeRect.x(), visibleRect.y(), exposeRect.width(), visibleRect.height());
789     int intersectWidth = intersection(visibleRect, exposeRectX).width();
790     if (intersectWidth == exposeRect.width() || intersectWidth >= MIN_INTERSECT_FOR_REVEAL)
791         // If the rectangle is fully visible, use the specified visible behavior.
792         // If the rectangle is partially visible, but over a certain threshold,
793         // then treat it as fully visible to avoid unnecessary horizontal scrolling
794         scrollX = getVisibleBehavior(alignX);
795     else if (intersectWidth == visibleRect.width()) {
796         // If the rect is bigger than the visible area, don't bother trying to center. Other alignments will work.
797         scrollX = getVisibleBehavior(alignX);
798         if (scrollX == alignCenter)
799             scrollX = noScroll;
800     } else if (intersectWidth > 0)
801         // If the rectangle is partially visible, but not above the minimum threshold, use the specified partial behavior
802         scrollX = getPartialBehavior(alignX);
803     else
804         scrollX = getHiddenBehavior(alignX);
805     // If we're trying to align to the closest edge, and the exposeRect is further right
806     // than the visibleRect, and not bigger than the visible area, then align with the right.
807     if (scrollX == alignToClosestEdge && exposeRect.right() > visibleRect.right() && exposeRect.width() < visibleRect.width())
808         scrollX = alignRight;
809
810     // Given the X behavior, compute the X coordinate.
811     int x;
812     if (scrollX == noScroll) 
813         x = visibleRect.x();
814     else if (scrollX == alignRight)
815         x = exposeRect.right() - visibleRect.width();
816     else if (scrollX == alignCenter)
817         x = exposeRect.x() + (exposeRect.width() - visibleRect.width()) / 2;
818     else
819         x = exposeRect.x();
820
821     // Determine the appropriate Y behavior.
822     ScrollBehavior scrollY;
823     IntRect exposeRectY(visibleRect.x(), exposeRect.y(), visibleRect.width(), exposeRect.height());
824     int intersectHeight = intersection(visibleRect, exposeRectY).height();
825     if (intersectHeight == exposeRect.height())
826         // If the rectangle is fully visible, use the specified visible behavior.
827         scrollY = getVisibleBehavior(alignY);
828     else if (intersectHeight == visibleRect.height()) {
829         // If the rect is bigger than the visible area, don't bother trying to center. Other alignments will work.
830         scrollY = getVisibleBehavior(alignY);
831         if (scrollY == alignCenter)
832             scrollY = noScroll;
833     } else if (intersectHeight > 0)
834         // If the rectangle is partially visible, use the specified partial behavior
835         scrollY = getPartialBehavior(alignY);
836     else
837         scrollY = getHiddenBehavior(alignY);
838     // If we're trying to align to the closest edge, and the exposeRect is further down
839     // than the visibleRect, and not bigger than the visible area, then align with the bottom.
840     if (scrollY == alignToClosestEdge && exposeRect.bottom() > visibleRect.bottom() && exposeRect.height() < visibleRect.height())
841         scrollY = alignBottom;
842
843     // Given the Y behavior, compute the Y coordinate.
844     int y;
845     if (scrollY == noScroll) 
846         y = visibleRect.y();
847     else if (scrollY == alignBottom)
848         y = exposeRect.bottom() - visibleRect.height();
849     else if (scrollY == alignCenter)
850         y = exposeRect.y() + (exposeRect.height() - visibleRect.height()) / 2;
851     else
852         y = exposeRect.y();
853
854     return IntRect(IntPoint(x, y), visibleRect.size());
855 }
856
857 void RenderLayer::autoscroll()
858 {
859     if (!renderer() || !renderer()->document() || !renderer()->document()->frame() || !renderer()->document()->frame()->view())
860         return;
861         
862     Frame* currentFrame = renderer()->document()->frame();
863     IntPoint currentPos = currentFrame->view()->windowToContents(currentFrame->eventHandler()->currentMousePosition());
864     
865     if (currentFrame->eventHandler()->mouseDownMayStartSelect()) {
866         // Convert the mouse position to local layer space.
867         int objectX, objectY;
868         renderer()->absolutePosition(objectX, objectY);
869         HitTestRequest request(true, false, true);
870         HitTestResult result(currentPos - IntSize(objectX, objectY));
871         if (hitTest(request, result) && result.innerNode()->renderer() && result.innerNode()->renderer()->shouldSelect()) {
872             VisiblePosition pos(result.innerNode()->renderer()->positionForPoint(result.localPoint()));
873             currentFrame->eventHandler()->updateSelectionForMouseDragOverPosition(pos);
874         }
875     }
876
877     scrollRectToVisible(IntRect(currentPos, IntSize(1, 1)), gAlignToEdgeIfNeeded, gAlignToEdgeIfNeeded);    
878 }
879
880 void RenderLayer::resize(const PlatformMouseEvent& evt, const IntSize& offsetFromResizeCorner)
881 {
882     if (!inResizeMode() || !renderer()->hasOverflowClip() || m_object->style()->resize() == RESIZE_NONE)
883         return;
884
885     if (!m_object->document()->frame()->eventHandler()->mousePressed())
886         return;
887
888     // FIXME Radar 4118559: This behaves very oddly for textareas that are in blocks with right-aligned text; you have
889     // to drag the bottom-right corner to make the bottom-left corner move.
890     // FIXME Radar 4118564: ideally we'd autoscroll the window as necessary to keep the point under
891     // the cursor in view.
892
893     IntPoint currentPoint = m_object->document()->view()->windowToContents(evt.pos());
894     currentPoint += offsetFromResizeCorner;
895
896     int x;
897     int y;
898     m_object->absolutePosition(x, y);
899     int right = x + m_object->width();
900     int bottom = y + m_object->height();
901     int diffWidth =  max(currentPoint.x() - right, min(0, MinimumWidthWhileResizing - m_object->width()));
902     int diffHeight = max(currentPoint.y() - bottom, min(0, MinimumHeightWhileResizing - m_object->height()));
903     
904     ExceptionCode ec = 0;
905     // Set the width and height for the shadow ancestor node.  This is necessary for textareas since the resizable layer is on the inner div.
906     // For non-shadow content, this will set the width and height on the original node.
907     RenderObject* renderer = m_object->node()->shadowAncestorNode()->renderer();
908     if (diffWidth && (m_object->style()->resize() == RESIZE_HORIZONTAL || m_object->style()->resize() == RESIZE_BOTH)) {
909         CSSStyleDeclaration* style = static_cast<Element*>(m_object->node()->shadowAncestorNode())->style();
910         if (renderer->element() && renderer->element()->isControl()) {
911             style->setProperty(CSS_PROP_MARGIN_LEFT, String::number(renderer->marginLeft()) + "px", false, ec);
912             style->setProperty(CSS_PROP_MARGIN_RIGHT, String::number(renderer->marginRight()) + "px", false, ec);
913         }
914         int baseWidth = renderer->width() - (renderer->style()->boxSizing() == BORDER_BOX ? 0 : renderer->borderLeft() + renderer->paddingLeft() + renderer->borderRight() + renderer->paddingRight());
915         style->setProperty(CSS_PROP_WIDTH, String::number(baseWidth + diffWidth) + "px", false, ec);
916     }
917
918     if (diffHeight && (m_object->style()->resize() == RESIZE_VERTICAL || m_object->style()->resize() == RESIZE_BOTH)) {
919         CSSStyleDeclaration* style = static_cast<Element*>(m_object->node()->shadowAncestorNode())->style();
920         if (renderer->element() && renderer->element()->isControl()) {
921             style->setProperty(CSS_PROP_MARGIN_TOP, String::number(renderer->marginTop()) + "px", false, ec);
922             style->setProperty(CSS_PROP_MARGIN_BOTTOM, String::number(renderer->marginBottom()) + "px", false, ec);
923         }
924         int baseHeight = renderer->height() - (renderer->style()->boxSizing() == BORDER_BOX ? 0 : renderer->borderTop() + renderer->paddingTop() + renderer->borderBottom() + renderer->paddingBottom());
925         style->setProperty(CSS_PROP_HEIGHT, String::number(baseHeight + diffHeight) + "px", false, ec);
926     }
927     
928     ASSERT(ec == 0);
929
930     if (m_object->style()->resize() != RESIZE_NONE) {
931         m_object->setNeedsLayout(true);
932         m_object->node()->shadowAncestorNode()->renderer()->setNeedsLayout(true);
933         m_object->document()->updateLayout();
934     }
935 }
936
937 PlatformScrollbar* RenderLayer::horizontaScrollbarWidget() const
938 {
939     if (m_hBar && m_hBar->isWidget())
940         return static_cast<PlatformScrollbar*>(m_hBar.get());
941     return 0;
942 }
943
944 PlatformScrollbar* RenderLayer::verticalScrollbarWidget() const
945 {
946     if (m_vBar && m_vBar->isWidget())
947         return static_cast<PlatformScrollbar*>(m_vBar.get());
948     return 0;
949 }
950
951 void RenderLayer::valueChanged(Scrollbar*)
952 {
953     // Update scroll position from scrollbars.
954
955     bool needUpdate = false;
956     int newX = scrollXOffset();
957     int newY = m_scrollY;
958     
959     if (m_hBar) {
960         newX = m_hBar->value();
961         if (newX != scrollXOffset())
962            needUpdate = true;
963     }
964
965     if (m_vBar) {
966         newY = m_vBar->value();
967         if (newY != m_scrollY)
968            needUpdate = true;
969     }
970
971     if (needUpdate)
972         scrollToOffset(newX, newY, false);
973 }
974
975 IntRect RenderLayer::windowClipRect() const
976 {
977     RenderView* view = renderer()->view();
978     ASSERT(view);
979     FrameView* frameView = view->frameView();
980     if (!frameView)
981         return IntRect();
982     return frameView->windowClipRectForLayer(this, false);
983 }
984
985 PassRefPtr<Scrollbar> RenderLayer::createScrollbar(ScrollbarOrientation orientation)
986 {
987     if (Scrollbar::hasPlatformScrollbars()) {
988         RefPtr<PlatformScrollbar> widget = new PlatformScrollbar(this, orientation, RegularScrollbar);
989         m_object->document()->view()->addChild(widget.get());
990         return widget.release();
991     }
992     
993     // FIXME: Create scrollbars using the engine.
994     return 0;
995 }
996
997 void RenderLayer::destroyScrollbar(ScrollbarOrientation orientation)
998 {
999     RefPtr<Scrollbar>& scrollbar = orientation == HorizontalScrollbar ? m_hBar : m_vBar;
1000     if (scrollbar) {
1001         if (scrollbar->isWidget())
1002             static_cast<PlatformScrollbar*>(scrollbar.get())->removeFromParent();
1003
1004         // FIXME: Destroy the engine scrollbar.
1005         scrollbar = 0;
1006     }
1007 }
1008
1009 void RenderLayer::setHasHorizontalScrollbar(bool hasScrollbar)
1010 {
1011     if (hasScrollbar == (m_hBar != 0))
1012         return;
1013
1014     if (hasScrollbar)
1015         m_hBar = createScrollbar(HorizontalScrollbar);
1016     else
1017         destroyScrollbar(HorizontalScrollbar);
1018
1019 #if PLATFORM(MAC)
1020     // Force an update since we know the scrollbars have changed things.
1021     if (m_object->document()->hasDashboardRegions())
1022         m_object->document()->setDashboardRegionsDirty(true);
1023 #endif
1024
1025 }
1026
1027 void RenderLayer::setHasVerticalScrollbar(bool hasScrollbar)
1028 {
1029     if (hasScrollbar == (m_vBar != 0))
1030         return;
1031
1032     if (hasScrollbar)
1033         m_vBar = createScrollbar(VerticalScrollbar);
1034     else
1035         destroyScrollbar(VerticalScrollbar);
1036
1037 #if PLATFORM(MAC)
1038     // Force an update since we know the scrollbars have changed things.
1039     if (m_object->document()->hasDashboardRegions())
1040         m_object->document()->setDashboardRegionsDirty(true);
1041 #endif
1042
1043 }
1044
1045 int RenderLayer::verticalScrollbarWidth() const
1046 {
1047     if (!m_vBar)
1048         return 0;
1049     return m_vBar->width();
1050 }
1051
1052 int RenderLayer::horizontalScrollbarHeight() const
1053 {
1054     if (!m_hBar)
1055         return 0;
1056     return m_hBar->height();
1057 }
1058
1059 IntSize RenderLayer::offsetFromResizeCorner(const IntPoint& p) const
1060 {
1061     // Currently the resize corner is always the bottom right corner
1062     int x = width();
1063     int y = height();
1064     convertToLayerCoords(root(), x, y);
1065     return IntSize(x - p.x(), y - p.y());
1066 }
1067
1068 static IntRect scrollCornerRect(RenderObject* renderer, const IntRect& absBounds)
1069 {
1070     int resizerWidth = PlatformScrollbar::verticalScrollbarWidth();
1071     int resizerHeight = PlatformScrollbar::horizontalScrollbarHeight();
1072     return IntRect(absBounds.right() - resizerWidth - renderer->style()->borderRightWidth(), 
1073                    absBounds.bottom() - resizerHeight - renderer->style()->borderBottomWidth(), resizerWidth, resizerHeight);
1074 }
1075
1076 void RenderLayer::positionOverflowControls()
1077 {
1078     if (!m_hBar && !m_vBar && (!m_object->hasOverflowClip() || m_object->style()->resize() == RESIZE_NONE))
1079         return;
1080     
1081     int x = 0;
1082     int y = 0;
1083     convertToLayerCoords(root(), x, y);
1084     IntRect absBounds(x, y, m_object->width(), m_object->height());
1085     
1086     IntRect resizeControlRect;
1087     if (m_object->style()->resize() != RESIZE_NONE)
1088         resizeControlRect = scrollCornerRect(m_object, absBounds);
1089     
1090     int resizeControlSize = max(resizeControlRect.height(), 0);
1091     if (m_vBar)
1092         m_vBar->setRect(IntRect(absBounds.right() - m_object->borderRight() - m_vBar->width(),
1093                                 absBounds.y() + m_object->borderTop(),
1094                                 m_vBar->width(),
1095                                 absBounds.height() - (m_object->borderTop() + m_object->borderBottom()) - (m_hBar ? m_hBar->height() : resizeControlSize)));
1096
1097     resizeControlSize = max(resizeControlRect.width(), 0);
1098     if (m_hBar)
1099         m_hBar->setRect(IntRect(absBounds.x() + m_object->borderLeft(),
1100                                 absBounds.bottom() - m_object->borderBottom() - m_hBar->height(),
1101                                 absBounds.width() - (m_object->borderLeft() + m_object->borderRight()) - (m_vBar ? m_vBar->width() : resizeControlSize),
1102                                 m_hBar->height()));
1103 }
1104
1105 int RenderLayer::scrollWidth()
1106 {
1107     if (m_scrollDimensionsDirty)
1108         computeScrollDimensions();
1109     return m_scrollWidth;
1110 }
1111
1112 int RenderLayer::scrollHeight()
1113 {
1114     if (m_scrollDimensionsDirty)
1115         computeScrollDimensions();
1116     return m_scrollHeight;
1117 }
1118
1119 void RenderLayer::computeScrollDimensions(bool* needHBar, bool* needVBar)
1120 {
1121     m_scrollDimensionsDirty = false;
1122     
1123     bool ltr = m_object->style()->direction() == LTR;
1124
1125     int clientWidth = m_object->clientWidth();
1126     int clientHeight = m_object->clientHeight();
1127
1128     m_scrollLeftOverflow = ltr ? 0 : min(0, m_object->leftmostPosition(true, false) - m_object->borderLeft());
1129
1130     int rightPos = ltr ?
1131                     m_object->rightmostPosition(true, false) - m_object->borderLeft() :
1132                     clientWidth - m_scrollLeftOverflow;
1133     int bottomPos = m_object->lowestPosition(true, false) - m_object->borderTop();
1134
1135     m_scrollWidth = max(rightPos, clientWidth);
1136     m_scrollHeight = max(bottomPos, clientHeight);
1137     
1138     m_scrollOriginX = ltr ? 0 : m_scrollWidth - clientWidth;
1139
1140     if (needHBar)
1141         *needHBar = rightPos > clientWidth;
1142     if (needVBar)
1143         *needVBar = bottomPos > clientHeight;
1144 }
1145
1146 void RenderLayer::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1147 {
1148     if (m_overflowStatusDirty) {
1149         m_horizontalOverflow = horizontalOverflow;
1150         m_verticalOverflow = verticalOverflow;
1151         m_overflowStatusDirty = false;
1152         
1153         return;
1154     }
1155     
1156     bool horizontalOverflowChanged = (m_horizontalOverflow != horizontalOverflow);
1157     bool verticalOverflowChanged = (m_verticalOverflow != verticalOverflow);
1158     
1159     if (horizontalOverflowChanged || verticalOverflowChanged) {
1160         m_horizontalOverflow = horizontalOverflow;
1161         m_verticalOverflow = verticalOverflow;
1162         
1163         if (FrameView* frameView = m_object->document()->view())
1164             frameView->scheduleEvent(new OverflowEvent(horizontalOverflowChanged, horizontalOverflow, verticalOverflowChanged, verticalOverflow),
1165             EventTargetNodeCast(m_object->element()), true);
1166     }
1167 }
1168
1169 void
1170 RenderLayer::updateScrollInfoAfterLayout()
1171 {
1172     m_scrollDimensionsDirty = true;
1173
1174     bool horizontalOverflow, verticalOverflow;
1175     computeScrollDimensions(&horizontalOverflow, &verticalOverflow);
1176
1177     if (m_object->style()->overflowX() != OMARQUEE) {
1178         // Layout may cause us to be in an invalid scroll position.  In this case we need
1179         // to pull our scroll offsets back to the max (or push them up to the min).
1180         int newX = max(0, min(scrollXOffset(), scrollWidth() - m_object->clientWidth()));
1181         int newY = max(0, min(m_scrollY, scrollHeight() - m_object->clientHeight()));
1182         if (newX != scrollXOffset() || newY != m_scrollY)
1183             scrollToOffset(newX, newY);
1184     }
1185
1186     bool haveHorizontalBar = m_hBar;
1187     bool haveVerticalBar = m_vBar;
1188     
1189     // overflow:scroll should just enable/disable.
1190     if (m_object->style()->overflowX() == OSCROLL)
1191         m_hBar->setEnabled(horizontalOverflow);
1192     if (m_object->style()->overflowY() == OSCROLL)
1193         m_vBar->setEnabled(verticalOverflow);
1194
1195     // A dynamic change from a scrolling overflow to overflow:hidden means we need to get rid of any
1196     // scrollbars that may be present.
1197     if (m_object->style()->overflowX() == OHIDDEN && haveHorizontalBar)
1198         setHasHorizontalScrollbar(false);
1199     if (m_object->style()->overflowY() == OHIDDEN && haveVerticalBar)
1200         setHasVerticalScrollbar(false);
1201     
1202     // overflow:auto may need to lay out again if scrollbars got added/removed.
1203     bool scrollbarsChanged = (m_object->hasAutoHorizontalScrollbar() && haveHorizontalBar != horizontalOverflow) || 
1204                              (m_object->hasAutoVerticalScrollbar() && haveVerticalBar != verticalOverflow);    
1205     if (scrollbarsChanged) {
1206         if (m_object->hasAutoHorizontalScrollbar())
1207             setHasHorizontalScrollbar(horizontalOverflow);
1208         if (m_object->hasAutoVerticalScrollbar())
1209             setHasVerticalScrollbar(verticalOverflow);
1210
1211 #if PLATFORM(MAC)
1212         // Force an update since we know the scrollbars have changed things.
1213         if (m_object->document()->hasDashboardRegions())
1214             m_object->document()->setDashboardRegionsDirty(true);
1215 #endif
1216
1217         m_object->repaint();
1218
1219         if (m_object->style()->overflowX() == OAUTO || m_object->style()->overflowY() == OAUTO) {
1220             if (!m_inOverflowRelayout) {
1221                 // Our proprietary overflow: overlay value doesn't trigger a layout.
1222                 m_inOverflowRelayout = true;
1223                 m_object->setNeedsLayout(true);
1224                 if (m_object->isRenderBlock())
1225                     static_cast<RenderBlock*>(m_object)->layoutBlock(true);
1226                 else
1227                     m_object->layout();
1228                 m_inOverflowRelayout = false;
1229             }
1230         }
1231     }
1232     
1233     // If overflow:scroll is turned into overflow:auto a bar might still be disabled (Bug 11985).
1234     if (m_hBar && m_object->hasAutoHorizontalScrollbar())
1235         m_hBar->setEnabled(true);
1236     if (m_vBar && m_object->hasAutoVerticalScrollbar())
1237         m_vBar->setEnabled(true);
1238
1239     // Set up the range (and page step/line step).
1240     if (m_hBar) {
1241         int clientWidth = m_object->clientWidth();
1242         int pageStep = (clientWidth-PAGE_KEEP);
1243         if (pageStep < 0) pageStep = clientWidth;
1244         m_hBar->setSteps(LINE_STEP, pageStep);
1245         m_hBar->setProportion(clientWidth, m_scrollWidth);
1246         m_hBar->setValue(scrollXOffset());
1247     }
1248     if (m_vBar) {
1249         int clientHeight = m_object->clientHeight();
1250         int pageStep = (clientHeight-PAGE_KEEP);
1251         if (pageStep < 0) pageStep = clientHeight;
1252         m_vBar->setSteps(LINE_STEP, pageStep);
1253         m_vBar->setProportion(clientHeight, m_scrollHeight);
1254         m_object->repaintRectangle(IntRect(m_object->borderLeft() + m_object->clientWidth(),
1255                                    m_object->borderTop(), verticalScrollbarWidth(), 
1256                                    m_object->height() - m_object->borderTop() - m_object->borderBottom()));
1257     }
1258  
1259     if (m_object->element() && m_object->document()->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
1260         updateOverflowStatus(horizontalOverflow, verticalOverflow);
1261 }
1262
1263 void RenderLayer::paintOverflowControls(GraphicsContext* p, int tx, int ty, const IntRect& damageRect)
1264 {
1265     // Don't do anything if we have no overflow.
1266     if (!m_object->hasOverflowClip())
1267         return;
1268     
1269     // Move the scrollbar widgets if necessary.  We normally move and resize widgets during layout, but sometimes
1270     // widgets can move without layout occurring (most notably when you scroll a document that
1271     // contains fixed positioned elements).
1272     positionOverflowControls();
1273
1274     // Now that we're sure the scrollbars are in the right place, paint them.
1275     if (m_hBar)
1276         m_hBar->paint(p, damageRect);
1277     if (m_vBar)
1278         m_vBar->paint(p, damageRect);
1279     
1280     // We fill our scroll corner with white if we have a scrollbar that doesn't run all the way up to the
1281     // edge of the box.
1282     IntRect paddingBox(m_object->xPos() + m_object->borderLeft() + tx, 
1283                        m_object->yPos() + m_object->borderTop() + ty, 
1284                        m_object->width() - m_object->borderLeft() - m_object->borderRight(),
1285                        m_object->height() - m_object->borderTop() - m_object->borderBottom());
1286     IntRect hCorner;
1287     if (m_hBar && paddingBox.width() - m_hBar->width() > 0) {
1288         hCorner = IntRect(paddingBox.x() + m_hBar->width(),
1289                           paddingBox.y() + paddingBox.height() - m_hBar->height(),
1290                           paddingBox.width() - m_hBar->width(),
1291                           m_hBar->height());
1292         if (hCorner.intersects(damageRect))
1293             p->fillRect(hCorner, Color::white);
1294     }
1295     if (m_vBar && paddingBox.height() - m_vBar->height() > 0) {
1296         IntRect vCorner(paddingBox.x() + paddingBox.width() - m_vBar->width(),
1297                         paddingBox.y() + m_vBar->height(),
1298                         m_vBar->width(),
1299                         paddingBox.height() - m_vBar->height());
1300         if (vCorner != hCorner && vCorner.intersects(damageRect))
1301             p->fillRect(vCorner, Color::white);
1302     }
1303
1304     if (m_object->style()->resize() != RESIZE_NONE)  {
1305         IntRect absBounds(m_object->xPos() + tx, m_object->yPos() + ty, m_object->width(), m_object->height());
1306         IntRect scrollCorner = scrollCornerRect(m_object, absBounds);
1307         if (!scrollCorner.intersects(damageRect))
1308             return;
1309
1310         // Paint the resizer control.
1311         static Image* resizeCornerImage;
1312         if (!resizeCornerImage)
1313             resizeCornerImage = Image::loadPlatformResource("textAreaResizeCorner");
1314         IntPoint imagePoint(scrollCorner.right() - resizeCornerImage->width(), scrollCorner.bottom() - resizeCornerImage->height());
1315         p->drawImage(resizeCornerImage, imagePoint);
1316
1317         // Draw a frame around the resizer (1px grey line) if there are any scrollbars present.
1318         // Clipping will exclude the right and bottom edges of this frame.
1319         if (m_hBar || m_vBar) {
1320             p->save();
1321             scrollCorner.setSize(IntSize(scrollCorner.width() + 1, scrollCorner.height() + 1));
1322             p->setStrokeColor(Color(makeRGB(217, 217, 217)));
1323             p->setStrokeThickness(1.0f);
1324             p->setFillColor(Color::transparent);
1325             p->drawRect(scrollCorner);
1326             p->restore();
1327         }
1328     }
1329 }
1330
1331 bool RenderLayer::isPointInResizeControl(const IntPoint& point)
1332 {
1333     if (!m_object->hasOverflowClip() || m_object->style()->resize() == RESIZE_NONE)
1334         return false;
1335     
1336     int x = 0;
1337     int y = 0;
1338     convertToLayerCoords(root(), x, y);
1339     IntRect absBounds(x, y, m_object->width(), m_object->height());
1340     return scrollCornerRect(m_object, absBounds).contains(point);
1341 }
1342     
1343 bool RenderLayer::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
1344 {
1345     bool didHorizontalScroll = false;
1346     bool didVerticalScroll = false;
1347     
1348     if (m_hBar) {
1349         if (granularity == ScrollByDocument) {
1350             // Special-case for the ScrollByDocument granularity. A document scroll can only be up 
1351             // or down and in both cases the horizontal bar goes all the way to the left.
1352             didHorizontalScroll = m_hBar->scroll(ScrollLeft, ScrollByDocument, multiplier);
1353         } else
1354             didHorizontalScroll = m_hBar->scroll(direction, granularity, multiplier);
1355     }
1356
1357     if (m_vBar)
1358         didVerticalScroll = m_vBar->scroll(direction, granularity, multiplier);
1359
1360     return (didHorizontalScroll || didVerticalScroll);
1361 }
1362
1363 void
1364 RenderLayer::paint(GraphicsContext* p, const IntRect& damageRect, PaintRestriction paintRestriction, RenderObject *paintingRoot)
1365 {
1366     paintLayer(this, p, damageRect, false, paintRestriction, paintingRoot);
1367 }
1368
1369 static void setClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
1370 {
1371     // Work around bugs in focus ring clipping on Mac.
1372     p->setFocusRingClip(clipRect);
1373     if (paintDirtyRect == clipRect)
1374         return;
1375     p->save();
1376     p->clip(clipRect);
1377 }
1378
1379 static void restoreClip(GraphicsContext* p, const IntRect& paintDirtyRect, const IntRect& clipRect)
1380 {
1381     // Work around bugs in focus ring clipping on Mac.
1382     p->clearFocusRingClip();
1383     if (paintDirtyRect == clipRect)
1384         return;
1385     p->restore();
1386 }
1387
1388 void
1389 RenderLayer::paintLayer(RenderLayer* rootLayer, GraphicsContext* p,
1390                         const IntRect& paintDirtyRect, bool haveTransparency, PaintRestriction paintRestriction,
1391                         RenderObject *paintingRoot)
1392 {
1393     // Avoid painting layers when stylesheets haven't loaded.  This eliminates FOUC.
1394     // It's ok not to draw, because later on, when all the stylesheets do load, updateStyleSelector on the Document
1395     // will do a full repaint().
1396     if (renderer()->document()->didLayoutWithPendingStylesheets() && !renderer()->isRenderView() && !renderer()->isRoot())
1397         return;
1398     
1399     // Calculate the clip rects we should use.
1400     IntRect layerBounds, damageRect, clipRectToApply, outlineRect;
1401     calculateRects(rootLayer, paintDirtyRect, layerBounds, damageRect, clipRectToApply, outlineRect);
1402     int x = layerBounds.x();
1403     int y = layerBounds.y();
1404     int tx = x - renderer()->xPos();
1405     int ty = y - renderer()->yPos() + renderer()->borderTopExtra();
1406                              
1407     // Ensure our lists are up-to-date.
1408     updateZOrderLists();
1409     updateOverflowList();
1410
1411     // If this layer is totally invisible then there is nothing to paint.
1412     if (!m_object->opacity())
1413         return;
1414         
1415     bool selectionOnly = paintRestriction == PaintRestrictionSelectionOnly || paintRestriction == PaintRestrictionSelectionOnlyWhiteText;
1416     bool forceWhiteText = paintRestriction == PaintRestrictionSelectionOnlyWhiteText;
1417
1418     if (isTransparent())
1419         haveTransparency = true;
1420
1421     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
1422     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
1423     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
1424     // so it will be tested against as we decend through the renderers.
1425     RenderObject *paintingRootForRenderer = 0;
1426     if (paintingRoot && !m_object->isDescendantOf(paintingRoot))
1427         paintingRootForRenderer = paintingRoot;
1428     
1429     // We want to paint our layer, but only if we intersect the damage rect.
1430     bool shouldPaint = intersectsDamageRect(layerBounds, damageRect);
1431     if (shouldPaint && !selectionOnly && !damageRect.isEmpty()) {
1432         // Begin transparency layers lazily now that we know we have to paint something.
1433         if (haveTransparency)
1434             beginTransparencyLayers(p, paintDirtyRect);
1435         
1436         // Paint our background first, before painting any child layers.
1437         // Establish the clip used to paint our background.
1438         setClip(p, paintDirtyRect, damageRect);
1439
1440         // Paint the background.
1441         RenderObject::PaintInfo paintInfo(p, damageRect, PaintPhaseBlockBackground, false, paintingRootForRenderer, 0);
1442         renderer()->paint(paintInfo, tx, ty);
1443
1444         // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with
1445         // z-index.  We paint after we painted the background/border, so that the scrollbars will
1446         // sit above the background/border.
1447         paintOverflowControls(p, tx, ty, damageRect);
1448         
1449         // Restore the clip.
1450         restoreClip(p, paintDirtyRect, damageRect);
1451     }
1452
1453     // Now walk the sorted list of children with negative z-indices.
1454     if (m_negZOrderList)
1455         for (Vector<RenderLayer*>::iterator it = m_negZOrderList->begin(); it != m_negZOrderList->end(); ++it)
1456             it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot);
1457     
1458     // Now establish the appropriate clip and paint our child RenderObjects.
1459     if (shouldPaint && !clipRectToApply.isEmpty()) {
1460         // Begin transparency layers lazily now that we know we have to paint something.
1461         if (haveTransparency)
1462             beginTransparencyLayers(p, paintDirtyRect);
1463
1464         // Set up the clip used when painting our children.
1465         setClip(p, paintDirtyRect, clipRectToApply);
1466         RenderObject::PaintInfo paintInfo(p, clipRectToApply, 
1467                                           selectionOnly ? PaintPhaseSelection : PaintPhaseChildBlockBackgrounds,
1468                                           forceWhiteText, paintingRootForRenderer, 0);
1469         renderer()->paint(paintInfo, tx, ty);
1470         if (!selectionOnly) {
1471             paintInfo.phase = PaintPhaseFloat;
1472             renderer()->paint(paintInfo, tx, ty);
1473             paintInfo.phase = PaintPhaseForeground;
1474             renderer()->paint(paintInfo, tx, ty);
1475             paintInfo.phase = PaintPhaseChildOutlines;
1476             renderer()->paint(paintInfo, tx, ty);
1477         }
1478
1479         // Now restore our clip.
1480         restoreClip(p, paintDirtyRect, clipRectToApply);
1481     }
1482     
1483     if (!outlineRect.isEmpty()) {
1484         // Paint our own outline
1485         RenderObject::PaintInfo paintInfo(p, outlineRect, PaintPhaseSelfOutline, false, paintingRootForRenderer, 0);
1486         setClip(p, paintDirtyRect, outlineRect);
1487         renderer()->paint(paintInfo, tx, ty);
1488         restoreClip(p, paintDirtyRect, outlineRect);
1489     }
1490     
1491     // Paint any child layers that have overflow.
1492     if (m_overflowList)
1493         for (Vector<RenderLayer*>::iterator it = m_overflowList->begin(); it != m_overflowList->end(); ++it)
1494             it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot);
1495     
1496     // Now walk the sorted list of children with positive z-indices.
1497     if (m_posZOrderList)
1498         for (Vector<RenderLayer*>::iterator it = m_posZOrderList->begin(); it != m_posZOrderList->end(); ++it)
1499             it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot);
1500     
1501     // End our transparency layer
1502     if (isTransparent() && m_usedTransparency) {
1503         p->endTransparencyLayer();
1504         p->restore();
1505         m_usedTransparency = false;
1506     }
1507 }
1508
1509 static inline IntRect frameVisibleRect(RenderObject* renderer)
1510 {
1511     FrameView* frameView = renderer->document()->view();
1512     if (!frameView)
1513         return IntRect();
1514
1515     return enclosingIntRect(frameView->visibleContentRect());
1516 }
1517
1518 bool RenderLayer::hitTest(const HitTestRequest& request, HitTestResult& result)
1519 {
1520     renderer()->document()->updateLayout();
1521     
1522     IntRect boundsRect(m_x, m_y, width(), height());
1523     boundsRect.intersect(frameVisibleRect(renderer()));
1524
1525     RenderLayer* insideLayer = hitTestLayer(this, request, result, boundsRect);
1526
1527     // Now determine if the result is inside an anchor; make sure an image map wins if
1528     // it already set URLElement and only use the innermost.
1529     Node* node = result.innerNode();
1530     while (node) {
1531         // for imagemaps, URLElement is the associated area element not the image itself
1532         if (node->isLink() && !result.URLElement() && !node->hasTagName(imgTag))
1533             result.setURLElement(static_cast<Element*>(node));
1534         node = node->parentNode();
1535     }
1536
1537     // Next set up the correct :hover/:active state along the new chain.
1538     updateHoverActiveState(request, result);
1539     
1540     // Now return whether we were inside this layer (this will always be true for the root
1541     // layer).
1542     return insideLayer;
1543 }
1544
1545 RenderLayer* RenderLayer::hitTestLayer(RenderLayer* rootLayer, const HitTestRequest& request,
1546     HitTestResult& result, const IntRect& hitTestRect)
1547 {
1548     // Calculate the clip rects we should use.
1549     IntRect layerBounds;
1550     IntRect bgRect;
1551     IntRect fgRect;
1552     IntRect outlineRect;
1553     calculateRects(rootLayer, hitTestRect, layerBounds, bgRect, fgRect, outlineRect);
1554     
1555     // Ensure our lists are up-to-date.
1556     updateZOrderLists();
1557     updateOverflowList();
1558
1559     // This variable tracks which layer the mouse ends up being inside.  The minute we find an insideLayer,
1560     // we are done and can return it.
1561     RenderLayer* insideLayer = 0;
1562     
1563     // Begin by walking our list of positive layers from highest z-index down to the lowest
1564     // z-index.
1565     if (m_posZOrderList) {
1566         for (int i = m_posZOrderList->size() - 1; i >= 0; --i) {
1567             insideLayer = m_posZOrderList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect);
1568             if (insideLayer)
1569                 return insideLayer;
1570         }
1571     }
1572
1573     // Now check our overflow objects.
1574     if (m_overflowList) {
1575         for (int i = m_overflowList->size() - 1; i >= 0; --i) {
1576             insideLayer = m_overflowList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect);
1577             if (insideLayer)
1578                 return insideLayer;
1579         }
1580     }
1581
1582     // Next we want to see if the mouse pos is inside the child RenderObjects of the layer.
1583     if (fgRect.contains(result.point()) && 
1584         renderer()->hitTest(request, result, result.point().x(), result.point().y(),
1585                             layerBounds.x() - renderer()->xPos(),
1586                             layerBounds.y() - renderer()->yPos() + m_object->borderTopExtra(), 
1587                             HitTestDescendants)) {
1588         // for positioned generated content, we might still not have a
1589         // node by the time we get to the layer level, since none of
1590         // the content in the layer has an element. So just walk up
1591         // the tree.
1592         if (!result.innerNode()) {
1593             for (RenderObject *r = renderer(); r != NULL; r = r->parent()) { 
1594                 if (r->element()) {
1595                     result.setInnerNode(r->element());
1596                     break;
1597                 }
1598             }
1599         }
1600
1601         if (!result.innerNonSharedNode()) {
1602              for (RenderObject *r = renderer(); r != NULL; r = r->parent()) { 
1603                  if (r->element()) {
1604                      result.setInnerNonSharedNode(r->element());
1605                      break;
1606                  }
1607              }
1608         }
1609         return this;
1610     }
1611         
1612     // Now check our negative z-index children.
1613     if (m_negZOrderList) {
1614         for (int i = m_negZOrderList->size() - 1; i >= 0; --i) {
1615             insideLayer = m_negZOrderList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect);
1616             if (insideLayer)
1617                 return insideLayer;
1618         }
1619     }
1620
1621     // Next we want to see if the mouse is inside this layer but not any of its children.
1622     if (bgRect.contains(result.point()) &&
1623         renderer()->hitTest(request, result, result.point().x(), result.point().y(),
1624                             layerBounds.x() - renderer()->xPos(),
1625                             layerBounds.y() - renderer()->yPos() + m_object->borderTopExtra(),
1626                             HitTestSelf))
1627         return this;
1628
1629     // We didn't hit any layer. If we are the root layer and the mouse is -- or just was -- down, 
1630     // return ourselves. We do this so mouse events continue getting delivered after a drag has 
1631     // exited the WebView, and so hit testing over a scrollbar hits the content document.
1632     if ((request.active || request.mouseUp) && renderer()->isRenderView()) {
1633         renderer()->updateHitTestResult(result, result.point());
1634         return this;
1635     }
1636
1637     return 0;
1638 }
1639
1640 void RenderLayer::calculateClipRects(const RenderLayer* rootLayer)
1641 {
1642     if (m_clipRects)
1643         return; // We have the correct cached value.
1644
1645     if (!parent()) {
1646         // The root layer's clip rect is always just its dimensions.
1647         m_clipRects = new (m_object->renderArena()) ClipRects(IntRect(0,0,width(),height()));
1648         m_clipRects->ref();
1649         return;
1650     }
1651
1652     // Ensure that our parent's clip has been calculated so that we can examine the values.
1653     parent()->calculateClipRects(rootLayer);
1654
1655     // Set up our three rects to initially match the parent rects.
1656     IntRect posClipRect(parent()->clipRects()->posClipRect());
1657     IntRect overflowClipRect(parent()->clipRects()->overflowClipRect());
1658     IntRect fixedClipRect(parent()->clipRects()->fixedClipRect());
1659     bool fixed = parent()->clipRects()->fixed();
1660
1661     // A fixed object is essentially the root of its containing block hierarchy, so when
1662     // we encounter such an object, we reset our clip rects to the fixedClipRect.
1663     if (m_object->style()->position() == FixedPosition) {
1664         posClipRect = fixedClipRect;
1665         overflowClipRect = fixedClipRect;
1666         fixed = true;
1667     }
1668     else if (m_object->style()->position() == RelativePosition)
1669         posClipRect = overflowClipRect;
1670     else if (m_object->style()->position() == AbsolutePosition)
1671         overflowClipRect = posClipRect;
1672     
1673     // Update the clip rects that will be passed to child layers.
1674     if (m_object->hasOverflowClip() || m_object->hasClip()) {
1675         // This layer establishes a clip of some kind.
1676         int x = 0;
1677         int y = 0;
1678         convertToLayerCoords(rootLayer, x, y);
1679         RenderView* view = renderer()->view();
1680         ASSERT(view);
1681         if (view && fixed) {
1682             x -= view->frameView()->contentsX();
1683             y -= view->frameView()->contentsY();
1684         }
1685         
1686         if (m_object->hasOverflowClip()) {
1687             IntRect newOverflowClip = m_object->getOverflowClipRect(x,y);
1688             overflowClipRect.intersect(newOverflowClip);
1689             if (m_object->isPositioned() || m_object->isRelPositioned())
1690                 posClipRect.intersect(newOverflowClip);
1691         }
1692         if (m_object->hasClip()) {
1693             IntRect newPosClip = m_object->getClipRect(x,y);
1694             posClipRect.intersect(newPosClip);
1695             overflowClipRect.intersect(newPosClip);
1696             fixedClipRect.intersect(newPosClip);
1697         }
1698     }
1699     
1700     // If our clip rects match our parent's clip, then we can just share its data structure and
1701     // ref count.
1702     if (fixed == parent()->clipRects()->fixed() &&
1703         posClipRect == parent()->clipRects()->posClipRect() &&
1704         overflowClipRect == parent()->clipRects()->overflowClipRect() &&
1705         fixedClipRect == parent()->clipRects()->fixedClipRect())
1706         m_clipRects = parent()->clipRects();
1707     else
1708         m_clipRects = new (m_object->renderArena()) ClipRects(overflowClipRect, fixedClipRect, posClipRect, fixed);
1709     m_clipRects->ref();
1710 }
1711
1712 void RenderLayer::calculateRects(const RenderLayer* rootLayer, const IntRect& paintDirtyRect, IntRect& layerBounds,
1713                                  IntRect& backgroundRect, IntRect& foregroundRect, IntRect& outlineRect) const
1714 {
1715     if (parent()) {
1716         parent()->calculateClipRects(rootLayer);
1717
1718         backgroundRect = m_object->style()->position() == FixedPosition ? parent()->clipRects()->fixedClipRect() :
1719                          (m_object->isPositioned() ? parent()->clipRects()->posClipRect() : 
1720                                                      parent()->clipRects()->overflowClipRect());
1721         RenderView* view = renderer()->view();
1722         ASSERT(view);
1723         if (view && parent()->clipRects()->fixed())
1724             backgroundRect.move(view->frameView()->contentsX(), view->frameView()->contentsY());
1725
1726         backgroundRect.intersect(paintDirtyRect);
1727     } else
1728         backgroundRect = paintDirtyRect;
1729     foregroundRect = backgroundRect;
1730     outlineRect = backgroundRect;
1731     
1732     int x = 0;
1733     int y = 0;
1734     convertToLayerCoords(rootLayer, x, y);
1735     layerBounds = IntRect(x,y,width(),height());
1736     
1737     // Update the clip rects that will be passed to child layers.
1738     if (m_object->hasOverflowClip() || m_object->hasClip()) {
1739         // This layer establishes a clip of some kind.
1740         if (m_object->hasOverflowClip())
1741             foregroundRect.intersect(m_object->getOverflowClipRect(x,y));
1742         if (m_object->hasClip()) {
1743             // Clip applies to *us* as well, so go ahead and update the damageRect.
1744             IntRect newPosClip = m_object->getClipRect(x,y);
1745             backgroundRect.intersect(newPosClip);
1746             foregroundRect.intersect(newPosClip);
1747             outlineRect.intersect(newPosClip);
1748         }
1749
1750         // If we establish a clip at all, then go ahead and make sure our background
1751         // rect is intersected with our layer's bounds.
1752         backgroundRect.intersect(layerBounds);
1753     }
1754 }
1755
1756 IntRect RenderLayer::childrenClipRect() const
1757 {
1758     RenderLayer* rootLayer = renderer()->document()->renderer()->layer();
1759     IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;
1760     calculateRects(rootLayer, rootLayer->absoluteBoundingBox(), layerBounds, backgroundRect, foregroundRect, outlineRect);
1761     return foregroundRect;
1762 }
1763
1764 IntRect RenderLayer::selfClipRect() const
1765 {
1766     RenderLayer* rootLayer = renderer()->document()->renderer()->layer();
1767     IntRect layerBounds, backgroundRect, foregroundRect, outlineRect;
1768     calculateRects(rootLayer, rootLayer->absoluteBoundingBox(), layerBounds, backgroundRect, foregroundRect, outlineRect);
1769     return backgroundRect;
1770 }
1771
1772 bool RenderLayer::intersectsDamageRect(const IntRect& layerBounds, const IntRect& damageRect) const
1773 {
1774     // Always examine the canvas and the root.
1775     // FIXME: Could eliminate the isRoot() check if we fix background painting so that the RenderView
1776     // paints the root's background.
1777     if (renderer()->isRenderView() || renderer()->isRoot())
1778         return true;
1779
1780     // If we aren't an inline flow, and our layer bounds do intersect the damage rect, then we 
1781     // can go ahead and return true.
1782     RenderView* view = renderer()->view();
1783     ASSERT(view);
1784     if (view && !renderer()->isInlineFlow()) {
1785         IntRect b = layerBounds;
1786         b.inflate(view->maximalOutlineSize());
1787         if (b.intersects(damageRect))
1788             return true;
1789     }
1790         
1791     // Otherwise we need to compute the bounding box of this single layer and see if it intersects
1792     // the damage rect.
1793     return absoluteBoundingBox().intersects(damageRect);
1794 }
1795
1796 IntRect RenderLayer::absoluteBoundingBox() const
1797 {
1798     // There are three special cases we need to consider.
1799     // (1) Inline Flows.  For inline flows we will create a bounding box that fully encompasses all of the lines occupied by the
1800     // inline.  In other words, if some <span> wraps to three lines, we'll create a bounding box that fully encloses the root
1801     // line boxes of all three lines (including overflow on those lines).
1802     // (2) Left/Top Overflow.  The width/height of layers already includes right/bottom overflow.  However, in the case of left/top
1803     // overflow, we have to create a bounding box that will extend to include this overflow.
1804     // (3) Floats.  When a layer has overhanging floats that it paints, we need to make sure to include these overhanging floats
1805     // as part of our bounding box.  We do this because we are the responsible layer for both hit testing and painting those
1806     // floats.
1807     IntRect result;
1808     if (renderer()->isInlineFlow()) {
1809         // Go from our first line box to our last line box.
1810         RenderInline* inlineFlow = static_cast<RenderInline*>(renderer());
1811         InlineFlowBox* firstBox = inlineFlow->firstLineBox();
1812         if (!firstBox)
1813             return result;
1814         int top = firstBox->root()->topOverflow();
1815         int bottom = inlineFlow->lastLineBox()->root()->bottomOverflow();
1816         int left = firstBox->xPos();
1817         for (InlineRunBox* curr = firstBox->nextLineBox(); curr; curr = curr->nextLineBox())
1818             left = min(left, curr->xPos());
1819         result = IntRect(m_x + left, m_y + (top - renderer()->yPos()), width(), bottom - top);
1820     } else if (renderer()->isTableRow()) {
1821         // Our bounding box is just the union of all of our cells' border/overflow rects.
1822         for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) {
1823             if (child->isTableCell()) {
1824                 IntRect bbox = child->borderBox();
1825                 bbox.move(0, child->borderTopExtra());
1826                 result.unite(bbox);
1827                 IntRect overflowRect = renderer()->overflowRect(false);
1828                 overflowRect.move(0, child->borderTopExtra());
1829                 if (bbox != overflowRect)
1830                     result.unite(overflowRect);
1831             }
1832         }
1833         result.move(m_x, m_y);
1834     } else {
1835         IntRect bbox = renderer()->borderBox();
1836         result = bbox;
1837         IntRect overflowRect = renderer()->overflowRect(false);
1838         if (bbox != overflowRect)
1839             result.unite(overflowRect);
1840         
1841         // We have to adjust the x/y of this result so that it is in the coordinate space of the layer.
1842         // We also have to add in borderTopExtra here, since borderBox(), in order to play well with methods like
1843         // floatRect that deal with child content, uses an origin of (0,0) that is at the child content box (so
1844         // border box returns a y coord of -borderTopExtra().  The layer, however, uses the outer box.  This is all
1845         // really confusing.
1846         result.move(m_x, m_y + renderer()->borderTopExtra());
1847     }
1848     
1849     // Convert the bounding box to an absolute position.  We can do this easily by looking at the delta
1850     // between the bounding box's xpos and our layer's xpos and then applying that to the absolute layerBounds
1851     // passed in.
1852     int absX = 0, absY = 0;
1853     convertToLayerCoords(root(), absX, absY);
1854     result.move(absX - m_x, absY - m_y);
1855     RenderView* view = renderer()->view();
1856     ASSERT(view);
1857     if (view)
1858         result.inflate(view->maximalOutlineSize());
1859     return result;
1860 }
1861
1862 void RenderLayer::clearClipRects()
1863 {
1864     if (!m_clipRects)
1865         return;
1866
1867     clearClipRect();
1868     
1869     for (RenderLayer* l = firstChild(); l; l = l->nextSibling())
1870         l->clearClipRects();
1871 }
1872
1873 void RenderLayer::clearClipRect()
1874 {
1875     if (m_clipRects) {
1876         m_clipRects->deref(m_object->renderArena());
1877         m_clipRects = 0;
1878     }
1879 }
1880
1881 static RenderObject* commonAncestor(RenderObject* obj1, RenderObject* obj2)
1882 {
1883     if (!obj1 || !obj2)
1884         return 0;
1885
1886     for (RenderObject* currObj1 = obj1; currObj1; currObj1 = currObj1->hoverAncestor())
1887         for (RenderObject* currObj2 = obj2; currObj2; currObj2 = currObj2->hoverAncestor())
1888             if (currObj1 == currObj2)
1889                 return currObj1;
1890
1891     return 0;
1892 }
1893
1894 void RenderLayer::updateHoverActiveState(const HitTestRequest& request, HitTestResult& result)
1895 {
1896     // We don't update :hover/:active state when the result is marked as readonly.
1897     if (request.readonly)
1898         return;
1899
1900     Document* doc = renderer()->document();
1901     if (!doc) return;
1902
1903     Node* activeNode = doc->activeNode();
1904     if (activeNode && !request.active) {
1905         // We are clearing the :active chain because the mouse has been released.
1906         for (RenderObject* curr = activeNode->renderer(); curr; curr = curr->parent()) {
1907             if (curr->element() && !curr->isText())
1908                 curr->element()->setInActiveChain(false);
1909         }
1910         doc->setActiveNode(0);
1911     } else {
1912         Node* newActiveNode = result.innerNode();
1913         if (!activeNode && newActiveNode && request.active) {
1914             // We are setting the :active chain and freezing it. If future moves happen, they
1915             // will need to reference this chain.
1916             for (RenderObject* curr = newActiveNode->renderer(); curr; curr = curr->parent()) {
1917                 if (curr->element() && !curr->isText()) {
1918                     curr->element()->setInActiveChain(true);
1919                 }
1920             }
1921             doc->setActiveNode(newActiveNode);
1922         }
1923     }
1924
1925     // If the mouse is down and if this is a mouse move event, we want to restrict changes in 
1926     // :hover/:active to only apply to elements that are in the :active chain that we froze
1927     // at the time the mouse went down.
1928     bool mustBeInActiveChain = request.active && request.mouseMove;
1929
1930     // Check to see if the hovered node has changed.  If not, then we don't need to
1931     // do anything.  
1932     RefPtr<Node> oldHoverNode = doc->hoverNode();
1933     Node* newHoverNode = result.innerNode();
1934
1935     // Update our current hover node.
1936     doc->setHoverNode(newHoverNode);
1937
1938     // We have two different objects.  Fetch their renderers.
1939     RenderObject* oldHoverObj = oldHoverNode ? oldHoverNode->renderer() : 0;
1940     RenderObject* newHoverObj = newHoverNode ? newHoverNode->renderer() : 0;
1941     
1942     // Locate the common ancestor render object for the two renderers.
1943     RenderObject* ancestor = commonAncestor(oldHoverObj, newHoverObj);
1944
1945     if (oldHoverObj != newHoverObj) {
1946         // The old hover path only needs to be cleared up to (and not including) the common ancestor;
1947         for (RenderObject* curr = oldHoverObj; curr && curr != ancestor; curr = curr->hoverAncestor()) {
1948             if (curr->element() && !curr->isText() && (!mustBeInActiveChain || curr->element()->inActiveChain())) {
1949                 curr->element()->setActive(false);
1950                 curr->element()->setHovered(false);
1951             }
1952         }
1953     }
1954
1955     // Now set the hover state for our new object up to the root.
1956     for (RenderObject* curr = newHoverObj; curr; curr = curr->hoverAncestor()) {
1957         if (curr->element() && !curr->isText() && (!mustBeInActiveChain || curr->element()->inActiveChain())) {
1958             curr->element()->setActive(request.active);
1959             curr->element()->setHovered(true);
1960         }
1961     }
1962 }
1963
1964 // Helper for the sorting of layers by z-index.
1965 static inline bool compareZIndex(RenderLayer* first, RenderLayer* second)
1966 {
1967     return first->zIndex() < second->zIndex();
1968 }
1969
1970 void RenderLayer::dirtyZOrderLists()
1971 {
1972     if (m_posZOrderList)
1973         m_posZOrderList->clear();
1974     if (m_negZOrderList)
1975         m_negZOrderList->clear();
1976     m_zOrderListsDirty = true;
1977 }
1978
1979 void RenderLayer::dirtyOverflowList()
1980 {
1981     if (m_overflowList)
1982         m_overflowList->clear();
1983     m_overflowListDirty = true;
1984 }
1985
1986 void RenderLayer::updateZOrderLists()
1987 {
1988     if (!isStackingContext() || !m_zOrderListsDirty)
1989         return;
1990         
1991     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
1992         child->collectLayers(m_posZOrderList, m_negZOrderList);
1993
1994     // Sort the two lists.
1995     if (m_posZOrderList)
1996         std::stable_sort(m_posZOrderList->begin(), m_posZOrderList->end(), compareZIndex);
1997     if (m_negZOrderList)
1998         std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(), compareZIndex);
1999
2000     m_zOrderListsDirty = false;
2001 }
2002
2003 void RenderLayer::updateOverflowList()
2004 {
2005     if (!m_overflowListDirty)
2006         return;
2007         
2008     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
2009         if (child->isOverflowOnly()) {
2010             if (!m_overflowList)
2011                 m_overflowList = new Vector<RenderLayer*>;
2012             m_overflowList->append(child);
2013         }
2014     }
2015     
2016     m_overflowListDirty = false;
2017 }
2018
2019 void RenderLayer::collectLayers(Vector<RenderLayer*>*& posBuffer, Vector<RenderLayer*>*& negBuffer)
2020 {
2021     updateVisibilityStatus();
2022         
2023     // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
2024     if (m_hasVisibleContent && !isOverflowOnly()) {
2025         // Determine which buffer the child should be in.
2026         Vector<RenderLayer*>*& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
2027
2028         // Create the buffer if it doesn't exist yet.
2029         if (!buffer)
2030             buffer = new Vector<RenderLayer*>;
2031         
2032         // Append ourselves at the end of the appropriate buffer.
2033         buffer->append(this);
2034     }
2035
2036     // Recur into our children to collect more layers, but only if we don't establish
2037     // a stacking context.
2038     if (m_hasVisibleDescendant && !isStackingContext())
2039         for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
2040             child->collectLayers(posBuffer, negBuffer);
2041 }
2042
2043 void RenderLayer::repaintIncludingDescendants()
2044 {
2045     m_object->repaint();
2046     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling())
2047         curr->repaintIncludingDescendants();
2048 }
2049
2050 bool RenderLayer::shouldBeOverflowOnly() const
2051 {
2052     return renderer()->hasOverflowClip() && 
2053            !renderer()->isPositioned() &&
2054            !renderer()->isRelPositioned() &&
2055            !isTransparent();
2056 }
2057
2058 void RenderLayer::styleChanged()
2059 {
2060     bool isOverflowOnly = shouldBeOverflowOnly();
2061     if (isOverflowOnly != m_isOverflowOnly) {
2062         m_isOverflowOnly = isOverflowOnly;
2063         RenderLayer* p = parent();
2064         RenderLayer* sc = stackingContext();
2065         if (p)
2066             p->dirtyOverflowList();
2067         if (sc)
2068             sc->dirtyZOrderLists();
2069     }
2070
2071     if (m_object->style()->overflowX() == OMARQUEE && m_object->style()->marqueeBehavior() != MNONE) {
2072         if (!m_marquee)
2073             m_marquee = new Marquee(this);
2074         m_marquee->updateMarqueeStyle();
2075     }
2076     else if (m_marquee) {
2077         delete m_marquee;
2078         m_marquee = 0;
2079     }
2080 }
2081
2082 void RenderLayer::suspendMarquees()
2083 {
2084     if (m_marquee)
2085         m_marquee->suspend();
2086     
2087     for (RenderLayer* curr = firstChild(); curr; curr = curr->nextSibling())
2088         curr->suspendMarquees();
2089 }
2090
2091 // --------------------------------------------------------------------------
2092 // Marquee implementation
2093
2094 Marquee::Marquee(RenderLayer* l)
2095     : m_layer(l), m_currentLoop(0)
2096     , m_totalLoops(0)
2097     , m_timer(this, &Marquee::timerFired)
2098     , m_start(0), m_end(0), m_speed(0), m_reset(false)
2099     , m_suspended(false), m_stopped(false), m_direction(MAUTO)
2100 {
2101 }
2102
2103 int Marquee::marqueeSpeed() const
2104 {
2105     int result = m_layer->renderer()->style()->marqueeSpeed();
2106     Node* elt = m_layer->renderer()->element();
2107     if (elt && elt->hasTagName(marqueeTag)) {
2108         HTMLMarqueeElement* marqueeElt = static_cast<HTMLMarqueeElement*>(elt);
2109         result = max(result, marqueeElt->minimumDelay());
2110     }
2111     return result;
2112 }
2113
2114 EMarqueeDirection Marquee::direction() const
2115 {
2116     // FIXME: Support the CSS3 "auto" value for determining the direction of the marquee.
2117     // For now just map MAUTO to MBACKWARD
2118     EMarqueeDirection result = m_layer->renderer()->style()->marqueeDirection();
2119     TextDirection dir = m_layer->renderer()->style()->direction();
2120     if (result == MAUTO)
2121         result = MBACKWARD;
2122     if (result == MFORWARD)
2123         result = (dir == LTR) ? MRIGHT : MLEFT;
2124     if (result == MBACKWARD)
2125         result = (dir == LTR) ? MLEFT : MRIGHT;
2126     
2127     // Now we have the real direction.  Next we check to see if the increment is negative.
2128     // If so, then we reverse the direction.
2129     Length increment = m_layer->renderer()->style()->marqueeIncrement();
2130     if (increment.isNegative())
2131         result = static_cast<EMarqueeDirection>(-result);
2132     
2133     return result;
2134 }
2135
2136 bool Marquee::isHorizontal() const
2137 {
2138     return direction() == MLEFT || direction() == MRIGHT;
2139 }
2140
2141 int Marquee::computePosition(EMarqueeDirection dir, bool stopAtContentEdge)
2142 {
2143     RenderObject* o = m_layer->renderer();
2144     RenderStyle* s = o->style();
2145     if (isHorizontal()) {
2146         bool ltr = s->direction() == LTR;
2147         int clientWidth = o->clientWidth();
2148         int contentWidth = ltr ? o->rightmostPosition(true, false) : o->leftmostPosition(true, false);
2149         if (ltr)
2150             contentWidth += (o->paddingRight() - o->borderLeft());
2151         else {
2152             contentWidth = o->width() - contentWidth;
2153             contentWidth += (o->paddingLeft() - o->borderRight());
2154         }
2155         if (dir == MRIGHT) {
2156             if (stopAtContentEdge)
2157                 return max(0, ltr ? (contentWidth - clientWidth) : (clientWidth - contentWidth));
2158             else
2159                 return ltr ? contentWidth : clientWidth;
2160         }
2161         else {
2162             if (stopAtContentEdge)
2163                 return min(0, ltr ? (contentWidth - clientWidth) : (clientWidth - contentWidth));
2164             else
2165                 return ltr ? -clientWidth : -contentWidth;
2166         }
2167     }
2168     else {
2169         int contentHeight = m_layer->renderer()->lowestPosition(true, false) - 
2170                             m_layer->renderer()->borderTop() + m_layer->renderer()->paddingBottom();
2171         int clientHeight = m_layer->renderer()->clientHeight();
2172         if (dir == MUP) {
2173             if (stopAtContentEdge)
2174                  return min(contentHeight - clientHeight, 0);
2175             else
2176                 return -clientHeight;
2177         }
2178         else {
2179             if (stopAtContentEdge)
2180                 return max(contentHeight - clientHeight, 0);
2181             else 
2182                 return contentHeight;
2183         }
2184     }    
2185 }
2186
2187 void Marquee::start()
2188 {
2189     if (m_timer.isActive() || m_layer->renderer()->style()->marqueeIncrement().isZero())
2190         return;
2191     
2192     if (!m_suspended && !m_stopped) {
2193         if (isHorizontal())
2194             m_layer->scrollToOffset(m_start, 0, false, false);
2195         else
2196             m_layer->scrollToOffset(0, m_start, false, false);
2197     }
2198     else {
2199         m_suspended = false;
2200         m_stopped = false;
2201     }
2202
2203     m_timer.startRepeating(speed() * 0.001);
2204 }
2205
2206 void Marquee::suspend()
2207 {
2208     m_timer.stop();
2209     m_suspended = true;
2210 }
2211
2212 void Marquee::stop()
2213 {
2214     m_timer.stop();
2215     m_stopped = true;
2216 }
2217
2218 void Marquee::updateMarqueePosition()
2219 {
2220     bool activate = (m_totalLoops <= 0 || m_currentLoop < m_totalLoops);
2221     if (activate) {
2222         EMarqueeBehavior behavior = m_layer->renderer()->style()->marqueeBehavior();
2223         m_start = computePosition(direction(), behavior == MALTERNATE);
2224         m_end = computePosition(reverseDirection(), behavior == MALTERNATE || behavior == MSLIDE);
2225         if (!m_stopped)
2226             start();
2227     }
2228 }
2229
2230 void Marquee::updateMarqueeStyle()
2231 {
2232     RenderStyle* s = m_layer->renderer()->style();
2233     
2234     if (m_direction != s->marqueeDirection() || (m_totalLoops != s->marqueeLoopCount() && m_currentLoop >= m_totalLoops))
2235         m_currentLoop = 0; // When direction changes or our loopCount is a smaller number than our current loop, reset our loop.
2236     
2237     m_totalLoops = s->marqueeLoopCount();
2238     m_direction = s->marqueeDirection();
2239     
2240     if (m_layer->renderer()->isHTMLMarquee()) {
2241         // Hack for WinIE.  In WinIE, a value of 0 or lower for the loop count for SLIDE means to only do
2242         // one loop.
2243         if (m_totalLoops <= 0 && s->marqueeBehavior() == MSLIDE)
2244             m_totalLoops = 1;
2245         
2246         // Hack alert: Set the white-space value to nowrap for horizontal marquees with inline children, thus ensuring
2247         // all the text ends up on one line by default.  Limit this hack to the <marquee> element to emulate
2248         // WinIE's behavior.  Someone using CSS3 can use white-space: nowrap on their own to get this effect.
2249         // Second hack alert: Set the text-align back to auto.  WinIE completely ignores text-align on the
2250         // marquee element.
2251         // FIXME: Bring these up with the CSS WG.
2252         if (isHorizontal() && m_layer->renderer()->childrenInline()) {
2253             s->setWhiteSpace(NOWRAP);
2254             s->setTextAlign(TAAUTO);
2255         }
2256     }
2257     
2258     // Marquee height hack!! Make sure that, if it is a horizontal marquee, the height attribute is overridden 
2259     // if it is smaller than the font size. If it is a vertical marquee and height is not specified, we default
2260     // to a marquee of 200px.
2261     if (isHorizontal()) {
2262         if (s->height().isFixed() && s->height().value() < s->fontSize())
2263             s->setHeight(Length(s->fontSize(),Fixed));
2264     } else if (s->height().isAuto())  //vertical marquee with no specified height
2265         s->setHeight(Length(200, Fixed)); 
2266    
2267     if (speed() != marqueeSpeed()) {
2268         m_speed = marqueeSpeed();
2269         if (m_timer.isActive())
2270             m_timer.startRepeating(speed() * 0.001);
2271     }
2272     
2273     // Check the loop count to see if we should now stop.
2274     bool activate = (m_totalLoops <= 0 || m_currentLoop < m_totalLoops);
2275     if (activate && !m_timer.isActive())
2276         m_layer->renderer()->setNeedsLayout(true);
2277     else if (!activate && m_timer.isActive())
2278         m_timer.stop();
2279 }
2280
2281 void Marquee::timerFired(Timer<Marquee>*)
2282 {
2283     if (m_layer->renderer()->needsLayout())
2284         return;
2285     
2286     if (m_reset) {
2287         m_reset = false;
2288         if (isHorizontal())
2289             m_layer->scrollToXOffset(m_start);
2290         else
2291             m_layer->scrollToYOffset(m_start);
2292         return;
2293     }
2294     
2295     RenderStyle* s = m_layer->renderer()->style();
2296     
2297     int endPoint = m_end;
2298     int range = m_end - m_start;
2299     int newPos;
2300     if (range == 0)
2301         newPos = m_end;
2302     else {  
2303         bool addIncrement = direction() == MUP || direction() == MLEFT;
2304         bool isReversed = s->marqueeBehavior() == MALTERNATE && m_currentLoop % 2;
2305         if (isReversed) {
2306             // We're going in the reverse direction.
2307             endPoint = m_start;
2308             range = -range;
2309             addIncrement = !addIncrement;
2310         }
2311         bool positive = range > 0;
2312         int clientSize = (isHorizontal() ? m_layer->renderer()->clientWidth() : m_layer->renderer()->clientHeight());
2313         int increment = max(1, abs(m_layer->renderer()->style()->marqueeIncrement().calcValue(clientSize)));
2314         int currentPos = (isHorizontal() ? m_layer->scrollXOffset() : m_layer->scrollYOffset());
2315         newPos =  currentPos + (addIncrement ? increment : -increment);
2316         if (positive)
2317             newPos = min(newPos, endPoint);
2318         else
2319             newPos = max(newPos, endPoint);
2320     }
2321
2322     if (newPos == endPoint) {
2323         m_currentLoop++;
2324         if (m_totalLoops > 0 && m_currentLoop >= m_totalLoops)
2325             m_timer.stop();
2326         else if (s->marqueeBehavior() != MALTERNATE)
2327             m_reset = true;
2328     }
2329     
2330     if (isHorizontal())
2331         m_layer->scrollToXOffset(newPos);
2332     else
2333         m_layer->scrollToYOffset(newPos);
2334 }
2335
2336 } // namespace WebCore