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