f054b38eb5d92e7dba38b43edea64f47ab02706b
[WebKit-https.git] / WebCore / page / EventHandler.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "EventHandler.h"
29
30 #include "AXObjectCache.h"
31 #include "CachedImage.h"
32 #include "ChromeClient.h"
33 #include "Cursor.h"
34 #include "Document.h"
35 #include "DragController.h"
36 #include "Editor.h"
37 #include "EventNames.h"
38 #include "FloatPoint.h"
39 #include "FloatRect.h"
40 #include "FocusController.h"
41 #include "Frame.h"
42 #include "FrameLoader.h"
43 #include "FrameTree.h"
44 #include "FrameView.h"
45 #include "HitTestRequest.h"
46 #include "HitTestResult.h"
47 #include "HTMLFrameSetElement.h"
48 #include "HTMLFrameElementBase.h"
49 #include "HTMLInputElement.h"
50 #include "HTMLNames.h"
51 #include "Image.h"
52 #include "InspectorController.h"
53 #include "KeyboardEvent.h"
54 #include "MouseEvent.h"
55 #include "MouseEventWithHitTestResults.h"
56 #include "Page.h"
57 #include "PlatformKeyboardEvent.h"
58 #include "PlatformWheelEvent.h"
59 #include "RenderFrameSet.h"
60 #include "RenderTextControlSingleLine.h"
61 #include "RenderWidget.h"
62 #include "RenderView.h"
63 #include "Scrollbar.h"
64 #include "SelectionController.h"
65 #include "Settings.h"
66 #include "TextEvent.h"
67 #include <wtf/StdLibExtras.h>
68
69 #if ENABLE(SVG)
70 #include "SVGDocument.h"
71 #include "SVGElementInstance.h"
72 #include "SVGNames.h"
73 #include "SVGUseElement.h"
74 #endif
75
76 namespace WebCore {
77
78 using namespace HTMLNames;
79
80 // The link drag hysteresis is much larger than the others because there
81 // needs to be enough space to cancel the link press without starting a link drag,
82 // and because dragging links is rare.
83 const int LinkDragHysteresis = 40;
84 const int ImageDragHysteresis = 5;
85 const int TextDragHysteresis = 3;
86 const int GeneralDragHysteresis = 3;
87
88 // Match key code of composition keydown event on windows.
89 // IE sends VK_PROCESSKEY which has value 229;
90 const int CompositionEventKeyCode = 229;
91
92 #if ENABLE(SVG)
93 using namespace SVGNames;
94 #endif
95
96 // When the autoscroll or the panScroll is triggered when do the scroll every 0.05s to make it smooth
97 const double autoscrollInterval = 0.05;
98
99 static Frame* subframeForTargetNode(Node*);
100 static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
101
102 static inline void scrollAndAcceptEvent(float delta, ScrollDirection positiveDirection, ScrollDirection negativeDirection, PlatformWheelEvent& e, Node* node)
103 {
104     if (!delta)
105         return;
106         
107     // Find the nearest enclosing box.
108     RenderBox* enclosingBox = node->renderer()->enclosingBox();
109
110     if (e.granularity() == ScrollByPageWheelEvent) {
111         if (enclosingBox->scroll(delta < 0 ? negativeDirection : positiveDirection, ScrollByPage, 1))
112             e.accept();
113         return;
114     } 
115     float pixelsToScroll = delta > 0 ? delta : -delta;
116     if (e.granularity() == ScrollByLineWheelEvent)
117         pixelsToScroll *= cMouseWheelPixelsPerLineStep;
118     if (enclosingBox->scroll(delta < 0 ? negativeDirection : positiveDirection, ScrollByPixel, pixelsToScroll))
119         e.accept();
120 }
121
122 EventHandler::EventHandler(Frame* frame)
123     : m_frame(frame)
124     , m_mousePressed(false)
125     , m_capturesDragging(false)
126     , m_mouseDownMayStartSelect(false)
127     , m_mouseDownMayStartDrag(false)
128     , m_mouseDownWasSingleClickInSelection(false)
129     , m_beganSelectingText(false)
130     , m_panScrollInProgress(false)
131     , m_hoverTimer(this, &EventHandler::hoverTimerFired)
132     , m_autoscrollTimer(this, &EventHandler::autoscrollTimerFired)
133     , m_autoscrollRenderer(0)
134     , m_autoscrollInProgress(false)
135     , m_mouseDownMayStartAutoscroll(false)
136     , m_mouseDownWasInSubframe(false)
137 #if ENABLE(SVG)
138     , m_svgPan(false)
139 #endif
140     , m_resizeLayer(0)
141     , m_capturingMouseEventsNode(0)
142     , m_clickCount(0)
143     , m_mouseDownTimestamp(0)
144     , m_pendingFrameUnloadEventCount(0)
145     , m_pendingFrameBeforeUnloadEventCount(0)
146 #if PLATFORM(MAC)
147     , m_mouseDownView(nil)
148     , m_sendingEventToSubview(false)
149     , m_activationEventNumber(0)
150 #endif
151 {
152 }
153
154 EventHandler::~EventHandler()
155 {
156 }
157     
158 EventHandler::EventHandlerDragState& EventHandler::dragState()
159 {
160     DEFINE_STATIC_LOCAL(EventHandlerDragState, state, ());
161     return state;
162 }
163     
164 void EventHandler::clear()
165 {
166     m_hoverTimer.stop();
167     m_resizeLayer = 0;
168     m_nodeUnderMouse = 0;
169     m_lastNodeUnderMouse = 0;
170 #if ENABLE(SVG)
171     m_instanceUnderMouse = 0;
172     m_lastInstanceUnderMouse = 0;
173 #endif
174     m_lastMouseMoveEventSubframe = 0;
175     m_lastScrollbarUnderMouse = 0;
176     m_clickCount = 0;
177     m_clickNode = 0;
178     m_frameSetBeingResized = 0;
179     m_dragTarget = 0;
180     m_currentMousePosition = IntPoint();
181     m_mousePressNode = 0;
182     m_mousePressed = false;
183     m_capturesDragging = false;
184     m_capturingMouseEventsNode = 0;
185 }
186
187 void EventHandler::selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults& result)
188 {
189     Node* innerNode = result.targetNode();
190     VisibleSelection newSelection;
191
192     if (innerNode && innerNode->renderer() && m_mouseDownMayStartSelect) {
193         VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));
194         if (pos.isNotNull()) {
195             newSelection = VisibleSelection(pos);
196             newSelection.expandUsingGranularity(WordGranularity);
197         }
198     
199         if (newSelection.isRange()) {
200             m_frame->setSelectionGranularity(WordGranularity);
201             m_beganSelectingText = true;
202             if (result.event().clickCount() == 2 && m_frame->editor()->isSelectTrailingWhitespaceEnabled()) 
203                 newSelection.appendTrailingWhitespace();            
204         }
205         
206         if (m_frame->shouldChangeSelection(newSelection))
207             m_frame->selection()->setSelection(newSelection);
208     }
209 }
210
211 void EventHandler::selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults& result)
212 {
213     if (!result.hitTestResult().isLiveLink())
214         return selectClosestWordFromMouseEvent(result);
215
216     Node* innerNode = result.targetNode();
217
218     if (innerNode && innerNode->renderer() && m_mouseDownMayStartSelect) {
219         VisibleSelection newSelection;
220         Element* URLElement = result.hitTestResult().URLElement();
221         VisiblePosition pos(innerNode->renderer()->positionForPoint(result.localPoint()));
222         if (pos.isNotNull() && pos.deepEquivalent().node()->isDescendantOf(URLElement))
223             newSelection = VisibleSelection::selectionFromContentsOfNode(URLElement);
224     
225         if (newSelection.isRange()) {
226             m_frame->setSelectionGranularity(WordGranularity);
227             m_beganSelectingText = true;
228         }
229
230         if (m_frame->shouldChangeSelection(newSelection))
231             m_frame->selection()->setSelection(newSelection);
232     }
233 }
234
235 bool EventHandler::handleMousePressEventDoubleClick(const MouseEventWithHitTestResults& event)
236 {
237     if (event.event().button() != LeftButton)
238         return false;
239
240     if (m_frame->selection()->isRange())
241         // A double-click when range is already selected
242         // should not change the selection.  So, do not call
243         // selectClosestWordFromMouseEvent, but do set
244         // m_beganSelectingText to prevent handleMouseReleaseEvent
245         // from setting caret selection.
246         m_beganSelectingText = true;
247     else
248         selectClosestWordFromMouseEvent(event);
249
250     return true;
251 }
252
253 bool EventHandler::handleMousePressEventTripleClick(const MouseEventWithHitTestResults& event)
254 {
255     if (event.event().button() != LeftButton)
256         return false;
257     
258     Node* innerNode = event.targetNode();
259     if (!(innerNode && innerNode->renderer() && m_mouseDownMayStartSelect))
260         return false;
261
262     VisibleSelection newSelection;
263     VisiblePosition pos(innerNode->renderer()->positionForPoint(event.localPoint()));
264     if (pos.isNotNull()) {
265         newSelection = VisibleSelection(pos);
266         newSelection.expandUsingGranularity(ParagraphGranularity);
267     }
268     if (newSelection.isRange()) {
269         m_frame->setSelectionGranularity(ParagraphGranularity);
270         m_beganSelectingText = true;
271     }
272     
273     if (m_frame->shouldChangeSelection(newSelection))
274         m_frame->selection()->setSelection(newSelection);
275
276     return true;
277 }
278
279 bool EventHandler::handleMousePressEventSingleClick(const MouseEventWithHitTestResults& event)
280 {
281     if (event.event().button() != LeftButton)
282         return false;
283     
284     Node* innerNode = event.targetNode();
285     if (!(innerNode && innerNode->renderer() && m_mouseDownMayStartSelect))
286         return false;
287
288     // Extend the selection if the Shift key is down, unless the click is in a link.
289     bool extendSelection = event.event().shiftKey() && !event.isOverLink();
290
291     // Don't restart the selection when the mouse is pressed on an
292     // existing selection so we can allow for text dragging.
293     IntPoint vPoint = m_frame->view()->windowToContents(event.event().pos());
294     if (!extendSelection && m_frame->selection()->contains(vPoint)) {
295         m_mouseDownWasSingleClickInSelection = true;
296         return false;
297     }
298
299     VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(event.localPoint()));
300     if (visiblePos.isNull())
301         visiblePos = VisiblePosition(innerNode, 0, DOWNSTREAM);
302     Position pos = visiblePos.deepEquivalent();
303     
304     VisibleSelection newSelection = m_frame->selection()->selection();
305     if (extendSelection && newSelection.isCaretOrRange()) {
306         m_frame->selection()->setLastChangeWasHorizontalExtension(false);
307         
308         // See <rdar://problem/3668157> REGRESSION (Mail): shift-click deselects when selection 
309         // was created right-to-left
310         Position start = newSelection.start();
311         Position end = newSelection.end();
312         short before = Range::compareBoundaryPoints(pos.node(), pos.offset(), start.node(), start.offset());
313         if (before <= 0)
314             newSelection = VisibleSelection(pos, end);
315         else
316             newSelection = VisibleSelection(start, pos);
317
318         if (m_frame->selectionGranularity() != CharacterGranularity)
319             newSelection.expandUsingGranularity(m_frame->selectionGranularity());
320         m_beganSelectingText = true;
321     } else {
322         newSelection = VisibleSelection(visiblePos);
323         m_frame->setSelectionGranularity(CharacterGranularity);
324     }
325     
326     if (m_frame->shouldChangeSelection(newSelection))
327         m_frame->selection()->setSelection(newSelection);
328
329     return true;
330 }
331
332 bool EventHandler::handleMousePressEvent(const MouseEventWithHitTestResults& event)
333 {
334     // Reset drag state.
335     dragState().m_dragSrc = 0;
336
337     bool singleClick = event.event().clickCount() <= 1;
338
339     // If we got the event back, that must mean it wasn't prevented,
340     // so it's allowed to start a drag or selection.
341     m_mouseDownMayStartSelect = canMouseDownStartSelect(event.targetNode());
342     
343     // Careful that the drag starting logic stays in sync with eventMayStartDrag()
344     m_mouseDownMayStartDrag = singleClick;
345
346     m_mouseDownWasSingleClickInSelection = false;
347
348     if (event.isOverWidget() && passWidgetMouseDownEventToWidget(event))
349         return true;
350
351 #if ENABLE(SVG)
352     if (m_frame->document()->isSVGDocument() &&
353        static_cast<SVGDocument*>(m_frame->document())->zoomAndPanEnabled()) {
354         if (event.event().shiftKey() && singleClick) {
355             m_svgPan = true;
356             static_cast<SVGDocument*>(m_frame->document())->startPan(event.event().pos());
357             return true;
358         }
359     }
360 #endif
361
362     // We don't do this at the start of mouse down handling,
363     // because we don't want to do it until we know we didn't hit a widget.
364     if (singleClick)
365         focusDocumentView();
366
367     Node* innerNode = event.targetNode();
368
369     m_mousePressNode = innerNode;
370     m_dragStartPos = event.event().pos();
371
372     bool swallowEvent = false;
373     if (event.event().button() == LeftButton || event.event().button() == MiddleButton) {
374         m_frame->selection()->setCaretBlinkingSuspended(true);
375         m_mousePressed = true;
376         m_beganSelectingText = false;
377
378         if (event.event().clickCount() == 2)
379             swallowEvent = handleMousePressEventDoubleClick(event);
380         else if (event.event().clickCount() >= 3)
381             swallowEvent = handleMousePressEventTripleClick(event);
382         else
383             swallowEvent = handleMousePressEventSingleClick(event);
384     }
385     
386     m_mouseDownMayStartAutoscroll = m_mouseDownMayStartSelect || 
387         (m_mousePressNode && m_mousePressNode->renderBox() && m_mousePressNode->renderBox()->canBeProgramaticallyScrolled(true));
388
389    return swallowEvent;
390 }
391
392 bool EventHandler::handleMouseDraggedEvent(const MouseEventWithHitTestResults& event)
393 {
394     if (handleDrag(event))
395         return true;
396
397     if (!m_mousePressed)
398         return false;
399
400     Node* targetNode = event.targetNode();
401     if (event.event().button() != LeftButton || !targetNode || !targetNode->renderer())
402         return false;
403
404 #if PLATFORM(MAC) // FIXME: Why does this assertion fire on other platforms?
405     ASSERT(m_mouseDownMayStartSelect || m_mouseDownMayStartAutoscroll);
406 #endif
407
408     m_mouseDownMayStartDrag = false;
409
410     if (m_mouseDownMayStartAutoscroll && !m_panScrollInProgress) {            
411         // If the selection is contained in a layer that can scroll, that layer should handle the autoscroll
412         // Otherwise, let the bridge handle it so the view can scroll itself.
413         RenderObject* renderer = targetNode->renderer();
414         while (renderer && (!renderer->isBox() || !toRenderBox(renderer)->canBeProgramaticallyScrolled(false))) {
415             if (!renderer->parent() && renderer->node() == renderer->document() && renderer->document()->ownerElement())
416                 renderer = renderer->document()->ownerElement()->renderer();
417             else
418                 renderer = renderer->parent();
419         }
420         
421         if (renderer) {
422             m_autoscrollInProgress = true;
423             handleAutoscroll(renderer);
424         }
425         
426         m_mouseDownMayStartAutoscroll = false;
427     }
428     
429     updateSelectionForMouseDrag(targetNode, event.localPoint());
430     return true;
431 }
432     
433 bool EventHandler::eventMayStartDrag(const PlatformMouseEvent& event) const
434 {
435     // This is a pre-flight check of whether the event might lead to a drag being started.  Be careful
436     // that its logic needs to stay in sync with handleMouseMoveEvent() and the way we setMouseDownMayStartDrag
437     // in handleMousePressEvent
438     
439     if (!m_frame->contentRenderer() || !m_frame->contentRenderer()->hasLayer()
440         || event.button() != LeftButton || event.clickCount() != 1)
441         return false;
442     
443     bool DHTMLFlag;
444     bool UAFlag;
445     allowDHTMLDrag(DHTMLFlag, UAFlag);
446     if (!DHTMLFlag && !UAFlag)
447         return false;
448     
449     HitTestRequest request(HitTestRequest::ReadOnly);
450     HitTestResult result(m_frame->view()->windowToContents(event.pos()));
451     m_frame->contentRenderer()->layer()->hitTest(request, result);
452     bool srcIsDHTML;
453     return result.innerNode() && result.innerNode()->renderer()->draggableNode(DHTMLFlag, UAFlag, result.point().x(), result.point().y(), srcIsDHTML);
454 }
455
456 void EventHandler::updateSelectionForMouseDrag()
457 {
458     FrameView* view = m_frame->view();
459     if (!view)
460         return;
461     RenderView* renderer = m_frame->contentRenderer();
462     if (!renderer)
463         return;
464     RenderLayer* layer = renderer->layer();
465     if (!layer)
466         return;
467
468     HitTestRequest request(HitTestRequest::ReadOnly |
469                            HitTestRequest::Active |
470                            HitTestRequest::MouseMove);
471     HitTestResult result(view->windowToContents(m_currentMousePosition));
472     layer->hitTest(request, result);
473     updateSelectionForMouseDrag(result.innerNode(), result.localPoint());
474 }
475
476 void EventHandler::updateSelectionForMouseDrag(Node* targetNode, const IntPoint& localPoint)
477 {
478     if (!m_mouseDownMayStartSelect)
479         return;
480
481     if (!targetNode)
482         return;
483
484     RenderObject* targetRenderer = targetNode->renderer();
485     if (!targetRenderer)
486         return;
487         
488     if (!canMouseDragExtendSelect(targetNode))
489         return;
490
491     VisiblePosition targetPosition(targetRenderer->positionForPoint(localPoint));
492
493     // Don't modify the selection if we're not on a node.
494     if (targetPosition.isNull())
495         return;
496
497     // Restart the selection if this is the first mouse move. This work is usually
498     // done in handleMousePressEvent, but not if the mouse press was on an existing selection.
499     VisibleSelection newSelection = m_frame->selection()->selection();
500
501 #if ENABLE(SVG)
502     // Special case to limit selection to the containing block for SVG text.
503     // FIXME: Isn't there a better non-SVG-specific way to do this?
504     if (Node* selectionBaseNode = newSelection.base().node())
505         if (RenderObject* selectionBaseRenderer = selectionBaseNode->renderer())
506             if (selectionBaseRenderer->isSVGText())
507                 if (targetNode->renderer()->containingBlock() != selectionBaseRenderer->containingBlock())
508                     return;
509 #endif
510
511     if (!m_beganSelectingText) {
512         m_beganSelectingText = true;
513         newSelection = VisibleSelection(targetPosition);
514     }
515
516     newSelection.setExtent(targetPosition);
517     if (m_frame->selectionGranularity() != CharacterGranularity)
518         newSelection.expandUsingGranularity(m_frame->selectionGranularity());
519
520     if (m_frame->shouldChangeSelection(newSelection)) {
521         m_frame->selection()->setLastChangeWasHorizontalExtension(false);
522         m_frame->selection()->setSelection(newSelection);
523     }
524 }
525     
526 bool EventHandler::handleMouseUp(const MouseEventWithHitTestResults& event)
527 {
528     if (eventLoopHandleMouseUp(event))
529         return true;
530     
531     // If this was the first click in the window, we don't even want to clear the selection.
532     // This case occurs when the user clicks on a draggable element, since we have to process
533     // the mouse down and drag events to see if we might start a drag.  For other first clicks
534     // in a window, we just don't acceptFirstMouse, and the whole down-drag-up sequence gets
535     // ignored upstream of this layer.
536     return eventActivatedView(event.event());
537 }    
538
539 bool EventHandler::handleMouseReleaseEvent(const MouseEventWithHitTestResults& event)
540 {
541     if (m_autoscrollInProgress)
542         stopAutoscrollTimer();
543
544     if (handleMouseUp(event))
545         return true;
546
547     // Used to prevent mouseMoveEvent from initiating a drag before
548     // the mouse is pressed again.
549     m_frame->selection()->setCaretBlinkingSuspended(false);
550     m_mousePressed = false;
551     m_capturesDragging = false;
552     m_mouseDownMayStartDrag = false;
553     m_mouseDownMayStartSelect = false;
554     m_mouseDownMayStartAutoscroll = false;
555     m_mouseDownWasInSubframe = false;
556   
557     bool handled = false;
558
559     // Clear the selection if the mouse didn't move after the last mouse press.
560     // We do this so when clicking on the selection, the selection goes away.
561     // However, if we are editing, place the caret.
562     if (m_mouseDownWasSingleClickInSelection && !m_beganSelectingText
563             && m_dragStartPos == event.event().pos()
564             && m_frame->selection()->isRange()) {
565         VisibleSelection newSelection;
566         Node *node = event.targetNode();
567         if (node && node->isContentEditable() && node->renderer()) {
568             VisiblePosition pos = node->renderer()->positionForPoint(event.localPoint());
569             newSelection = VisibleSelection(pos);
570         }
571         if (m_frame->shouldChangeSelection(newSelection))
572             m_frame->selection()->setSelection(newSelection);
573
574         handled = true;
575     }
576
577     m_frame->notifyRendererOfSelectionChange(true);
578
579     m_frame->selection()->selectFrameElementInParentIfFullySelected();
580
581     return handled;
582 }
583
584 void EventHandler::handleAutoscroll(RenderObject* renderer)
585 {
586     // We don't want to trigger the autoscroll or the panScroll if it's already active
587     if (m_autoscrollTimer.isActive())
588         return;     
589
590     setAutoscrollRenderer(renderer);
591
592 #if ENABLE(PAN_SCROLLING)
593     if (m_panScrollInProgress) {
594         m_panScrollStartPos = currentMousePosition();
595         m_frame->view()->addPanScrollIcon(m_panScrollStartPos);
596         // If we're not in the top frame we notify it that we are using the panScroll
597         if (m_frame != m_frame->page()->mainFrame())
598             m_frame->page()->mainFrame()->eventHandler()->setPanScrollInProgress(true);
599     }
600 #endif
601
602     startAutoscrollTimer();
603 }
604
605 void EventHandler::autoscrollTimerFired(Timer<EventHandler>*)
606 {
607     RenderObject* r = autoscrollRenderer();
608     if (!r || !r->isBox()) {
609         stopAutoscrollTimer();
610         return;
611     }
612
613     if (m_autoscrollInProgress) {
614         if (!m_mousePressed) {
615             stopAutoscrollTimer();
616             return;
617         }
618         toRenderBox(r)->autoscroll();
619     } else {
620         // we verify that the main frame hasn't received the order to stop the panScroll
621         if (!m_frame->page()->mainFrame()->eventHandler()->panScrollInProgress()) {
622             stopAutoscrollTimer();
623             return;
624         }
625 #if ENABLE(PAN_SCROLLING)
626         setPanScrollCursor();
627         toRenderBox(r)->panScroll(m_panScrollStartPos);
628 #endif
629     }
630 }
631
632 #if ENABLE(PAN_SCROLLING)
633 void EventHandler::setPanScrollCursor()
634 {
635     // At the original click location we draw a 4 arrowed icon. Over this icon there won't be any scroll
636     // So we don't want to change the cursor over this area
637     const int noScrollRadius = 9;
638     bool east = m_panScrollStartPos.x() < (m_currentMousePosition.x() - noScrollRadius);
639     bool west = m_panScrollStartPos.x() > (m_currentMousePosition.x() + noScrollRadius);
640     bool north = m_panScrollStartPos.y() > (m_currentMousePosition.y() + noScrollRadius);
641     bool south = m_panScrollStartPos.y() < (m_currentMousePosition.y() - noScrollRadius);
642          
643     if (north) {
644         if (east)
645             m_frame->view()->setCursor(northEastPanningCursor());
646         else if (west)
647             m_frame->view()->setCursor(northWestPanningCursor());
648         else
649             m_frame->view()->setCursor(northPanningCursor());
650     } else if (south) {
651         if (east)
652             m_frame->view()->setCursor(southEastPanningCursor());
653         else if (west)
654             m_frame->view()->setCursor(southWestPanningCursor());
655         else
656             m_frame->view()->setCursor(southPanningCursor());
657     } else if (east)
658         m_frame->view()->setCursor(eastPanningCursor());
659     else if (west)
660         m_frame->view()->setCursor(westPanningCursor());
661     else
662         m_frame->view()->setCursor(middlePanningCursor());
663 }
664 #endif  // ENABLE(PAN_SCROLLING)
665
666 RenderObject* EventHandler::autoscrollRenderer() const
667 {
668     return m_autoscrollRenderer;
669 }
670
671 void EventHandler::updateAutoscrollRenderer()
672 {
673     if (!m_autoscrollRenderer)
674         return;
675
676     HitTestResult hitTest = hitTestResultAtPoint(m_panScrollStartPos, true);
677
678     if (Node* nodeAtPoint = hitTest.innerNode())
679         m_autoscrollRenderer = nodeAtPoint->renderer();
680
681     while (m_autoscrollRenderer && (!m_autoscrollRenderer->isBox() || !toRenderBox(m_autoscrollRenderer)->canBeProgramaticallyScrolled(false)))
682         m_autoscrollRenderer = m_autoscrollRenderer->parent();
683 }
684
685 void EventHandler::setAutoscrollRenderer(RenderObject* renderer)
686 {
687     m_autoscrollRenderer = renderer;
688 }
689
690 void EventHandler::allowDHTMLDrag(bool& flagDHTML, bool& flagUA) const
691 {
692     if (!m_frame) {
693         flagDHTML = false;
694         flagUA = false;
695         return;
696     }
697     
698     unsigned mask = m_frame->page()->dragController()->delegateDragSourceAction(m_frame->view()->contentsToWindow(m_mouseDownPos));
699     flagDHTML = (mask & DragSourceActionDHTML) != DragSourceActionNone;
700     flagUA = ((mask & DragSourceActionImage) || (mask & DragSourceActionLink) || (mask & DragSourceActionSelection));
701 }
702     
703 HitTestResult EventHandler::hitTestResultAtPoint(const IntPoint& point, bool allowShadowContent, bool ignoreClipping)
704 {
705     HitTestResult result(point);
706     if (!m_frame->contentRenderer())
707         return result;
708     int hitType = HitTestRequest::ReadOnly | HitTestRequest::Active;
709     if (ignoreClipping)
710         hitType |= HitTestRequest::IgnoreClipping;
711     m_frame->contentRenderer()->layer()->hitTest(HitTestRequest(hitType), result);
712
713     while (true) {
714         Node* n = result.innerNode();
715         if (!result.isOverWidget() || !n || !n->renderer() || !n->renderer()->isWidget())
716             break;
717         RenderWidget* renderWidget = static_cast<RenderWidget*>(n->renderer());
718         Widget* widget = renderWidget->widget();
719         if (!widget || !widget->isFrameView())
720             break;
721         Frame* frame = static_cast<HTMLFrameElementBase*>(n)->contentFrame();
722         if (!frame || !frame->contentRenderer())
723             break;
724         FrameView* view = static_cast<FrameView*>(widget);
725         IntPoint widgetPoint(result.localPoint().x() + view->scrollX() - renderWidget->borderLeft() - renderWidget->paddingLeft(), 
726             result.localPoint().y() + view->scrollY() - renderWidget->borderTop() - renderWidget->paddingTop());
727         HitTestResult widgetHitTestResult(widgetPoint);
728         frame->contentRenderer()->layer()->hitTest(HitTestRequest(hitType), widgetHitTestResult);
729         result = widgetHitTestResult;
730     }
731     
732     // If our HitTestResult is not visible, then we started hit testing too far down the frame chain. 
733     // Another hit test at the main frame level should get us the correct visible result.
734     Frame* resultFrame = result.innerNonSharedNode() ? result.innerNonSharedNode()->document()->frame() : 0;
735     Frame* mainFrame = m_frame->page()->mainFrame();
736     if (m_frame != mainFrame && resultFrame && resultFrame != mainFrame && !resultFrame->editor()->insideVisibleArea(result.point())) {
737         IntPoint windowPoint = resultFrame->view()->contentsToWindow(result.point());
738         IntPoint mainFramePoint = mainFrame->view()->windowToContents(windowPoint);
739         result = mainFrame->eventHandler()->hitTestResultAtPoint(mainFramePoint, allowShadowContent, ignoreClipping);
740     }
741
742     if (!allowShadowContent)
743         result.setToNonShadowAncestor();
744
745     return result;
746 }
747
748
749 void EventHandler::startAutoscrollTimer()
750 {
751     m_autoscrollTimer.startRepeating(autoscrollInterval);
752 }
753
754 void EventHandler::stopAutoscrollTimer(bool rendererIsBeingDestroyed)
755 {
756     if (m_autoscrollInProgress) {
757         if (m_mouseDownWasInSubframe) {
758             if (Frame* subframe = subframeForTargetNode(m_mousePressNode.get()))
759                 subframe->eventHandler()->stopAutoscrollTimer(rendererIsBeingDestroyed);
760             return;
761         }
762     }
763
764     if (autoscrollRenderer()) {
765         if (!rendererIsBeingDestroyed && (m_autoscrollInProgress || m_panScrollInProgress))
766             toRenderBox(autoscrollRenderer())->stopAutoscroll();
767 #if ENABLE(PAN_SCROLLING)
768         if (m_panScrollInProgress) {
769             m_frame->view()->removePanScrollIcon();
770             m_frame->view()->setCursor(pointerCursor());
771         }
772 #endif
773
774         setAutoscrollRenderer(0);
775     }
776
777     m_autoscrollTimer.stop();
778
779     m_panScrollInProgress = false;
780     // If we're not in the top frame we notify it that we are not using the panScroll anymore
781     if (m_frame->page() && m_frame != m_frame->page()->mainFrame())
782             m_frame->page()->mainFrame()->eventHandler()->setPanScrollInProgress(false);
783     m_autoscrollInProgress = false;
784 }
785
786 Node* EventHandler::mousePressNode() const
787 {
788     return m_mousePressNode.get();
789 }
790
791 void EventHandler::setMousePressNode(PassRefPtr<Node> node)
792 {
793     m_mousePressNode = node;
794 }
795
796 bool EventHandler::scrollOverflow(ScrollDirection direction, ScrollGranularity granularity)
797 {
798     Node* node = m_frame->document()->focusedNode();
799     if (!node)
800         node = m_mousePressNode.get();
801     
802     if (node) {
803         RenderObject* r = node->renderer();
804         if (r && !r->isListBox())
805             return r->enclosingBox()->scroll(direction, granularity);
806     }
807
808     return false;
809 }
810
811 IntPoint EventHandler::currentMousePosition() const
812 {
813     return m_currentMousePosition;
814 }
815
816 Frame* subframeForHitTestResult(const MouseEventWithHitTestResults& hitTestResult)
817 {
818     if (!hitTestResult.isOverWidget())
819         return 0;
820     return subframeForTargetNode(hitTestResult.targetNode());
821 }
822
823 Frame* subframeForTargetNode(Node* node)
824 {
825     if (!node)
826         return 0;
827
828     RenderObject* renderer = node->renderer();
829     if (!renderer || !renderer->isWidget())
830         return 0;
831
832     Widget* widget = static_cast<RenderWidget*>(renderer)->widget();
833     if (!widget || !widget->isFrameView())
834         return 0;
835
836     return static_cast<FrameView*>(widget)->frame();
837 }
838
839 static bool isSubmitImage(Node* node)
840 {
841     return node && node->hasTagName(inputTag)
842         && static_cast<HTMLInputElement*>(node)->inputType() == HTMLInputElement::IMAGE;
843 }
844
845 // Returns true if the node's editable block is not current focused for editing
846 static bool nodeIsNotBeingEdited(Node* node, Frame* frame)
847 {
848     return frame->selection()->rootEditableElement() != node->rootEditableElement();
849 }
850
851 Cursor EventHandler::selectCursor(const MouseEventWithHitTestResults& event, Scrollbar* scrollbar)
852 {
853     // During selection, use an I-beam no matter what we're over.
854     // If you're capturing mouse events for a particular node, don't treat this as a selection.
855     if (m_mousePressed && m_mouseDownMayStartSelect && m_frame->selection()->isCaretOrRange() && !m_capturingMouseEventsNode)
856         return iBeamCursor();
857
858     Node* node = event.targetNode();
859     RenderObject* renderer = node ? node->renderer() : 0;
860     RenderStyle* style = renderer ? renderer->style() : 0;
861
862     if (renderer && renderer->isFrameSet()) {
863         RenderFrameSet* fs = static_cast<RenderFrameSet*>(renderer);
864         if (fs->canResizeRow(event.localPoint()))
865             return rowResizeCursor();
866         if (fs->canResizeColumn(event.localPoint()))
867             return columnResizeCursor();
868     }
869
870     if (style && style->cursors()) {
871         const CursorList* cursors = style->cursors();
872         for (unsigned i = 0; i < cursors->size(); ++i) {
873             CachedImage* cimage = (*cursors)[i].cursorImage.get();
874             IntPoint hotSpot = (*cursors)[i].hotSpot;
875             if (!cimage)
876                 continue;
877             // Limit the size of cursors so that they cannot be used to cover UI elements in chrome.
878             IntSize size = cimage->image()->size();
879             if (size.width() > 128 || size.height() > 128)
880                 continue;
881             // Do not let the hotspot be outside the bounds of the image. 
882             if (hotSpot.x() < 0 || hotSpot.y() < 0 || hotSpot.x() > size.width() || hotSpot.y() > size.height())
883                 continue;
884             if (cimage->image()->isNull())
885                 break;
886             if (!cimage->errorOccurred())
887                 return Cursor(cimage->image(), hotSpot);
888         }
889     }
890
891     switch (style ? style->cursor() : CURSOR_AUTO) {
892         case CURSOR_AUTO: {
893             bool editable = (node && node->isContentEditable());
894             bool editableLinkEnabled = false;
895
896             // If the link is editable, then we need to check the settings to see whether or not the link should be followed
897             if (editable) {
898                 ASSERT(m_frame->settings());
899                 switch(m_frame->settings()->editableLinkBehavior()) {
900                     default:
901                     case EditableLinkDefaultBehavior:
902                     case EditableLinkAlwaysLive:
903                         editableLinkEnabled = true;
904                         break;
905
906                     case EditableLinkNeverLive:
907                         editableLinkEnabled = false;
908                         break;
909
910                     case EditableLinkLiveWhenNotFocused:
911                         editableLinkEnabled = nodeIsNotBeingEdited(node, m_frame) || event.event().shiftKey();
912                         break;
913                     
914                     case EditableLinkOnlyLiveWithShiftKey:
915                         editableLinkEnabled = event.event().shiftKey();
916                         break;
917                 }
918             }
919             
920             if ((event.isOverLink() || isSubmitImage(node)) && (!editable || editableLinkEnabled))
921                 return handCursor();
922             RenderLayer* layer = renderer ? renderer->enclosingLayer() : 0;
923             bool inResizer = false;
924             if (m_frame->view() && layer && layer->isPointInResizeControl(m_frame->view()->windowToContents(event.event().pos())))
925                 inResizer = true;
926             if ((editable || (renderer && renderer->isText() && node->canStartSelection())) && !inResizer && !scrollbar)
927                 return iBeamCursor();
928             return pointerCursor();
929         }
930         case CURSOR_CROSS:
931             return crossCursor();
932         case CURSOR_POINTER:
933             return handCursor();
934         case CURSOR_MOVE:
935             return moveCursor();
936         case CURSOR_ALL_SCROLL:
937             return moveCursor();
938         case CURSOR_E_RESIZE:
939             return eastResizeCursor();
940         case CURSOR_W_RESIZE:
941             return westResizeCursor();
942         case CURSOR_N_RESIZE:
943             return northResizeCursor();
944         case CURSOR_S_RESIZE:
945             return southResizeCursor();
946         case CURSOR_NE_RESIZE:
947             return northEastResizeCursor();
948         case CURSOR_SW_RESIZE:
949             return southWestResizeCursor();
950         case CURSOR_NW_RESIZE:
951             return northWestResizeCursor();
952         case CURSOR_SE_RESIZE:
953             return southEastResizeCursor();
954         case CURSOR_NS_RESIZE:
955             return northSouthResizeCursor();
956         case CURSOR_EW_RESIZE:
957             return eastWestResizeCursor();
958         case CURSOR_NESW_RESIZE:
959             return northEastSouthWestResizeCursor();
960         case CURSOR_NWSE_RESIZE:
961             return northWestSouthEastResizeCursor();
962         case CURSOR_COL_RESIZE:
963             return columnResizeCursor();
964         case CURSOR_ROW_RESIZE:
965             return rowResizeCursor();
966         case CURSOR_TEXT:
967             return iBeamCursor();
968         case CURSOR_WAIT:
969             return waitCursor();
970         case CURSOR_HELP:
971             return helpCursor();
972         case CURSOR_VERTICAL_TEXT:
973             return verticalTextCursor();
974         case CURSOR_CELL:
975             return cellCursor();
976         case CURSOR_CONTEXT_MENU:
977             return contextMenuCursor();
978         case CURSOR_PROGRESS:
979             return progressCursor();
980         case CURSOR_NO_DROP:
981             return noDropCursor();
982         case CURSOR_ALIAS:
983             return aliasCursor();
984         case CURSOR_COPY:
985             return copyCursor();
986         case CURSOR_NONE:
987             return noneCursor();
988         case CURSOR_NOT_ALLOWED:
989             return notAllowedCursor();
990         case CURSOR_DEFAULT:
991             return pointerCursor();
992         case CURSOR_WEBKIT_ZOOM_IN:
993             return zoomInCursor();
994         case CURSOR_WEBKIT_ZOOM_OUT:
995             return zoomOutCursor();
996         case CURSOR_WEBKIT_GRAB:
997             return grabCursor();
998         case CURSOR_WEBKIT_GRABBING:
999             return grabbingCursor();
1000     }
1001     return pointerCursor();
1002 }
1003
1004 bool EventHandler::handleMousePressEvent(const PlatformMouseEvent& mouseEvent)
1005 {
1006     RefPtr<FrameView> protector(m_frame->view());
1007
1008     m_mousePressed = true;
1009     m_capturesDragging = true;
1010     m_currentMousePosition = mouseEvent.pos();
1011     m_mouseDownTimestamp = mouseEvent.timestamp();
1012     m_mouseDownMayStartDrag = false;
1013     m_mouseDownMayStartSelect = false;
1014     m_mouseDownMayStartAutoscroll = false;
1015     m_mouseDownPos = m_frame->view()->windowToContents(mouseEvent.pos());
1016     m_mouseDownWasInSubframe = false;
1017
1018     HitTestRequest request(HitTestRequest::Active);
1019     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1020
1021     if (!mev.targetNode()) {
1022         invalidateClick();
1023         return false;
1024     }
1025
1026     m_mousePressNode = mev.targetNode();
1027
1028     InspectorController* inspector = m_frame->page()->inspectorController();
1029     if (inspector && inspector->enabled() && inspector->searchingForNodeInPage()) {
1030         inspector->handleMousePressOnNode(m_mousePressNode.get());
1031         invalidateClick();
1032         return true;
1033     }
1034
1035     Frame* subframe = subframeForHitTestResult(mev);
1036     if (subframe && passMousePressEventToSubframe(mev, subframe)) {
1037         // Start capturing future events for this frame.  We only do this if we didn't clear
1038         // the m_mousePressed flag, which may happen if an AppKit widget entered a modal event loop.
1039         m_capturesDragging = subframe->eventHandler()->capturesDragging();
1040         if (m_mousePressed && m_capturesDragging)
1041             m_capturingMouseEventsNode = mev.targetNode();
1042         invalidateClick();
1043         return true;
1044     }
1045
1046 #if ENABLE(PAN_SCROLLING)
1047     if (m_frame->page()->mainFrame()->eventHandler()->panScrollInProgress() || m_autoscrollInProgress) {
1048         stopAutoscrollTimer();
1049         invalidateClick();
1050         return true;
1051     }
1052     
1053     if (mouseEvent.button() == MiddleButton && !mev.isOverLink()) {
1054         RenderObject* renderer = mev.targetNode()->renderer();
1055
1056         while (renderer && (!renderer->isBox() || !toRenderBox(renderer)->canBeProgramaticallyScrolled(false))) {
1057             if (!renderer->parent() && renderer->node() == renderer->document() && renderer->document()->ownerElement())
1058                 renderer = renderer->document()->ownerElement()->renderer();
1059             else
1060                 renderer = renderer->parent();
1061         }
1062
1063         if (renderer) {
1064             m_panScrollInProgress = true;
1065             handleAutoscroll(renderer);
1066             invalidateClick();
1067             return true;
1068         }
1069    }
1070 #endif
1071
1072     m_clickCount = mouseEvent.clickCount();
1073     m_clickNode = mev.targetNode();
1074     
1075     RenderLayer* layer = m_clickNode->renderer() ? m_clickNode->renderer()->enclosingLayer() : 0;
1076     IntPoint p = m_frame->view()->windowToContents(mouseEvent.pos());
1077     if (layer && layer->isPointInResizeControl(p)) {
1078         layer->setInResizeMode(true);
1079         m_resizeLayer = layer;
1080         m_offsetFromResizeCorner = layer->offsetFromResizeCorner(p);
1081         invalidateClick();
1082         return true;
1083     }
1084
1085     bool swallowEvent = dispatchMouseEvent(eventNames().mousedownEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true);
1086     m_capturesDragging = !swallowEvent;
1087
1088     // If the hit testing originally determined the event was in a scrollbar, refetch the MouseEventWithHitTestResults
1089     // in case the scrollbar widget was destroyed when the mouse event was handled.
1090     if (mev.scrollbar()) {
1091         const bool wasLastScrollBar = mev.scrollbar() == m_lastScrollbarUnderMouse.get();
1092         HitTestRequest request(HitTestRequest::ReadOnly |
1093                                HitTestRequest::Active);
1094         mev = prepareMouseEvent(request, mouseEvent);
1095
1096         if (wasLastScrollBar && mev.scrollbar() != m_lastScrollbarUnderMouse.get())
1097             m_lastScrollbarUnderMouse = 0;
1098     }
1099
1100     if (swallowEvent) {
1101         // scrollbars should get events anyway, even disabled controls might be scrollable
1102         if (mev.scrollbar())
1103             passMousePressEventToScrollbar(mev, mev.scrollbar());
1104     } else {
1105         // Refetch the event target node if it currently is the shadow node inside an <input> element.
1106         // If a mouse event handler changes the input element type to one that has a widget associated,
1107         // we'd like to EventHandler::handleMousePressEvent to pass the event to the widget and thus the
1108         // event target node can't still be the shadow node.
1109         if (mev.targetNode()->isShadowNode() && mev.targetNode()->shadowParentNode()->hasTagName(inputTag)) {
1110             HitTestRequest request(HitTestRequest::ReadOnly |
1111                                    HitTestRequest::Active);
1112             mev = prepareMouseEvent(request, mouseEvent);
1113         }
1114
1115         Scrollbar* scrollbar = m_frame->view()->scrollbarUnderMouse(mouseEvent);
1116         if (!scrollbar)
1117             scrollbar = mev.scrollbar();
1118         if (scrollbar && passMousePressEventToScrollbar(mev, scrollbar))
1119             swallowEvent = true;
1120         else
1121             swallowEvent = handleMousePressEvent(mev);
1122     }
1123
1124     return swallowEvent;
1125 }
1126
1127 // This method only exists for platforms that don't know how to deliver 
1128 bool EventHandler::handleMouseDoubleClickEvent(const PlatformMouseEvent& mouseEvent)
1129 {
1130     RefPtr<FrameView> protector(m_frame->view());
1131
1132     // We get this instead of a second mouse-up 
1133     m_mousePressed = false;
1134     m_currentMousePosition = mouseEvent.pos();
1135
1136     HitTestRequest request(HitTestRequest::Active);
1137     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1138     Frame* subframe = subframeForHitTestResult(mev);
1139     if (subframe && passMousePressEventToSubframe(mev, subframe)) {
1140         m_capturingMouseEventsNode = 0;
1141         return true;
1142     }
1143
1144     m_clickCount = mouseEvent.clickCount();
1145     bool swallowMouseUpEvent = dispatchMouseEvent(eventNames().mouseupEvent, mev.targetNode(), true, m_clickCount, mouseEvent, false);
1146
1147     bool swallowClickEvent = false;
1148     // Don't ever dispatch click events for right clicks
1149     if (mouseEvent.button() != RightButton && mev.targetNode() == m_clickNode)
1150         swallowClickEvent = dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true);
1151
1152     if (m_lastScrollbarUnderMouse)
1153         swallowMouseUpEvent = m_lastScrollbarUnderMouse->mouseUp();
1154             
1155     bool swallowMouseReleaseEvent = false;
1156     if (!swallowMouseUpEvent)
1157         swallowMouseReleaseEvent = handleMouseReleaseEvent(mev);
1158
1159     invalidateClick();
1160
1161     return swallowMouseUpEvent || swallowClickEvent || swallowMouseReleaseEvent;
1162 }
1163
1164 bool EventHandler::mouseMoved(const PlatformMouseEvent& event)
1165 {
1166     HitTestResult hoveredNode = HitTestResult(IntPoint());
1167     bool result = handleMouseMoveEvent(event, &hoveredNode);
1168
1169     Page* page = m_frame->page();
1170     if (!page)
1171         return result;
1172
1173     hoveredNode.setToNonShadowAncestor();
1174     page->chrome()->mouseDidMoveOverElement(hoveredNode, event.modifierFlags());
1175     page->chrome()->setToolTip(hoveredNode);
1176     return result;
1177 }
1178
1179 bool EventHandler::handleMouseMoveEvent(const PlatformMouseEvent& mouseEvent, HitTestResult* hoveredNode)
1180 {
1181     // in Radar 3703768 we saw frequent crashes apparently due to the
1182     // part being null here, which seems impossible, so check for nil
1183     // but also assert so that we can try to figure this out in debug
1184     // builds, if it happens.
1185     ASSERT(m_frame);
1186     if (!m_frame)
1187         return false;
1188
1189     RefPtr<FrameView> protector(m_frame->view());
1190     m_currentMousePosition = mouseEvent.pos();
1191
1192     if (m_hoverTimer.isActive())
1193         m_hoverTimer.stop();
1194
1195 #if ENABLE(SVG)
1196     if (m_svgPan) {
1197         static_cast<SVGDocument*>(m_frame->document())->updatePan(m_currentMousePosition);
1198         return true;
1199     }
1200 #endif
1201
1202     if (m_frameSetBeingResized)
1203         return dispatchMouseEvent(eventNames().mousemoveEvent, m_frameSetBeingResized.get(), false, 0, mouseEvent, false);
1204
1205     // Send events right to a scrollbar if the mouse is pressed.
1206     if (m_lastScrollbarUnderMouse && m_mousePressed)
1207         return m_lastScrollbarUnderMouse->mouseMoved(m_lastScrollbarUnderMouse->transformEvent(mouseEvent));
1208
1209     // Treat mouse move events while the mouse is pressed as "read-only" in prepareMouseEvent
1210     // if we are allowed to select.
1211     // This means that :hover and :active freeze in the state they were in when the mouse
1212     // was pressed, rather than updating for nodes the mouse moves over as you hold the mouse down.
1213     int hitType = HitTestRequest::MouseMove;
1214     if (m_mousePressed && m_mouseDownMayStartSelect)
1215         hitType |= HitTestRequest::ReadOnly;
1216     if (m_mousePressed)
1217         hitType |= HitTestRequest::Active;
1218     HitTestRequest request(hitType);
1219     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1220     if (hoveredNode)
1221         *hoveredNode = mev.hitTestResult();
1222
1223     Scrollbar* scrollbar = 0;
1224
1225     if (m_resizeLayer && m_resizeLayer->inResizeMode())
1226         m_resizeLayer->resize(mouseEvent, m_offsetFromResizeCorner);
1227     else {
1228         if (m_frame->view())
1229             scrollbar = m_frame->view()->scrollbarUnderMouse(mouseEvent);
1230
1231         if (!scrollbar)
1232             scrollbar = mev.scrollbar();
1233
1234         if (m_lastScrollbarUnderMouse != scrollbar) {
1235             // Send mouse exited to the old scrollbar.
1236             if (m_lastScrollbarUnderMouse)
1237                 m_lastScrollbarUnderMouse->mouseExited();
1238             m_lastScrollbarUnderMouse = m_mousePressed ? 0 : scrollbar;
1239         }
1240     }
1241
1242     bool swallowEvent = false;
1243     RefPtr<Frame> newSubframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
1244  
1245     // We want mouseouts to happen first, from the inside out.  First send a move event to the last subframe so that it will fire mouseouts.
1246     if (m_lastMouseMoveEventSubframe && m_lastMouseMoveEventSubframe->tree()->isDescendantOf(m_frame) && m_lastMouseMoveEventSubframe != newSubframe)
1247         passMouseMoveEventToSubframe(mev, m_lastMouseMoveEventSubframe.get());
1248
1249     if (newSubframe) {
1250         // Update over/out state before passing the event to the subframe.
1251         updateMouseEventTargetNode(mev.targetNode(), mouseEvent, true);
1252         
1253         // Event dispatch in updateMouseEventTargetNode may have caused the subframe of the target
1254         // node to be detached from its FrameView, in which case the event should not be passed.
1255         if (newSubframe->view())
1256             swallowEvent |= passMouseMoveEventToSubframe(mev, newSubframe.get(), hoveredNode);
1257     } else {
1258         if (scrollbar && !m_mousePressed)
1259             scrollbar->mouseMoved(scrollbar->transformEvent(mouseEvent)); // Handle hover effects on platforms that support visual feedback on scrollbar hovering.
1260         if ((!m_resizeLayer || !m_resizeLayer->inResizeMode()) && !m_frame->page()->mainFrame()->eventHandler()->panScrollInProgress() && m_frame->view())
1261             m_frame->view()->setCursor(selectCursor(mev, scrollbar));
1262     }
1263     
1264     m_lastMouseMoveEventSubframe = newSubframe;
1265
1266     if (swallowEvent)
1267         return true;
1268     
1269     swallowEvent = dispatchMouseEvent(eventNames().mousemoveEvent, mev.targetNode(), false, 0, mouseEvent, true);
1270     if (!swallowEvent)
1271         swallowEvent = handleMouseDraggedEvent(mev);
1272
1273     return swallowEvent;
1274 }
1275
1276 void EventHandler::invalidateClick()
1277 {
1278     m_clickCount = 0;
1279     m_clickNode = 0;
1280 }
1281
1282 bool EventHandler::handleMouseReleaseEvent(const PlatformMouseEvent& mouseEvent)
1283 {
1284     RefPtr<FrameView> protector(m_frame->view());
1285
1286     m_mousePressed = false;
1287     m_currentMousePosition = mouseEvent.pos();
1288
1289 #if ENABLE(SVG)
1290     if (m_svgPan) {
1291         m_svgPan = false;
1292         static_cast<SVGDocument*>(m_frame->document())->updatePan(m_currentMousePosition);
1293         return true;
1294     }
1295 #endif
1296
1297     if (m_frameSetBeingResized)
1298         return dispatchMouseEvent(eventNames().mouseupEvent, m_frameSetBeingResized.get(), true, m_clickCount, mouseEvent, false);
1299
1300     if (m_lastScrollbarUnderMouse) {
1301         invalidateClick();
1302         return m_lastScrollbarUnderMouse->mouseUp();
1303     }
1304
1305     HitTestRequest request(HitTestRequest::MouseUp);
1306     MouseEventWithHitTestResults mev = prepareMouseEvent(request, mouseEvent);
1307     Frame* subframe = m_capturingMouseEventsNode.get() ? subframeForTargetNode(m_capturingMouseEventsNode.get()) : subframeForHitTestResult(mev);
1308     if (subframe && passMouseReleaseEventToSubframe(mev, subframe)) {
1309         m_capturingMouseEventsNode = 0;
1310         return true;
1311     }
1312
1313     bool swallowMouseUpEvent = dispatchMouseEvent(eventNames().mouseupEvent, mev.targetNode(), true, m_clickCount, mouseEvent, false);
1314
1315     // Don't ever dispatch click events for right clicks
1316     bool swallowClickEvent = false;
1317     if (m_clickCount > 0 && mouseEvent.button() != RightButton && mev.targetNode() == m_clickNode)
1318         swallowClickEvent = dispatchMouseEvent(eventNames().clickEvent, mev.targetNode(), true, m_clickCount, mouseEvent, true);
1319
1320     if (m_resizeLayer) {
1321         m_resizeLayer->setInResizeMode(false);
1322         m_resizeLayer = 0;
1323     }
1324
1325     bool swallowMouseReleaseEvent = false;
1326     if (!swallowMouseUpEvent)
1327         swallowMouseReleaseEvent = handleMouseReleaseEvent(mev);
1328
1329     invalidateClick();
1330
1331     return swallowMouseUpEvent || swallowClickEvent || swallowMouseReleaseEvent;
1332 }
1333
1334 bool EventHandler::dispatchDragEvent(const AtomicString& eventType, Node* dragTarget, const PlatformMouseEvent& event, Clipboard* clipboard)
1335 {
1336     IntPoint contentsPos = m_frame->view()->windowToContents(event.pos());
1337     
1338     RefPtr<MouseEvent> me = MouseEvent::create(eventType,
1339         true, true, m_frame->document()->defaultView(),
1340         0, event.globalX(), event.globalY(), contentsPos.x(), contentsPos.y(),
1341         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
1342         0, 0, clipboard);
1343
1344     ExceptionCode ec = 0;
1345     dragTarget->dispatchEvent(me.get(), ec);
1346     return me->defaultPrevented();
1347 }
1348
1349 bool EventHandler::updateDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
1350 {
1351     bool accept = false;
1352
1353     if (!m_frame->view())
1354         return false;
1355
1356     HitTestRequest request(HitTestRequest::ReadOnly);
1357     MouseEventWithHitTestResults mev = prepareMouseEvent(request, event);
1358
1359     // Drag events should never go to text nodes (following IE, and proper mouseover/out dispatch)
1360     Node* newTarget = mev.targetNode();
1361     if (newTarget && newTarget->isTextNode())
1362         newTarget = newTarget->parentNode();
1363     if (newTarget)
1364         newTarget = newTarget->shadowAncestorNode();
1365
1366     if (m_dragTarget != newTarget) {
1367         // FIXME: this ordering was explicitly chosen to match WinIE. However,
1368         // it is sometimes incorrect when dragging within subframes, as seen with
1369         // LayoutTests/fast/events/drag-in-frames.html.
1370         if (newTarget)
1371             if (newTarget->hasTagName(frameTag) || newTarget->hasTagName(iframeTag))
1372                 accept = static_cast<HTMLFrameElementBase*>(newTarget)->contentFrame()->eventHandler()->updateDragAndDrop(event, clipboard);
1373             else
1374                 accept = dispatchDragEvent(eventNames().dragenterEvent, newTarget, event, clipboard);
1375         
1376         if (m_dragTarget) {
1377             Frame* frame = (m_dragTarget->hasTagName(frameTag) || m_dragTarget->hasTagName(iframeTag)) 
1378                             ? static_cast<HTMLFrameElementBase*>(m_dragTarget.get())->contentFrame() : 0;
1379             if (frame)
1380                 accept = frame->eventHandler()->updateDragAndDrop(event, clipboard);
1381             else
1382                 dispatchDragEvent(eventNames().dragleaveEvent, m_dragTarget.get(), event, clipboard);
1383         }
1384     } else {
1385         if (newTarget)
1386             if (newTarget->hasTagName(frameTag) || newTarget->hasTagName(iframeTag))
1387                 accept = static_cast<HTMLFrameElementBase*>(newTarget)->contentFrame()->eventHandler()->updateDragAndDrop(event, clipboard);
1388             else
1389                 accept = dispatchDragEvent(eventNames().dragoverEvent, newTarget, event, clipboard);
1390     }
1391     m_dragTarget = newTarget;
1392
1393     return accept;
1394 }
1395
1396 void EventHandler::cancelDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
1397 {
1398     if (m_dragTarget) {
1399         Frame* frame = (m_dragTarget->hasTagName(frameTag) || m_dragTarget->hasTagName(iframeTag)) 
1400                         ? static_cast<HTMLFrameElementBase*>(m_dragTarget.get())->contentFrame() : 0;
1401         if (frame)
1402             frame->eventHandler()->cancelDragAndDrop(event, clipboard);
1403         else
1404             dispatchDragEvent(eventNames().dragleaveEvent, m_dragTarget.get(), event, clipboard);
1405     }
1406     clearDragState();
1407 }
1408
1409 bool EventHandler::performDragAndDrop(const PlatformMouseEvent& event, Clipboard* clipboard)
1410 {
1411     bool accept = false;
1412     if (m_dragTarget) {
1413         Frame* frame = (m_dragTarget->hasTagName(frameTag) || m_dragTarget->hasTagName(iframeTag)) 
1414                         ? static_cast<HTMLFrameElementBase*>(m_dragTarget.get())->contentFrame() : 0;
1415         if (frame)
1416             accept = frame->eventHandler()->performDragAndDrop(event, clipboard);
1417         else
1418             accept = dispatchDragEvent(eventNames().dropEvent, m_dragTarget.get(), event, clipboard);
1419     }
1420     clearDragState();
1421     return accept;
1422 }
1423
1424 void EventHandler::clearDragState()
1425 {
1426     m_dragTarget = 0;
1427     m_capturingMouseEventsNode = 0;
1428 #if PLATFORM(MAC)
1429     m_sendingEventToSubview = false;
1430 #endif
1431 }
1432
1433 void EventHandler::setCapturingMouseEventsNode(PassRefPtr<Node> n)
1434 {
1435     m_capturingMouseEventsNode = n;
1436 }
1437
1438 MouseEventWithHitTestResults EventHandler::prepareMouseEvent(const HitTestRequest& request, const PlatformMouseEvent& mev)
1439 {
1440     ASSERT(m_frame);
1441     ASSERT(m_frame->document());
1442     
1443     IntPoint documentPoint = m_frame->view()->windowToContents(mev.pos());
1444     return m_frame->document()->prepareMouseEvent(request, documentPoint, mev);
1445 }
1446
1447 #if ENABLE(SVG)
1448 static inline SVGElementInstance* instanceAssociatedWithShadowTreeElement(Node* referenceNode)
1449 {
1450     if (!referenceNode || !referenceNode->isSVGElement())
1451         return 0;
1452
1453     Node* shadowTreeElement = referenceNode->shadowTreeRootNode();
1454     if (!shadowTreeElement)
1455         return 0;
1456
1457     Node* shadowTreeParentElement = shadowTreeElement->shadowParentNode();
1458     if (!shadowTreeParentElement)
1459         return 0;
1460
1461     ASSERT(shadowTreeParentElement->hasTagName(useTag));
1462     return static_cast<SVGUseElement*>(shadowTreeParentElement)->instanceForShadowTreeElement(referenceNode);
1463 }
1464 #endif
1465
1466 void EventHandler::updateMouseEventTargetNode(Node* targetNode, const PlatformMouseEvent& mouseEvent, bool fireMouseOverOut)
1467 {
1468     Node* result = targetNode;
1469     
1470     // If we're capturing, we always go right to that node.
1471     if (m_capturingMouseEventsNode)
1472         result = m_capturingMouseEventsNode.get();
1473     else {
1474         // If the target node is a text node, dispatch on the parent node - rdar://4196646
1475         if (result && result->isTextNode())
1476             result = result->parentNode();
1477         if (result)
1478             result = result->shadowAncestorNode();
1479     }
1480     m_nodeUnderMouse = result;
1481 #if ENABLE(SVG)
1482     m_instanceUnderMouse = instanceAssociatedWithShadowTreeElement(result);
1483
1484     // <use> shadow tree elements may have been recloned, update node under mouse in any case
1485     if (m_lastInstanceUnderMouse) {
1486         SVGElement* lastCorrespondingElement = m_lastInstanceUnderMouse->correspondingElement();
1487         SVGElement* lastCorrespondingUseElement = m_lastInstanceUnderMouse->correspondingUseElement();
1488
1489         if (lastCorrespondingElement && lastCorrespondingUseElement) {
1490             HashSet<SVGElementInstance*> instances = lastCorrespondingElement->instancesForElement();
1491
1492             // Locate the recloned shadow tree element for our corresponding instance
1493             HashSet<SVGElementInstance*>::iterator end = instances.end();
1494             for (HashSet<SVGElementInstance*>::iterator it = instances.begin(); it != end; ++it) {
1495                 SVGElementInstance* instance = (*it);
1496                 ASSERT(instance->correspondingElement() == lastCorrespondingElement);
1497
1498                 if (instance == m_lastInstanceUnderMouse)
1499                     continue;
1500
1501                 if (instance->correspondingUseElement() != lastCorrespondingUseElement)
1502                     continue;
1503
1504                 SVGElement* shadowTreeElement = instance->shadowTreeElement();
1505                 if (!shadowTreeElement->inDocument() || m_lastNodeUnderMouse == shadowTreeElement)
1506                     continue;
1507
1508                 m_lastNodeUnderMouse = shadowTreeElement;
1509                 m_lastInstanceUnderMouse = instance;
1510                 break;
1511             }
1512         }
1513     }
1514 #endif
1515
1516     // Fire mouseout/mouseover if the mouse has shifted to a different node.
1517     if (fireMouseOverOut) {
1518         if (m_lastNodeUnderMouse && m_lastNodeUnderMouse->document() != m_frame->document()) {
1519             m_lastNodeUnderMouse = 0;
1520             m_lastScrollbarUnderMouse = 0;
1521 #if ENABLE(SVG)
1522             m_lastInstanceUnderMouse = 0;
1523 #endif
1524         }
1525
1526         if (m_lastNodeUnderMouse != m_nodeUnderMouse) {
1527             // send mouseout event to the old node
1528             if (m_lastNodeUnderMouse)
1529                 m_lastNodeUnderMouse->dispatchMouseEvent(mouseEvent, eventNames().mouseoutEvent, 0, m_nodeUnderMouse.get());
1530             // send mouseover event to the new node
1531             if (m_nodeUnderMouse)
1532                 m_nodeUnderMouse->dispatchMouseEvent(mouseEvent, eventNames().mouseoverEvent, 0, m_lastNodeUnderMouse.get());
1533         }
1534         m_lastNodeUnderMouse = m_nodeUnderMouse;
1535 #if ENABLE(SVG)
1536         m_lastInstanceUnderMouse = instanceAssociatedWithShadowTreeElement(m_nodeUnderMouse.get());
1537 #endif
1538     }
1539 }
1540
1541 bool EventHandler::dispatchMouseEvent(const AtomicString& eventType, Node* targetNode, bool /*cancelable*/, int clickCount, const PlatformMouseEvent& mouseEvent, bool setUnder)
1542 {
1543     updateMouseEventTargetNode(targetNode, mouseEvent, setUnder);
1544
1545     bool swallowEvent = false;
1546
1547     if (m_nodeUnderMouse)
1548         swallowEvent = m_nodeUnderMouse->dispatchMouseEvent(mouseEvent, eventType, clickCount);
1549     
1550     if (!swallowEvent && eventType == eventNames().mousedownEvent) {
1551         // Blur current focus node when a link/button is clicked; this
1552         // is expected by some sites that rely on onChange handlers running
1553         // from form fields before the button click is processed.
1554         Node* node = m_nodeUnderMouse.get();
1555         RenderObject* renderer = node ? node->renderer() : 0;
1556                 
1557         // Walk up the render tree to search for a node to focus.
1558         // Walking up the DOM tree wouldn't work for shadow trees, like those behind the engine-based text fields.
1559         while (renderer) {
1560             node = renderer->node();
1561             if (node && node->isFocusable()) {
1562                 // To fix <rdar://problem/4895428> Can't drag selected ToDo, we don't focus a 
1563                 // node on mouse down if it's selected and inside a focused node. It will be 
1564                 // focused if the user does a mouseup over it, however, because the mouseup
1565                 // will set a selection inside it, which will call setFocuseNodeIfNeeded.
1566                 ExceptionCode ec = 0;
1567                 Node* n = node->isShadowNode() ? node->shadowParentNode() : node;
1568                 if (m_frame->selection()->isRange() && 
1569                     m_frame->selection()->toNormalizedRange()->compareNode(n, ec) == Range::NODE_INSIDE &&
1570                     n->isDescendantOf(m_frame->document()->focusedNode()))
1571                     return false;
1572                     
1573                 break;
1574             }
1575             
1576             renderer = renderer->parent();
1577         }
1578         // If focus shift is blocked, we eat the event.  Note we should never clear swallowEvent
1579         // if the page already set it (e.g., by canceling default behavior).
1580         if (node && node->isMouseFocusable()) {
1581             if (!m_frame->page()->focusController()->setFocusedNode(node, m_frame))
1582                 swallowEvent = true;
1583         } else if (!node || !node->focused()) {
1584             if (!m_frame->page()->focusController()->setFocusedNode(0, m_frame))
1585                 swallowEvent = true;
1586         }
1587     }
1588
1589     return swallowEvent;
1590 }
1591
1592 bool EventHandler::handleWheelEvent(PlatformWheelEvent& e)
1593 {
1594     Document* doc = m_frame->document();
1595
1596     RenderObject* docRenderer = doc->renderer();
1597     if (!docRenderer)
1598         return false;
1599     
1600     RefPtr<FrameView> protector(m_frame->view());
1601
1602     IntPoint vPoint = m_frame->view()->windowToContents(e.pos());
1603
1604     HitTestRequest request(HitTestRequest::ReadOnly);
1605     HitTestResult result(vPoint);
1606     doc->renderView()->layer()->hitTest(request, result);
1607     Node* node = result.innerNode();
1608     
1609     if (node) {
1610         // Figure out which view to send the event to.
1611         RenderObject* target = node->renderer();
1612         
1613         if (result.isOverWidget() && target && target->isWidget()) {
1614             Widget* widget = static_cast<RenderWidget*>(target)->widget();
1615
1616             if (widget && passWheelEventToWidget(e, widget)) {
1617                 e.accept();
1618                 return true;
1619             }
1620         }
1621
1622         node = node->shadowAncestorNode();
1623         node->dispatchWheelEvent(e);
1624         if (e.isAccepted())
1625             return true;
1626         
1627         // If we don't have a renderer, send the wheel event to the first node we find with a renderer.
1628         // This is needed for <option> and <optgroup> elements so that <select>s get a wheel scroll.
1629         while (node && !node->renderer())
1630             node = node->parent();
1631         
1632         if (node && node->renderer()) {
1633             // Just break up into two scrolls if we need to.  Diagonal movement on 
1634             // a MacBook pro is an example of a 2-dimensional mouse wheel event (where both deltaX and deltaY can be set).
1635             scrollAndAcceptEvent(e.deltaX(), ScrollLeft, ScrollRight, e, node);
1636             scrollAndAcceptEvent(e.deltaY(), ScrollUp, ScrollDown, e, node);
1637         }
1638     }
1639
1640     if (!e.isAccepted())
1641         m_frame->view()->wheelEvent(e);
1642     
1643     return e.isAccepted();
1644 }
1645
1646 bool EventHandler::sendContextMenuEvent(const PlatformMouseEvent& event)
1647 {
1648     Document* doc = m_frame->document();
1649     FrameView* v = m_frame->view();
1650     if (!v)
1651         return false;
1652     
1653     bool swallowEvent;
1654     IntPoint viewportPos = v->windowToContents(event.pos());
1655     HitTestRequest request(HitTestRequest::Active);
1656     MouseEventWithHitTestResults mev = doc->prepareMouseEvent(request, viewportPos, event);
1657
1658     // Context menu events shouldn't select text in GTK+ applications or in Chromium.
1659     // FIXME: This should probably be configurable by embedders. Consider making it a WebPreferences setting.
1660     // See: https://bugs.webkit.org/show_bug.cgi?id=15279
1661 #if !PLATFORM(GTK) && !PLATFORM(CHROMIUM)
1662     if (!m_frame->selection()->contains(viewportPos) && 
1663         // FIXME: In the editable case, word selection sometimes selects content that isn't underneath the mouse.
1664         // If the selection is non-editable, we do word selection to make it easier to use the contextual menu items
1665         // available for text selections.  But only if we're above text.
1666         (m_frame->selection()->isContentEditable() || mev.targetNode() && mev.targetNode()->isTextNode())) {
1667         m_mouseDownMayStartSelect = true; // context menu events are always allowed to perform a selection
1668         selectClosestWordOrLinkFromMouseEvent(mev);
1669     }
1670 #endif
1671
1672     swallowEvent = dispatchMouseEvent(eventNames().contextmenuEvent, mev.targetNode(), true, 0, event, true);
1673     
1674     return swallowEvent;
1675 }
1676
1677 void EventHandler::scheduleHoverStateUpdate()
1678 {
1679     if (!m_hoverTimer.isActive())
1680         m_hoverTimer.startOneShot(0);
1681 }
1682
1683 // Whether or not a mouse down can begin the creation of a selection.  Fires the selectStart event.
1684 bool EventHandler::canMouseDownStartSelect(Node* node)
1685 {
1686     if (!node || !node->renderer())
1687         return true;
1688     
1689     // Some controls and images can't start a select on a mouse down.
1690     if (!node->canStartSelection())
1691         return false;
1692             
1693     for (RenderObject* curr = node->renderer(); curr; curr = curr->parent()) {
1694         if (Node* node = curr->node())
1695             return node->dispatchEventForType(eventNames().selectstartEvent, true, true);
1696     }
1697
1698     return true;
1699 }
1700
1701 bool EventHandler::canMouseDragExtendSelect(Node* node)
1702 {
1703     if (!node || !node->renderer())
1704         return true;
1705             
1706     for (RenderObject* curr = node->renderer(); curr; curr = curr->parent()) {
1707         if (Node* node = curr->node())
1708             return node->dispatchEventForType(eventNames().selectstartEvent, true, true);
1709     }
1710
1711     return true;
1712 }
1713
1714 void EventHandler::setResizingFrameSet(HTMLFrameSetElement* frameSet)
1715 {
1716     m_frameSetBeingResized = frameSet;
1717 }
1718
1719 void EventHandler::resizeLayerDestroyed()
1720 {
1721     ASSERT(m_resizeLayer);
1722     m_resizeLayer = 0;
1723 }
1724
1725 void EventHandler::hoverTimerFired(Timer<EventHandler>*)
1726 {
1727     m_hoverTimer.stop();
1728
1729     ASSERT(m_frame);
1730     ASSERT(m_frame->document());
1731
1732     if (RenderView* renderer = m_frame->contentRenderer()) {
1733         HitTestRequest request(HitTestRequest::MouseMove);
1734         HitTestResult result(m_frame->view()->windowToContents(m_currentMousePosition));
1735         renderer->layer()->hitTest(request, result);
1736         m_frame->document()->updateRendering();
1737     }
1738 }
1739
1740 static Node* eventTargetNodeForDocument(Document* doc)
1741 {
1742     if (!doc)
1743         return 0;
1744     Node* node = doc->focusedNode();
1745     if (!node) {
1746         if (doc->isHTMLDocument())
1747             node = doc->body();
1748         else
1749             node = doc->documentElement();
1750         if (!node)
1751             return 0;
1752     }
1753     return node;
1754 }
1755
1756 bool EventHandler::handleAccessKey(const PlatformKeyboardEvent& evt)
1757 {
1758     // FIXME: Ignoring the state of Shift key is what neither IE nor Firefox do.
1759     // IE matches lower and upper case access keys regardless of Shift key state - but if both upper and
1760     // lower case variants are present in a document, the correct element is matched based on Shift key state.
1761     // Firefox only matches an access key if Shift is not pressed, and does that case-insensitively.
1762     ASSERT(!(accessKeyModifiers() & PlatformKeyboardEvent::ShiftKey));
1763     if ((evt.modifiers() & ~PlatformKeyboardEvent::ShiftKey) != accessKeyModifiers())
1764         return false;
1765     String key = evt.unmodifiedText();
1766     Element* elem = m_frame->document()->getElementByAccessKey(key.lower());
1767     if (!elem)
1768         return false;
1769     elem->accessKeyAction(false);
1770     return true;
1771 }
1772
1773 #if !PLATFORM(MAC)
1774 bool EventHandler::needsKeyboardEventDisambiguationQuirks() const
1775 {
1776     return false;
1777 }
1778 #endif
1779
1780 bool EventHandler::keyEvent(const PlatformKeyboardEvent& initialKeyEvent)
1781 {
1782 #if ENABLE(PAN_SCROLLING)
1783     if (m_frame->page()->mainFrame()->eventHandler()->panScrollInProgress() || m_autoscrollInProgress) {
1784         String escKeyId = "U+001B";
1785         // If a key is pressed while the autoscroll/panScroll is in progress then we want to stop
1786         if (initialKeyEvent.keyIdentifier() == escKeyId && initialKeyEvent.type() == PlatformKeyboardEvent::KeyUp) 
1787             stopAutoscrollTimer();
1788
1789         // If we were in autoscroll/panscroll mode, we swallow the key event
1790         return true;
1791     }
1792 #endif
1793
1794     // Check for cases where we are too early for events -- possible unmatched key up
1795     // from pressing return in the location bar.
1796     RefPtr<Node> node = eventTargetNodeForDocument(m_frame->document());
1797     if (!node)
1798         return false;
1799
1800     // FIXME: what is this doing here, in keyboard event handler?
1801     m_frame->loader()->resetMultipleFormSubmissionProtection();
1802
1803     // In IE, access keys are special, they are handled after default keydown processing, but cannot be canceled - this is hard to match.
1804     // On Mac OS X, we process them before dispatching keydown, as the default keydown handler implements Emacs key bindings, which may conflict
1805     // with access keys. Then we dispatch keydown, but suppress its default handling.
1806     // On Windows, WebKit explicitly calls handleAccessKey() instead of dispatching a keypress event for WM_SYSCHAR messages.
1807     // Other platforms currently match either Mac or Windows behavior, depending on whether they send combined KeyDown events.
1808     bool matchedAnAccessKey = false;
1809     if (initialKeyEvent.type() == PlatformKeyboardEvent::KeyDown)
1810         matchedAnAccessKey = handleAccessKey(initialKeyEvent);
1811
1812     // FIXME: it would be fair to let an input method handle KeyUp events before DOM dispatch.
1813     if (initialKeyEvent.type() == PlatformKeyboardEvent::KeyUp || initialKeyEvent.type() == PlatformKeyboardEvent::Char)
1814         return !node->dispatchKeyEvent(initialKeyEvent);
1815
1816     bool backwardCompatibilityMode = needsKeyboardEventDisambiguationQuirks();
1817
1818     ExceptionCode ec;
1819     PlatformKeyboardEvent keyDownEvent = initialKeyEvent;    
1820     if (keyDownEvent.type() != PlatformKeyboardEvent::RawKeyDown)
1821         keyDownEvent.disambiguateKeyDownEvent(PlatformKeyboardEvent::RawKeyDown, backwardCompatibilityMode);
1822     RefPtr<KeyboardEvent> keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->defaultView());
1823     if (matchedAnAccessKey)
1824         keydown->setDefaultPrevented(true);
1825     keydown->setTarget(node);
1826
1827     if (initialKeyEvent.type() == PlatformKeyboardEvent::RawKeyDown) {
1828         node->dispatchEvent(keydown, ec);
1829         return keydown->defaultHandled() || keydown->defaultPrevented();
1830     }
1831
1832     // Run input method in advance of DOM event handling.  This may result in the IM
1833     // modifying the page prior the keydown event, but this behaviour is necessary
1834     // in order to match IE:
1835     // 1. preventing default handling of keydown and keypress events has no effect on IM input;
1836     // 2. if an input method handles the event, its keyCode is set to 229 in keydown event.
1837     m_frame->editor()->handleInputMethodKeydown(keydown.get());
1838     
1839     bool handledByInputMethod = keydown->defaultHandled();
1840     
1841     if (handledByInputMethod) {
1842         keyDownEvent.setWindowsVirtualKeyCode(CompositionEventKeyCode);
1843         keydown = KeyboardEvent::create(keyDownEvent, m_frame->document()->defaultView());
1844         keydown->setTarget(node);
1845         keydown->setDefaultHandled();
1846     }
1847
1848     node->dispatchEvent(keydown, ec);
1849     bool keydownResult = keydown->defaultHandled() || keydown->defaultPrevented();
1850     if (handledByInputMethod || (keydownResult && !backwardCompatibilityMode))
1851         return keydownResult;
1852     
1853     // Focus may have changed during keydown handling, so refetch node.
1854     // But if we are dispatching a fake backward compatibility keypress, then we pretend that the keypress happened on the original node.
1855     if (!keydownResult) {
1856         node = eventTargetNodeForDocument(m_frame->document());
1857         if (!node)
1858             return false;
1859     }
1860
1861     PlatformKeyboardEvent keyPressEvent = initialKeyEvent;
1862     keyPressEvent.disambiguateKeyDownEvent(PlatformKeyboardEvent::Char, backwardCompatibilityMode);
1863     if (keyPressEvent.text().isEmpty())
1864         return keydownResult;
1865     RefPtr<KeyboardEvent> keypress = KeyboardEvent::create(keyPressEvent, m_frame->document()->defaultView());
1866     keypress->setTarget(node);
1867     if (keydownResult)
1868         keypress->setDefaultPrevented(true);
1869 #if PLATFORM(MAC)
1870     keypress->keypressCommands() = keydown->keypressCommands();
1871 #endif
1872     node->dispatchEvent(keypress, ec);
1873
1874     return keydownResult || keypress->defaultPrevented() || keypress->defaultHandled();
1875 }
1876
1877 void EventHandler::handleKeyboardSelectionMovement(KeyboardEvent* event)
1878 {
1879     if (!event)
1880         return;
1881     
1882     String key = event->keyIdentifier();           
1883     bool isShifted = event->getModifierState("Shift");
1884     bool isOptioned = event->getModifierState("Alt");
1885     
1886     if (key == "Up") {
1887         m_frame->selection()->modify((isShifted) ? SelectionController::EXTEND : SelectionController::MOVE, SelectionController::BACKWARD, LineGranularity, true);
1888         event->setDefaultHandled();
1889     }
1890     else if (key == "Down") { 
1891         m_frame->selection()->modify((isShifted) ? SelectionController::EXTEND : SelectionController::MOVE, SelectionController::FORWARD, LineGranularity, true);
1892         event->setDefaultHandled();
1893     }
1894     else if (key == "Left") {
1895         m_frame->selection()->modify((isShifted) ? SelectionController::EXTEND : SelectionController::MOVE, SelectionController::LEFT, (isOptioned) ? WordGranularity : CharacterGranularity, true);
1896         event->setDefaultHandled();
1897     }
1898     else if (key == "Right") {
1899         m_frame->selection()->modify((isShifted) ? SelectionController::EXTEND : SelectionController::MOVE, SelectionController::RIGHT, (isOptioned) ? WordGranularity : CharacterGranularity, true);
1900         event->setDefaultHandled();
1901     }    
1902 }
1903     
1904 void EventHandler::defaultKeyboardEventHandler(KeyboardEvent* event)
1905 {
1906    if (event->type() == eventNames().keydownEvent) {
1907         m_frame->editor()->handleKeyboardEvent(event);
1908         if (event->defaultHandled())
1909             return;
1910         if (event->keyIdentifier() == "U+0009")
1911             defaultTabEventHandler(event);
1912
1913        // provides KB navigation and selection for enhanced accessibility users
1914        if (AXObjectCache::accessibilityEnhancedUserInterfaceEnabled())
1915            handleKeyboardSelectionMovement(event);       
1916    }
1917    if (event->type() == eventNames().keypressEvent) {
1918         m_frame->editor()->handleKeyboardEvent(event);
1919         if (event->defaultHandled())
1920             return;
1921         if (event->charCode() == ' ')
1922             defaultSpaceEventHandler(event);
1923    }
1924 }
1925
1926 bool EventHandler::dragHysteresisExceeded(const FloatPoint& floatDragViewportLocation) const
1927 {
1928     IntPoint dragViewportLocation((int)floatDragViewportLocation.x(), (int)floatDragViewportLocation.y());
1929     return dragHysteresisExceeded(dragViewportLocation);
1930 }
1931     
1932 bool EventHandler::dragHysteresisExceeded(const IntPoint& dragViewportLocation) const
1933 {
1934     IntPoint dragLocation = m_frame->view()->windowToContents(dragViewportLocation);
1935     IntSize delta = dragLocation - m_mouseDownPos;
1936     
1937     int threshold = GeneralDragHysteresis;
1938     if (dragState().m_dragSrcIsImage)
1939         threshold = ImageDragHysteresis;
1940     else if (dragState().m_dragSrcIsLink)
1941         threshold = LinkDragHysteresis;
1942     else if (dragState().m_dragSrcInSelection)
1943         threshold = TextDragHysteresis;
1944     
1945     return abs(delta.width()) >= threshold || abs(delta.height()) >= threshold;
1946 }
1947     
1948 void EventHandler::freeClipboard()
1949 {
1950     if (dragState().m_dragClipboard)
1951         dragState().m_dragClipboard->setAccessPolicy(ClipboardNumb);
1952 }
1953
1954 bool EventHandler::shouldDragAutoNode(Node* node, const IntPoint& point) const
1955 {
1956     if (!node || node->hasChildNodes() || !m_frame->view())
1957         return false;
1958     return m_frame->page() && m_frame->page()->dragController()->mayStartDragAtEventLocation(m_frame, point);
1959 }
1960     
1961 void EventHandler::dragSourceMovedTo(const PlatformMouseEvent& event)
1962 {
1963     if (dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML)
1964         // for now we don't care if event handler cancels default behavior, since there is none
1965         dispatchDragSrcEvent(eventNames().dragEvent, event);
1966 }
1967     
1968 void EventHandler::dragSourceEndedAt(const PlatformMouseEvent& event, DragOperation operation)
1969 {
1970     if (dragState().m_dragSrc && dragState().m_dragSrcMayBeDHTML) {
1971         dragState().m_dragClipboard->setDestinationOperation(operation);
1972         // for now we don't care if event handler cancels default behavior, since there is none
1973         dispatchDragSrcEvent(eventNames().dragendEvent, event);
1974     }
1975     freeClipboard();
1976     dragState().m_dragSrc = 0;
1977 }
1978     
1979 // returns if we should continue "default processing", i.e., whether eventhandler canceled
1980 bool EventHandler::dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent& event)
1981 {
1982     return !dispatchDragEvent(eventType, dragState().m_dragSrc.get(), event, dragState().m_dragClipboard.get());
1983 }
1984     
1985 bool EventHandler::handleDrag(const MouseEventWithHitTestResults& event)
1986 {
1987     if (event.event().button() != LeftButton || event.event().eventType() != MouseEventMoved) {
1988         // If we allowed the other side of the bridge to handle a drag
1989         // last time, then m_mousePressed might still be set. So we
1990         // clear it now to make sure the next move after a drag
1991         // doesn't look like a drag.
1992         m_mousePressed = false;
1993         return false;
1994     }
1995     
1996     if (eventLoopHandleMouseDragged(event))
1997         return true;
1998     
1999     // Careful that the drag starting logic stays in sync with eventMayStartDrag()
2000     
2001     if (m_mouseDownMayStartDrag && !dragState().m_dragSrc) {
2002         allowDHTMLDrag(dragState().m_dragSrcMayBeDHTML, dragState().m_dragSrcMayBeUA);
2003         if (!dragState().m_dragSrcMayBeDHTML && !dragState().m_dragSrcMayBeUA)
2004             m_mouseDownMayStartDrag = false;     // no element is draggable
2005     }
2006
2007     if (m_mouseDownMayStartDrag && !dragState().m_dragSrc) {
2008         // try to find an element that wants to be dragged
2009         HitTestRequest request(HitTestRequest::ReadOnly);
2010         HitTestResult result(m_mouseDownPos);
2011         m_frame->contentRenderer()->layer()->hitTest(request, result);
2012         Node* node = result.innerNode();
2013         if (node && node->renderer())
2014             dragState().m_dragSrc = node->renderer()->draggableNode(dragState().m_dragSrcMayBeDHTML, dragState().m_dragSrcMayBeUA,
2015                                                                     m_mouseDownPos.x(), m_mouseDownPos.y(), dragState().m_dragSrcIsDHTML);
2016         else
2017             dragState().m_dragSrc = 0;
2018         
2019         if (!dragState().m_dragSrc)
2020             m_mouseDownMayStartDrag = false;     // no element is draggable
2021         else {
2022             // remember some facts about this source, while we have a HitTestResult handy
2023             node = result.URLElement();
2024             dragState().m_dragSrcIsLink = node && node->isLink();
2025             
2026             node = result.innerNonSharedNode();
2027             dragState().m_dragSrcIsImage = node && node->renderer() && node->renderer()->isImage();
2028             
2029             dragState().m_dragSrcInSelection = m_frame->selection()->contains(m_mouseDownPos);
2030         }                
2031     }
2032     
2033     // For drags starting in the selection, the user must wait between the mousedown and mousedrag,
2034     // or else we bail on the dragging stuff and allow selection to occur
2035     if (m_mouseDownMayStartDrag && !dragState().m_dragSrcIsImage && dragState().m_dragSrcInSelection && event.event().timestamp() - m_mouseDownTimestamp < TextDragDelay) {
2036         m_mouseDownMayStartDrag = false;
2037         dragState().m_dragSrc = 0;
2038         // ...but if this was the first click in the window, we don't even want to start selection
2039         if (eventActivatedView(event.event()))
2040             m_mouseDownMayStartSelect = false;
2041     }
2042     
2043     if (!m_mouseDownMayStartDrag)
2044         return !mouseDownMayStartSelect() && !m_mouseDownMayStartAutoscroll;
2045     
2046     // We are starting a text/image/url drag, so the cursor should be an arrow
2047     m_frame->view()->setCursor(pointerCursor());
2048     
2049     if (!dragHysteresisExceeded(event.event().pos())) 
2050         return true;
2051     
2052     // Once we're past the hysteresis point, we don't want to treat this gesture as a click
2053     invalidateClick();
2054     
2055     DragOperation srcOp = DragOperationNone;      
2056     
2057     freeClipboard();    // would only happen if we missed a dragEnd.  Do it anyway, just
2058                         // to make sure it gets numbified
2059     dragState().m_dragClipboard = createDraggingClipboard();  
2060     
2061     if (dragState().m_dragSrcMayBeDHTML) {
2062         // Check to see if the is a DOM based drag, if it is get the DOM specified drag 
2063         // image and offset
2064         if (dragState().m_dragSrcIsDHTML) {
2065             if (RenderObject* renderer = dragState().m_dragSrc->renderer()) {
2066                 // FIXME: This doesn't work correctly with transforms.
2067                 FloatPoint absPos = renderer->localToAbsolute();
2068                 IntSize delta = m_mouseDownPos - roundedIntPoint(absPos);
2069                 dragState().m_dragClipboard->setDragImageElement(dragState().m_dragSrc.get(), IntPoint() + delta);
2070             } else {
2071                 // The renderer has disappeared, this can happen if the onStartDrag handler has hidden
2072                 // the element in some way.  In this case we just kill the drag.
2073                 m_mouseDownMayStartDrag = false;
2074                 goto cleanupDrag;
2075             }
2076         } 
2077         
2078         m_mouseDownMayStartDrag = dispatchDragSrcEvent(eventNames().dragstartEvent, m_mouseDown)
2079             && !m_frame->selection()->isInPasswordField();
2080         
2081         // Invalidate clipboard here against anymore pasteboard writing for security.  The drag
2082         // image can still be changed as we drag, but not the pasteboard data.
2083         dragState().m_dragClipboard->setAccessPolicy(ClipboardImageWritable);
2084         
2085         if (m_mouseDownMayStartDrag) {
2086             // gather values from DHTML element, if it set any
2087             dragState().m_dragClipboard->sourceOperation(srcOp);
2088             
2089             // Yuck, dragSourceMovedTo() can be called as a result of kicking off the drag with
2090             // dragImage!  Because of that dumb reentrancy, we may think we've not started the
2091             // drag when that happens.  So we have to assume it's started before we kick it off.
2092             dragState().m_dragClipboard->setDragHasStarted();
2093         }
2094     }
2095     
2096     if (m_mouseDownMayStartDrag) {
2097         DragController* dragController = m_frame->page() ? m_frame->page()->dragController() : 0;
2098         bool startedDrag = dragController && dragController->startDrag(m_frame, dragState().m_dragClipboard.get(), srcOp, event.event(), m_mouseDownPos, dragState().m_dragSrcIsDHTML);
2099         if (!startedDrag && dragState().m_dragSrcMayBeDHTML) {
2100             // Drag was canned at the last minute - we owe m_dragSrc a DRAGEND event
2101             dispatchDragSrcEvent(eventNames().dragendEvent, event.event());
2102             m_mouseDownMayStartDrag = false;
2103         }
2104     } 
2105
2106 cleanupDrag:
2107     if (!m_mouseDownMayStartDrag) {
2108         // something failed to start the drag, cleanup
2109         freeClipboard();
2110         dragState().m_dragSrc = 0;
2111     }
2112     
2113     // No more default handling (like selection), whether we're past the hysteresis bounds or not
2114     return true;
2115 }
2116   
2117 bool EventHandler::handleTextInputEvent(const String& text, Event* underlyingEvent, bool isLineBreak, bool isBackTab)
2118 {
2119     // Platforms should differentiate real commands like selectAll from text input in disguise (like insertNewline),
2120     // and avoid dispatching text input events from keydown default handlers.
2121     ASSERT(!underlyingEvent || !underlyingEvent->isKeyboardEvent() || static_cast<KeyboardEvent*>(underlyingEvent)->type() == eventNames().keypressEvent);
2122
2123     if (!m_frame)
2124         return false;
2125
2126     EventTarget* target;
2127     if (underlyingEvent)
2128         target = underlyingEvent->target();
2129     else
2130         target = eventTargetNodeForDocument(m_frame->document());
2131     if (!target)
2132         return false;
2133
2134     RefPtr<TextEvent> event = TextEvent::create(m_frame->domWindow(), text);
2135     event->setUnderlyingEvent(underlyingEvent);
2136     event->setIsLineBreak(isLineBreak);
2137     event->setIsBackTab(isBackTab);
2138     ExceptionCode ec;
2139     target->dispatchEvent(event, ec);
2140     return event->defaultHandled();
2141 }
2142     
2143     
2144 #if !PLATFORM(MAC) && !PLATFORM(QT)
2145 bool EventHandler::invertSenseOfTabsToLinks(KeyboardEvent*) const
2146 {
2147     return false;
2148 }
2149 #endif
2150
2151 bool EventHandler::tabsToLinks(KeyboardEvent* event) const
2152 {
2153     Page* page = m_frame->page();
2154     if (!page)
2155         return false;
2156
2157     if (page->chrome()->client()->tabsToLinks())
2158         return !invertSenseOfTabsToLinks(event);
2159
2160     return invertSenseOfTabsToLinks(event);
2161 }
2162
2163 void EventHandler::defaultTextInputEventHandler(TextEvent* event)
2164 {
2165     String data = event->data();
2166     if (data == "\n") {
2167         if (event->isLineBreak()) {
2168             if (m_frame->editor()->insertLineBreak())
2169                 event->setDefaultHandled();
2170         } else {
2171             if (m_frame->editor()->insertParagraphSeparator())
2172                 event->setDefaultHandled();
2173         }
2174     } else {
2175         if (m_frame->editor()->insertTextWithoutSendingTextEvent(data, false, event))
2176             event->setDefaultHandled();
2177     }
2178 }
2179
2180 #if PLATFORM(QT) || PLATFORM(MAC)
2181
2182 // These two platforms handle the space event in the platform-specific WebKit code.
2183 // Eventually it would be good to eliminate that and use the code here instead, but
2184 // the Qt version is inside an ifdef and the Mac version has some extra behavior
2185 // so we can't unify everything yet.
2186 void EventHandler::defaultSpaceEventHandler(KeyboardEvent*)
2187 {
2188 }
2189
2190 #else
2191
2192 void EventHandler::defaultSpaceEventHandler(KeyboardEvent* event)
2193 {
2194     ScrollDirection direction = event->shiftKey() ? ScrollUp : ScrollDown;
2195     if (scrollOverflow(direction, ScrollByPage)) {
2196         event->setDefaultHandled();
2197         return;
2198     }
2199
2200     FrameView* view = m_frame->view();
2201     if (!view)
2202         return;
2203
2204     if (view->scroll(direction, ScrollByPage))
2205         event->setDefaultHandled();
2206 }
2207
2208 #endif
2209
2210 void EventHandler::defaultTabEventHandler(KeyboardEvent* event)
2211 {
2212     // We should only advance focus on tabs if no special modifier keys are held down.
2213     if (event->ctrlKey() || event->metaKey() || event->altGraphKey())
2214         return;
2215
2216     Page* page = m_frame->page();
2217     if (!page)
2218         return;
2219     if (!page->tabKeyCyclesThroughElements())
2220         return;
2221
2222     FocusDirection focusDirection = event->shiftKey() ? FocusDirectionBackward : FocusDirectionForward;
2223
2224     // Tabs can be used in design mode editing.
2225     if (m_frame->document()->inDesignMode())
2226         return;
2227
2228     if (page->focusController()->advanceFocus(focusDirection, event))
2229         event->setDefaultHandled();
2230 }
2231
2232 void EventHandler::capsLockStateMayHaveChanged()
2233 {
2234     Document* d = m_frame->document();
2235     if (Node* node = d->focusedNode()) {
2236         if (RenderObject* r = node->renderer()) {
2237             if (r->isTextField())
2238                 static_cast<RenderTextControlSingleLine*>(r)->capsLockStateMayHaveChanged();
2239         }
2240     }
2241 }
2242
2243 unsigned EventHandler::pendingFrameUnloadEventCount()
2244 {
2245     return m_pendingFrameUnloadEventCount;
2246 }
2247
2248 void EventHandler::addPendingFrameUnloadEventCount() 
2249 {
2250     m_pendingFrameUnloadEventCount += 1;
2251     m_frame->page()->changePendingUnloadEventCount(1);
2252     return; 
2253 }
2254     
2255 void EventHandler::removePendingFrameUnloadEventCount() 
2256 {
2257     ASSERT( (-1 + (int)m_pendingFrameUnloadEventCount) >= 0 );
2258     m_pendingFrameUnloadEventCount -= 1;
2259     m_frame->page()->changePendingUnloadEventCount(-1);
2260     return; 
2261 }
2262     
2263 void EventHandler::clearPendingFrameUnloadEventCount() 
2264 {
2265     m_frame->page()->changePendingUnloadEventCount(-((int)m_pendingFrameUnloadEventCount));
2266     m_pendingFrameUnloadEventCount = 0;
2267     return; 
2268 }
2269
2270 void EventHandler::sendResizeEvent()
2271 {
2272     m_frame->document()->dispatchWindowEvent(eventNames().resizeEvent, false, false);
2273 }
2274
2275 void EventHandler::sendScrollEvent()
2276 {
2277     FrameView* v = m_frame->view();
2278     if (!v)
2279         return;
2280     v->setWasScrolledByUser(true);
2281     m_frame->document()->dispatchEventForType(eventNames().scrollEvent, true, false);
2282 }
2283
2284 unsigned EventHandler::pendingFrameBeforeUnloadEventCount()
2285 {
2286     return m_pendingFrameBeforeUnloadEventCount;
2287 }
2288
2289 void EventHandler::addPendingFrameBeforeUnloadEventCount() 
2290 {
2291     m_pendingFrameBeforeUnloadEventCount += 1;
2292     m_frame->page()->changePendingBeforeUnloadEventCount(1);
2293     return; 
2294 }
2295     
2296 void EventHandler::removePendingFrameBeforeUnloadEventCount() 
2297 {
2298     ASSERT( (-1 + (int)m_pendingFrameBeforeUnloadEventCount) >= 0 );
2299     m_pendingFrameBeforeUnloadEventCount -= 1;
2300     m_frame->page()->changePendingBeforeUnloadEventCount(-1);
2301     return; 
2302 }
2303
2304     void EventHandler::clearPendingFrameBeforeUnloadEventCount() 
2305 {
2306     m_frame->page()->changePendingBeforeUnloadEventCount(-((int)m_pendingFrameBeforeUnloadEventCount));
2307     m_pendingFrameBeforeUnloadEventCount = 0;
2308     return; 
2309 }
2310
2311 bool EventHandler::passMousePressEventToScrollbar(MouseEventWithHitTestResults& mev, Scrollbar* scrollbar)
2312 {
2313     if (!scrollbar || !scrollbar->enabled())
2314         return false;
2315     return scrollbar->mouseDown(mev.event());
2316 }
2317
2318 }