Add magnify and rotate gesture event support for Mac
[WebKit-https.git] / Source / WebCore / page / EventHandler.h
1 /*
2  * Copyright (C) 2006-2015 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::DisallowShadowContent,
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     static Frame* subframeForTargetNode(Node*);
183     static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
184
185     WEBCORE_EXPORT bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
186     WEBCORE_EXPORT bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
187     WEBCORE_EXPORT bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
188
189     bool tabsToLinks(KeyboardEvent*) const;
190     bool tabsToAllFormControls(KeyboardEvent*) const;
191
192     WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
193     WEBCORE_EXPORT bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
194
195     void lostMouseCapture();
196
197     WEBCORE_EXPORT bool handleMousePressEvent(const PlatformMouseEvent&);
198     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false);
199     WEBCORE_EXPORT bool handleMouseReleaseEvent(const PlatformMouseEvent&);
200     bool handleMouseForceEvent(const PlatformMouseEvent&);
201     WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
202     void defaultWheelEventHandler(Node*, WheelEvent*);
203     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
204
205     void platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, RefPtr<Element>& eventTarget, RefPtr<ContainerNode>& scrollableContainer, ScrollableArea*&, bool& isOverWidget);
206     void platformRecordWheelEvent(const PlatformWheelEvent&);
207     bool platformCompleteWheelEvent(const PlatformWheelEvent&, ContainerNode* scrollableContainer, ScrollableArea*);
208     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
209     void platformNotifyIfEndGesture(const PlatformWheelEvent&, ScrollableArea*);
210
211 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
212     typedef Vector<RefPtr<Touch>> TouchArray;
213     typedef HashMap<EventTarget*, TouchArray*> EventTargetTouchMap;
214 #endif
215
216 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
217     typedef HashSet<RefPtr<EventTarget>> EventTargetSet;
218 #endif
219
220 #if ENABLE(IOS_TOUCH_EVENTS)
221     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetTouchMap&, float, float);
222     bool dispatchSimulatedTouchEvent(IntPoint location);
223 #endif
224
225 #if ENABLE(IOS_GESTURE_EVENTS)
226     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetSet&, float, float);
227 #elif ENABLE(MAC_GESTURE_EVENTS)
228     bool dispatchGestureEvent(const PlatformGestureEvent&, const AtomicString&, const EventTargetSet&, float, float);
229     WEBCORE_EXPORT bool handleGestureEvent(const PlatformGestureEvent&);
230 #endif
231
232 #if PLATFORM(IOS)
233     void defaultTouchEventHandler(Node*, TouchEvent*);
234 #endif
235
236 #if ENABLE(CONTEXT_MENUS)
237     WEBCORE_EXPORT bool sendContextMenuEvent(const PlatformMouseEvent&);
238     bool sendContextMenuEventForKey();
239 #endif
240
241     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
242
243     bool needsKeyboardEventDisambiguationQuirks() const;
244
245     static unsigned accessKeyModifiers();
246     WEBCORE_EXPORT bool handleAccessKey(const PlatformKeyboardEvent&);
247     WEBCORE_EXPORT bool keyEvent(const PlatformKeyboardEvent&);
248     void defaultKeyboardEventHandler(KeyboardEvent*);
249
250     bool accessibilityPreventsEventPropogation(KeyboardEvent*);
251     WEBCORE_EXPORT void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent*);
252
253     bool handleTextInputEvent(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard);
254     void defaultTextInputEventHandler(TextEvent*);
255
256 #if ENABLE(DRAG_SUPPORT)
257     WEBCORE_EXPORT bool eventMayStartDrag(const PlatformMouseEvent&) const;
258     
259     WEBCORE_EXPORT void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
260 #endif
261
262     void focusDocumentView();
263     
264     WEBCORE_EXPORT void sendScrollEvent();
265
266 #if PLATFORM(COCOA) && defined(__OBJC__)
267 #if !PLATFORM(IOS)
268     WEBCORE_EXPORT void mouseDown(NSEvent *, NSEvent *correspondingPressureEvent);
269     WEBCORE_EXPORT void mouseDragged(NSEvent *, NSEvent *correspondingPressureEvent);
270     WEBCORE_EXPORT void mouseUp(NSEvent *, NSEvent *correspondingPressureEvent);
271     WEBCORE_EXPORT void mouseMoved(NSEvent *, NSEvent *correspondingPressureEvent);
272     WEBCORE_EXPORT void pressureChange(NSEvent *, NSEvent* correspondingPressureEvent);
273     WEBCORE_EXPORT bool keyEvent(NSEvent *);
274     WEBCORE_EXPORT bool wheelEvent(NSEvent *);
275 #else
276     WEBCORE_EXPORT void mouseDown(WebEvent *);
277     WEBCORE_EXPORT void mouseUp(WebEvent *);
278     WEBCORE_EXPORT void mouseMoved(WebEvent *);
279     WEBCORE_EXPORT bool keyEvent(WebEvent *);
280     WEBCORE_EXPORT bool wheelEvent(WebEvent *);
281 #endif
282
283 #if ENABLE(IOS_TOUCH_EVENTS)
284     WEBCORE_EXPORT void touchEvent(WebEvent *);
285 #endif
286
287 #if !PLATFORM(IOS)
288     WEBCORE_EXPORT void passMouseMovedEventToScrollbars(NSEvent *, NSEvent* correspondingPressureEvent);
289
290     WEBCORE_EXPORT void sendFakeEventsAfterWidgetTracking(NSEvent *initiatingEvent);
291 #endif
292
293 #if !PLATFORM(IOS)
294     void setActivationEventNumber(int num) { m_activationEventNumber = num; }
295
296     WEBCORE_EXPORT static NSEvent *currentNSEvent();
297     static NSEvent *correspondingPressureEvent();
298 #else
299     static WebEvent *currentEvent();
300 #endif // !PLATFORM(IOS)
301 #endif // PLATFORM(COCOA) && defined(__OBJC__)
302
303 #if PLATFORM(IOS)
304     void invalidateClick();
305 #endif
306
307 #if ENABLE(TOUCH_EVENTS)
308     WEBCORE_EXPORT bool handleTouchEvent(const PlatformTouchEvent&);
309 #endif
310
311     bool useHandCursor(Node*, bool isOverLink, bool shiftKey);
312     void updateCursor();
313
314     bool isHandlingWheelEvent() const { return m_isHandlingWheelEvent; }
315
316     WEBCORE_EXPORT void setImmediateActionStage(ImmediateActionStage stage);
317     ImmediateActionStage immediateActionStage() const { return m_immediateActionStage; }
318
319 private:
320 #if ENABLE(DRAG_SUPPORT)
321     static DragState& dragState();
322     static const double TextDragDelay;
323     
324     PassRefPtr<DataTransfer> createDraggingDataTransfer() const;
325 #endif // ENABLE(DRAG_SUPPORT)
326
327     bool eventActivatedView(const PlatformMouseEvent&) const;
328     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
329     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
330     VisibleSelection selectClosestWordFromHitTestResultBasedOnLookup(const HitTestResult&);
331     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
332     void selectClosestContextualWordFromMouseEvent(const MouseEventWithHitTestResults&);
333     void selectClosestContextualWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
334
335     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
336
337     WEBCORE_EXPORT bool handleMousePressEvent(const MouseEventWithHitTestResults&);
338     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
339     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
340     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
341 #if ENABLE(DRAG_SUPPORT)
342     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
343 #endif
344     WEBCORE_EXPORT bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
345
346     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
347
348     void hoverTimerFired();
349 #if ENABLE(CURSOR_SUPPORT)
350     void cursorUpdateTimerFired();
351 #endif
352
353     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
354     
355     bool shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const;
356     
357     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
358
359     static bool isKeyboardOptionTab(KeyboardEvent*);
360     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
361
362 #if !ENABLE(IOS_TOUCH_EVENTS)
363     void fakeMouseMoveEventTimerFired();
364     void cancelFakeMouseMoveEvent();
365 #endif
366
367     bool isInsideScrollbar(const IntPoint&) const;
368
369 #if ENABLE(TOUCH_EVENTS)
370     bool dispatchSyntheticTouchEventIfEnabled(const PlatformMouseEvent&);
371 #endif
372
373 #if !PLATFORM(IOS)
374     void invalidateClick();
375 #endif
376
377     Node* nodeUnderMouse() const;
378     
379     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&, bool fireMouseOverOut);
380     void fireMouseOverOut(bool fireMouseOver = true, bool fireMouseOut = true, bool updateLastNodeUnderMouse = true);
381     
382     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
383
384     bool dispatchMouseEvent(const AtomicString& eventType, Node* target, bool cancelable, int clickCount, const PlatformMouseEvent&, bool setUnder);
385 #if ENABLE(DRAG_SUPPORT)
386     bool dispatchDragEvent(const AtomicString& eventType, Element& target, const PlatformMouseEvent&, DataTransfer*);
387
388     void freeDataTransfer();
389
390     bool handleDrag(const MouseEventWithHitTestResults&, CheckDragHysteresis);
391 #endif
392     bool handleMouseUp(const MouseEventWithHitTestResults&);
393 #if ENABLE(DRAG_SUPPORT)
394     void clearDragState();
395
396     bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
397
398     bool dragHysteresisExceeded(const FloatPoint&) const;
399     bool dragHysteresisExceeded(const IntPoint&) const;
400 #endif // ENABLE(DRAG_SUPPORT)
401     
402     bool mouseMovementExceedsThreshold(const FloatPoint&, int pointsThreshold) const;
403
404     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
405     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
406     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
407
408     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
409
410     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
411
412     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
413     bool passWidgetMouseDownEventToWidget(RenderWidget*);
414
415     bool passMouseDownEventToWidget(Widget*);
416     bool passWheelEventToWidget(const PlatformWheelEvent&, Widget&);
417
418     void defaultSpaceEventHandler(KeyboardEvent*);
419     void defaultBackspaceEventHandler(KeyboardEvent*);
420     void defaultTabEventHandler(KeyboardEvent*);
421     void defaultArrowEventHandler(FocusDirection, KeyboardEvent*);
422
423 #if ENABLE(DRAG_SUPPORT)
424     DragSourceAction updateDragSourceActionsAllowed() const;
425 #endif
426
427     // The following are called at the beginning of handleMouseUp and handleDrag.  
428     // If they return true it indicates that they have consumed the event.
429     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
430 #if ENABLE(DRAG_SUPPORT)
431     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
432 #endif
433
434 #if ENABLE(DRAG_SUPPORT)
435     void updateSelectionForMouseDrag(const HitTestResult&);
436 #endif
437
438     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
439     
440     void setFrameWasScrolledByUser();
441
442     bool capturesDragging() const { return m_capturesDragging; }
443
444 #if PLATFORM(COCOA) && defined(__OBJC__)
445     NSView *mouseDownViewIfStillGood();
446
447     PlatformMouseEvent currentPlatformMouseEvent() const;
448 #endif
449
450 #if ENABLE(FULLSCREEN_API)
451     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
452 #endif
453
454     void setLastKnownMousePosition(const PlatformMouseEvent&);
455
456 #if ENABLE(CURSOR_VISIBILITY)
457     void startAutoHideCursorTimer();
458     void cancelAutoHideCursorTimer();
459     void autoHideCursorTimerFired();
460 #endif
461
462     void beginTrackingPotentialLongMousePress(const HitTestResult&);
463     void recognizeLongMousePress();
464     void cancelTrackingPotentialLongMousePress();
465     bool longMousePressHysteresisExceeded();
466     void clearLongMousePressState();
467     bool handleLongMousePressMouseMovedEvent(const PlatformMouseEvent&);
468
469     void clearLatchedState();
470
471     Frame& m_frame;
472
473     bool m_mousePressed { false };
474     bool m_capturesDragging { false };
475     RefPtr<Node> m_mousePressNode;
476
477     bool m_mouseDownMayStartSelect { false };
478 #if ENABLE(DRAG_SUPPORT)
479     bool m_mouseDownMayStartDrag { false };
480     bool m_dragMayStartSelectionInstead { false };
481 #endif
482     bool m_mouseDownWasSingleClickInSelection { false };
483     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
484     SelectionInitiationState m_selectionInitiationState { HaveNotStartedSelection };
485
486 #if ENABLE(DRAG_SUPPORT)
487     LayoutPoint m_dragStartPos;
488 #endif
489
490     bool m_panScrollButtonPressed { false };
491
492     Timer m_hoverTimer;
493 #if ENABLE(CURSOR_SUPPORT)
494     Timer m_cursorUpdateTimer;
495 #endif
496
497     Timer m_longMousePressTimer;
498     bool m_didRecognizeLongMousePress { false };
499
500     std::unique_ptr<AutoscrollController> m_autoscrollController;
501     bool m_mouseDownMayStartAutoscroll { false };
502     bool m_mouseDownWasInSubframe { false };
503
504 #if !ENABLE(IOS_TOUCH_EVENTS)
505     Timer m_fakeMouseMoveEventTimer;
506 #endif
507
508     bool m_svgPan { false };
509
510     RenderLayer* m_resizeLayer { nullptr };
511
512     RefPtr<Element> m_capturingMouseEventsElement;
513     bool m_eventHandlerWillResetCapturingMouseEventsElement { false };
514     
515     RefPtr<Element> m_elementUnderMouse;
516     RefPtr<Element> m_lastElementUnderMouse;
517     RefPtr<Frame> m_lastMouseMoveEventSubframe;
518     WeakPtr<Scrollbar> m_lastScrollbarUnderMouse;
519     Cursor m_currentMouseCursor;
520
521     int m_clickCount { 0 };
522     RefPtr<Node> m_clickNode;
523
524 #if ENABLE(IOS_GESTURE_EVENTS)
525     float m_gestureInitialDiameter { GestureUnknown };
526     float m_gestureInitialRotation { GestureUnknown };
527 #endif
528 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
529     float m_gestureLastDiameter { GestureUnknown };
530     float m_gestureLastRotation { GestureUnknown };
531     EventTargetSet m_gestureTargets;
532 #endif
533 #if ENABLE(MAC_GESTURE_EVENTS)
534     bool m_hasActiveGesture { false };
535 #endif
536
537 #if ENABLE(IOS_TOUCH_EVENTS)
538     unsigned m_firstTouchID { InvalidTouchIdentifier };
539
540     TouchArray m_touches;
541     RefPtr<Frame> m_touchEventTargetSubframe;
542 #endif
543
544 #if ENABLE(DRAG_SUPPORT)
545     RefPtr<Element> m_dragTarget;
546     bool m_shouldOnlyFireDragOverEvent { false };
547 #endif
548     
549     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
550
551     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
552     
553     bool m_mousePositionIsUnknown { true };
554     IntPoint m_lastKnownMousePosition;
555     IntPoint m_lastKnownMouseGlobalPosition;
556     IntPoint m_mouseDownPos; // In our view's coords.
557     double m_mouseDownTimestamp { 0 };
558     PlatformMouseEvent m_mouseDown;
559
560 #if PLATFORM(COCOA)
561     NSView *m_mouseDownView { nullptr };
562     bool m_sendingEventToSubview { false };
563 #if !PLATFORM(IOS)
564     int m_activationEventNumber { -1 };
565 #endif
566 #endif
567 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
568     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
569     TouchTargetMap m_originatingTouchPointTargets;
570     RefPtr<Document> m_originatingTouchPointDocument;
571     unsigned m_originatingTouchPointTargetKey { 0 };
572     bool m_touchPressed { false };
573 #endif
574
575     double m_maxMouseMovedDuration { 0 };
576     PlatformEvent::Type m_baseEventType { PlatformEvent::NoType };
577     bool m_didStartDrag { false };
578     bool m_didLongPressInvokeContextMenu { false };
579     bool m_isHandlingWheelEvent { false };
580
581 #if ENABLE(CURSOR_VISIBILITY)
582     Timer m_autoHideCursorTimer;
583 #endif
584
585     ImmediateActionStage m_immediateActionStage { ImmediateActionStage::None };
586 };
587
588 } // namespace WebCore
589
590 #endif // EventHandler_h