DOM event handling should pass Event around by reference.
[WebKit-https.git] / Source / WebCore / page / EventHandler.h
1 /*
2  * Copyright (C) 2006-2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #ifndef EventHandler_h
27 #define EventHandler_h
28
29 #include "Cursor.h"
30 #include "DragActions.h"
31 #include "FocusDirection.h"
32 #include "HitTestRequest.h"
33 #include "LayoutPoint.h"
34 #include "PlatformMouseEvent.h"
35 #include "PlatformWheelEvent.h"
36 #include "ScrollTypes.h"
37 #include "TextEventInputType.h"
38 #include "TextGranularity.h"
39 #include "Timer.h"
40 #include "WheelEventDeltaFilter.h"
41 #include <memory>
42 #include <wtf/Forward.h>
43 #include <wtf/HashMap.h>
44 #include <wtf/HashSet.h>
45 #include <wtf/RefPtr.h>
46 #include <wtf/Vector.h>
47 #include <wtf/WeakPtr.h>
48
49 #if PLATFORM(IOS)
50 OBJC_CLASS WebEvent;
51 OBJC_CLASS WAKView;
52 #ifdef __OBJC__
53 #include "WAKAppKitStubs.h"
54 #endif
55 #endif // PLATFORM(IOS)
56
57 #if PLATFORM(COCOA)
58 OBJC_CLASS NSView;
59 #endif
60
61 namespace WebCore {
62
63 class AutoscrollController;
64 class ContainerNode;
65 class DataTransfer;
66 class Document;
67 class Element;
68 class Event;
69 class EventTarget;
70 class FloatPoint;
71 class FloatQuad;
72 class Frame;
73 class HTMLFrameSetElement;
74 class HitTestRequest;
75 class HitTestResult;
76 class KeyboardEvent;
77 class MouseEventWithHitTestResults;
78 class Node;
79 class OptionalCursor;
80 class PlatformGestureEvent;
81 class PlatformKeyboardEvent;
82 class PlatformTouchEvent;
83 class PlatformWheelEvent;
84 class RenderBox;
85 class RenderElement;
86 class RenderLayer;
87 class RenderWidget;
88 class ScrollableArea;
89 class Scrollbar;
90 class TextEvent;
91 class Touch;
92 class TouchEvent;
93 class VisibleSelection;
94 class WheelEvent;
95 class Widget;
96
97 struct DragState;
98
99 #if ENABLE(DRAG_SUPPORT)
100 extern const int LinkDragHysteresis;
101 extern const int ImageDragHysteresis;
102 extern const int TextDragHysteresis;
103 extern const int GeneralDragHysteresis;
104 #endif // ENABLE(DRAG_SUPPORT)
105
106 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
107 extern const float GestureUnknown;
108 extern const unsigned InvalidTouchIdentifier;
109 #endif
110
111 enum AppendTrailingWhitespace { ShouldAppendTrailingWhitespace, DontAppendTrailingWhitespace };
112 enum CheckDragHysteresis { ShouldCheckDragHysteresis, DontCheckDragHysteresis };
113
114 enum class ImmediateActionStage {
115     None,
116     PerformedHitTest,
117     ActionUpdated,
118     ActionCancelledWithoutUpdate,
119     ActionCancelledAfterUpdate,
120     ActionCompleted
121 };
122
123 class EventHandler {
124     WTF_MAKE_NONCOPYABLE(EventHandler);
125     WTF_MAKE_FAST_ALLOCATED;
126 public:
127     explicit EventHandler(Frame&);
128     ~EventHandler();
129
130     void clear();
131     void nodeWillBeRemoved(Node&);
132
133 #if ENABLE(DRAG_SUPPORT)
134     void updateSelectionForMouseDrag();
135 #endif
136
137 #if ENABLE(PAN_SCROLLING)
138     void didPanScrollStart();
139     void didPanScrollStop();
140     void startPanScrolling(RenderElement*);
141 #endif
142
143     void stopAutoscrollTimer(bool rendererIsBeingDestroyed = false);
144     RenderBox* autoscrollRenderer() const;
145     void updateAutoscrollRenderer();
146     bool autoscrollInProgress() const;
147     bool mouseDownWasInSubframe() const { return m_mouseDownWasInSubframe; }
148     bool panScrollInProgress() const;
149
150     WEBCORE_EXPORT void dispatchFakeMouseMoveEventSoon();
151     void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
152
153     WEBCORE_EXPORT HitTestResult hitTestResultAtPoint(const LayoutPoint&,
154         HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowUserAgentShadowContent,
155         const LayoutSize& padding = LayoutSize());
156
157     bool mousePressed() const { return m_mousePressed; }
158     Node* mousePressNode() const { return m_mousePressNode.get(); }
159
160     WEBCORE_EXPORT void setCapturingMouseEventsElement(PassRefPtr<Element>); // A caller is responsible for resetting capturing element to 0.
161
162 #if ENABLE(DRAG_SUPPORT)
163     bool updateDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
164     void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
165     bool performDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
166     void updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement);
167 #endif
168
169     void scheduleHoverStateUpdate();
170 #if ENABLE(CURSOR_SUPPORT)
171     void scheduleCursorUpdate();
172 #endif
173
174     void setResizingFrameSet(HTMLFrameSetElement*);
175
176     void resizeLayerDestroyed();
177
178     IntPoint lastKnownMousePosition() const;
179     IntPoint lastKnownMouseGlobalPosition() const { return m_lastKnownMouseGlobalPosition; }
180     Cursor currentMouseCursor() const { return m_currentMouseCursor; }
181
182     IntPoint effectiveMousePositionForSelectionAutoscroll() const;
183
184     static Frame* subframeForTargetNode(Node*);
185     static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
186
187     WEBCORE_EXPORT bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
188     WEBCORE_EXPORT bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
189     WEBCORE_EXPORT bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
190
191     bool tabsToLinks(KeyboardEvent*) const;
192     bool tabsToAllFormControls(KeyboardEvent*) const;
193
194     WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
195     WEBCORE_EXPORT bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
196
197     void lostMouseCapture();
198
199     WEBCORE_EXPORT bool handleMousePressEvent(const PlatformMouseEvent&);
200     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false);
201     WEBCORE_EXPORT bool handleMouseReleaseEvent(const PlatformMouseEvent&);
202     bool handleMouseForceEvent(const PlatformMouseEvent&);
203     WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
204     void defaultWheelEventHandler(Node*, WheelEvent&);
205     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
206
207     void platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, RefPtr<Element>& eventTarget, RefPtr<ContainerNode>& scrollableContainer, WeakPtr<ScrollableArea>&, bool& isOverWidget);
208     void platformRecordWheelEvent(const PlatformWheelEvent&);
209     bool platformCompleteWheelEvent(const PlatformWheelEvent&, ContainerNode* scrollableContainer, const WeakPtr<ScrollableArea>&);
210     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
211     void platformNotifyIfEndGesture(const PlatformWheelEvent&, const WeakPtr<ScrollableArea>&);
212
213 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
214     typedef Vector<RefPtr<Touch>> TouchArray;
215     typedef HashMap<EventTarget*, TouchArray*> EventTargetTouchMap;
216 #endif
217
218 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
219     typedef HashSet<RefPtr<EventTarget>> EventTargetSet;
220 #endif
221
222 #if ENABLE(IOS_TOUCH_EVENTS)
223     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetTouchMap&, float, float);
224     bool dispatchSimulatedTouchEvent(IntPoint location);
225 #endif
226
227 #if ENABLE(IOS_GESTURE_EVENTS)
228     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetSet&, float, float);
229 #elif ENABLE(MAC_GESTURE_EVENTS)
230     bool dispatchGestureEvent(const PlatformGestureEvent&, const AtomicString&, const EventTargetSet&, float, float);
231     WEBCORE_EXPORT bool handleGestureEvent(const PlatformGestureEvent&);
232 #endif
233
234 #if PLATFORM(IOS)
235     void defaultTouchEventHandler(Node*, TouchEvent*);
236 #endif
237
238 #if ENABLE(CONTEXT_MENUS)
239     WEBCORE_EXPORT bool sendContextMenuEvent(const PlatformMouseEvent&);
240     bool sendContextMenuEventForKey();
241 #endif
242
243     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
244
245     bool needsKeyboardEventDisambiguationQuirks() const;
246
247     static unsigned accessKeyModifiers();
248     WEBCORE_EXPORT bool handleAccessKey(const PlatformKeyboardEvent&);
249     WEBCORE_EXPORT bool keyEvent(const PlatformKeyboardEvent&);
250     void defaultKeyboardEventHandler(KeyboardEvent&);
251
252     bool accessibilityPreventsEventPropogation(KeyboardEvent&);
253     WEBCORE_EXPORT void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent&);
254
255     bool handleTextInputEvent(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard);
256     void defaultTextInputEventHandler(TextEvent&);
257
258 #if ENABLE(DRAG_SUPPORT)
259     WEBCORE_EXPORT bool eventMayStartDrag(const PlatformMouseEvent&) const;
260     
261     WEBCORE_EXPORT void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
262 #endif
263
264     void focusDocumentView();
265     
266     WEBCORE_EXPORT void sendScrollEvent();
267
268 #if PLATFORM(COCOA) && defined(__OBJC__)
269 #if !PLATFORM(IOS)
270     WEBCORE_EXPORT void mouseDown(NSEvent *, NSEvent *correspondingPressureEvent);
271     WEBCORE_EXPORT void mouseDragged(NSEvent *, NSEvent *correspondingPressureEvent);
272     WEBCORE_EXPORT void mouseUp(NSEvent *, NSEvent *correspondingPressureEvent);
273     WEBCORE_EXPORT void mouseMoved(NSEvent *, NSEvent *correspondingPressureEvent);
274     WEBCORE_EXPORT void pressureChange(NSEvent *, NSEvent* correspondingPressureEvent);
275     WEBCORE_EXPORT bool keyEvent(NSEvent *);
276     WEBCORE_EXPORT bool wheelEvent(NSEvent *);
277 #else
278     WEBCORE_EXPORT void mouseDown(WebEvent *);
279     WEBCORE_EXPORT void mouseUp(WebEvent *);
280     WEBCORE_EXPORT void mouseMoved(WebEvent *);
281     WEBCORE_EXPORT bool keyEvent(WebEvent *);
282     WEBCORE_EXPORT bool wheelEvent(WebEvent *);
283 #endif
284
285 #if ENABLE(IOS_TOUCH_EVENTS)
286     WEBCORE_EXPORT void touchEvent(WebEvent *);
287 #endif
288
289 #if !PLATFORM(IOS)
290     WEBCORE_EXPORT void passMouseMovedEventToScrollbars(NSEvent *, NSEvent* correspondingPressureEvent);
291
292     WEBCORE_EXPORT void sendFakeEventsAfterWidgetTracking(NSEvent *initiatingEvent);
293 #endif
294
295 #if !PLATFORM(IOS)
296     void setActivationEventNumber(int num) { m_activationEventNumber = num; }
297
298     WEBCORE_EXPORT static NSEvent *currentNSEvent();
299     static NSEvent *correspondingPressureEvent();
300 #else
301     static WebEvent *currentEvent();
302 #endif // !PLATFORM(IOS)
303 #endif // PLATFORM(COCOA) && defined(__OBJC__)
304
305 #if PLATFORM(IOS)
306     void invalidateClick();
307 #endif
308
309 #if ENABLE(TOUCH_EVENTS)
310     WEBCORE_EXPORT bool handleTouchEvent(const PlatformTouchEvent&);
311 #endif
312
313     bool useHandCursor(Node*, bool isOverLink, bool shiftKey);
314     void updateCursor();
315
316     bool isHandlingWheelEvent() const { return m_isHandlingWheelEvent; }
317
318     WEBCORE_EXPORT void setImmediateActionStage(ImmediateActionStage stage);
319     ImmediateActionStage immediateActionStage() const { return m_immediateActionStage; }
320
321     static Widget* widgetForEventTarget(Element* eventTarget);
322
323 private:
324 #if ENABLE(DRAG_SUPPORT)
325     static DragState& dragState();
326     static const double TextDragDelay;
327     
328     PassRefPtr<DataTransfer> createDraggingDataTransfer() const;
329 #endif // ENABLE(DRAG_SUPPORT)
330
331     bool eventActivatedView(const PlatformMouseEvent&) const;
332     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
333     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
334     VisibleSelection selectClosestWordFromHitTestResultBasedOnLookup(const HitTestResult&);
335     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
336     void selectClosestContextualWordFromMouseEvent(const MouseEventWithHitTestResults&);
337     void selectClosestContextualWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
338
339     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
340
341     WEBCORE_EXPORT bool handleMousePressEvent(const MouseEventWithHitTestResults&);
342     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
343     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
344     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
345 #if ENABLE(DRAG_SUPPORT)
346     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
347 #endif
348     WEBCORE_EXPORT bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
349
350     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
351
352     void hoverTimerFired();
353 #if ENABLE(CURSOR_SUPPORT)
354     void cursorUpdateTimerFired();
355 #endif
356
357     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
358     
359     bool shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const;
360     
361     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
362
363     static bool isKeyboardOptionTab(KeyboardEvent*);
364     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
365
366 #if !ENABLE(IOS_TOUCH_EVENTS)
367     void fakeMouseMoveEventTimerFired();
368     void cancelFakeMouseMoveEvent();
369 #endif
370
371     bool isInsideScrollbar(const IntPoint&) const;
372
373 #if ENABLE(TOUCH_EVENTS)
374     bool dispatchSyntheticTouchEventIfEnabled(const PlatformMouseEvent&);
375 #endif
376
377 #if !PLATFORM(IOS)
378     void invalidateClick();
379 #endif
380
381     Node* nodeUnderMouse() const;
382     
383     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&, bool fireMouseOverOut);
384     void fireMouseOverOut(bool fireMouseOver = true, bool fireMouseOut = true, bool updateLastNodeUnderMouse = true);
385     
386     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
387
388     bool dispatchMouseEvent(const AtomicString& eventType, Node* target, bool cancelable, int clickCount, const PlatformMouseEvent&, bool setUnder);
389 #if ENABLE(DRAG_SUPPORT)
390     bool dispatchDragEvent(const AtomicString& eventType, Element& target, const PlatformMouseEvent&, DataTransfer*);
391
392     void freeDataTransfer();
393
394     bool handleDrag(const MouseEventWithHitTestResults&, CheckDragHysteresis);
395 #endif
396     bool handleMouseUp(const MouseEventWithHitTestResults&);
397 #if ENABLE(DRAG_SUPPORT)
398     void clearDragState();
399
400     bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
401
402     bool dragHysteresisExceeded(const FloatPoint&) const;
403     bool dragHysteresisExceeded(const IntPoint&) const;
404 #endif // ENABLE(DRAG_SUPPORT)
405     
406     bool mouseMovementExceedsThreshold(const FloatPoint&, int pointsThreshold) const;
407
408     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
409     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
410     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
411
412     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
413
414     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
415
416     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
417     bool passWidgetMouseDownEventToWidget(RenderWidget*);
418
419     bool passMouseDownEventToWidget(Widget*);
420     bool widgetDidHandleWheelEvent(const PlatformWheelEvent&, Widget&);
421     bool completeWidgetWheelEvent(const PlatformWheelEvent&, const WeakPtr<Widget>&, const WeakPtr<ScrollableArea>&, ContainerNode*);
422
423     void defaultSpaceEventHandler(KeyboardEvent&);
424     void defaultBackspaceEventHandler(KeyboardEvent&);
425     void defaultTabEventHandler(KeyboardEvent&);
426     void defaultArrowEventHandler(FocusDirection, KeyboardEvent&);
427
428 #if ENABLE(DRAG_SUPPORT)
429     DragSourceAction updateDragSourceActionsAllowed() const;
430 #endif
431
432     // The following are called at the beginning of handleMouseUp and handleDrag.  
433     // If they return true it indicates that they have consumed the event.
434     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
435 #if ENABLE(DRAG_SUPPORT)
436     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
437 #endif
438
439 #if ENABLE(DRAG_SUPPORT)
440     void updateSelectionForMouseDrag(const HitTestResult&);
441 #endif
442
443     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
444     
445     void setFrameWasScrolledByUser();
446
447     bool capturesDragging() const { return m_capturesDragging; }
448
449 #if PLATFORM(COCOA) && defined(__OBJC__)
450     NSView *mouseDownViewIfStillGood();
451
452     PlatformMouseEvent currentPlatformMouseEvent() const;
453 #endif
454
455 #if ENABLE(FULLSCREEN_API)
456     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
457 #endif
458
459     void setLastKnownMousePosition(const PlatformMouseEvent&);
460
461 #if ENABLE(CURSOR_VISIBILITY)
462     void startAutoHideCursorTimer();
463     void cancelAutoHideCursorTimer();
464     void autoHideCursorTimerFired();
465 #endif
466
467     void clearOrScheduleClearingLatchedStateIfNeeded(const PlatformWheelEvent&);
468     void clearLatchedState();
469
470     Frame& m_frame;
471
472     bool m_mousePressed { false };
473     bool m_capturesDragging { false };
474     RefPtr<Node> m_mousePressNode;
475
476     bool m_mouseDownMayStartSelect { false };
477 #if ENABLE(DRAG_SUPPORT)
478     bool m_mouseDownMayStartDrag { false };
479     bool m_dragMayStartSelectionInstead { false };
480 #endif
481     bool m_mouseDownWasSingleClickInSelection { false };
482     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
483     SelectionInitiationState m_selectionInitiationState { HaveNotStartedSelection };
484
485 #if ENABLE(DRAG_SUPPORT)
486     LayoutPoint m_dragStartPos;
487 #endif
488
489     bool m_panScrollButtonPressed { false };
490
491     Timer m_hoverTimer;
492 #if ENABLE(CURSOR_SUPPORT)
493     Timer m_cursorUpdateTimer;
494 #endif
495
496 #if PLATFORM(MAC)
497     Timer m_pendingMomentumWheelEventsTimer;
498 #endif
499     std::unique_ptr<AutoscrollController> m_autoscrollController;
500     bool m_mouseDownMayStartAutoscroll { false };
501     bool m_mouseDownWasInSubframe { false };
502
503 #if !ENABLE(IOS_TOUCH_EVENTS)
504     Timer m_fakeMouseMoveEventTimer;
505 #endif
506
507     bool m_svgPan { false };
508
509     RenderLayer* m_resizeLayer { nullptr };
510
511     RefPtr<Element> m_capturingMouseEventsElement;
512     bool m_eventHandlerWillResetCapturingMouseEventsElement { false };
513     
514     RefPtr<Element> m_elementUnderMouse;
515     RefPtr<Element> m_lastElementUnderMouse;
516     RefPtr<Frame> m_lastMouseMoveEventSubframe;
517     WeakPtr<Scrollbar> m_lastScrollbarUnderMouse;
518     Cursor m_currentMouseCursor;
519
520     int m_clickCount { 0 };
521     RefPtr<Node> m_clickNode;
522
523 #if ENABLE(IOS_GESTURE_EVENTS)
524     float m_gestureInitialDiameter { GestureUnknown };
525     float m_gestureInitialRotation { GestureUnknown };
526 #endif
527 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
528     float m_gestureLastDiameter { GestureUnknown };
529     float m_gestureLastRotation { GestureUnknown };
530     EventTargetSet m_gestureTargets;
531 #endif
532 #if ENABLE(MAC_GESTURE_EVENTS)
533     bool m_hasActiveGesture { false };
534 #endif
535
536 #if ENABLE(IOS_TOUCH_EVENTS)
537     unsigned m_firstTouchID { InvalidTouchIdentifier };
538
539     TouchArray m_touches;
540     RefPtr<Frame> m_touchEventTargetSubframe;
541 #endif
542
543 #if ENABLE(DRAG_SUPPORT)
544     RefPtr<Element> m_dragTarget;
545     bool m_shouldOnlyFireDragOverEvent { false };
546 #endif
547     
548     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
549
550     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
551     
552     bool m_mousePositionIsUnknown { true };
553     IntPoint m_lastKnownMousePosition;
554     IntPoint m_lastKnownMouseGlobalPosition;
555     IntPoint m_mouseDownPos; // In our view's coords.
556     double m_mouseDownTimestamp { 0 };
557     PlatformMouseEvent m_mouseDown;
558
559 #if PLATFORM(COCOA)
560     NSView *m_mouseDownView { nullptr };
561     bool m_sendingEventToSubview { false };
562 #if !PLATFORM(IOS)
563     int m_activationEventNumber { -1 };
564 #endif
565 #endif
566 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
567     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
568     TouchTargetMap m_originatingTouchPointTargets;
569     RefPtr<Document> m_originatingTouchPointDocument;
570     unsigned m_originatingTouchPointTargetKey { 0 };
571     bool m_touchPressed { false };
572 #endif
573
574     double m_maxMouseMovedDuration { 0 };
575     PlatformEvent::Type m_baseEventType { PlatformEvent::NoType };
576     bool m_didStartDrag { false };
577     bool m_isHandlingWheelEvent { false };
578
579 #if ENABLE(CURSOR_VISIBILITY)
580     Timer m_autoHideCursorTimer;
581 #endif
582
583     ImmediateActionStage m_immediateActionStage { ImmediateActionStage::None };
584 };
585
586 } // namespace WebCore
587
588 #endif // EventHandler_h