clang-tidy: Fix unnecessary copy/ref churn of for loop variables in WebCore
[WebKit-https.git] / Source / WebCore / page / EventHandler.h
1 /*
2  * Copyright (C) 2006-2018 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 "RenderObject.h"
35 #include "ScrollTypes.h"
36 #include "TextEventInputType.h"
37 #include "TextGranularity.h"
38 #include "Timer.h"
39 #include <memory>
40 #include <wtf/Forward.h>
41 #include <wtf/HashMap.h>
42 #include <wtf/HashSet.h>
43 #include <wtf/RefPtr.h>
44 #include <wtf/WeakPtr.h>
45
46 #if PLATFORM(COCOA)
47 OBJC_CLASS NSView;
48 #endif
49
50 #if PLATFORM(IOS_FAMILY)
51 OBJC_CLASS WebEvent;
52 #endif
53
54 #if PLATFORM(MAC)
55 OBJC_CLASS NSEvent;
56 #endif
57
58 #if PLATFORM(IOS_FAMILY) && defined(__OBJC__)
59 #include "WAKAppKitStubs.h"
60 #endif
61
62 namespace WebCore {
63
64 class AutoscrollController;
65 class ContainerNode;
66 class DataTransfer;
67 class Document;
68 class Element;
69 class Event;
70 class EventTarget;
71 class FloatQuad;
72 class Frame;
73 class FrameView;
74 class HTMLFrameSetElement;
75 class HitTestResult;
76 class KeyboardEvent;
77 class MouseEventWithHitTestResults;
78 class Node;
79 class Pasteboard;
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 ColorDragHystersis;
104 extern const int GeneralDragHysteresis;
105 #endif
106
107 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
108 extern const float GestureUnknown;
109 extern const unsigned InvalidTouchIdentifier;
110 #endif
111
112 enum AppendTrailingWhitespace { ShouldAppendTrailingWhitespace, DontAppendTrailingWhitespace };
113 enum CheckDragHysteresis { ShouldCheckDragHysteresis, DontCheckDragHysteresis };
114
115 enum class ImmediateActionStage {
116     None,
117     PerformedHitTest,
118     ActionUpdated,
119     ActionCancelledWithoutUpdate,
120     ActionCancelledAfterUpdate,
121     ActionCompleted
122 };
123
124 class EventHandler {
125     WTF_MAKE_FAST_ALLOCATED;
126 public:
127     explicit EventHandler(Frame&);
128     ~EventHandler();
129
130     void clear();
131     void nodeWillBeRemoved(Node&);
132
133     WEBCORE_EXPORT VisiblePosition selectionExtentRespectingEditingBoundary(const VisibleSelection&, const LayoutPoint&, Node*);
134
135 #if ENABLE(DRAG_SUPPORT)
136     void updateSelectionForMouseDrag();
137 #endif
138
139 #if ENABLE(PAN_SCROLLING)
140     void didPanScrollStart();
141     void didPanScrollStop();
142     void startPanScrolling(RenderElement&);
143 #endif
144
145     void stopAutoscrollTimer(bool rendererIsBeingDestroyed = false);
146     RenderBox* autoscrollRenderer() const;
147     void updateAutoscrollRenderer();
148     bool autoscrollInProgress() const;
149     bool mouseDownWasInSubframe() const { return m_mouseDownWasInSubframe; }
150     bool panScrollInProgress() const;
151
152     WEBCORE_EXPORT void dispatchFakeMouseMoveEventSoon();
153     void dispatchFakeMouseMoveEventSoonInQuad(const FloatQuad&);
154
155     WEBCORE_EXPORT HitTestResult hitTestResultAtPoint(const LayoutPoint&, HitTestRequest::HitTestRequestType, const LayoutSize& padding = LayoutSize()) const;
156
157     bool mousePressed() const { return m_mousePressed; }
158     Node* mousePressNode() const { return m_mousePressNode.get(); }
159
160     WEBCORE_EXPORT void setCapturingMouseEventsElement(Element*);
161 #if ENABLE(POINTER_EVENTS)
162     void pointerCaptureElementDidChange(Element*);
163 #endif
164
165 #if ENABLE(DRAG_SUPPORT)
166     struct DragTargetResponse {
167         bool accept { false };
168         Optional<DragOperation> operation;
169     };
170     DragTargetResponse updateDragAndDrop(const PlatformMouseEvent&, const std::function<std::unique_ptr<Pasteboard>()>&, DragOperation sourceOperation, bool draggingFiles);
171     void cancelDragAndDrop(const PlatformMouseEvent&, std::unique_ptr<Pasteboard>&&, DragOperation, bool draggingFiles);
172     bool performDragAndDrop(const PlatformMouseEvent&, std::unique_ptr<Pasteboard>&&, DragOperation, bool draggingFiles);
173     void updateDragStateAfterEditDragIfNeeded(Element& rootEditableElement);
174     RefPtr<Element> draggedElement() const;
175 #endif
176
177     void scheduleHoverStateUpdate();
178 #if ENABLE(CURSOR_SUPPORT)
179     void scheduleCursorUpdate();
180 #endif
181
182     void setResizingFrameSet(HTMLFrameSetElement*);
183
184     void resizeLayerDestroyed();
185
186     IntPoint lastKnownMousePosition() const;
187     IntPoint lastKnownMouseGlobalPosition() const { return m_lastKnownMouseGlobalPosition; }
188     Cursor currentMouseCursor() const { return m_currentMouseCursor; }
189
190     IntPoint targetPositionInWindowForSelectionAutoscroll() const;
191     bool shouldUpdateAutoscroll();
192
193     static Frame* subframeForTargetNode(Node*);
194     static Frame* subframeForHitTestResult(const MouseEventWithHitTestResults&);
195
196     WEBCORE_EXPORT bool scrollOverflow(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
197     WEBCORE_EXPORT bool scrollRecursively(ScrollDirection, ScrollGranularity, Node* startingNode = nullptr);
198     WEBCORE_EXPORT bool logicalScrollRecursively(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
199
200     bool tabsToLinks(KeyboardEvent*) const;
201     bool tabsToAllFormControls(KeyboardEvent*) const;
202
203     WEBCORE_EXPORT bool mouseMoved(const PlatformMouseEvent&);
204     WEBCORE_EXPORT bool passMouseMovedEventToScrollbars(const PlatformMouseEvent&);
205
206     void lostMouseCapture();
207
208     WEBCORE_EXPORT bool handleMousePressEvent(const PlatformMouseEvent&);
209     bool handleMouseMoveEvent(const PlatformMouseEvent&, HitTestResult* hoveredNode = nullptr, bool onlyUpdateScrollbars = false);
210     WEBCORE_EXPORT bool handleMouseReleaseEvent(const PlatformMouseEvent&);
211     bool handleMouseForceEvent(const PlatformMouseEvent&);
212     WEBCORE_EXPORT bool handleWheelEvent(const PlatformWheelEvent&);
213     void defaultWheelEventHandler(Node*, WheelEvent&);
214     bool handlePasteGlobalSelection(const PlatformMouseEvent&);
215
216     void platformPrepareForWheelEvents(const PlatformWheelEvent&, const HitTestResult&, RefPtr<Element>& eventTarget, RefPtr<ContainerNode>& scrollableContainer, WeakPtr<ScrollableArea>&, bool& isOverWidget);
217     void platformRecordWheelEvent(const PlatformWheelEvent&);
218     bool platformCompleteWheelEvent(const PlatformWheelEvent&, ContainerNode* scrollableContainer, const WeakPtr<ScrollableArea>&);
219     bool platformCompletePlatformWidgetWheelEvent(const PlatformWheelEvent&, const Widget&, ContainerNode* scrollableContainer);
220     void platformNotifyIfEndGesture(const PlatformWheelEvent&, const WeakPtr<ScrollableArea>&);
221
222 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
223     using TouchArray = Vector<RefPtr<Touch>>;
224     using EventTargetTouchMap = HashMap<EventTarget*, TouchArray*>;
225 #endif
226
227 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
228     using EventTargetSet = HashSet<RefPtr<EventTarget>>;
229 #endif
230
231 #if ENABLE(IOS_TOUCH_EVENTS)
232     bool dispatchTouchEvent(const PlatformTouchEvent&, const AtomString&, const EventTargetTouchMap&, float, float);
233     bool dispatchSimulatedTouchEvent(IntPoint location);
234     Frame* touchEventTargetSubframe() const { return m_touchEventTargetSubframe.get(); }
235     const TouchArray& touches() const { return m_touches; }
236 #endif
237
238 #if ENABLE(IOS_GESTURE_EVENTS)
239     bool dispatchGestureEvent(const PlatformTouchEvent&, const AtomString&, const EventTargetSet&, float, float);
240 #elif ENABLE(MAC_GESTURE_EVENTS)
241     bool dispatchGestureEvent(const PlatformGestureEvent&, const AtomString&, const EventTargetSet&, float, float);
242     WEBCORE_EXPORT bool handleGestureEvent(const PlatformGestureEvent&);
243 #endif
244
245 #if PLATFORM(IOS_FAMILY)
246     void defaultTouchEventHandler(Node&, TouchEvent&);
247     WEBCORE_EXPORT void dispatchSyntheticMouseOut(const PlatformMouseEvent&);
248     WEBCORE_EXPORT void dispatchSyntheticMouseMove(const PlatformMouseEvent&);
249 #endif
250
251 #if ENABLE(CONTEXT_MENUS)
252     WEBCORE_EXPORT bool sendContextMenuEvent(const PlatformMouseEvent&);
253     WEBCORE_EXPORT bool sendContextMenuEventForKey();
254 #endif
255
256     void setMouseDownMayStartAutoscroll() { m_mouseDownMayStartAutoscroll = true; }
257
258     bool needsKeyboardEventDisambiguationQuirks() const;
259
260     WEBCORE_EXPORT static OptionSet<PlatformEvent::Modifier> accessKeyModifiers();
261     WEBCORE_EXPORT bool handleAccessKey(const PlatformKeyboardEvent&);
262     WEBCORE_EXPORT bool keyEvent(const PlatformKeyboardEvent&);
263     void defaultKeyboardEventHandler(KeyboardEvent&);
264     WEBCORE_EXPORT void capsLockStateMayHaveChanged() const;
265
266     bool accessibilityPreventsEventPropagation(KeyboardEvent&);
267     WEBCORE_EXPORT void handleKeyboardSelectionMovementForAccessibility(KeyboardEvent&);
268
269     bool handleTextInputEvent(const String& text, Event* underlyingEvent = nullptr, TextEventInputType = TextEventInputKeyboard);
270     void defaultTextInputEventHandler(TextEvent&);
271
272 #if ENABLE(DRAG_SUPPORT)
273     WEBCORE_EXPORT bool eventMayStartDrag(const PlatformMouseEvent&) const;
274     
275     WEBCORE_EXPORT void didStartDrag();
276     WEBCORE_EXPORT void dragCancelled();
277     WEBCORE_EXPORT void dragSourceEndedAt(const PlatformMouseEvent&, DragOperation, MayExtendDragSession = MayExtendDragSession::No);
278 #endif
279
280     void focusDocumentView();
281     
282     WEBCORE_EXPORT void sendScrollEvent();
283
284 #if PLATFORM(MAC)
285     WEBCORE_EXPORT void mouseDown(NSEvent *, NSEvent *correspondingPressureEvent);
286     WEBCORE_EXPORT void mouseDragged(NSEvent *, NSEvent *correspondingPressureEvent);
287     WEBCORE_EXPORT void mouseUp(NSEvent *, NSEvent *correspondingPressureEvent);
288     WEBCORE_EXPORT void mouseMoved(NSEvent *, NSEvent *correspondingPressureEvent);
289     WEBCORE_EXPORT void pressureChange(NSEvent *, NSEvent* correspondingPressureEvent);
290     WEBCORE_EXPORT bool keyEvent(NSEvent *);
291     WEBCORE_EXPORT bool wheelEvent(NSEvent *);
292 #endif
293
294 #if PLATFORM(IOS_FAMILY)
295     WEBCORE_EXPORT void mouseDown(WebEvent *);
296     WEBCORE_EXPORT void mouseUp(WebEvent *);
297     WEBCORE_EXPORT void mouseMoved(WebEvent *);
298     WEBCORE_EXPORT bool keyEvent(WebEvent *);
299     WEBCORE_EXPORT bool wheelEvent(WebEvent *);
300 #endif
301
302 #if ENABLE(IOS_TOUCH_EVENTS)
303     WEBCORE_EXPORT void touchEvent(WebEvent *);
304 #endif
305
306 #if PLATFORM(MAC)
307     WEBCORE_EXPORT void passMouseMovedEventToScrollbars(NSEvent *, NSEvent* correspondingPressureEvent);
308
309     WEBCORE_EXPORT void sendFakeEventsAfterWidgetTracking(NSEvent *initiatingEvent);
310
311     void setActivationEventNumber(int num) { m_activationEventNumber = num; }
312
313     WEBCORE_EXPORT static NSEvent *currentNSEvent();
314     static NSEvent *correspondingPressureEvent();
315 #endif
316
317 #if PLATFORM(IOS_FAMILY)
318     static WebEvent *currentEvent();
319
320     void invalidateClick();
321 #endif
322
323 #if ENABLE(TOUCH_EVENTS)
324     WEBCORE_EXPORT bool handleTouchEvent(const PlatformTouchEvent&);
325 #endif
326
327     bool useHandCursor(Node*, bool isOverLink, bool shiftKey);
328     void updateCursor();
329
330     bool isHandlingWheelEvent() const { return m_isHandlingWheelEvent; }
331
332     WEBCORE_EXPORT void setImmediateActionStage(ImmediateActionStage stage);
333     ImmediateActionStage immediateActionStage() const { return m_immediateActionStage; }
334
335     static Widget* widgetForEventTarget(Element* eventTarget);
336
337 #if PLATFORM(IOS_FAMILY) && ENABLE(DRAG_SUPPORT)
338     WEBCORE_EXPORT bool tryToBeginDragAtPoint(const IntPoint& clientPosition, const IntPoint& globalPosition);
339 #endif
340     
341 #if PLATFORM(IOS_FAMILY)
342     WEBCORE_EXPORT void startSelectionAutoscroll(RenderObject* renderer, const FloatPoint& positionInWindow);
343     WEBCORE_EXPORT void cancelSelectionAutoscroll();
344     IntPoint m_targetAutoscrollPositionInWindow;
345     bool m_isAutoscrolling { false };
346 #endif
347
348 private:
349 #if ENABLE(DRAG_SUPPORT)
350     static DragState& dragState();
351     static const Seconds TextDragDelay;
352 #endif
353
354     bool eventActivatedView(const PlatformMouseEvent&) const;
355     bool updateSelectionForMouseDownDispatchingSelectStart(Node*, const VisibleSelection&, TextGranularity);
356     void selectClosestWordFromHitTestResult(const HitTestResult&, AppendTrailingWhitespace);
357     VisibleSelection selectClosestWordFromHitTestResultBasedOnLookup(const HitTestResult&);
358     void selectClosestWordFromMouseEvent(const MouseEventWithHitTestResults&);
359     void selectClosestContextualWordFromMouseEvent(const MouseEventWithHitTestResults&);
360     void selectClosestContextualWordOrLinkFromMouseEvent(const MouseEventWithHitTestResults&);
361
362     bool handleMouseDoubleClickEvent(const PlatformMouseEvent&);
363
364     WEBCORE_EXPORT bool handleMousePressEvent(const MouseEventWithHitTestResults&);
365     bool handleMousePressEventSingleClick(const MouseEventWithHitTestResults&);
366     bool handleMousePressEventDoubleClick(const MouseEventWithHitTestResults&);
367     bool handleMousePressEventTripleClick(const MouseEventWithHitTestResults&);
368
369 #if ENABLE(DRAG_SUPPORT)
370     bool handleMouseDraggedEvent(const MouseEventWithHitTestResults&, CheckDragHysteresis = ShouldCheckDragHysteresis);
371     bool shouldAllowMouseDownToStartDrag() const;
372 #endif
373
374     WEBCORE_EXPORT bool handleMouseReleaseEvent(const MouseEventWithHitTestResults&);
375
376     bool internalKeyEvent(const PlatformKeyboardEvent&);
377
378     Optional<Cursor> selectCursor(const HitTestResult&, bool shiftKey);
379     void updateCursor(FrameView&, const HitTestResult&, bool shiftKey);
380
381     void hoverTimerFired();
382
383 #if ENABLE(CURSOR_SUPPORT)
384     void cursorUpdateTimerFired();
385 #endif
386
387     bool logicalScrollOverflow(ScrollLogicalDirection, ScrollGranularity, Node* startingNode = nullptr);
388     
389     bool shouldSwapScrollDirection(const HitTestResult&, const PlatformWheelEvent&) const;
390     
391     bool mouseDownMayStartSelect() const { return m_mouseDownMayStartSelect; }
392
393     static bool isKeyboardOptionTab(KeyboardEvent&);
394     static bool eventInvertsTabsToLinksClientCallResult(KeyboardEvent&);
395
396 #if !ENABLE(IOS_TOUCH_EVENTS)
397     void fakeMouseMoveEventTimerFired();
398     void cancelFakeMouseMoveEvent();
399 #endif
400
401     bool isInsideScrollbar(const IntPoint&) const;
402
403 #if ENABLE(TOUCH_EVENTS)
404     bool dispatchSyntheticTouchEventIfEnabled(const PlatformMouseEvent&);
405 #endif
406
407 #if !PLATFORM(IOS_FAMILY)
408     void invalidateClick();
409 #endif
410
411     Node* nodeUnderMouse() const;
412     
413     enum class FireMouseOverOut { No, Yes };
414     void updateMouseEventTargetNode(Node*, const PlatformMouseEvent&, FireMouseOverOut);
415
416     MouseEventWithHitTestResults prepareMouseEvent(const HitTestRequest&, const PlatformMouseEvent&);
417
418     bool dispatchMouseEvent(const AtomString& eventType, Node* target, bool cancelable, int clickCount, const PlatformMouseEvent&, bool setUnder);
419
420 #if ENABLE(DRAG_SUPPORT)
421     bool dispatchDragEvent(const AtomString& eventType, Element& target, const PlatformMouseEvent&, DataTransfer&);
422     DragTargetResponse dispatchDragEnterOrDragOverEvent(const AtomString& eventType, Element& target, const PlatformMouseEvent&, std::unique_ptr<Pasteboard>&& , DragOperation, bool draggingFiles);
423     void invalidateDataTransfer();
424
425     bool handleDrag(const MouseEventWithHitTestResults&, CheckDragHysteresis);
426 #endif
427
428     bool handleMouseUp(const MouseEventWithHitTestResults&);
429
430 #if ENABLE(DRAG_SUPPORT)
431     void clearDragState();
432
433     void dispatchDragSrcEvent(const AtomString& eventType, const PlatformMouseEvent&);
434     bool dispatchDragStartEventOnSourceElement(DataTransfer&);
435
436     bool dragHysteresisExceeded(const FloatPoint&) const;
437     bool dragHysteresisExceeded(const IntPoint&) const;
438 #endif
439     
440     bool mouseMovementExceedsThreshold(const FloatPoint&, int pointsThreshold) const;
441
442     bool passMousePressEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
443     bool passMouseMoveEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
444     bool passMouseReleaseEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe);
445
446     bool passSubframeEventToSubframe(MouseEventWithHitTestResults&, Frame* subframe, HitTestResult* hoveredNode = nullptr);
447
448     bool passMousePressEventToScrollbar(MouseEventWithHitTestResults&, Scrollbar*);
449
450     bool passWidgetMouseDownEventToWidget(const MouseEventWithHitTestResults&);
451     bool passWidgetMouseDownEventToWidget(RenderWidget*);
452
453     bool passMouseDownEventToWidget(Widget*);
454     bool widgetDidHandleWheelEvent(const PlatformWheelEvent&, Widget&);
455     bool completeWidgetWheelEvent(const PlatformWheelEvent&, const WeakPtr<Widget>&, const WeakPtr<ScrollableArea>&, ContainerNode*);
456
457     void defaultSpaceEventHandler(KeyboardEvent&);
458     void defaultBackspaceEventHandler(KeyboardEvent&);
459     void defaultTabEventHandler(KeyboardEvent&);
460     void defaultArrowEventHandler(FocusDirection, KeyboardEvent&);
461
462 #if ENABLE(DRAG_SUPPORT)
463     DragSourceAction updateDragSourceActionsAllowed() const;
464     bool supportsSelectionUpdatesOnMouseDrag() const;
465 #endif
466
467     // The following are called at the beginning of handleMouseUp and handleDrag.  
468     // If they return true it indicates that they have consumed the event.
469     bool eventLoopHandleMouseUp(const MouseEventWithHitTestResults&);
470
471 #if ENABLE(DRAG_SUPPORT)
472     bool eventLoopHandleMouseDragged(const MouseEventWithHitTestResults&);
473     void updateSelectionForMouseDrag(const HitTestResult&);
474 #endif
475
476     enum class SetOrClearLastScrollbar { Clear, Set };
477     void updateLastScrollbarUnderMouse(Scrollbar*, SetOrClearLastScrollbar);
478     
479     void setFrameWasScrolledByUser();
480
481     bool capturesDragging() const { return m_capturesDragging; }
482
483 #if PLATFORM(COCOA) && defined(__OBJC__)
484     NSView *mouseDownViewIfStillGood();
485
486     PlatformMouseEvent currentPlatformMouseEvent() const;
487 #endif
488
489 #if ENABLE(FULLSCREEN_API)
490     bool isKeyEventAllowedInFullScreen(const PlatformKeyboardEvent&) const;
491 #endif
492
493     void setLastKnownMousePosition(const PlatformMouseEvent&);
494
495 #if ENABLE(CURSOR_VISIBILITY)
496     void startAutoHideCursorTimer();
497     void cancelAutoHideCursorTimer();
498     void autoHideCursorTimerFired();
499 #endif
500
501     void clearOrScheduleClearingLatchedStateIfNeeded(const PlatformWheelEvent&);
502     void clearLatchedState();
503
504     bool shouldSendMouseEventsToInactiveWindows() const;
505
506     Frame& m_frame;
507
508     bool m_mousePressed { false };
509     bool m_capturesDragging { false };
510     RefPtr<Node> m_mousePressNode;
511
512     bool m_mouseDownMayStartSelect { false };
513
514 #if ENABLE(DRAG_SUPPORT)
515     bool m_mouseDownMayStartDrag { false };
516     bool m_dragMayStartSelectionInstead { false };
517 #endif
518
519     bool m_mouseDownWasSingleClickInSelection { false };
520     enum SelectionInitiationState { HaveNotStartedSelection, PlacedCaret, ExtendedSelection };
521     SelectionInitiationState m_selectionInitiationState { HaveNotStartedSelection };
522
523 #if ENABLE(DRAG_SUPPORT)
524     LayoutPoint m_dragStartPosition;
525 #endif
526
527     Timer m_hoverTimer;
528
529 #if ENABLE(CURSOR_SUPPORT)
530     Timer m_cursorUpdateTimer;
531 #endif
532
533 #if PLATFORM(MAC)
534     Timer m_pendingMomentumWheelEventsTimer;
535 #endif
536
537     std::unique_ptr<AutoscrollController> m_autoscrollController;
538     bool m_mouseDownMayStartAutoscroll { false };
539     bool m_mouseDownWasInSubframe { false };
540
541 #if !ENABLE(IOS_TOUCH_EVENTS)
542     Timer m_fakeMouseMoveEventTimer;
543 #endif
544
545     bool m_svgPan { false };
546
547     RenderLayer* m_resizeLayer { nullptr };
548
549     RefPtr<Element> m_capturingMouseEventsElement;
550     bool m_eventHandlerWillResetCapturingMouseEventsElement { false };
551     
552     RefPtr<Element> m_elementUnderMouse;
553     RefPtr<Element> m_lastElementUnderMouse;
554     RefPtr<Frame> m_lastMouseMoveEventSubframe;
555     WeakPtr<Scrollbar> m_lastScrollbarUnderMouse;
556     Cursor m_currentMouseCursor;
557
558     int m_clickCount { 0 };
559     RefPtr<Node> m_clickNode;
560
561 #if ENABLE(IOS_GESTURE_EVENTS)
562     float m_gestureInitialDiameter { GestureUnknown };
563     float m_gestureInitialRotation { GestureUnknown };
564 #endif
565
566 #if ENABLE(IOS_GESTURE_EVENTS) || ENABLE(MAC_GESTURE_EVENTS)
567     float m_gestureLastDiameter { GestureUnknown };
568     float m_gestureLastRotation { GestureUnknown };
569     EventTargetSet m_gestureTargets;
570 #endif
571
572 #if ENABLE(MAC_GESTURE_EVENTS)
573     bool m_hasActiveGesture { false };
574 #endif
575
576 #if ENABLE(IOS_TOUCH_EVENTS)
577     unsigned m_firstTouchID { InvalidTouchIdentifier };
578
579     TouchArray m_touches;
580     RefPtr<Frame> m_touchEventTargetSubframe;
581 #endif
582
583 #if ENABLE(DRAG_SUPPORT)
584     RefPtr<Element> m_dragTarget;
585     bool m_shouldOnlyFireDragOverEvent { false };
586 #endif
587     
588     RefPtr<HTMLFrameSetElement> m_frameSetBeingResized;
589
590     LayoutSize m_offsetFromResizeCorner; // In the coords of m_resizeLayer.
591     
592     bool m_mousePositionIsUnknown { true };
593     IntPoint m_lastKnownMousePosition;
594     IntPoint m_lastKnownMouseGlobalPosition;
595     IntPoint m_mouseDownPos; // In our view's coords.
596     WallTime m_mouseDownTimestamp;
597     PlatformMouseEvent m_mouseDown;
598 #if ENABLE(POINTER_EVENTS)
599     PlatformMouseEvent m_lastPlatformMouseEvent;
600 #endif
601
602 #if PLATFORM(COCOA)
603     NSView *m_mouseDownView { nullptr };
604     bool m_sendingEventToSubview { false };
605 #endif
606
607 #if PLATFORM(MAC)
608     int m_activationEventNumber { -1 };
609 #endif
610
611 #if ENABLE(TOUCH_EVENTS) && !ENABLE(IOS_TOUCH_EVENTS)
612     using TouchTargetMap = HashMap<int, RefPtr<EventTarget>>;
613     TouchTargetMap m_originatingTouchPointTargets;
614     RefPtr<Document> m_originatingTouchPointDocument;
615     unsigned m_originatingTouchPointTargetKey { 0 };
616     bool m_touchPressed { false };
617 #endif
618
619 #if ENABLE(IOS_TOUCH_EVENTS)
620     unsigned touchIdentifierForMouseEvents { 0 };
621 #endif
622
623 #if ENABLE(POINTER_EVENTS) && ENABLE(IOS_TOUCH_EVENTS)
624     unsigned m_touchIdentifierForPrimaryTouch { 0 };
625 #endif
626
627     double m_maxMouseMovedDuration { 0 };
628     bool m_didStartDrag { false };
629     bool m_isHandlingWheelEvent { false };
630
631 #if PLATFORM(IOS_FAMILY)
632     bool m_shouldAllowMouseDownToStartDrag { false };
633 #endif
634
635 #if ENABLE(CURSOR_VISIBILITY)
636     Timer m_autoHideCursorTimer;
637 #endif
638
639     ImmediateActionStage m_immediateActionStage { ImmediateActionStage::None };
640 };
641
642 } // namespace WebCore