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