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 "WheelEventDeltaTracker.h"
  41 #include <memory>
  42 #include <wtf/Forward.h>
  43 #include <wtf/RefPtr.h>
  44 #include <wtf/WeakPtr.h>
  45
  46 #if PLATFORM(IOS)
  47 #ifdef __OBJC__
  48 @class WebEvent;
  49 @class WAKView;
  50 #include "WAKAppKitStubs.h"
  51 #else
  52 class WebEvent;
  53 #endif
  54 #endif // PLATFORM(IOS)
  55
  56 #if PLATFORM(COCOA) && !defined(__OBJC__)
  57 class NSView;
  58 #endif
  59
  60 #if ENABLE(TOUCH_EVENTS)
  61 #include <wtf/HashMap.h>
  62 #endif
  63
  64 #if ENABLE(IOS_TOUCH_EVENTS)
  65 #include <wtf/HashSet.h>
  66 #include <wtf/Vector.h>
  67 #endif
  68
  69 namespace WebCore {
  70
  71 class AutoscrollController;
  72 class ContainerNode;
  73 class DataTransfer;
  74 class Document;
  75 class Element;
  76 class Event;
  77 class EventTarget;
  78 class FloatPoint;
  79 class FloatQuad;
  80 class Frame;
  81 class HTMLFrameSetElement;
  82 class HitTestRequest;
  83 class HitTestResult;
  84 class KeyboardEvent;
  85 class MouseEventWithHitTestResults;
  86 class Node;
  87 class OptionalCursor;
  88 class PlatformKeyboardEvent;
  89 class PlatformTouchEvent;
  90 class PlatformWheelEvent;
  91 class RenderBox;
  92 class RenderElement;
  93 class RenderLayer;
  94 class RenderWidget;
  95 class ScrollableArea;
  96 class Scrollbar;
  97 class TextEvent;
  98 class Touch;
  99 class TouchEvent;
 100 class VisibleSelection;
 101 class WheelEvent;
 102 class Widget;
 103
 104 struct DragState;
 105
 106 #if ENABLE(DRAG_SUPPORT)
 107 extern const int LinkDragHysteresis;
 108 extern const int ImageDragHysteresis;
 109 extern const int TextDragHysteresis;
 110 extern const int GeneralDragHysteresis;
 111 #endif // ENABLE(DRAG_SUPPORT)
 112
 113 #if ENABLE(IOS_GESTURE_EVENTS)
 114 extern const float GestureUnknown;
 115 #endif
 116
 117 enum AppendTrailingWhitespace { ShouldAppendTrailingWhitespace, DontAppendTrailingWhitespace };
 118 enum CheckDragHysteresis { ShouldCheckDragHysteresis, DontCheckDragHysteresis };
 119
 120 class EventHandler {
 121     WTF_MAKE_NONCOPYABLE(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&,
 151         HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent,
 152         const LayoutSize& padding = LayoutSize());
 153
 154     bool mousePressed() const { return m_mousePressed; }
 155     Node* mousePressNode() const { return m_mousePressNode.get(); }
 156
 157     WEBCORE_EXPORT void setCapturingMouseEventsElement(PassRefPtr<Element>); // A caller is responsible for resetting capturing element to 0.
 158
 159 #if ENABLE(DRAG_SUPPORT)
 160     bool updateDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
 161     void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
 162     bool performDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
 163     void updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement);
 164 #endif
 165
 166     void scheduleHoverStateUpdate();
 167 #if ENABLE(CURSOR_SUPPORT)
 168     void scheduleCursorUpdate();
 169 #endif
 170
 171     void setResizingFrameSet(HTMLFrameSetElement*);
 172
 173     void resizeLayerDestroyed();
 174
 175     IntPoint lastKnownMousePosition() const;
 176     Cursor currentMouseCursor() const { return m_currentMouseCursor; }
 177
 178     static Frame* subframeForTargetNode(Node*);
 179     static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
 180
 181     WEBCORE_EXPORT bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
 182     WEBCORE_EXPORT bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
 183     WEBCORE_EXPORT bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = 0);
 184
 185     bool tabsToLinks(KeyboardEvent*) const;
 186     bool tabsToAllFormControls(KeyboardEvent*) const;
 187
 188     WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
 189     WEBCORE_EXPORT bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
 190
 191     void lostMouseCapture();
 192
 193     WEBCORE_EXPORT bool handleMousePressEvent(const PlatformMouseEvent&);
 194     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = 0, bool onlyUpdateScrollbars = false);
 195     WEBCORE_EXPORT bool handleMouseReleaseEvent(const PlatformMouseEvent&);
 196     WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
 197     void defaultWheelEventHandler(Node*, WheelEvent*);
 198     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
 199
 200     void platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, RefPtr<Element>& eventTarget, RefPtr<ContainerNode>& scrollableContainer, ScrollableArea*&, bool& isOverWidget);
 201     void platformRecordWheelEvent(const PlatformWheelEvent&);
 202     bool platformCompleteWheelEvent(const PlatformWheelEvent&, Element* eventTarget, ContainerNode* scrollableContainer, ScrollableArea*);
 203     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
 204
 205 #if ENABLE(CSS_SCROLL_SNAP)
 206     void platformNotifySnapIfNecessary(const PlatformWheelEvent&, ScrollableArea&);
 207 #endif
 208
 209 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
 210     typedef Vector<RefPtr<Touch>> TouchArray;
 211     typedef HashMap<EventTarget*, TouchArray*> EventTargetTouchMap;
 212     typedef HashSet<RefPtr<EventTarget>> EventTargetSet;
 213 #endif
 214
 215 #if ENABLE(IOS_TOUCH_EVENTS)
 216     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetTouchMap&, float, float);
 217     bool dispatchSimulatedTouchEvent(IntPoint location);
 218 #endif
 219
 220 #if ENABLE(IOS_GESTURE_EVENTS)
 221     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetSet&, float, float);
 222 #endif
 223
 224 #if PLATFORM(IOS)
 225     void defaultTouchEventHandler(Node*, TouchEvent*);
 226 #endif
 227
 228 #if ENABLE(CONTEXT_MENUS)
 229     WEBCORE_EXPORT bool sendContextMenuEvent(const PlatformMouseEvent&);
 230     bool sendContextMenuEventForKey();
 231 #endif
 232
 233     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
 234
 235     bool needsKeyboardEventDisambiguationQuirks() const;
 236
 237     static unsigned accessKeyModifiers();
 238     WEBCORE_EXPORT bool handleAccessKey(const PlatformKeyboardEvent&);
 239     WEBCORE_EXPORT bool keyEvent(const PlatformKeyboardEvent&);
 240     void defaultKeyboardEventHandler(KeyboardEvent*);
 241
 242     bool accessibilityPreventsEventPropogation(KeyboardEvent*);
 243     WEBCORE_EXPORT void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent*);
 244
 245     bool handleTextInputEvent(const String& text, Event* underlyingEvent = 0, TextEventInputType = TextEventInputKeyboard);
 246     void defaultTextInputEventHandler(TextEvent*);
 247
 248 #if ENABLE(DRAG_SUPPORT)
 249     WEBCORE_EXPORT bool eventMayStartDrag(const PlatformMouseEvent&) const;
 250
 251     WEBCORE_EXPORT void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
 252 #endif
 253
 254     void focusDocumentView();
 255
 256     void capsLockStateMayHaveChanged(); // Only called by FrameSelection
 257
 258     WEBCORE_EXPORT void sendScrollEvent(); // Ditto
 259
 260 #if PLATFORM(COCOA) && defined(__OBJC__)
 261 #if !PLATFORM(IOS)
 262     WEBCORE_EXPORT void mouseDown(NSEvent *);
 263     WEBCORE_EXPORT void mouseDragged(NSEvent *);
 264     WEBCORE_EXPORT void mouseUp(NSEvent *);
 265     WEBCORE_EXPORT void mouseMoved(NSEvent *);
 266     WEBCORE_EXPORT bool keyEvent(NSEvent *);
 267     WEBCORE_EXPORT bool wheelEvent(NSEvent *);
 268 #else
 269     WEBCORE_EXPORT void mouseDown(WebEvent *);
 270     WEBCORE_EXPORT void mouseUp(WebEvent *);
 271     WEBCORE_EXPORT void mouseMoved(WebEvent *);
 272     WEBCORE_EXPORT bool keyEvent(WebEvent *);
 273     WEBCORE_EXPORT bool wheelEvent(WebEvent *);
 274 #endif
 275
 276 #if ENABLE(IOS_TOUCH_EVENTS)
 277     WEBCORE_EXPORT void touchEvent(WebEvent *);
 278 #endif
 279
 280 #if !PLATFORM(IOS)
 281     WEBCORE_EXPORT void passMouseMovedEventToScrollbars(NSEvent *);
 282
 283     WEBCORE_EXPORT void sendFakeEventsAfterWidgetTracking(NSEvent *initiatingEvent);
 284 #endif
 285
 286 #if !PLATFORM(IOS)
 287     void setActivationEventNumber(int num) { m_activationEventNumber = num; }
 288
 289     WEBCORE_EXPORT static NSEvent *currentNSEvent();
 290 #else
 291     static WebEvent *currentEvent();
 292 #endif // !PLATFORM(IOS)
 293 #endif // PLATFORM(COCOA) && defined(__OBJC__)
 294
 295 #if PLATFORM(IOS)
 296     void invalidateClick();
 297 #endif
 298
 299 #if ENABLE(TOUCH_EVENTS)
 300     WEBCORE_EXPORT bool handleTouchEvent(const PlatformTouchEvent&);
 301 #endif
 302
 303     bool useHandCursor(Node*, bool isOverLink, bool shiftKey);
 304     void updateCursor();
 305
 306     bool isHandlingWheelEvent() const { return m_isHandlingWheelEvent; }
 307
 308 private:
 309 #if ENABLE(DRAG_SUPPORT)
 310     static DragState& dragState();
 311     static const double TextDragDelay;
 312
 313     PassRefPtr<DataTransfer> createDraggingDataTransfer() const;
 314 #endif // ENABLE(DRAG_SUPPORT)
 315
 316     bool eventActivatedView(const PlatformMouseEvent&) const;
 317     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
 318     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
 319     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
 320     void selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
 321
 322     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
 323
 324     WEBCORE_EXPORT bool handleMousePressEvent(const MouseEventWithHitTestResults&);
 325     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
 326     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
 327     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
 328 #if ENABLE(DRAG_SUPPORT)
 329     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
 330 #endif
 331     WEBCORE_EXPORT bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
 332
 333     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
 334
 335     void hoverTimerFired();
 336 #if ENABLE(CURSOR_SUPPORT)
 337     void cursorUpdateTimerFired();
 338 #endif
 339
 340     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = 0);
 341
 342     bool shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const;
 343
 344     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
 345
 346     static bool isKeyboardOptionTab(KeyboardEvent*);
 347     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
 348
 349 #if !ENABLE(IOS_TOUCH_EVENTS)
 350     void fakeMouseMoveEventTimerFired();
 351     void cancelFakeMouseMoveEvent();
 352 #endif
 353
 354     bool isInsideScrollbar(const IntPoint&) const;
 355
 356 #if ENABLE(TOUCH_EVENTS)
 357     bool dispatchSyntheticTouchEventIfEnabled(const PlatformMouseEvent&);
 358 #endif
 359
 360 #if !PLATFORM(IOS)
 361     void invalidateClick();
 362 #endif
 363
 364     Node* nodeUnderMouse() const;
 365
 366     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&, bool fireMouseOverOut);
 367     void fireMouseOverOut(bool fireMouseOver = true, bool fireMouseOut = true, bool updateLastNodeUnderMouse = true);
 368
 369     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
 370
 371     bool dispatchMouseEvent(const AtomicString& eventType, Node* target, bool cancelable, int clickCount, const PlatformMouseEvent&, bool setUnder);
 372 #if ENABLE(DRAG_SUPPORT)
 373     bool dispatchDragEvent(const AtomicString& eventType, Element& target, const PlatformMouseEvent&, DataTransfer*);
 374
 375     void freeDataTransfer();
 376
 377     bool handleDrag(const MouseEventWithHitTestResults&, CheckDragHysteresis);
 378 #endif
 379     bool handleMouseUp(const MouseEventWithHitTestResults&);
 380 #if ENABLE(DRAG_SUPPORT)
 381     void clearDragState();
 382
 383     bool dispatchDragSrcEvent(const AtomicString& eventType, const PlatformMouseEvent&);
 384
 385     bool dragHysteresisExceeded(const FloatPoint&) const;
 386     bool dragHysteresisExceeded(const IntPoint&) const;
 387 #endif // ENABLE(DRAG_SUPPORT)
 388
 389     bool mouseMovementExceedsThreshold(const FloatPoint&, int pointsThreshold) const;
 390
 391     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
 392     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = 0);
 393     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
 394
 395     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = 0);
 396
 397     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
 398
 399     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
 400     bool passWidgetMouseDownEventToWidget(RenderWidget*);
 401
 402     bool passMouseDownEventToWidget(Widget*);
 403     bool passWheelEventToWidget(const PlatformWheelEvent&, Widget&);
 404
 405     void defaultSpaceEventHandler(KeyboardEvent*);
 406     void defaultBackspaceEventHandler(KeyboardEvent*);
 407     void defaultTabEventHandler(KeyboardEvent*);
 408     void defaultArrowEventHandler(FocusDirection, KeyboardEvent*);
 409
 410 #if ENABLE(DRAG_SUPPORT)
 411     DragSourceAction updateDragSourceActionsAllowed() const;
 412 #endif
 413
 414     // The following are called at the beginning of handleMouseUp and handleDrag.
 415     // If they return true it indicates that they have consumed the event.
 416     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
 417 #if ENABLE(DRAG_SUPPORT)
 418     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
 419 #endif
 420
 421 #if ENABLE(DRAG_SUPPORT)
 422     void updateSelectionForMouseDrag(const HitTestResult&);
 423 #endif
 424
 425     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
 426
 427     void setFrameWasScrolledByUser();
 428
 429     bool capturesDragging() const { return m_capturesDragging; }
 430
 431 #if PLATFORM(COCOA) && defined(__OBJC__)
 432     NSView *mouseDownViewIfStillGood();
 433
 434     PlatformMouseEvent currentPlatformMouseEvent() const;
 435 #endif
 436
 437 #if ENABLE(FULLSCREEN_API)
 438     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
 439 #endif
 440
 441     void setLastKnownMousePosition(const PlatformMouseEvent&);
 442
 443 #if ENABLE(CURSOR_VISIBILITY)
 444     void startAutoHideCursorTimer();
 445     void cancelAutoHideCursorTimer();
 446     void autoHideCursorTimerFired();
 447 #endif
 448
 449     void beginTrackingPotentialLongMousePress(const HitTestResult&);
 450     void recognizeLongMousePress();
 451     void cancelTrackingPotentialLongMousePress();
 452     bool longMousePressHysteresisExceeded();
 453     void clearLongMousePressState();
 454     bool handleLongMousePressMouseMovedEvent(const PlatformMouseEvent&);
 455
 456     void clearLatchedState();
 457
 458     Frame& m_frame;
 459
 460     bool m_mousePressed;
 461     bool m_capturesDragging;
 462     RefPtr<Node> m_mousePressNode;
 463
 464     bool m_mouseDownMayStartSelect;
 465 #if ENABLE(DRAG_SUPPORT)
 466     bool m_mouseDownMayStartDrag;
 467     bool m_dragMayStartSelectionInstead;
 468 #endif
 469     bool m_mouseDownWasSingleClickInSelection;
 470     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
 471     SelectionInitiationState m_selectionInitiationState;
 472
 473 #if ENABLE(DRAG_SUPPORT)
 474     LayoutPoint m_dragStartPos;
 475 #endif
 476
 477     bool m_panScrollButtonPressed;
 478
 479     Timer m_hoverTimer;
 480 #if ENABLE(CURSOR_SUPPORT)
 481     Timer m_cursorUpdateTimer;
 482 #endif
 483
 484     Timer m_longMousePressTimer;
 485     bool m_didRecognizeLongMousePress;
 486
 487     std::unique_ptr<AutoscrollController> m_autoscrollController;
 488     bool m_mouseDownMayStartAutoscroll;
 489     bool m_mouseDownWasInSubframe;
 490
 491 #if !ENABLE(IOS_TOUCH_EVENTS)
 492     Timer m_fakeMouseMoveEventTimer;
 493 #endif
 494
 495     bool m_svgPan;
 496
 497     RenderLayer* m_resizeLayer;
 498
 499     RefPtr<Element> m_capturingMouseEventsElement;
 500     bool m_eventHandlerWillResetCapturingMouseEventsElement;
 501
 502     RefPtr<Element> m_elementUnderMouse;
 503     RefPtr<Element> m_lastElementUnderMouse;
 504     RefPtr<Frame> m_lastMouseMoveEventSubframe;
 505     WeakPtr<Scrollbar> m_lastScrollbarUnderMouse;
 506     Cursor m_currentMouseCursor;
 507
 508     int m_clickCount;
 509     RefPtr<Node> m_clickNode;
 510
 511 #if ENABLE(IOS_GESTURE_EVENTS)
 512     float m_gestureInitialDiameter;
 513     float m_gestureLastDiameter;
 514     float m_gestureInitialRotation;
 515     float m_gestureLastRotation;
 516 #endif
 517
 518 #if ENABLE(IOS_TOUCH_EVENTS)
 519     unsigned m_firstTouchID;
 520
 521     TouchArray m_touches;
 522     EventTargetSet m_gestureTargets;
 523     RefPtr<Frame> m_touchEventTargetSubframe;
 524 #endif
 525
 526 #if ENABLE(DRAG_SUPPORT)
 527     RefPtr<Element> m_dragTarget;
 528     bool m_shouldOnlyFireDragOverEvent;
 529 #endif
 530
 531     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
 532
 533     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
 534
 535     bool m_mousePositionIsUnknown;
 536     IntPoint m_lastKnownMousePosition;
 537     IntPoint m_lastKnownMouseGlobalPosition;
 538     IntPoint m_mouseDownPos; // In our view's coords.
 539     double m_mouseDownTimestamp;
 540     PlatformMouseEvent m_mouseDown;
 541
 542 #if PLATFORM(COCOA)
 543     NSView *m_mouseDownView;
 544     bool m_sendingEventToSubview;
 545     bool m_startedGestureAtScrollLimit;
 546 #if !PLATFORM(IOS)
 547     int m_activationEventNumber;
 548 #endif
 549 #endif
 550 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
 551     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
 552     TouchTargetMap m_originatingTouchPointTargets;
 553     RefPtr<Document> m_originatingTouchPointDocument;
 554     unsigned m_originatingTouchPointTargetKey;
 555     bool m_touchPressed;
 556 #endif
 557
 558     double m_maxMouseMovedDuration;
 559     PlatformEvent::Type m_baseEventType;
 560     bool m_didStartDrag;
 561     bool m_didLongPressInvokeContextMenu;
 562     bool m_isHandlingWheelEvent;
 563
 564 #if ENABLE(CURSOR_VISIBILITY)
 565     Timer m_autoHideCursorTimer;
 566 #endif
 567 };
 568
 569 } // namespace WebCore
 570
 571 #endif // EventHandler_h