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