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