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