ac58e9ddf34b31a2a9d511bccc25c1248ccfa91e
[WebKit.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     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, ScrollableArea*&, bool& isOverWidget);
208     void platformRecordWheelEvent(const PlatformWheelEvent&);
209     bool platformCompleteWheelEvent(const PlatformWheelEvent&, ContainerNode* scrollableContainer, ScrollableArea*);
210     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
211     void platformNotifyIfEndGesture(const PlatformWheelEvent&, 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 private:
322 #if ENABLE(DRAG_SUPPORT)
323     static DragState& dragState();
324     static const double TextDragDelay;
325     
326     PassRefPtr<DataTransfer> createDraggingDataTransfer() const;
327 #endif // ENABLE(DRAG_SUPPORT)
328
329     bool eventActivatedView(const PlatformMouseEvent&) const;
330     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
331     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
332     VisibleSelection selectClosestWordFromHitTestResultBasedOnLookup(const HitTestResult&);
333     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
334     void selectClosestContextualWordFromMouseEvent(const MouseEventWithHitTestResults&);
335     void selectClosestContextualWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
336
337     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
338
339     WEBCORE_EXPORT bool handleMousePressEvent(const MouseEventWithHitTestResults&);
340     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
341     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
342     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
343 #if ENABLE(DRAG_SUPPORT)
344     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
345 #endif
346     WEBCORE_EXPORT bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
347
348     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
349
350     void hoverTimerFired();
351 #if ENABLE(CURSOR_SUPPORT)
352     void cursorUpdateTimerFired();
353 #endif
354
355     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
356     
357     bool shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const;
358     
359     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
360
361     static bool isKeyboardOptionTab(KeyboardEvent*);
362     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
363
364 #if !ENABLE(IOS_TOUCH_EVENTS)
365     void fakeMouseMoveEventTimerFired();
366     void cancelFakeMouseMoveEvent();
367 #endif
368
369     bool isInsideScrollbar(const IntPoint&) const;
370
371 #if ENABLE(TOUCH_EVENTS)
372     bool dispatchSyntheticTouchEventIfEnabled(const PlatformMouseEvent&);
373 #endif
374
375 #if !PLATFORM(IOS)
376     void invalidateClick();
377 #endif
378
379     Node* nodeUnderMouse() const;
380     
381     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&, bool fireMouseOverOut);
382     void fireMouseOverOut(bool fireMouseOver = true, bool fireMouseOut = true, bool updateLastNodeUnderMouse = true);
383     
384     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
385
386     bool dispatchMouseEvent(const AtomicString& eventType, Node* target, bool cancelable, int clickCount, const PlatformMouseEvent&, bool setUnder);
387 #if ENABLE(DRAG_SUPPORT)
388     bool dispatchDragEvent(const AtomicString& eventType, Element& target, const PlatformMouseEvent&, DataTransfer*);
389
390     void freeDataTransfer();
391
392     bool handleDrag(const MouseEventWithHitTestResults&, CheckDragHysteresis);
393 #endif
394     bool handleMouseUp(const MouseEventWithHitTestResults&);
395 #if ENABLE(DRAG_SUPPORT)
396     void clearDragState();
397
398     bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
399
400     bool dragHysteresisExceeded(const FloatPoint&) const;
401     bool dragHysteresisExceeded(const IntPoint&) const;
402 #endif // ENABLE(DRAG_SUPPORT)
403     
404     bool mouseMovementExceedsThreshold(const FloatPoint&, int pointsThreshold) const;
405
406     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
407     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
408     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
409
410     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
411
412     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
413
414     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
415     bool passWidgetMouseDownEventToWidget(RenderWidget*);
416
417     bool passMouseDownEventToWidget(Widget*);
418     bool passWheelEventToWidget(const PlatformWheelEvent&, Widget&);
419
420     void defaultSpaceEventHandler(KeyboardEvent*);
421     void defaultBackspaceEventHandler(KeyboardEvent*);
422     void defaultTabEventHandler(KeyboardEvent*);
423     void defaultArrowEventHandler(FocusDirection, KeyboardEvent*);
424
425 #if ENABLE(DRAG_SUPPORT)
426     DragSourceAction updateDragSourceActionsAllowed() const;
427 #endif
428
429     // The following are called at the beginning of handleMouseUp and handleDrag.  
430     // If they return true it indicates that they have consumed the event.
431     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
432 #if ENABLE(DRAG_SUPPORT)
433     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
434 #endif
435
436 #if ENABLE(DRAG_SUPPORT)
437     void updateSelectionForMouseDrag(const HitTestResult&);
438 #endif
439
440     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
441     
442     void setFrameWasScrolledByUser();
443
444     bool capturesDragging() const { return m_capturesDragging; }
445
446 #if PLATFORM(COCOA) && defined(__OBJC__)
447     NSView *mouseDownViewIfStillGood();
448
449     PlatformMouseEvent currentPlatformMouseEvent() const;
450 #endif
451
452 #if ENABLE(FULLSCREEN_API)
453     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
454 #endif
455
456     void setLastKnownMousePosition(const PlatformMouseEvent&);
457
458 #if ENABLE(CURSOR_VISIBILITY)
459     void startAutoHideCursorTimer();
460     void cancelAutoHideCursorTimer();
461     void autoHideCursorTimerFired();
462 #endif
463
464     void clearOrScheduleClearingLatchedStateIfNeeded(const PlatformWheelEvent&);
465     void clearLatchedState();
466
467     Frame& m_frame;
468
469     bool m_mousePressed { false };
470     bool m_capturesDragging { false };
471     RefPtr<Node> m_mousePressNode;
472
473     bool m_mouseDownMayStartSelect { false };
474 #if ENABLE(DRAG_SUPPORT)
475     bool m_mouseDownMayStartDrag { false };
476     bool m_dragMayStartSelectionInstead { false };
477 #endif
478     bool m_mouseDownWasSingleClickInSelection { false };
479     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
480     SelectionInitiationState m_selectionInitiationState { HaveNotStartedSelection };
481
482 #if ENABLE(DRAG_SUPPORT)
483     LayoutPoint m_dragStartPos;
484 #endif
485
486     bool m_panScrollButtonPressed { false };
487
488     Timer m_hoverTimer;
489 #if ENABLE(CURSOR_SUPPORT)
490     Timer m_cursorUpdateTimer;
491 #endif
492
493 #if PLATFORM(MAC)
494     Timer m_pendingMomentumWheelEventsTimer;
495 #endif
496     std::unique_ptr<AutoscrollController> m_autoscrollController;
497     bool m_mouseDownMayStartAutoscroll { false };
498     bool m_mouseDownWasInSubframe { false };
499
500 #if !ENABLE(IOS_TOUCH_EVENTS)
501     Timer m_fakeMouseMoveEventTimer;
502 #endif
503
504     bool m_svgPan { false };
505
506     RenderLayer* m_resizeLayer { nullptr };
507
508     RefPtr<Element> m_capturingMouseEventsElement;
509     bool m_eventHandlerWillResetCapturingMouseEventsElement { false };
510     
511     RefPtr<Element> m_elementUnderMouse;
512     RefPtr<Element> m_lastElementUnderMouse;
513     RefPtr<Frame> m_lastMouseMoveEventSubframe;
514     WeakPtr<Scrollbar> m_lastScrollbarUnderMouse;
515     Cursor m_currentMouseCursor;
516
517     int m_clickCount { 0 };
518     RefPtr<Node> m_clickNode;
519
520 #if ENABLE(IOS_GESTURE_EVENTS)
521     float m_gestureInitialDiameter { GestureUnknown };
522     float m_gestureInitialRotation { GestureUnknown };
523 #endif
524 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
525     float m_gestureLastDiameter { GestureUnknown };
526     float m_gestureLastRotation { GestureUnknown };
527     EventTargetSet m_gestureTargets;
528 #endif
529 #if ENABLE(MAC_GESTURE_EVENTS)
530     bool m_hasActiveGesture { false };
531 #endif
532
533 #if ENABLE(IOS_TOUCH_EVENTS)
534     unsigned m_firstTouchID { InvalidTouchIdentifier };
535
536     TouchArray m_touches;
537     RefPtr<Frame> m_touchEventTargetSubframe;
538 #endif
539
540 #if ENABLE(DRAG_SUPPORT)
541     RefPtr<Element> m_dragTarget;
542     bool m_shouldOnlyFireDragOverEvent { false };
543 #endif
544     
545     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
546
547     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
548     
549     bool m_mousePositionIsUnknown { true };
550     IntPoint m_lastKnownMousePosition;
551     IntPoint m_lastKnownMouseGlobalPosition;
552     IntPoint m_mouseDownPos; // In our view's coords.
553     double m_mouseDownTimestamp { 0 };
554     PlatformMouseEvent m_mouseDown;
555
556 #if PLATFORM(COCOA)
557     NSView *m_mouseDownView { nullptr };
558     bool m_sendingEventToSubview { false };
559 #if !PLATFORM(IOS)
560     int m_activationEventNumber { -1 };
561 #endif
562 #endif
563 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
564     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
565     TouchTargetMap m_originatingTouchPointTargets;
566     RefPtr<Document> m_originatingTouchPointDocument;
567     unsigned m_originatingTouchPointTargetKey { 0 };
568     bool m_touchPressed { false };
569 #endif
570
571     double m_maxMouseMovedDuration { 0 };
572     PlatformEvent::Type m_baseEventType { PlatformEvent::NoType };
573     bool m_didStartDrag { false };
574     bool m_isHandlingWheelEvent { false };
575
576 #if ENABLE(CURSOR_VISIBILITY)
577     Timer m_autoHideCursorTimer;
578 #endif
579
580     ImmediateActionStage m_immediateActionStage { ImmediateActionStage::None };
581 };
582
583 } // namespace WebCore
584
585 #endif // EventHandler_h