Build fix.
[WebKit-https.git] / 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/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 enum class ImmediateActionStage {
121     None,
122     PerformedHitTest,
123     ActionUpdated,
124     ActionCancelledWithoutUpdate,
125     ActionCancelledAfterUpdate,
126     ActionCompleted
127 };
128
129 class EventHandler {
130     WTF_MAKE_NONCOPYABLE(EventHandler);
131     WTF_MAKE_FAST_ALLOCATED;
132 public:
133     explicit EventHandler(Frame&);
134     ~EventHandler();
135
136     void clear();
137     void nodeWillBeRemoved(Node&);
138
139 #if ENABLE(DRAG_SUPPORT)
140     void updateSelectionForMouseDrag();
141 #endif
142
143 #if ENABLE(PAN_SCROLLING)
144     void didPanScrollStart();
145     void didPanScrollStop();
146     void startPanScrolling(RenderElement*);
147 #endif
148
149     void stopAutoscrollTimer(bool rendererIsBeingDestroyed = false);
150     RenderBox* autoscrollRenderer() const;
151     void updateAutoscrollRenderer();
152     bool autoscrollInProgress() const;
153     bool mouseDownWasInSubframe() const { return m_mouseDownWasInSubframe; }
154     bool panScrollInProgress() const;
155
156     WEBCORE_EXPORT void dispatchFakeMouseMoveEventSoon();
157     void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
158
159     WEBCORE_EXPORT HitTestResult hitTestResultAtPoint(const LayoutPoint&,
160         HitTestRequest::HitTestRequestType hitType = HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent,
161         const LayoutSize& padding = LayoutSize());
162
163     bool mousePressed() const { return m_mousePressed; }
164     Node* mousePressNode() const { return m_mousePressNode.get(); }
165
166     WEBCORE_EXPORT void setCapturingMouseEventsElement(PassRefPtr<Element>); // A caller is responsible for resetting capturing element to 0.
167
168 #if ENABLE(DRAG_SUPPORT)
169     bool updateDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
170     void cancelDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
171     bool performDragAndDrop(const PlatformMouseEvent&, DataTransfer*);
172     void updateDragStateAfterEditDragIfNeeded(Element* rootEditableElement);
173 #endif
174
175     void scheduleHoverStateUpdate();
176 #if ENABLE(CURSOR_SUPPORT)
177     void scheduleCursorUpdate();
178 #endif
179
180     void setResizingFrameSet(HTMLFrameSetElement*);
181
182     void resizeLayerDestroyed();
183
184     IntPoint lastKnownMousePosition() const;
185     IntPoint lastKnownMouseGlobalPosition() const { return m_lastKnownMouseGlobalPosition; }
186     Cursor currentMouseCursor() const { return m_currentMouseCursor; }
187
188     static Frame* subframeForTargetNode(Node*);
189     static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
190
191     WEBCORE_EXPORT bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
192     WEBCORE_EXPORT bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
193     WEBCORE_EXPORT bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
194
195     bool tabsToLinks(KeyboardEvent*) const;
196     bool tabsToAllFormControls(KeyboardEvent*) const;
197
198     WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
199     WEBCORE_EXPORT bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
200
201     void lostMouseCapture();
202
203     WEBCORE_EXPORT bool handleMousePressEvent(const PlatformMouseEvent&);
204     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false);
205     WEBCORE_EXPORT bool handleMouseReleaseEvent(const PlatformMouseEvent&);
206     bool handleMouseForceEvent(const PlatformMouseEvent&);
207     WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
208     void defaultWheelEventHandler(Node*, WheelEvent*);
209     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
210
211     void platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, RefPtr<Element>& eventTarget, RefPtr<ContainerNode>& scrollableContainer, ScrollableArea*&, bool& isOverWidget);
212     void platformRecordWheelEvent(const PlatformWheelEvent&);
213     bool platformCompleteWheelEvent(const PlatformWheelEvent&, ContainerNode* scrollableContainer, ScrollableArea*);
214     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
215     void platformNotifyIfEndGesture(const PlatformWheelEvent&, ScrollableArea*);
216
217 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
218     typedef Vector<RefPtr<Touch>> TouchArray;
219     typedef HashMap<EventTarget*, TouchArray*> EventTargetTouchMap;
220     typedef HashSet<RefPtr<EventTarget>> EventTargetSet;
221 #endif
222
223 #if ENABLE(IOS_TOUCH_EVENTS)
224     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetTouchMap&, float, float);
225     bool dispatchSimulatedTouchEvent(IntPoint location);
226 #endif
227
228 #if ENABLE(IOS_GESTURE_EVENTS)
229     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetSet&, float, float);
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(); // Ditto
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;
474     bool m_capturesDragging;
475     RefPtr<Node> m_mousePressNode;
476
477     bool m_mouseDownMayStartSelect;
478 #if ENABLE(DRAG_SUPPORT)
479     bool m_mouseDownMayStartDrag;
480     bool m_dragMayStartSelectionInstead;
481 #endif
482     bool m_mouseDownWasSingleClickInSelection;
483     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
484     SelectionInitiationState m_selectionInitiationState;
485
486 #if ENABLE(DRAG_SUPPORT)
487     LayoutPoint m_dragStartPos;
488 #endif
489
490     bool m_panScrollButtonPressed;
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;
499
500     std::unique_ptr<AutoscrollController> m_autoscrollController;
501     bool m_mouseDownMayStartAutoscroll;
502     bool m_mouseDownWasInSubframe;
503
504 #if !ENABLE(IOS_TOUCH_EVENTS)
505     Timer m_fakeMouseMoveEventTimer;
506 #endif
507
508     bool m_svgPan;
509
510     RenderLayer* m_resizeLayer;
511
512     RefPtr<Element> m_capturingMouseEventsElement;
513     bool m_eventHandlerWillResetCapturingMouseEventsElement;
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;
522     RefPtr<Node> m_clickNode;
523
524 #if ENABLE(IOS_GESTURE_EVENTS)
525     float m_gestureInitialDiameter;
526     float m_gestureLastDiameter;
527     float m_gestureInitialRotation;
528     float m_gestureLastRotation;
529 #endif
530
531 #if ENABLE(IOS_TOUCH_EVENTS)
532     unsigned m_firstTouchID;
533
534     TouchArray m_touches;
535     EventTargetSet m_gestureTargets;
536     RefPtr<Frame> m_touchEventTargetSubframe;
537 #endif
538
539 #if ENABLE(DRAG_SUPPORT)
540     RefPtr<Element> m_dragTarget;
541     bool m_shouldOnlyFireDragOverEvent;
542 #endif
543     
544     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
545
546     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
547     
548     bool m_mousePositionIsUnknown;
549     IntPoint m_lastKnownMousePosition;
550     IntPoint m_lastKnownMouseGlobalPosition;
551     IntPoint m_mouseDownPos; // In our view's coords.
552     double m_mouseDownTimestamp;
553     PlatformMouseEvent m_mouseDown;
554
555 #if PLATFORM(COCOA)
556     NSView *m_mouseDownView;
557     bool m_sendingEventToSubview;
558     bool m_startedGestureAtScrollLimit;
559 #if !PLATFORM(IOS)
560     int m_activationEventNumber;
561 #endif
562 #endif
563 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
564     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
565     TouchTargetMap m_originatingTouchPointTargets;
566     RefPtr<Document> m_originatingTouchPointDocument;
567     unsigned m_originatingTouchPointTargetKey;
568     bool m_touchPressed;
569 #endif
570
571     double m_maxMouseMovedDuration;
572     PlatformEvent::Type m_baseEventType;
573     bool m_didStartDrag;
574     bool m_didLongPressInvokeContextMenu;
575     bool m_isHandlingWheelEvent;
576
577 #if ENABLE(CURSOR_VISIBILITY)
578     Timer m_autoHideCursorTimer;
579 #endif
580
581     ImmediateActionStage m_immediateActionStage;
582 };
583
584 } // namespace WebCore
585
586 #endif // EventHandler_h