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