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