WebCore/page/FrameView.cpp

   1 /* This file is part of the KDE project
   2  *
   3  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
   4  *                     1999 Lars Knoll <knoll@kde.org>
   5  *                     1999 Antti Koivisto <koivisto@kde.org>
   6  *                     2000 Dirk Mueller <mueller@kde.org>
   7  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.
   8  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Library General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Library General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Library General Public License
  21  * along with this library; see the file COPYING.LIB.  If not, write to
  22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23  * Boston, MA 02111-1307, USA.
  24  */
  25
  26 #include "config.h"
  27 #include "FrameView.h"
  28
  29 #include "AXObjectCache.h"
  30 #include "CachedImage.h"
  31 #include "Cursor.h"
  32 #include "EventNames.h"
  33 #include "Frame.h"
  34 #include "FrameTree.h"
  35 #include "HTMLDocument.h"
  36 #include "HTMLFrameSetElement.h"
  37 #include "HTMLInputElement.h"
  38 #include "HTMLNames.h"
  39 #include "Image.h"
  40 #include "MouseEvent.h"
  41 #include "MouseEventWithHitTestResults.h"
  42 #include "OverflowEvent.h"
  43 #include "PlatformKeyboardEvent.h"
  44 #include "PlatformScrollBar.h"
  45 #include "PlatformWheelEvent.h"
  46 #include "RenderArena.h"
  47 #include "RenderPart.h"
  48 #include "RenderText.h"
  49 #include "RenderView.h"
  50 #include "SelectionController.h"
  51 #include "Settings.h"
  52 #include "cssstyleselector.h"
  53
  54 #ifdef SVG_SUPPORT
  55 #include "XLinkNames.h"
  56 #include "SVGNames.h"
  57 #include "SVGCursorElement.h"
  58 #include "SVGLength.h"
  59 #endif
  60
  61 namespace WebCore {
  62
  63 using namespace EventNames;
  64 using namespace HTMLNames;
  65 #ifdef SVG_SUPPORT
  66 using namespace SVGNames;
  67 #endif
  68
  69 struct ScheduledEvent {
  70     RefPtr<Event> m_event;
  71     RefPtr<EventTargetNode> m_eventTarget;
  72     bool m_tempEvent;
  73 };
  74
  75 class FrameViewPrivate {
  76 public:
  77     FrameViewPrivate(FrameView* view)
  78         : m_hasBorder(false)
  79         , layoutTimer(view, &FrameView::layoutTimerFired)
  80         , hoverTimer(view, &FrameView::hoverTimerFired)
  81         , m_resizeLayer(0)
  82         , m_mediaType("screen")
  83         , m_scheduledEvents(0)
  84         , m_overflowStatusDirty(true)
  85         , m_viewportRenderer(0)
  86     {
  87         repaintRects = 0;
  88         isTransparent = false;
  89         baseBackgroundColor = Color::white;
  90         vmode = hmode = ScrollBarAuto;
  91         needToInitScrollBars = true;
  92         reset();
  93     }
  94     ~FrameViewPrivate()
  95     {
  96         delete repaintRects;
  97         delete m_scheduledEvents;
  98     }
  99     void reset()
 100     {
 101         underMouse = 0;
 102         oldUnder = 0;
 103         oldSubframe = 0;
 104         oldScrollBar = 0;
 105         linkPressed = false;
 106         useSlowRepaints = false;
 107         slowRepaintObjectCount = 0;
 108         dragTarget = 0;
 109         borderTouched = false;
 110         scrollBarMoved = false;
 111         ignoreWheelEvents = false;
 112         borderX = 30;
 113         borderY = 30;
 114         clickCount = 0;
 115         clickNode = 0;
 116         scrollingSelf = false;
 117         layoutTimer.stop();
 118         layoutRoot = 0;
 119         delayedLayout = false;
 120         mousePressed = false;
 121         doFullRepaint = true;
 122         layoutSchedulingEnabled = true;
 123         layoutCount = 0;
 124         firstLayout = true;
 125         hoverTimer.stop();
 126         if (repaintRects)
 127             repaintRects->clear();
 128         resizingFrameSet = 0;
 129         m_resizeLayer = 0;
 130         m_currentMousePosition = IntPoint();
 131     }
 132
 133     RefPtr<Node> underMouse;
 134     RefPtr<Node> oldUnder;
 135     RefPtr<Frame> oldSubframe;
 136     RefPtr<PlatformScrollBar> oldScrollBar;
 137
 138     bool borderTouched : 1;
 139     bool borderStart : 1;
 140     bool scrollBarMoved : 1;
 141     bool doFullRepaint : 1;
 142     bool m_hasBorder : 1;
 143
 144     ScrollBarMode vmode;
 145     ScrollBarMode hmode;
 146     bool linkPressed;
 147     bool useSlowRepaints;
 148     unsigned slowRepaintObjectCount;
 149     bool ignoreWheelEvents;
 150
 151     int borderX, borderY;
 152     int clickCount;
 153     RefPtr<Node> clickNode;
 154
 155     bool scrollingSelf;
 156     Timer<FrameView> layoutTimer;
 157     bool delayedLayout;
 158     RefPtr<Node> layoutRoot;
 159
 160     bool layoutSchedulingEnabled;
 161     int layoutCount;
 162
 163     bool firstLayout;
 164     bool needToInitScrollBars;
 165     bool mousePressed;
 166     bool isTransparent;
 167     Color baseBackgroundColor;
 168
 169     Timer<FrameView> hoverTimer;
 170
 171     RenderLayer* m_resizeLayer;
 172     IntSize offsetFromResizeCorner;
 173
 174     // Used by objects during layout to communicate repaints that need to take place only
 175     // after all layout has been completed.
 176     DeprecatedPtrList<RenderObject::RepaintInfo>* repaintRects;
 177
 178     RefPtr<Node> dragTarget;
 179     RefPtr<HTMLFrameSetElement> resizingFrameSet;
 180
 181     String m_mediaType;
 182
 183     Vector<ScheduledEvent*>* m_scheduledEvents;
 184
 185     bool m_overflowStatusDirty;
 186     bool horizontalOverflow;
 187     bool m_verticalOverflow;
 188     RenderObject* m_viewportRenderer;
 189
 190     IntPoint m_currentMousePosition;
 191 };
 192
 193 FrameView::FrameView(Frame *frame)
 194     : m_refCount(1)
 195     , m_frame(frame)
 196     , d(new FrameViewPrivate(this))
 197 {
 198     init();
 199
 200     show();
 201 }
 202
 203 FrameView::~FrameView()
 204 {
 205     resetScrollBars();
 206
 207     ASSERT(m_refCount == 0);
 208
 209     if (d->hoverTimer.isActive())
 210         d->hoverTimer.stop();
 211     if (m_frame) {
 212         // FIXME: Is this really the right place to call detach on the document?
 213         if (Document* doc = m_frame->document())
 214             doc->detach();
 215         if (RenderPart* renderer = m_frame->ownerRenderer())
 216             renderer->setWidget(0);
 217     }
 218
 219     delete d;
 220     d = 0;
 221 }
 222
 223 bool FrameView::isFrameView() const
 224 {
 225     return true;
 226 }
 227
 228 void FrameView::clearPart()
 229 {
 230     m_frame = 0;
 231 }
 232
 233 void FrameView::resetScrollBars()
 234 {
 235     // Reset the document's scrollbars back to our defaults before we yield the floor.
 236     d->firstLayout = true;
 237     suppressScrollBars(true);
 238     ScrollView::setVScrollBarMode(d->vmode);
 239     ScrollView::setHScrollBarMode(d->hmode);
 240     suppressScrollBars(false);
 241 }
 242
 243 void FrameView::init()
 244 {
 245     m_margins = IntSize(-1, -1); // undefined
 246     m_size = IntSize();
 247 }
 248
 249 void FrameView::clear()
 250 {
 251     setStaticBackground(false);
 252
 253     m_frame->selectionController()->clear();
 254
 255     d->reset();
 256
 257 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
 258     if (d->layoutTimer.isActive() && m_frame->document() && !m_frame->document()->ownerElement())
 259         printf("Killing the layout timer from a clear at %d\n", m_frame->document()->elapsedTime());
 260 #endif
 261     d->layoutTimer.stop();
 262
 263     cleared();
 264
 265     suppressScrollBars(true);
 266 }
 267
 268 bool FrameView::didFirstLayout() const
 269 {
 270     return !d->firstLayout;
 271 }
 272
 273 void FrameView::initScrollBars()
 274 {
 275     if (!d->needToInitScrollBars)
 276         return;
 277     d->needToInitScrollBars = false;
 278     setScrollBarsMode(hScrollBarMode());
 279 }
 280
 281 void FrameView::setMarginWidth(int w)
 282 {
 283     // make it update the rendering area when set
 284     m_margins.setWidth(w);
 285 }
 286
 287 void FrameView::setMarginHeight(int h)
 288 {
 289     // make it update the rendering area when set
 290     m_margins.setHeight(h);
 291 }
 292
 293 void FrameView::adjustViewSize()
 294 {
 295     if (m_frame->document()) {
 296         Document *document = m_frame->document();
 297
 298         RenderView* root = static_cast<RenderView *>(document->renderer());
 299         if (!root)
 300             return;
 301
 302         int docw = root->docWidth();
 303         int doch = root->docHeight();
 304
 305         resizeContents(docw, doch);
 306     }
 307 }
 308
 309 void FrameView::applyOverflowToViewport(RenderObject* o, ScrollBarMode& hMode, ScrollBarMode& vMode)
 310 {
 311     // Handle the overflow:hidden/scroll case for the body/html elements.  WinIE treats
 312     // overflow:hidden and overflow:scroll on <body> as applying to the document's
 313     // scrollbars.  The CSS2.1 draft states that HTML UAs should use the <html> or <body> element and XML/XHTML UAs should
 314     // use the root element.
 315     switch (o->style()->overflowX()) {
 316         case OHIDDEN:
 317             hMode = ScrollBarAlwaysOff;
 318             break;
 319         case OSCROLL:
 320             hMode = ScrollBarAlwaysOn;
 321             break;
 322         case OAUTO:
 323             hMode = ScrollBarAuto;
 324             break;
 325         default:
 326             // Don't set it at all.
 327             ;
 328     }
 329
 330      switch (o->style()->overflowY()) {
 331         case OHIDDEN:
 332             vMode = ScrollBarAlwaysOff;
 333             break;
 334         case OSCROLL:
 335             vMode = ScrollBarAlwaysOn;
 336             break;
 337         case OAUTO:
 338             vMode = ScrollBarAuto;
 339             break;
 340         default:
 341             // Don't set it at all.
 342             ;
 343     }
 344
 345     d->m_viewportRenderer = o;
 346 }
 347
 348 int FrameView::layoutCount() const
 349 {
 350     return d->layoutCount;
 351 }
 352
 353 bool FrameView::needsFullRepaint() const
 354 {
 355     return d->doFullRepaint;
 356 }
 357
 358 void FrameView::addRepaintInfo(RenderObject* o, const IntRect& r)
 359 {
 360     if (!d->repaintRects) {
 361         d->repaintRects = new DeprecatedPtrList<RenderObject::RepaintInfo>;
 362         d->repaintRects->setAutoDelete(true);
 363     }
 364
 365     d->repaintRects->append(new RenderObject::RepaintInfo(o, r));
 366 }
 367
 368 Node* FrameView::layoutRoot() const
 369 {
 370     return layoutPending() ? 0 : d->layoutRoot.get();
 371 }
 372
 373 void FrameView::layout(bool allowSubtree)
 374 {
 375     d->layoutTimer.stop();
 376     d->delayedLayout = false;
 377
 378     // Protect the view from being deleted during layout (in recalcStyle)
 379     RefPtr<FrameView> protector(this);
 380
 381     if (!m_frame) {
 382         // FIXME: Do we need to set m_size.width here?
 383         // FIXME: Should we set m_size.height here too?
 384         m_size.setWidth(visibleWidth());
 385         return;
 386     }
 387
 388     if (!allowSubtree && d->layoutRoot) {
 389         if (d->layoutRoot->renderer())
 390             d->layoutRoot->renderer()->markContainingBlocksForLayout(false);
 391         d->layoutRoot = 0;
 392     }
 393
 394     bool subtree = d->layoutRoot;
 395     Document* document = m_frame->document();
 396     if (!document) {
 397         // FIXME: Should we set m_size.height here too?
 398         m_size.setWidth(visibleWidth());
 399         return;
 400     }
 401
 402     Node* rootNode = subtree ? d->layoutRoot.get() : document;
 403     d->layoutSchedulingEnabled = false;
 404
 405     // Always ensure our style info is up-to-date.  This can happen in situations where
 406     // the layout beats any sort of style recalc update that needs to occur.
 407     if (document->hasChangedChild())
 408         document->recalcStyle();
 409
 410     // If there is only one ref to this view left, then its going to be destroyed as soon as we exit,
 411     // so there's no point to continuiing to layout
 412     if (protector->hasOneRef())
 413         return;
 414
 415     RenderObject* root = rootNode->renderer();
 416     if (!root) {
 417         // FIXME: Do we need to set m_size here?
 418         d->layoutSchedulingEnabled = true;
 419         return;
 420     }
 421
 422     ScrollBarMode hMode = d->hmode;
 423     ScrollBarMode vMode = d->vmode;
 424
 425     if (!subtree) {
 426         Document* document = static_cast<Document*>(rootNode);
 427         RenderObject* rootRenderer = document->documentElement() ? document->documentElement()->renderer() : 0;
 428         if (document->isHTMLDocument()) {
 429             Node *body = static_cast<HTMLDocument*>(document)->body();
 430             if (body && body->renderer()) {
 431                 if (body->hasTagName(framesetTag)) {
 432                     body->renderer()->setNeedsLayout(true);
 433                     vMode = ScrollBarAlwaysOff;
 434                     hMode = ScrollBarAlwaysOff;
 435                 } else if (body->hasTagName(bodyTag)) {
 436                     if (!d->firstLayout && m_size.height() != visibleHeight() && static_cast<RenderBox*>(body->renderer())->stretchesToViewHeight())
 437                         body->renderer()->setChildNeedsLayout(true);
 438                     // It's sufficient to just check one overflow direction, since it's illegal to have visible in only one direction.
 439                     RenderObject* o = rootRenderer->style()->overflowX() == OVISIBLE ? body->renderer() : rootRenderer;
 440                     applyOverflowToViewport(o, hMode, vMode); // Only applies to HTML UAs, not to XML/XHTML UAs
 441                 }
 442             }
 443         } else if (rootRenderer)
 444             applyOverflowToViewport(rootRenderer, hMode, vMode); // XML/XHTML UAs use the root element.
 445 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
 446         if (d->firstLayout && !document->ownerElement())
 447             printf("Elapsed time before first layout: %d\n", document->elapsedTime());
 448 #endif
 449     }
 450
 451     d->doFullRepaint = !subtree && (d->firstLayout || static_cast<RenderView*>(root)->printingMode());
 452     if (d->repaintRects)
 453         d->repaintRects->clear();
 454
 455     bool didFirstLayout = false;
 456     if (!subtree) {
 457         // Now set our scrollbar state for the layout.
 458         ScrollBarMode currentHMode = hScrollBarMode();
 459         ScrollBarMode currentVMode = vScrollBarMode();
 460
 461         if (d->firstLayout || (hMode != currentHMode || vMode != currentVMode)) {
 462             suppressScrollBars(true);
 463             if (d->firstLayout) {
 464                 d->firstLayout = false;
 465                 didFirstLayout = true;
 466
 467                 // Set the initial vMode to AlwaysOn if we're auto.
 468                 if (vMode == ScrollBarAuto)
 469                     ScrollView::setVScrollBarMode(ScrollBarAlwaysOn); // This causes a vertical scrollbar to appear.
 470                 // Set the initial hMode to AlwaysOff if we're auto.
 471                 if (hMode == ScrollBarAuto)
 472                     ScrollView::setHScrollBarMode(ScrollBarAlwaysOff); // This causes a horizontal scrollbar to disappear.
 473             }
 474
 475             if (hMode == vMode)
 476                 ScrollView::setScrollBarsMode(hMode);
 477             else {
 478                 ScrollView::setHScrollBarMode(hMode);
 479                 ScrollView::setVScrollBarMode(vMode);
 480             }
 481
 482             suppressScrollBars(false, true);
 483         }
 484
 485         IntSize oldSize = m_size;
 486
 487         m_size = IntSize(visibleWidth(), visibleHeight());
 488
 489         if (oldSize != m_size)
 490             d->doFullRepaint = true;
 491     }
 492
 493     RenderLayer* layer = root->enclosingLayer();
 494
 495     if (!d->doFullRepaint) {
 496         layer->checkForRepaintOnResize();
 497         root->repaintObjectsBeforeLayout();
 498     }
 499
 500     if (subtree) {
 501         if (root->recalcMinMax())
 502             root->recalcMinMaxWidths();
 503     }
 504     root->layout();
 505     d->layoutRoot = 0;
 506
 507     m_frame->invalidateSelection();
 508
 509     d->layoutSchedulingEnabled=true;
 510
 511     if (!subtree && !static_cast<RenderView*>(root)->printingMode())
 512         resizeContents(layer->width(), layer->height());
 513
 514     // Now update the positions of all layers.
 515     layer->updateLayerPositions(d->doFullRepaint);
 516
 517     // We update our widget positions right after doing a layout.
 518     if (!subtree)
 519         static_cast<RenderView*>(root)->updateWidgetPositions();
 520
 521     if (d->repaintRects && !d->repaintRects->isEmpty()) {
 522         // FIXME: Could optimize this and have objects removed from this list
 523         // if they ever do full repaints.
 524         RenderObject::RepaintInfo* r;
 525         DeprecatedPtrListIterator<RenderObject::RepaintInfo> it(*d->repaintRects);
 526         for (; (r = it.current()); ++it)
 527             r->m_object->repaintRectangle(r->m_repaintRect);
 528         d->repaintRects->clear();
 529     }
 530
 531     d->layoutCount++;
 532
 533 #if __APPLE__
 534     if (AXObjectCache::accessibilityEnabled())
 535         root->document()->axObjectCache()->postNotificationToElement(root, "AXLayoutComplete");
 536     updateDashboardRegions();
 537 #endif
 538
 539     if (didFirstLayout)
 540         m_frame->didFirstLayout();
 541
 542     if (root->needsLayout()) {
 543         scheduleRelayout();
 544         return;
 545     }
 546     setStaticBackground(useSlowRepaints());
 547
 548     if (document->hasListenerType(Document::OVERFLOWCHANGED_LISTENER))
 549         updateOverflowStatus(visibleWidth() < contentsWidth(),
 550                              visibleHeight() < contentsHeight());
 551
 552     // Dispatch events scheduled during layout
 553     dispatchScheduledEvents();
 554 }
 555
 556 //
 557 // Event Handling
 558 //
 559 /////////////////
 560
 561 static Frame* subframeForTargetNode(Node* node)
 562 {
 563     if (!node)
 564         return 0;
 565
 566     RenderObject* renderer = node->renderer();
 567     if (!renderer || !renderer->isWidget())
 568         return 0;
 569
 570     Widget* widget = static_cast<RenderWidget*>(renderer)->widget();
 571     if (!widget || !widget->isFrameView())
 572         return 0;
 573
 574     return static_cast<FrameView*>(widget)->frame();
 575 }
 576
 577 IntPoint FrameView::currentMousePosition() const
 578 {
 579     return d->m_currentMousePosition;
 580 }
 581
 582 void FrameView::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
 583 {
 584     if (!m_frame->document())
 585         return;
 586
 587     RefPtr<FrameView> protector(this);
 588
 589     d->mousePressed = true;
 590     d->m_currentMousePosition = windowToContents(mouseEvent.pos());
 591
 592     MouseEventWithHitTestResults mev = prepareMouseEvent(false, true, false, mouseEvent);
 593
 594     Frame* subframe = subframeForTargetNode(mev.targetNode());
 595     if (subframe && passMousePressEventToSubframe(mev, subframe)) {
 596         invalidateClick();
 597         return;
 598     }
 599
 600     d->clickCount = mouseEvent.clickCount();
 601     d->clickNode = mev.targetNode();
 602
 603     RenderLayer* layer = d->clickNode->renderer()? d->clickNode->renderer()->enclosingLayer() : 0;
 604     IntPoint p =  windowToContents(mouseEvent.pos());
 605     if (layer && layer->isPointInResizeControl(p)) {
 606         layer->setInResizeMode(true);
 607         d->m_resizeLayer = layer;
 608         d->offsetFromResizeCorner = layer->offsetFromResizeCorner(p);
 609         invalidateClick();
 610         return;
 611     }
 612
 613     bool swallowEvent = dispatchMouseEvent(mousedownEvent, mev.targetNode(), true, d->clickCount, mouseEvent, true);
 614
 615     if (!swallowEvent) {
 616         // Refetch the event target node if it currently is the shadow node inside an <input> element.
 617         // If a mouse event handler changes the input element type to one that has a widget associated,
 618         // we'd like to Frame::handleMousePressEvent to pass the event to the widget and thus the
 619         // event target node can't still be the shadow node.
 620         if (mev.targetNode()->isShadowNode() && mev.targetNode()->shadowParentNode()->hasTagName(inputTag))
 621             mev = prepareMouseEvent(true, true, false, mouseEvent);
 622
 623         PlatformScrollBar* scrollbar = scrollbarUnderMouse(mouseEvent);
 624         if (!scrollbar)
 625             scrollbar = mev.scrollbar();
 626         if (!scrollbar || !passMousePressEventToScrollbar(mev, scrollbar))
 627             m_frame->handleMousePressEvent(mev);
 628
 629         // Many AK widgets run their own event loops and consume events while the mouse is down.
 630         // When they finish, currentEvent is the mouseUp that they exited on.  We need to update
 631         // the khtml state with this mouseUp, which khtml never saw.
 632         // If this event isn't a mouseUp, we assume that the mouseUp will be coming later.  There
 633         // is a hole here if the widget consumes the mouseUp and subsequent events.
 634         if (m_frame->lastEventIsMouseUp())
 635             d->mousePressed = false;
 636     }
 637 }
 638
 639 // This method only exists for platforms that don't know how to deliver
 640 void FrameView::handleMouseDoubleClickEvent(const PlatformMouseEvent& mouseEvent)
 641 {
 642     if (!m_frame->document())
 643         return;
 644
 645     RefPtr<FrameView> protector(this);
 646
 647     // We get this instead of a second mouse-up
 648     d->mousePressed = false;
 649     d->m_currentMousePosition = windowToContents(mouseEvent.pos());
 650
 651     MouseEventWithHitTestResults mev = prepareMouseEvent(false, true, false, mouseEvent);
 652     Frame* subframe = subframeForTargetNode(mev.targetNode());
 653     if (subframe && passMousePressEventToSubframe(mev, subframe))
 654         return;
 655
 656     d->clickCount = mouseEvent.clickCount();
 657     bool swallowEvent = dispatchMouseEvent(mouseupEvent, mev.targetNode(), true, d->clickCount, mouseEvent, false);
 658
 659     if (mev.targetNode() == d->clickNode)
 660         dispatchMouseEvent(clickEvent, mev.targetNode(), true, d->clickCount, mouseEvent, true);
 661
 662     if (!swallowEvent)
 663         m_frame->handleMouseReleaseEvent(mev);
 664
 665     invalidateClick();
 666 }
 667
 668 static bool isSubmitImage(Node *node)
 669 {
 670     return node && node->hasTagName(inputTag) && static_cast<HTMLInputElement*>(node)->inputType() == HTMLInputElement::IMAGE;
 671 }
 672
 673 // Returns true if the node's editable block is not current focused for editing
 674 static bool nodeIsNotBeingEdited(Node* node, Frame* frame)
 675 {
 676     return frame->selectionController()->rootEditableElement() != node->rootEditableElement();
 677 }
 678
 679 static Cursor selectCursor(const MouseEventWithHitTestResults& event, Frame* frame, bool mousePressed, PlatformScrollBar* scrollbar)
 680 {
 681     // During selection, use an I-beam no matter what we're over.
 682     if (mousePressed && frame->hasSelection())
 683         return iBeamCursor();
 684
 685     Node* node = event.targetNode();
 686     RenderObject* renderer = node ? node->renderer() : 0;
 687     RenderStyle* style = renderer ? renderer->style() : 0;
 688
 689     if (style && style->cursors()) {
 690         const CursorList* cursors = style->cursors();
 691         for (unsigned i = 0; i < cursors->size(); ++i) {
 692             CachedImage* cimage = (*cursors)[i].cursorImage;
 693             IntPoint hotSpot = (*cursors)[i].hotSpot;
 694 #ifdef SVG_SUPPORT
 695             if (!cimage) {
 696                 Element* e = node->document()->getElementById((*cursors)[i].cursorFragmentId);
 697                 if (e && e->hasTagName(cursorTag)) {
 698                     hotSpot.setX(int(static_cast<SVGCursorElement*>(e)->x()->value()));
 699                     hotSpot.setY(int(static_cast<SVGCursorElement*>(e)->y()->value()));
 700                     cimage = static_cast<SVGCursorElement*>(e)->cachedImage();
 701                 }
 702             }
 703 #endif
 704             if (!cimage)
 705                 continue;
 706             if (cimage->image()->isNull())
 707                 break;
 708             if (!cimage->isErrorImage()) {
 709                 return Cursor(cimage->image(), hotSpot);
 710 }
 711         }
 712     }
 713
 714     switch (style ? style->cursor() : CURSOR_AUTO) {
 715         case CURSOR_AUTO: {
 716             bool editable = (node && node->isContentEditable());
 717             bool editableLinkEnabled = false;
 718
 719             // If the link is editable, then we need to check the settings to see whether or not the link should be followed
 720             if (editable) {
 721                 switch(frame->settings()->editableLinkBehavior()) {
 722                     default:
 723                     case Settings::EditableLinkDefaultBehavior:
 724                     case Settings::EditableLinkAlwaysLive:
 725                         editableLinkEnabled = true;
 726                         break;
 727
 728                     case Settings::EditableLinkLiveWhenNotFocused:
 729                         editableLinkEnabled = nodeIsNotBeingEdited(node, frame) || event.event().shiftKey();
 730                         break;
 731
 732                     case Settings::EditableLinkOnlyLiveWithShiftKey:
 733                         editableLinkEnabled = event.event().shiftKey();
 734                         break;
 735                 }
 736             }
 737
 738             if ((event.isOverLink() || isSubmitImage(node)) && (!editable || editableLinkEnabled))
 739                 return handCursor();
 740             RenderLayer* layer = renderer ? renderer->enclosingLayer() : 0;
 741             bool inResizer = false;
 742             if (frame->view() && layer && layer->isPointInResizeControl(frame->view()->windowToContents(event.event().pos())))
 743                 inResizer = true;
 744             if ((editable || (renderer && renderer->isText() && renderer->canSelect())) && !inResizer && !scrollbar)
 745                 return iBeamCursor();
 746             // FIXME: If the point is in a layer's overflow scrollbars, we should use the pointer cursor
 747             return pointerCursor();
 748         }
 749         case CURSOR_CROSS:
 750             return crossCursor();
 751         case CURSOR_POINTER:
 752             return handCursor();
 753         case CURSOR_MOVE:
 754             return moveCursor();
 755         case CURSOR_E_RESIZE:
 756             return eastResizeCursor();
 757         case CURSOR_W_RESIZE:
 758             return westResizeCursor();
 759         case CURSOR_N_RESIZE:
 760             return northResizeCursor();
 761         case CURSOR_S_RESIZE:
 762             return southResizeCursor();
 763         case CURSOR_NE_RESIZE:
 764             return northEastResizeCursor();
 765         case CURSOR_SW_RESIZE:
 766             return southWestResizeCursor();
 767         case CURSOR_NW_RESIZE:
 768             return northWestResizeCursor();
 769         case CURSOR_SE_RESIZE:
 770             return southEastResizeCursor();
 771         case CURSOR_NS_RESIZE:
 772             return northSouthResizeCursor();
 773         case CURSOR_EW_RESIZE:
 774             return eastWestResizeCursor();
 775         case CURSOR_NESW_RESIZE:
 776             return northEastSouthWestResizeCursor();
 777         case CURSOR_NWSE_RESIZE:
 778             return northWestSouthEastResizeCursor();
 779         case CURSOR_COL_RESIZE:
 780             return columnResizeCursor();
 781         case CURSOR_ROW_RESIZE:
 782             return rowResizeCursor();
 783         case CURSOR_TEXT:
 784             return iBeamCursor();
 785         case CURSOR_WAIT:
 786             return waitCursor();
 787         case CURSOR_HELP:
 788             return helpCursor();
 789         case CURSOR_DEFAULT:
 790             return pointerCursor();
 791     }
 792     return pointerCursor();
 793 }
 794
 795 void FrameView::handleMouseMoveEvent(const PlatformMouseEvent& mouseEvent)
 796 {
 797     // in Radar 3703768 we saw frequent crashes apparently due to the
 798     // part being null here, which seems impossible, so check for nil
 799     // but also assert so that we can try to figure this out in debug
 800     // builds, if it happens.
 801     ASSERT(m_frame);
 802     if (!m_frame || !m_frame->document())
 803         return;
 804
 805     RefPtr<FrameView> protector(this);
 806     d->m_currentMousePosition = windowToContents(mouseEvent.pos());
 807
 808     if (d->hoverTimer.isActive())
 809         d->hoverTimer.stop();
 810
 811     if (d->resizingFrameSet) {
 812         dispatchMouseEvent(mousemoveEvent, d->resizingFrameSet.get(), false, 0, mouseEvent, false);
 813         return;
 814     }
 815
 816     // Treat mouse move events while the mouse is pressed as "read-only" in prepareMouseEvent
 817     // if we are allowed to select.
 818     // This means that :hover and :active freeze in the state they were in when the mouse
 819     // was pressed, rather than updating for nodes the mouse moves over as you hold the mouse down.
 820     MouseEventWithHitTestResults mev = prepareMouseEvent(d->mousePressed && m_frame->mouseDownMayStartSelect(),
 821         d->mousePressed, true, mouseEvent);
 822
 823     if (d->oldSubframe && d->oldSubframe->tree()->isDescendantOf(m_frame.get()))
 824         passMouseMoveEventToSubframe(mev, d->oldSubframe.get());
 825
 826     bool swallowEvent = dispatchMouseEvent(mousemoveEvent, mev.targetNode(), false, 0, mouseEvent, true);
 827
 828     PlatformScrollBar* scrollbar = scrollbarUnderMouse(mouseEvent);
 829     if (!scrollbar)
 830         scrollbar = mev.scrollbar();
 831
 832     if (d->oldScrollBar != scrollbar) {
 833         // Send mouse exited to the old scrollbar.
 834         if (d->oldScrollBar)
 835             d->oldScrollBar->handleMouseOutEvent(mouseEvent);
 836         d->oldScrollBar = scrollbar;
 837     }
 838
 839     if (d->m_resizeLayer && d->m_resizeLayer->inResizeMode())
 840         d->m_resizeLayer->resize(mouseEvent, d->offsetFromResizeCorner);
 841
 842     if (!swallowEvent)
 843         m_frame->handleMouseMoveEvent(mev);
 844
 845     RefPtr<Frame> newSubframe = subframeForTargetNode(mev.targetNode());
 846     if (newSubframe && d->oldSubframe != newSubframe)
 847         passMouseMoveEventToSubframe(mev, newSubframe.get());
 848     else {
 849         if (scrollbar && !d->mousePressed)
 850             scrollbar->handleMouseMoveEvent(mouseEvent); // Handle hover effects on platforms that support visual feedback on scrollbar hovering.
 851         setCursor(selectCursor(mev, m_frame.get(), d->mousePressed, scrollbar));
 852     }
 853
 854     d->oldSubframe = newSubframe;
 855 }
 856
 857 void FrameView::invalidateClick()
 858 {
 859     d->clickCount = 0;
 860     d->clickNode = 0;
 861 }
 862
 863 bool FrameView::mousePressed()
 864 {
 865     return d->mousePressed;
 866 }
 867
 868 void FrameView::setMousePressed(bool pressed)
 869 {
 870     d->mousePressed = pressed;
 871 }
 872
 873 void FrameView::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
 874 {
 875     if (!m_frame->document())
 876         return;
 877
 878     RefPtr<FrameView> protector(this);
 879
 880     d->mousePressed = false;
 881     d->m_currentMousePosition = windowToContents(mouseEvent.pos());
 882
 883     if (d->resizingFrameSet) {
 884         dispatchMouseEvent(mouseupEvent, d->resizingFrameSet.get(), true, d->clickCount, mouseEvent, false);
 885         return;
 886     }
 887
 888     MouseEventWithHitTestResults mev = prepareMouseEvent(false, false, false, mouseEvent);
 889     Frame* subframe = subframeForTargetNode(mev.targetNode());
 890     if (subframe && passMouseReleaseEventToSubframe(mev, subframe))
 891         return;
 892
 893     bool swallowEvent = dispatchMouseEvent(mouseupEvent, mev.targetNode(), true, d->clickCount, mouseEvent, false);
 894
 895     if (d->clickCount > 0 && mev.targetNode() == d->clickNode)
 896         dispatchMouseEvent(clickEvent, mev.targetNode(), true, d->clickCount, mouseEvent, true);
 897
 898     if (d->m_resizeLayer) {
 899         d->m_resizeLayer->setInResizeMode(false);
 900         d->m_resizeLayer = 0;
 901     }
 902
 903     if (!swallowEvent)
 904         m_frame->handleMouseReleaseEvent(mev);
 905
 906     invalidateClick();
 907 }
 908
 909 bool FrameView::dispatchDragEvent(const AtomicString& eventType, Node *dragTarget, const PlatformMouseEvent& event, Clipboard* clipboard)
 910 {
 911     IntPoint contentsPos = windowToContents(event.pos());
 912
 913     RefPtr<MouseEvent> me = new MouseEvent(eventType,
 914         true, true, m_frame->document()->defaultView(),
 915         0, event.globalX(), event.globalY(), contentsPos.x(), contentsPos.y(),
 916         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
 917         0, 0, clipboard);
 918
 919     ExceptionCode ec = 0;
 920     EventTargetNodeCast(dragTarget)->dispatchEvent(me.get(), ec, true);
 921     return me->defaultPrevented();
 922 }
 923
 924 bool FrameView::updateDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
 925 {
 926     bool accept = false;
 927
 928     MouseEventWithHitTestResults mev = prepareMouseEvent(true, false, false, event);
 929
 930     // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
 931     Node* newTarget = mev.targetNode();
 932     if (newTarget && newTarget->isTextNode())
 933         newTarget = newTarget->parentNode();
 934     if (newTarget)
 935         newTarget = newTarget->shadowAncestorNode();
 936
 937     if (d->dragTarget != newTarget) {
 938         // note this ordering is explicitly chosen to match WinIE
 939         if (newTarget)
 940             accept = dispatchDragEvent(dragenterEvent, newTarget, event, clipboard);
 941         if (d->dragTarget)
 942             dispatchDragEvent(dragleaveEvent, d->dragTarget.get(), event, clipboard);
 943     } else {
 944         if (newTarget)
 945             accept = dispatchDragEvent(dragoverEvent, newTarget, event, clipboard);
 946     }
 947     d->dragTarget = newTarget;
 948
 949     return accept;
 950 }
 951
 952 void FrameView::cancelDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
 953 {
 954     if (d->dragTarget)
 955         dispatchDragEvent(dragleaveEvent, d->dragTarget.get(), event, clipboard);
 956     d->dragTarget = 0;
 957 }
 958
 959 bool FrameView::performDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
 960 {
 961     bool accept = false;
 962     if (d->dragTarget)
 963         accept = dispatchDragEvent(dropEvent, d->dragTarget.get(), event, clipboard);
 964     d->dragTarget = 0;
 965     return accept;
 966 }
 967
 968 Node* FrameView::nodeUnderMouse() const
 969 {
 970     return d->underMouse.get();
 971 }
 972
 973 bool FrameView::scrollTo(const IntRect& bounds)
 974 {
 975     d->scrollingSelf = true; // so scroll events get ignored
 976
 977     int x, y, xe, ye;
 978     x = bounds.x();
 979     y = bounds.y();
 980     xe = bounds.right() - 1;
 981     ye = bounds.bottom() - 1;
 982
 983     int deltax;
 984     int deltay;
 985
 986     int curHeight = visibleHeight();
 987     int curWidth = visibleWidth();
 988
 989     if (ye - y>curHeight-d->borderY)
 990         ye = y + curHeight - d->borderY;
 991
 992     if (xe - x>curWidth-d->borderX)
 993         xe = x + curWidth - d->borderX;
 994
 995     // is xpos of target left of the view's border?
 996     if (x < contentsX() + d->borderX)
 997         deltax = x - contentsX() - d->borderX;
 998     // is xpos of target right of the view's right border?
 999     else if (xe + d->borderX > contentsX() + curWidth)
1000         deltax = xe + d->borderX - (contentsX() + curWidth);
1001     else
1002         deltax = 0;
1003
1004     // is ypos of target above upper border?
1005     if (y < contentsY() + d->borderY)
1006         deltay = y - contentsY() - d->borderY;
1007     // is ypos of target below lower border?
1008     else if (ye + d->borderY > contentsY() + curHeight)
1009         deltay = ye + d->borderY - (contentsY() + curHeight);
1010     else
1011         deltay = 0;
1012
1013     int maxx = curWidth - d->borderX;
1014     int maxy = curHeight - d->borderY;
1015
1016     int scrollX = deltax > 0 ? (deltax > maxx ? maxx : deltax) : deltax == 0 ? 0 : (deltax > -maxx ? deltax : -maxx);
1017     int scrollY = deltay > 0 ? (deltay > maxy ? maxy : deltay) : deltay == 0 ? 0 : (deltay > -maxy ? deltay : -maxy);
1018
1019     if (contentsX() + scrollX < 0)
1020         scrollX = -contentsX();
1021     else if (contentsWidth() - visibleWidth() - contentsX() < scrollX)
1022         scrollX = contentsWidth() - visibleWidth() - contentsX();
1023
1024     if (contentsY() + scrollY < 0)
1025         scrollY = -contentsY();
1026     else if (contentsHeight() - visibleHeight() - contentsY() < scrollY)
1027         scrollY = contentsHeight() - visibleHeight() - contentsY();
1028
1029     scrollBy(scrollX, scrollY);
1030
1031     // generate abs(scroll.)
1032     if (scrollX < 0)
1033         scrollX = -scrollX;
1034     if (scrollY < 0)
1035         scrollY = -scrollY;
1036
1037     d->scrollingSelf = false;
1038
1039     return scrollX != maxx && scrollY != maxy;
1040 }
1041
1042 bool FrameView::advanceFocus(bool forward)
1043 {
1044     Document* document = m_frame->document();
1045     if (!document)
1046         return false;
1047
1048     Node* node = forward
1049         ? document->nextFocusNode(document->focusNode())
1050         : document->previousFocusNode(document->focusNode());
1051
1052     if (!node)
1053         // FIXME: Need to support tabbing out of the document to the UI.
1054         return false;
1055
1056     if (!node->isElementNode())
1057         // FIXME: May need a way to focus a document here.
1058         return false;
1059
1060     static_cast<Element*>(node)->focus();
1061     return true;
1062 }
1063
1064 void FrameView::setMediaType(const String& mediaType)
1065 {
1066     d->m_mediaType = mediaType;
1067 }
1068
1069 String FrameView::mediaType() const
1070 {
1071     // See if we have an override type.
1072     String overrideType = m_frame->overrideMediaType();
1073     if (!overrideType.isNull())
1074         return overrideType;
1075     return d->m_mediaType;
1076 }
1077
1078 bool FrameView::useSlowRepaints() const
1079 {
1080     return d->useSlowRepaints || d->slowRepaintObjectCount > 0;
1081 }
1082
1083 void FrameView::setUseSlowRepaints()
1084 {
1085     d->useSlowRepaints = true;
1086     setStaticBackground(true);
1087 }
1088
1089 void FrameView::addSlowRepaintObject()
1090 {
1091     if (d->slowRepaintObjectCount == 0)
1092         setStaticBackground(true);
1093     d->slowRepaintObjectCount++;
1094 }
1095
1096 void FrameView::removeSlowRepaintObject()
1097 {
1098     d->slowRepaintObjectCount--;
1099     if (d->slowRepaintObjectCount == 0)
1100         setStaticBackground(d->useSlowRepaints);
1101 }
1102
1103 void FrameView::setScrollBarsMode(ScrollBarMode mode)
1104 {
1105     d->vmode = mode;
1106     d->hmode = mode;
1107
1108     ScrollView::setScrollBarsMode(mode);
1109 }
1110
1111 void FrameView::setVScrollBarMode(ScrollBarMode mode)
1112 {
1113     d->vmode = mode;
1114     ScrollView::setVScrollBarMode(mode);
1115 }
1116
1117 void FrameView::setHScrollBarMode(ScrollBarMode mode)
1118 {
1119     d->hmode = mode;
1120     ScrollView::setHScrollBarMode(mode);
1121 }
1122
1123 void FrameView::restoreScrollBar()
1124 {
1125     suppressScrollBars(false);
1126 }
1127
1128 void FrameView::setResizingFrameSet(HTMLFrameSetElement* frameSet)
1129 {
1130     d->resizingFrameSet = frameSet;
1131 }
1132
1133 void FrameView::scrollPointRecursively(int x, int y)
1134 {
1135     if (frame()->prohibitsScrolling())
1136         return;
1137
1138     ScrollView::scrollPointRecursively(x, y);
1139 }
1140
1141 void FrameView::setContentsPos(int x, int y)
1142 {
1143     if (frame()->prohibitsScrolling())
1144         return;
1145
1146     ScrollView::setContentsPos(x, y);
1147 }
1148
1149 MouseEventWithHitTestResults FrameView::prepareMouseEvent(bool readonly, bool active, bool mouseMove, const PlatformMouseEvent& mev)
1150 {
1151     ASSERT(m_frame);
1152     ASSERT(m_frame->document());
1153
1154     IntPoint vPoint = windowToContents(mev.pos());
1155     return m_frame->document()->prepareMouseEvent(readonly, active, mouseMove, vPoint, mev);
1156 }
1157
1158 bool FrameView::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, bool cancelable,
1159     int clickCount, const PlatformMouseEvent& mouseEvent, bool setUnder)
1160 {
1161     // if the target node is a text node, dispatch on the parent node - rdar://4196646
1162     if (targetNode && targetNode->isTextNode())
1163         targetNode = targetNode->parentNode();
1164     if (targetNode)
1165         targetNode = targetNode->shadowAncestorNode();
1166     d->underMouse = targetNode;
1167
1168     // mouseout/mouseover
1169     if (setUnder) {
1170         if (d->oldUnder && d->oldUnder->document() != frame()->document()) {
1171             d->oldUnder = 0;
1172             d->oldScrollBar = 0;
1173         }
1174
1175         if (d->oldUnder != targetNode) {
1176             // send mouseout event to the old node
1177             if (d->oldUnder)
1178                 EventTargetNodeCast(d->oldUnder.get())->dispatchMouseEvent(mouseEvent, mouseoutEvent, 0, targetNode);
1179             // send mouseover event to the new node
1180             if (targetNode)
1181                 EventTargetNodeCast(targetNode)->dispatchMouseEvent(mouseEvent, mouseoverEvent, 0, d->oldUnder.get());
1182         }
1183         d->oldUnder = targetNode;
1184     }
1185
1186     bool swallowEvent = false;
1187
1188     if (targetNode)
1189         swallowEvent = EventTargetNodeCast(targetNode)->dispatchMouseEvent(mouseEvent, eventType, clickCount);
1190
1191     if (!swallowEvent && eventType == mousedownEvent) {
1192         // Blur current focus node when a link/button is clicked; this
1193         // is expected by some sites that rely on onChange handlers running
1194         // from form fields before the button click is processed.
1195         Node* node = targetNode;
1196         RenderObject* renderer = node ? node->renderer() : 0;
1197
1198         // Walk up the render tree to search for a node to focus.
1199         // Walking up the DOM tree wouldn't work for shadow trees, like those behind the engine-based text fields.
1200         while (renderer) {
1201             node = renderer->element();
1202             if (node && node->isFocusable())
1203                 break;
1204             renderer = renderer->parent();
1205         }
1206         // If focus shift is blocked, we eat the event.  Note we should never clear swallowEvent
1207         // if the page already set it (e.g., by canceling default behavior).
1208         if (node && node->isMouseFocusable()) {
1209             if (!m_frame->document()->setFocusNode(node))
1210                 swallowEvent = true;
1211         } else if (!node || !node->focused()) {
1212             if (!m_frame->document()->setFocusNode(0))
1213                 swallowEvent = true;
1214         }
1215
1216 #if PLATFORM(WIN)
1217         // It's ok to shift focus to this view now that we know that no focus change got blocked.
1218         if (!swallowEvent && !hasFocus())
1219             setFocus();
1220 #endif
1221     }
1222
1223     return swallowEvent;
1224 }
1225
1226 void FrameView::setIgnoreWheelEvents(bool e)
1227 {
1228     d->ignoreWheelEvents = e;
1229 }
1230
1231 void FrameView::handleWheelEvent(PlatformWheelEvent& e)
1232 {
1233     Document *doc = m_frame->document();
1234     if (doc) {
1235         RenderObject *docRenderer = doc->renderer();
1236         if (docRenderer) {
1237             IntPoint vPoint = windowToContents(e.pos());
1238
1239             RenderObject::NodeInfo hitTestResult(true, false);
1240             doc->renderer()->layer()->hitTest(hitTestResult, vPoint);
1241             Node *node = hitTestResult.innerNode();
1242             Frame* subframe = subframeForTargetNode(node);
1243             if (subframe && passWheelEventToSubframe(e, subframe)) {
1244                 e.accept();
1245                 return;
1246             }
1247
1248             if (node) {
1249                 node = node->shadowAncestorNode();
1250                 EventTargetNodeCast(node)->dispatchWheelEvent(e);
1251                 if (e.isAccepted())
1252                     return;
1253
1254                 if (node->renderer()) {
1255                     // Just break up into two scrolls if we need to.  Diagonal movement on
1256                     // a MacBook pro is an example of a 2-dimensional mouse wheel event (where both deltaX and deltaY can be set).
1257                     if (e.deltaX() && node->renderer()->scroll(e.deltaX() < 0 ? ScrollRight : ScrollLeft, ScrollByWheel,
1258                                                                e.deltaX() < 0 ? -e.deltaX() : e.deltaX()))
1259                         e.accept();
1260                     if (e.deltaY() && node->renderer()->scroll(e.deltaY() < 0 ? ScrollDown : ScrollUp, ScrollByWheel,
1261                                                                e.deltaY() < 0 ? -e.deltaY() : e.deltaY()))
1262                         e.accept();
1263
1264                     if (!e.isAccepted())
1265                         wheelEvent(e);
1266                 }
1267             }
1268         }
1269     }
1270 }
1271
1272 void FrameView::scrollBarMoved()
1273 {
1274     // FIXME: Need to arrange for this to be called when the view is scrolled!
1275     if (!d->scrollingSelf)
1276         d->scrollBarMoved = true;
1277 }
1278
1279 void FrameView::repaintRectangle(const IntRect& r, bool immediate)
1280 {
1281     updateContents(r, immediate);
1282 }
1283
1284 void FrameView::layoutTimerFired(Timer<FrameView>*)
1285 {
1286 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1287     if (m_frame->document() && !m_frame->document()->ownerElement())
1288         printf("Layout timer fired at %d\n", m_frame->document()->elapsedTime());
1289 #endif
1290     layout();
1291 }
1292
1293 void FrameView::hoverTimerFired(Timer<FrameView>*)
1294 {
1295     d->hoverTimer.stop();
1296     prepareMouseEvent(false, false, true, PlatformMouseEvent(PlatformMouseEvent::currentEvent));
1297 }
1298
1299 void FrameView::scheduleRelayout()
1300 {
1301     if (d->layoutRoot) {
1302         if (d->layoutRoot->renderer())
1303             d->layoutRoot->renderer()->markContainingBlocksForLayout(false);
1304         d->layoutRoot = 0;
1305     }
1306     if (!d->layoutSchedulingEnabled)
1307         return;
1308
1309     if (!m_frame->document() || !m_frame->document()->shouldScheduleLayout())
1310         return;
1311
1312     int delay = m_frame->document()->minimumLayoutDelay();
1313     if (d->layoutTimer.isActive() && d->delayedLayout && !delay)
1314         unscheduleRelayout();
1315     if (d->layoutTimer.isActive())
1316         return;
1317
1318     d->delayedLayout = delay != 0;
1319
1320 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1321     if (!m_frame->document()->ownerElement())
1322         printf("Scheduling layout for %d\n", delay);
1323 #endif
1324
1325     d->layoutTimer.startOneShot(delay * 0.001);
1326 }
1327
1328 void FrameView::scheduleRelayoutOfSubtree(Node* n)
1329 {
1330     if (!d->layoutSchedulingEnabled || m_frame->document() && m_frame->document()->renderer() && m_frame->document()->renderer()->needsLayout()) {
1331         if (n->renderer())
1332             n->renderer()->markContainingBlocksForLayout(false);
1333         return;
1334     }
1335
1336     if (layoutPending()) {
1337         if (d->layoutRoot != n) {
1338             // Just do a full relayout
1339             if (d->layoutRoot && d->layoutRoot->renderer())
1340                 d->layoutRoot->renderer()->markContainingBlocksForLayout(false);
1341             d->layoutRoot = 0;
1342             if (n->renderer())
1343                 n->renderer()->markContainingBlocksForLayout(false);
1344         }
1345     } else {
1346         int delay = m_frame->document()->minimumLayoutDelay();
1347         d->layoutRoot = n;
1348         d->delayedLayout = delay != 0;
1349         d->layoutTimer.startOneShot(delay * 0.001);
1350     }
1351 }
1352
1353 bool FrameView::layoutPending() const
1354 {
1355     return d->layoutTimer.isActive();
1356 }
1357
1358 bool FrameView::haveDelayedLayoutScheduled()
1359 {
1360     return d->layoutTimer.isActive() && d->delayedLayout;
1361 }
1362
1363 void FrameView::unscheduleRelayout()
1364 {
1365     if (!d->layoutTimer.isActive())
1366         return;
1367
1368 #ifdef INSTRUMENT_LAYOUT_SCHEDULING
1369     if (m_frame->document() && !m_frame->document()->ownerElement())
1370         printf("Layout timer unscheduled at %d\n", m_frame->document()->elapsedTime());
1371 #endif
1372
1373     d->layoutTimer.stop();
1374     d->delayedLayout = false;
1375 }
1376
1377 bool FrameView::isTransparent() const
1378 {
1379     return d->isTransparent;
1380 }
1381
1382 void FrameView::setTransparent(bool isTransparent)
1383 {
1384     d->isTransparent = isTransparent;
1385 }
1386
1387 Color FrameView::baseBackgroundColor() const
1388 {
1389     return d->baseBackgroundColor;
1390 }
1391
1392 void FrameView::setBaseBackgroundColor(Color bc)
1393 {
1394     if (!bc.isValid())
1395         bc = Color::white;
1396     d->baseBackgroundColor = bc;
1397 }
1398
1399 void FrameView::scheduleHoverStateUpdate()
1400 {
1401     if (!d->hoverTimer.isActive())
1402         d->hoverTimer.startOneShot(0);
1403 }
1404
1405 void FrameView::setHasBorder(bool b)
1406 {
1407     d->m_hasBorder = b;
1408     updateBorder();
1409 }
1410
1411 bool FrameView::hasBorder() const
1412 {
1413     return d->m_hasBorder;
1414 }
1415
1416 void FrameView::cleared()
1417 {
1418     if (m_frame)
1419         if (RenderPart* renderer = m_frame->ownerRenderer())
1420             renderer->viewCleared();
1421 }
1422
1423
1424 void FrameView::scheduleEvent(PassRefPtr<Event> event, PassRefPtr<EventTargetNode> eventTarget, bool tempEvent)
1425 {
1426     if (!d->m_scheduledEvents)
1427         d->m_scheduledEvents = new Vector<ScheduledEvent*>;
1428
1429     ScheduledEvent *scheduledEvent = new ScheduledEvent;
1430     scheduledEvent->m_event = event;
1431     scheduledEvent->m_eventTarget = eventTarget;
1432     scheduledEvent->m_tempEvent = tempEvent;
1433
1434     d->m_scheduledEvents->append(scheduledEvent);
1435 }
1436
1437 void FrameView::updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow)
1438 {
1439     if (!d->m_viewportRenderer)
1440         return;
1441
1442     if (d->m_overflowStatusDirty) {
1443         d->horizontalOverflow = horizontalOverflow;
1444         d->m_verticalOverflow = verticalOverflow;
1445         d->m_overflowStatusDirty = false;
1446
1447         return;
1448     }
1449
1450     bool horizontalOverflowChanged = (d->horizontalOverflow != horizontalOverflow);
1451     bool verticalOverflowChanged = (d->m_verticalOverflow != verticalOverflow);
1452
1453     if (horizontalOverflowChanged || verticalOverflowChanged) {
1454         d->horizontalOverflow = horizontalOverflow;
1455         d->m_verticalOverflow = verticalOverflow;
1456
1457         scheduleEvent(new OverflowEvent(horizontalOverflowChanged, horizontalOverflow, verticalOverflowChanged, verticalOverflow),
1458                                         EventTargetNodeCast(d->m_viewportRenderer->element()), true);
1459     }
1460
1461 }
1462
1463 void FrameView::dispatchScheduledEvents()
1464 {
1465     if (!d->m_scheduledEvents)
1466         return;
1467
1468     Vector<ScheduledEvent*> scheduledEventsCopy = *d->m_scheduledEvents;
1469     d->m_scheduledEvents->clear();
1470
1471     Vector<ScheduledEvent*>::iterator end = scheduledEventsCopy.end();
1472     for (Vector<ScheduledEvent*>::iterator it = scheduledEventsCopy.begin(); it != end; ++it) {
1473         ScheduledEvent* scheduledEvent = *it;
1474
1475         ExceptionCode ec = 0;
1476
1477         // Only dispatch events to nodes that are in the document
1478         if (scheduledEvent->m_eventTarget->inDocument())
1479             scheduledEvent->m_eventTarget->dispatchEvent(scheduledEvent->m_event, ec, scheduledEvent->m_tempEvent);
1480
1481         delete scheduledEvent;
1482     }
1483 }
1484
1485 }