Source/WebCore/page/EventHandler.h

   1 /*
   2  * Copyright (C) 2006-2015 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef EventHandler_h
  27 #define EventHandler_h
  28
  29 #include "Cursor.h"
  30 #include "DragActions.h"
  31 #include "FocusDirection.h"
  32 #include "HitTestRequest.h"
  33 #include "LayoutPoint.h"
  34 #include "PlatformMouseEvent.h"
  35 #include "PlatformWheelEvent.h"
  36 #include "ScrollTypes.h"
  37 #include "TextEventInputType.h"
  38 #include "TextGranularity.h"
  39 #include "Timer.h"
  40 #include "WheelEventDeltaFilter.h"
  41 #include <memory>
  42 #include <wtf/Forward.h>
  43 #include <wtf/HashMap.h>
  44 #include <wtf/HashSet.h>
  45 #include <wtf/RefPtr.h>
  46 #include <wtf/Vector.h>
  47 #include <wtf/WeakPtr.h>
  48
  49 #if PLATFORM(IOS)
  50 OBJC_CLASS WebEvent;
  51 OBJC_CLASS WAKView;
  52 #ifdef __OBJC__
  53 #include "WAKAppKitStubs.h"
  54 #endif
  55 #endif // PLATFORM(IOS)
  56
  57 #if PLATFORM(COCOA)
  58 OBJC_CLASS NSView;
  59 #endif
  60
  61 namespace WebCore {
  62
  63 class AutoscrollController;
  64 class ContainerNode;
  65 class DataTransfer;
  66 class Document;
  67 class Element;
  68 class Event;
  69 class EventTarget;
  70 class FloatPoint;
  71 class FloatQuad;
  72 class Frame;
  73 class HTMLFrameSetElement;
  74 class HitTestRequest;
  75 class HitTestResult;
  76 class KeyboardEvent;
  77 class MouseEventWithHitTestResults;
  78 class Node;
  79 class OptionalCursor;
  80 class PlatformGestureEvent;
  81 class PlatformKeyboardEvent;
  82 class PlatformTouchEvent;
  83 class PlatformWheelEvent;
  84 class RenderBox;
  85 class RenderElement;
  86 class RenderLayer;
  87 class RenderWidget;
  88 class ScrollableArea;
  89 class Scrollbar;
  90 class TextEvent;
  91 class Touch;
  92 class TouchEvent;
  93 class VisibleSelection;
  94 class WheelEvent;
  95 class Widget;
  96
  97 struct DragState;
  98
  99 #if ENABLE(DRAG_SUPPORT)
 100 extern const int LinkDragHysteresis;
 101 extern const int ImageDragHysteresis;
 102 extern const int TextDragHysteresis;
 103 extern const int GeneralDragHysteresis;
 104 #endif // ENABLE(DRAG_SUPPORT)
 105
 106 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
 107 extern const float GestureUnknown;
 108 extern const unsigned InvalidTouchIdentifier;
 109 #endif
 110
 111 enum AppendTrailingWhitespace { ShouldAppendTrailingWhitespace, DontAppendTrailingWhitespace };
 112 enum CheckDragHysteresis { ShouldCheckDragHysteresis, DontCheckDragHysteresis };
 113
 114 enum class ImmediateActionStage {
 115     None,
 116     PerformedHitTest,
 117     ActionUpdated,
 118     ActionCancelledWithoutUpdate,
 119     ActionCancelledAfterUpdate,
 120     ActionCompleted
 121 };
 122
 123 class EventHandler {
 124     WTF_MAKE_NONCOPYABLE(EventHandler);
 125     WTF_MAKE_FAST_ALLOCATED;
 126 public:
 127     explicit EventHandler(Frame&);
 128     ~EventHandler();
 129
 130     void clear();
 131     void nodeWillBeRemoved(Node&);
 132
 133 #if ENABLE(DRAG_SUPPORT)
 134     void updateSelectionForMouseDrag();
 135 #endif
 136
 137 #if ENABLE(PAN_SCROLLING)
 138     void didPanScrollStart();
 139     void didPanScrollStop();
 140     void startPanScrolling(RenderElement*);
 141 #endif
 142
 143     void stopAutoscrollTimer(bool rendererIsBeingDestroyed = false);
 144     RenderBox* autoscrollRenderer() const;
 145     void updateAutoscrollRenderer();
 146     bool autoscrollInProgress() const;
 147     bool mouseDownWasInSubframe() const { return m_mouseDownWasInSubframe; }
 148     bool panScrollInProgress() const;
 149
 150     WEBCORE_EXPORT void dispatchFakeMouseMoveEventSoon();
 151     void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
 152
 153     WEBCORE_EXPORT HitTestResult hitTestResultAtPoint(const LayoutPoint&,
 154         HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent,
 155         const LayoutSize& padding = LayoutSize());
 156
 157     bool mousePressed() const { return m_mousePressed; }
 158     Node* mousePressNode() const { return m_mousePressNode.get(); }
 159
 160     WEBCORE_EXPORT void setCapturingMouseEventsElement(PassRefPtr<Element>); // A caller is responsible for resetting capturing element to 0.
 161
 162 #if ENABLE(DRAG_SUPPORT)
 163     bool updateDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
 164     void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
 165     bool performDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
 166     void updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement);
 167 #endif
 168
 169     void scheduleHoverStateUpdate();
 170 #if ENABLE(CURSOR_SUPPORT)
 171     void scheduleCursorUpdate();
 172 #endif
 173
 174     void setResizingFrameSet(HTMLFrameSetElement*);
 175
 176     void resizeLayerDestroyed();
 177
 178     IntPoint lastKnownMousePosition() const;
 179     IntPoint lastKnownMouseGlobalPosition() const { return m_lastKnownMouseGlobalPosition; }
 180     Cursor currentMouseCursor() const { return m_currentMouseCursor; }
 181
 182     static Frame* subframeForTargetNode(Node*);
 183     static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
 184
 185     WEBCORE_EXPORT bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
 186     WEBCORE_EXPORT bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
 187     WEBCORE_EXPORT bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
 188
 189     bool tabsToLinks(KeyboardEvent*) const;
 190     bool tabsToAllFormControls(KeyboardEvent*) const;
 191
 192     WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
 193     WEBCORE_EXPORT bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
 194
 195     void lostMouseCapture();
 196
 197     WEBCORE_EXPORT bool handleMousePressEvent(const PlatformMouseEvent&);
 198     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false);
 199     WEBCORE_EXPORT bool handleMouseReleaseEvent(const PlatformMouseEvent&);
 200     bool handleMouseForceEvent(const PlatformMouseEvent&);
 201     WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
 202     void defaultWheelEventHandler(Node*, WheelEvent*);
 203     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
 204
 205     void platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, RefPtr<Element>& eventTarget, RefPtr<ContainerNode>& scrollableContainer, ScrollableArea*&, bool& isOverWidget);
 206     void platformRecordWheelEvent(const PlatformWheelEvent&);
 207     bool platformCompleteWheelEvent(const PlatformWheelEvent&, ContainerNode* scrollableContainer, ScrollableArea*);
 208     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
 209     void platformNotifyIfEndGesture(const PlatformWheelEvent&, ScrollableArea*);
 210
 211 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
 212     typedef Vector<RefPtr<Touch>> TouchArray;
 213     typedef HashMap<EventTarget*, TouchArray*> EventTargetTouchMap;
 214 #endif
 215
 216 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
 217     typedef HashSet<RefPtr<EventTarget>> EventTargetSet;
 218 #endif
 219
 220 #if ENABLE(IOS_TOUCH_EVENTS)
 221     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetTouchMap&, float, float);
 222     bool dispatchSimulatedTouchEvent(IntPoint location);
 223 #endif
 224
 225 #if ENABLE(IOS_GESTURE_EVENTS)
 226     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetSet&, float, float);
 227 #elif ENABLE(MAC_GESTURE_EVENTS)
 228     bool dispatchGestureEvent(const PlatformGestureEvent&, const AtomicString&, const EventTargetSet&, float, float);
 229     WEBCORE_EXPORT bool handleGestureEvent(const PlatformGestureEvent&);
 230 #endif
 231
 232 #if PLATFORM(IOS)
 233     void defaultTouchEventHandler(Node*, TouchEvent*);
 234 #endif
 235
 236 #if ENABLE(CONTEXT_MENUS)
 237     WEBCORE_EXPORT bool sendContextMenuEvent(const PlatformMouseEvent&);
 238     bool sendContextMenuEventForKey();
 239 #endif
 240
 241     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
 242
 243     bool needsKeyboardEventDisambiguationQuirks() const;
 244
 245     static unsigned accessKeyModifiers();
 246     WEBCORE_EXPORT bool handleAccessKey(const PlatformKeyboardEvent&);
 247     WEBCORE_EXPORT bool keyEvent(const PlatformKeyboardEvent&);
 248     void defaultKeyboardEventHandler(KeyboardEvent*);
 249
 250     bool accessibilityPreventsEventPropogation(KeyboardEvent*);
 251     WEBCORE_EXPORT void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent*);
 252
 253     bool handleTextInputEvent(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard);
 254     void defaultTextInputEventHandler(TextEvent*);
 255
 256 #if ENABLE(DRAG_SUPPORT)
 257     WEBCORE_EXPORT bool eventMayStartDrag(const PlatformMouseEvent&) const;
 258
 259     WEBCORE_EXPORT void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
 260 #endif
 261
 262     void focusDocumentView();
 263
 264     WEBCORE_EXPORT void sendScrollEvent();
 265
 266 #if PLATFORM(COCOA) && defined(__OBJC__)
 267 #if !PLATFORM(IOS)
 268     WEBCORE_EXPORT void mouseDown(NSEvent *, NSEvent *correspondingPressureEvent);
 269     WEBCORE_EXPORT void mouseDragged(NSEvent *, NSEvent *correspondingPressureEvent);
 270     WEBCORE_EXPORT void mouseUp(NSEvent *, NSEvent *correspondingPressureEvent);
 271     WEBCORE_EXPORT void mouseMoved(NSEvent *, NSEvent *correspondingPressureEvent);
 272     WEBCORE_EXPORT void pressureChange(NSEvent *, NSEvent* correspondingPressureEvent);
 273     WEBCORE_EXPORT bool keyEvent(NSEvent *);
 274     WEBCORE_EXPORT bool wheelEvent(NSEvent *);
 275 #else
 276     WEBCORE_EXPORT void mouseDown(WebEvent *);
 277     WEBCORE_EXPORT void mouseUp(WebEvent *);
 278     WEBCORE_EXPORT void mouseMoved(WebEvent *);
 279     WEBCORE_EXPORT bool keyEvent(WebEvent *);
 280     WEBCORE_EXPORT bool wheelEvent(WebEvent *);
 281 #endif
 282
 283 #if ENABLE(IOS_TOUCH_EVENTS)
 284     WEBCORE_EXPORT void touchEvent(WebEvent *);
 285 #endif
 286
 287 #if !PLATFORM(IOS)
 288     WEBCORE_EXPORT void passMouseMovedEventToScrollbars(NSEvent *, NSEvent* correspondingPressureEvent);
 289
 290     WEBCORE_EXPORT void sendFakeEventsAfterWidgetTracking(NSEvent *initiatingEvent);
 291 #endif
 292
 293 #if !PLATFORM(IOS)
 294     void setActivationEventNumber(int num) { m_activationEventNumber = num; }
 295
 296     WEBCORE_EXPORT static NSEvent *currentNSEvent();
 297     static NSEvent *correspondingPressureEvent();
 298 #else
 299     static WebEvent *currentEvent();
 300 #endif // !PLATFORM(IOS)
 301 #endif // PLATFORM(COCOA) && defined(__OBJC__)
 302
 303 #if PLATFORM(IOS)
 304     void invalidateClick();
 305 #endif
 306
 307 #if ENABLE(TOUCH_EVENTS)
 308     WEBCORE_EXPORT bool handleTouchEvent(const PlatformTouchEvent&);
 309 #endif
 310
 311     bool useHandCursor(Node*, bool isOverLink, bool shiftKey);
 312     void updateCursor();
 313
 314     bool isHandlingWheelEvent() const { return m_isHandlingWheelEvent; }
 315
 316     WEBCORE_EXPORT void setImmediateActionStage(ImmediateActionStage stage);
 317     ImmediateActionStage immediateActionStage() const { return m_immediateActionStage; }
 318
 319 private:
 320 #if ENABLE(DRAG_SUPPORT)
 321     static DragState& dragState();
 322     static const double TextDragDelay;
 323
 324     PassRefPtr<DataTransfer> createDraggingDataTransfer() const;
 325 #endif // ENABLE(DRAG_SUPPORT)
 326
 327     bool eventActivatedView(const PlatformMouseEvent&) const;
 328     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
 329     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
 330     VisibleSelection selectClosestWordFromHitTestResultBasedOnLookup(const HitTestResult&);
 331     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
 332     void selectClosestContextualWordFromMouseEvent(const MouseEventWithHitTestResults&);
 333     void selectClosestContextualWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
 334
 335     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
 336
 337     WEBCORE_EXPORT bool handleMousePressEvent(const MouseEventWithHitTestResults&);
 338     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
 339     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
 340     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
 341 #if ENABLE(DRAG_SUPPORT)
 342     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
 343 #endif
 344     WEBCORE_EXPORT bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
 345
 346     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
 347
 348     void hoverTimerFired();
 349 #if ENABLE(CURSOR_SUPPORT)
 350     void cursorUpdateTimerFired();
 351 #endif
 352
 353     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
 354
 355     bool shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const;
 356
 357     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
 358
 359     static bool isKeyboardOptionTab(KeyboardEvent*);
 360     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
 361
 362 #if !ENABLE(IOS_TOUCH_EVENTS)
 363     void fakeMouseMoveEventTimerFired();
 364     void cancelFakeMouseMoveEvent();
 365 #endif
 366
 367     bool isInsideScrollbar(const IntPoint&) const;
 368
 369 #if ENABLE(TOUCH_EVENTS)
 370     bool dispatchSyntheticTouchEventIfEnabled(const PlatformMouseEvent&);
 371 #endif
 372
 373 #if !PLATFORM(IOS)
 374     void invalidateClick();
 375 #endif
 376
 377     Node* nodeUnderMouse() const;
 378
 379     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&, bool fireMouseOverOut);
 380     void fireMouseOverOut(bool fireMouseOver = true, bool fireMouseOut = true, bool updateLastNodeUnderMouse = true);
 381
 382     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
 383
 384     bool dispatchMouseEvent(const AtomicString& eventType, Node* target, bool cancelable, int clickCount, const PlatformMouseEvent&, bool setUnder);
 385 #if ENABLE(DRAG_SUPPORT)
 386     bool dispatchDragEvent(const AtomicString& eventType, Element& target, const PlatformMouseEvent&, DataTransfer*);
 387
 388     void freeDataTransfer();
 389
 390     bool handleDrag(const MouseEventWithHitTestResults&, CheckDragHysteresis);
 391 #endif
 392     bool handleMouseUp(const MouseEventWithHitTestResults&);
 393 #if ENABLE(DRAG_SUPPORT)
 394     void clearDragState();
 395
 396     bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
 397
 398     bool dragHysteresisExceeded(const FloatPoint&) const;
 399     bool dragHysteresisExceeded(const IntPoint&) const;
 400 #endif // ENABLE(DRAG_SUPPORT)
 401
 402     bool mouseMovementExceedsThreshold(const FloatPoint&, int pointsThreshold) const;
 403
 404     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
 405     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
 406     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
 407
 408     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
 409
 410     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
 411
 412     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
 413     bool passWidgetMouseDownEventToWidget(RenderWidget*);
 414
 415     bool passMouseDownEventToWidget(Widget*);
 416     bool passWheelEventToWidget(const PlatformWheelEvent&, Widget&);
 417
 418     void defaultSpaceEventHandler(KeyboardEvent*);
 419     void defaultBackspaceEventHandler(KeyboardEvent*);
 420     void defaultTabEventHandler(KeyboardEvent*);
 421     void defaultArrowEventHandler(FocusDirection, KeyboardEvent*);
 422
 423 #if ENABLE(DRAG_SUPPORT)
 424     DragSourceAction updateDragSourceActionsAllowed() const;
 425 #endif
 426
 427     // The following are called at the beginning of handleMouseUp and handleDrag.
 428     // If they return true it indicates that they have consumed the event.
 429     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
 430 #if ENABLE(DRAG_SUPPORT)
 431     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
 432 #endif
 433
 434 #if ENABLE(DRAG_SUPPORT)
 435     void updateSelectionForMouseDrag(const HitTestResult&);
 436 #endif
 437
 438     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
 439
 440     void setFrameWasScrolledByUser();
 441
 442     bool capturesDragging() const { return m_capturesDragging; }
 443
 444 #if PLATFORM(COCOA) && defined(__OBJC__)
 445     NSView *mouseDownViewIfStillGood();
 446
 447     PlatformMouseEvent currentPlatformMouseEvent() const;
 448 #endif
 449
 450 #if ENABLE(FULLSCREEN_API)
 451     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
 452 #endif
 453
 454     void setLastKnownMousePosition(const PlatformMouseEvent&);
 455
 456 #if ENABLE(CURSOR_VISIBILITY)
 457     void startAutoHideCursorTimer();
 458     void cancelAutoHideCursorTimer();
 459     void autoHideCursorTimerFired();
 460 #endif
 461
 462     void beginTrackingPotentialLongMousePress(const HitTestResult&);
 463     void recognizeLongMousePress();
 464     void cancelTrackingPotentialLongMousePress();
 465     bool longMousePressHysteresisExceeded();
 466     void clearLongMousePressState();
 467     bool handleLongMousePressMouseMovedEvent(const PlatformMouseEvent&);
 468
 469     void clearLatchedState();
 470
 471     Frame& m_frame;
 472
 473     bool m_mousePressed { false };
 474     bool m_capturesDragging { false };
 475     RefPtr<Node> m_mousePressNode;
 476
 477     bool m_mouseDownMayStartSelect { false };
 478 #if ENABLE(DRAG_SUPPORT)
 479     bool m_mouseDownMayStartDrag { false };
 480     bool m_dragMayStartSelectionInstead { false };
 481 #endif
 482     bool m_mouseDownWasSingleClickInSelection { false };
 483     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
 484     SelectionInitiationState m_selectionInitiationState { HaveNotStartedSelection };
 485
 486 #if ENABLE(DRAG_SUPPORT)
 487     LayoutPoint m_dragStartPos;
 488 #endif
 489
 490     bool m_panScrollButtonPressed { false };
 491
 492     Timer m_hoverTimer;
 493 #if ENABLE(CURSOR_SUPPORT)
 494     Timer m_cursorUpdateTimer;
 495 #endif
 496
 497     Timer m_longMousePressTimer;
 498     bool m_didRecognizeLongMousePress { false };
 499
 500     std::unique_ptr<AutoscrollController> m_autoscrollController;
 501     bool m_mouseDownMayStartAutoscroll { false };
 502     bool m_mouseDownWasInSubframe { false };
 503
 504 #if !ENABLE(IOS_TOUCH_EVENTS)
 505     Timer m_fakeMouseMoveEventTimer;
 506 #endif
 507
 508     bool m_svgPan { false };
 509
 510     RenderLayer* m_resizeLayer { nullptr };
 511
 512     RefPtr<Element> m_capturingMouseEventsElement;
 513     bool m_eventHandlerWillResetCapturingMouseEventsElement { false };
 514
 515     RefPtr<Element> m_elementUnderMouse;
 516     RefPtr<Element> m_lastElementUnderMouse;
 517     RefPtr<Frame> m_lastMouseMoveEventSubframe;
 518     WeakPtr<Scrollbar> m_lastScrollbarUnderMouse;
 519     Cursor m_currentMouseCursor;
 520
 521     int m_clickCount { 0 };
 522     RefPtr<Node> m_clickNode;
 523
 524 #if ENABLE(IOS_GESTURE_EVENTS)
 525     float m_gestureInitialDiameter { GestureUnknown };
 526     float m_gestureInitialRotation { GestureUnknown };
 527 #endif
 528 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
 529     float m_gestureLastDiameter { GestureUnknown };
 530     float m_gestureLastRotation { GestureUnknown };
 531     EventTargetSet m_gestureTargets;
 532 #endif
 533 #if ENABLE(MAC_GESTURE_EVENTS)
 534     bool m_hasActiveGesture { false };
 535 #endif
 536
 537 #if ENABLE(IOS_TOUCH_EVENTS)
 538     unsigned m_firstTouchID { InvalidTouchIdentifier };
 539
 540     TouchArray m_touches;
 541     RefPtr<Frame> m_touchEventTargetSubframe;
 542 #endif
 543
 544 #if ENABLE(DRAG_SUPPORT)
 545     RefPtr<Element> m_dragTarget;
 546     bool m_shouldOnlyFireDragOverEvent { false };
 547 #endif
 548
 549     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
 550
 551     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
 552
 553     bool m_mousePositionIsUnknown { true };
 554     IntPoint m_lastKnownMousePosition;
 555     IntPoint m_lastKnownMouseGlobalPosition;
 556     IntPoint m_mouseDownPos; // In our view's coords.
 557     double m_mouseDownTimestamp { 0 };
 558     PlatformMouseEvent m_mouseDown;
 559
 560 #if PLATFORM(COCOA)
 561     NSView *m_mouseDownView { nullptr };
 562     bool m_sendingEventToSubview { false };
 563 #if !PLATFORM(IOS)
 564     int m_activationEventNumber { -1 };
 565 #endif
 566 #endif
 567 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
 568     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
 569     TouchTargetMap m_originatingTouchPointTargets;
 570     RefPtr<Document> m_originatingTouchPointDocument;
 571     unsigned m_originatingTouchPointTargetKey { 0 };
 572     bool m_touchPressed { false };
 573 #endif
 574
 575     double m_maxMouseMovedDuration { 0 };
 576     PlatformEvent::Type m_baseEventType { PlatformEvent::NoType };
 577     bool m_didStartDrag { false };
 578     bool m_didLongPressInvokeContextMenu { false };
 579     bool m_isHandlingWheelEvent { false };
 580
 581 #if ENABLE(CURSOR_VISIBILITY)
 582     Timer m_autoHideCursorTimer;
 583 #endif
 584
 585     ImmediateActionStage m_immediateActionStage { ImmediateActionStage::None };
 586 };
 587
 588 } // namespace WebCore
 589
 590 #endif // EventHandler_h