8ed5d9671b201398097f29dddc27ce62b55e867d
[WebKit-https.git] / Source / WebCore / page / EventHandler.h
1 /*
2  * Copyright (C) 2006, 2007, 2009, 2010, 2011, 2013 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 COMPUTER, 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 COMPUTER, 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 <wtf/Deque.h>
41 #include <wtf/Forward.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/RefPtr.h>
44
45 #if PLATFORM(IOS)
46 #ifdef __OBJC__
47 @class WebEvent;
48 @class WAKView;
49 #include "WAKAppKitStubs.h"
50 #else
51 class WebEvent;
52 #endif
53 #endif // PLATFORM(IOS)
54
55 #if PLATFORM(MAC) && !defined(__OBJC__)
56 class NSView;
57 #endif
58
59 #if ENABLE(TOUCH_EVENTS)
60 #include <wtf/HashMap.h>
61 #endif
62
63 #if ENABLE(IOS_TOUCH_EVENTS)
64 #include <wtf/HashSet.h>
65 #include <wtf/Vector.h>
66 #endif
67
68 namespace WebCore {
69
70 class AutoscrollController;
71 class Clipboard;
72 class Document;
73 class Element;
74 class Event;
75 class EventTarget;
76 class FloatPoint;
77 class FloatQuad;
78 class Frame;
79 class HTMLFrameSetElement;
80 class HitTestRequest;
81 class HitTestResult;
82 class KeyboardEvent;
83 class MouseEventWithHitTestResults;
84 class Node;
85 class OptionalCursor;
86 class PlatformKeyboardEvent;
87 class PlatformTouchEvent;
88 class PlatformWheelEvent;
89 class RenderElement;
90 class RenderLayer;
91 class RenderObject;
92 class RenderWidget;
93 class SVGElementInstance;
94 class Scrollbar;
95 class TextEvent;
96 class Touch;
97 class TouchEvent;
98 class VisibleSelection;
99 class WheelEvent;
100 class Widget;
101
102 struct DragState;
103
104 #if ENABLE(DRAG_SUPPORT)
105 extern const int LinkDragHysteresis;
106 extern const int ImageDragHysteresis;
107 extern const int TextDragHysteresis;
108 extern const int GeneralDragHysteresis;
109 #endif // ENABLE(DRAG_SUPPORT)
110
111 #if ENABLE(IOS_GESTURE_EVENTS)
112 extern const float GestureUnknown;
113 #endif
114
115 enum AppendTrailingWhitespace { ShouldAppendTrailingWhitespace, DontAppendTrailingWhitespace };
116 enum CheckDragHysteresis { ShouldCheckDragHysteresis, DontCheckDragHysteresis };
117
118 class EventHandler {
119     WTF_MAKE_NONCOPYABLE(EventHandler);
120 public:
121     explicit EventHandler(Frame&);
122     ~EventHandler();
123
124     void clear();
125     void nodeWillBeRemoved(Node*);
126
127 #if ENABLE(DRAG_SUPPORT)
128     void updateSelectionForMouseDrag();
129 #endif
130
131     Node* mousePressNode() const;
132     void setMousePressNode(PassRefPtr<Node>);
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     RenderElement* autoscrollRenderer() const;
142     void updateAutoscrollRenderer();
143     bool autoscrollInProgress() const;
144     bool mouseDownWasInSubframe() const { return m_mouseDownWasInSubframe; }
145     bool panScrollInProgress() const;
146
147     void dispatchFakeMouseMoveEventSoon();
148     void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
149
150     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     void setMousePressed(bool pressed) { m_mousePressed = pressed; }
156
157     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&, Clipboard*);
161     void cancelDragAndDrop(const PlatformMouseEvent&, Clipboard*);
162     bool performDragAndDrop(const PlatformMouseEvent&, Clipboard*);
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     bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
182     bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = 0);
183     bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = 0);
184
185     bool tabsToLinks(KeyboardEvent*) const;
186     bool tabsToAllFormControls(KeyboardEvent*) const;
187
188     bool mouseMoved(const PlatformMouseEvent&);
189     bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
190
191     void lostMouseCapture();
192
193     bool handleMousePressEvent(const PlatformMouseEvent&);
194     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = 0, bool onlyUpdateScrollbars = false);
195     bool handleMouseReleaseEvent(const PlatformMouseEvent&);
196     bool handleWheelEvent(const PlatformWheelEvent&);
197     void defaultWheelEventHandler(Node*, WheelEvent*);
198     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
199
200 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
201     typedef Vector<RefPtr<Touch>> TouchArray;
202     typedef HashMap<EventTarget*, TouchArray*> EventTargetTouchMap;
203     typedef HashSet<RefPtr<EventTarget>> EventTargetSet;
204 #endif
205
206 #if ENABLE(IOS_TOUCH_EVENTS)
207     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetTouchMap&, float, float);
208 #endif
209
210 #if ENABLE(IOS_GESTURE_EVENTS)
211     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomicString&, const EventTargetSet&, float, float);
212 #endif
213
214 #if PLATFORM(IOS)
215     void defaultTouchEventHandler(Node*, TouchEvent*);
216 #endif
217
218 #if ENABLE(TOUCH_ADJUSTMENT)
219     bool bestClickableNodeForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntPoint& targetPoint, Node*& targetNode);
220     bool bestContextMenuNodeForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntPoint& targetPoint, Node*& targetNode);
221     bool bestZoomableAreaForTouchPoint(const IntPoint& touchCenter, const IntSize& touchRadius, IntRect& targetArea, Node*& targetNode);
222 #endif
223
224 #if ENABLE(CONTEXT_MENUS)
225     bool sendContextMenuEvent(const PlatformMouseEvent&);
226     bool sendContextMenuEventForKey();
227 #endif
228
229     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
230
231     bool needsKeyboardEventDisambiguationQuirks() const;
232
233     static unsigned accessKeyModifiers();
234     bool handleAccessKey(const PlatformKeyboardEvent&);
235     bool keyEvent(const PlatformKeyboardEvent&);
236     void defaultKeyboardEventHandler(KeyboardEvent*);
237
238     void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent*);
239
240     bool handleTextInputEvent(const String& text, Event* underlyingEvent = 0, TextEventInputType = TextEventInputKeyboard);
241     void defaultTextInputEventHandler(TextEvent*);
242
243 #if ENABLE(DRAG_SUPPORT)
244     bool eventMayStartDrag(const PlatformMouseEvent&) const;
245     
246     void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation);
247 #endif
248
249     void focusDocumentView();
250
251     void capsLockStateMayHaveChanged(); // Only called by FrameSelection
252     
253     void sendScrollEvent(); // Ditto
254
255 #if PLATFORM(MAC) && defined(__OBJC__)
256 #if !PLATFORM(IOS)
257     void mouseDown(NSEvent *);
258     void mouseDragged(NSEvent *);
259     void mouseUp(NSEvent *);
260     void mouseMoved(NSEvent *);
261     bool keyEvent(NSEvent *);
262     bool wheelEvent(NSEvent *);
263 #else
264     void mouseDown(WebEvent *);
265     void mouseUp(WebEvent *);
266     void mouseMoved(WebEvent *);
267     bool keyEvent(WebEvent *);
268     bool wheelEvent(WebEvent *);
269 #endif
270
271 #if ENABLE(IOS_TOUCH_EVENTS)
272     void touchEvent(WebEvent *);
273 #endif
274
275 #if !PLATFORM(IOS)
276     void passMouseMovedEventToScrollbars(NSEvent *);
277
278     void sendFakeEventsAfterWidgetTracking(NSEvent *initiatingEvent);
279 #endif
280
281 #if !PLATFORM(IOS)
282     void setActivationEventNumber(int num) { m_activationEventNumber = num; }
283
284     static NSEvent *currentNSEvent();
285 #else
286     static WebEvent *currentEvent();
287 #endif // !PLATFORM(IOS)
288 #endif // PLATFORM(MAC) && defined(__OBJC__)
289
290 #if PLATFORM(IOS)
291     void invalidateClick();
292 #endif
293
294 #if ENABLE(TOUCH_EVENTS)
295     bool handleTouchEvent(const PlatformTouchEvent&);
296 #endif
297
298     bool useHandCursor(Node*, bool isOverLink, bool shiftKey);
299     void updateCursor();
300
301     bool isHandlingWheelEvent() const { return m_isHandlingWheelEvent; }
302
303 private:
304 #if ENABLE(DRAG_SUPPORT)
305     static DragState& dragState();
306     static const double TextDragDelay;
307     
308     PassRefPtr<Clipboard> createDraggingClipboard() const;
309 #endif // ENABLE(DRAG_SUPPORT)
310
311     bool eventActivatedView(const PlatformMouseEvent&) const;
312     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
313     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
314     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
315     void selectClosestWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
316
317     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
318
319     bool handleMousePressEvent(const MouseEventWithHitTestResults&);
320     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
321     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
322     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
323 #if ENABLE(DRAG_SUPPORT)
324     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&);
325 #endif
326     bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
327
328     OptionalCursor selectCursor(const HitTestResult&, bool shiftKey);
329
330     void hoverTimerFired(Timer<EventHandler>*);
331 #if ENABLE(CURSOR_SUPPORT)
332     void cursorUpdateTimerFired(Timer<EventHandler>*);
333 #endif
334
335     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = 0);
336     
337     bool shouldTurnVerticalTicksIntoHorizontal(const HitTestResult&, const PlatformWheelEvent&) const;
338     void recordWheelEventDelta(const PlatformWheelEvent&);
339     enum DominantScrollGestureDirection {
340         DominantScrollDirectionNone,
341         DominantScrollDirectionVertical,
342         DominantScrollDirectionHorizontal
343     };
344     DominantScrollGestureDirection dominantScrollGestureDirection() const;
345     
346     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
347
348     static bool isKeyboardOptionTab(KeyboardEvent*);
349     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent*);
350
351     void fakeMouseMoveEventTimerFired(Timer<EventHandler>*);
352     void cancelFakeMouseMoveEvent();
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&, Clipboard*);
374
375     void freeClipboard();
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 passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
390     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = 0);
391     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
392
393     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = 0);
394
395     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
396
397     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
398     bool passWidgetMouseDownEventToWidget(RenderWidget*);
399
400     bool passMouseDownEventToWidget(Widget*);
401     bool passWheelEventToWidget(const PlatformWheelEvent&, Widget*);
402
403     void defaultSpaceEventHandler(KeyboardEvent*);
404     void defaultBackspaceEventHandler(KeyboardEvent*);
405     void defaultTabEventHandler(KeyboardEvent*);
406     void defaultArrowEventHandler(FocusDirection, KeyboardEvent*);
407
408 #if ENABLE(DRAG_SUPPORT)
409     DragSourceAction updateDragSourceActionsAllowed() const;
410 #endif
411
412     // The following are called at the beginning of handleMouseUp and handleDrag.  
413     // If they return true it indicates that they have consumed the event.
414     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
415 #if ENABLE(DRAG_SUPPORT)
416     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
417 #endif
418
419 #if ENABLE(DRAG_SUPPORT)
420     void updateSelectionForMouseDrag(const HitTestResult&);
421 #endif
422
423     void updateLastScrollbarUnderMouse(Scrollbar*, bool);
424     
425     void setFrameWasScrolledByUser();
426
427     bool capturesDragging() const { return m_capturesDragging; }
428
429 #if PLATFORM(MAC) && defined(__OBJC__)
430     NSView *mouseDownViewIfStillGood();
431
432     PlatformMouseEvent currentPlatformMouseEvent() const;
433 #endif
434
435 #if ENABLE(FULLSCREEN_API)
436     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
437 #endif
438
439     void setLastKnownMousePosition(const PlatformMouseEvent&);
440
441 #if ENABLE(CURSOR_VISIBILITY)
442     void startAutoHideCursorTimer();
443     void cancelAutoHideCursorTimer();
444     void autoHideCursorTimerFired(Timer<EventHandler>*);
445 #endif
446
447     Frame& m_frame;
448
449     bool m_mousePressed;
450     bool m_capturesDragging;
451     RefPtr<Node> m_mousePressNode;
452
453     bool m_mouseDownMayStartSelect;
454 #if ENABLE(DRAG_SUPPORT)
455     bool m_mouseDownMayStartDrag;
456     bool m_dragMayStartSelectionInstead;
457 #endif
458     bool m_mouseDownWasSingleClickInSelection;
459     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
460     SelectionInitiationState m_selectionInitiationState;
461
462 #if ENABLE(DRAG_SUPPORT)
463     LayoutPoint m_dragStartPos;
464 #endif
465
466     bool m_panScrollButtonPressed;
467
468     Timer<EventHandler> m_hoverTimer;
469 #if ENABLE(CURSOR_SUPPORT)
470     Timer<EventHandler> m_cursorUpdateTimer;
471 #endif
472
473     OwnPtr<AutoscrollController> m_autoscrollController;
474     bool m_mouseDownMayStartAutoscroll;
475     bool m_mouseDownWasInSubframe;
476
477     Timer<EventHandler> m_fakeMouseMoveEventTimer;
478
479 #if ENABLE(SVG)
480     bool m_svgPan;
481     RefPtr<SVGElementInstance> m_instanceUnderMouse;
482     RefPtr<SVGElementInstance> m_lastInstanceUnderMouse;
483 #endif
484
485     RenderLayer* m_resizeLayer;
486
487     RefPtr<Element> m_capturingMouseEventsElement;
488     bool m_eventHandlerWillResetCapturingMouseEventsElement;
489     
490     RefPtr<Element> m_elementUnderMouse;
491     RefPtr<Element> m_lastElementUnderMouse;
492     RefPtr<Frame> m_lastMouseMoveEventSubframe;
493     RefPtr<Scrollbar> m_lastScrollbarUnderMouse;
494     Cursor m_currentMouseCursor;
495
496     int m_clickCount;
497     RefPtr<Node> m_clickNode;
498
499 #if ENABLE(IOS_GESTURE_EVENTS)
500     float m_gestureInitialDiameter;
501     float m_gestureLastDiameter;
502     float m_gestureInitialRotation;
503     float m_gestureLastRotation;
504 #endif
505
506 #if ENABLE(IOS_TOUCH_EVENTS)
507     unsigned m_firstTouchID;
508
509     TouchArray m_touches;
510     EventTargetSet m_gestureTargets;
511     RefPtr<Frame> m_touchEventTargetSubframe;
512 #endif
513
514 #if ENABLE(DRAG_SUPPORT)
515     RefPtr<Element> m_dragTarget;
516     bool m_shouldOnlyFireDragOverEvent;
517 #endif
518     
519     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
520
521     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
522     
523     bool m_mousePositionIsUnknown;
524     IntPoint m_lastKnownMousePosition;
525     IntPoint m_lastKnownMouseGlobalPosition;
526     IntPoint m_mouseDownPos; // In our view's coords.
527     double m_mouseDownTimestamp;
528     PlatformMouseEvent m_mouseDown;
529
530     Deque<FloatSize> m_recentWheelEventDeltas;
531     RefPtr<Element> m_latchedWheelEventElement;
532     bool m_inTrackingScrollGesturePhase;
533     bool m_widgetIsLatched;
534
535     RefPtr<Element> m_previousWheelScrolledElement;
536
537 #if PLATFORM(MAC) || PLATFORM(IOS)
538     NSView *m_mouseDownView;
539     bool m_sendingEventToSubview;
540 #if !PLATFORM(IOS)
541     int m_activationEventNumber;
542 #endif
543 #endif
544 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
545     typedef HashMap<int, RefPtr<EventTarget>> TouchTargetMap;
546     TouchTargetMap m_originatingTouchPointTargets;
547     RefPtr<Document> m_originatingTouchPointDocument;
548     unsigned m_originatingTouchPointTargetKey;
549     bool m_touchPressed;
550 #endif
551
552     double m_maxMouseMovedDuration;
553     PlatformEvent::Type m_baseEventType;
554     bool m_didStartDrag;
555     bool m_didLongPressInvokeContextMenu;
556     bool m_isHandlingWheelEvent;
557
558 #if ENABLE(CURSOR_VISIBILITY)
559     Timer<EventHandler> m_autoHideCursorTimer;
560 #endif
561 };
562
563 } // namespace WebCore
564
565 #endif // EventHandler_h