Add USE(LIBWPE) for WebKit events
[WebKit-https.git] / Source / WebKit / Shared / WebEvent.h
1 /*
2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
3  * Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
15  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
18  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
19  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
20  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
21  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
22  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
23  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
24  * THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 #ifndef WebEvent_h
28 #define WebEvent_h
29
30 // FIXME: We should probably move to makeing the WebCore/PlatformFooEvents trivial classes so that
31 // we can use them as the event type.
32
33 #include <WebCore/FloatPoint.h>
34 #include <WebCore/FloatSize.h>
35 #include <WebCore/IntPoint.h>
36 #include <WebCore/IntSize.h>
37 #include <wtf/WallTime.h>
38 #include <wtf/text/WTFString.h>
39
40 namespace IPC {
41 class Decoder;
42 class Encoder;
43 }
44
45 #if USE(APPKIT)
46 namespace WebCore {
47 struct KeypressCommand;
48 }
49 #endif
50
51 namespace WebKit {
52
53 class WebEvent {
54 public:
55     enum Type {
56         NoType = -1,
57         
58         // WebMouseEvent
59         MouseDown,
60         MouseUp,
61         MouseMove,
62         MouseForceChanged,
63         MouseForceDown,
64         MouseForceUp,
65
66         // WebWheelEvent
67         Wheel,
68
69         // WebKeyboardEvent
70         KeyDown,
71         KeyUp,
72         RawKeyDown,
73         Char,
74
75 #if ENABLE(TOUCH_EVENTS)
76         // WebTouchEvent
77         TouchStart,
78         TouchMove,
79         TouchEnd,
80         TouchCancel,
81 #endif
82
83 #if ENABLE(MAC_GESTURE_EVENTS)
84         GestureStart,
85         GestureChange,
86         GestureEnd,
87 #endif
88     };
89
90     enum Modifiers {
91         ShiftKey    = 1 << 0,
92         ControlKey  = 1 << 1,
93         AltKey      = 1 << 2,
94         MetaKey     = 1 << 3,
95         CapsLockKey = 1 << 4,
96     };
97
98     Type type() const { return static_cast<Type>(m_type); }
99
100     bool shiftKey() const { return m_modifiers & ShiftKey; }
101     bool controlKey() const { return m_modifiers & ControlKey; }
102     bool altKey() const { return m_modifiers & AltKey; }
103     bool metaKey() const { return m_modifiers & MetaKey; }
104     bool capsLockKey() const { return m_modifiers & CapsLockKey; }
105
106     Modifiers modifiers() const { return static_cast<Modifiers>(m_modifiers); }
107
108     WallTime timestamp() const { return m_timestamp; }
109
110 protected:
111     WebEvent();
112
113     WebEvent(Type, Modifiers, WallTime timestamp);
114
115     void encode(IPC::Encoder&) const;
116     static bool decode(IPC::Decoder&, WebEvent&);
117
118 private:
119     uint32_t m_type; // Type
120     uint32_t m_modifiers; // Modifiers
121     WallTime m_timestamp;
122 };
123
124 // FIXME: Move this class to its own header file.
125 class WebMouseEvent : public WebEvent {
126 public:
127     enum Button {
128         NoButton = -1,
129         LeftButton,
130         MiddleButton,
131         RightButton
132     };
133
134     enum SyntheticClickType { NoTap, OneFingerTap, TwoFingerTap };
135
136     WebMouseEvent();
137
138 #if PLATFORM(MAC)
139     WebMouseEvent(Type, Button, unsigned short buttons, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, float deltaX, float deltaY, float deltaZ, int clickCount, Modifiers, WallTime timestamp, double force, SyntheticClickType = NoTap, int eventNumber = -1, int menuType = 0);
140 #else
141     WebMouseEvent(Type, Button, unsigned short buttons, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, float deltaX, float deltaY, float deltaZ, int clickCount, Modifiers, WallTime timestamp, double force = 0, SyntheticClickType = NoTap);
142 #endif
143
144     Button button() const { return static_cast<Button>(m_button); }
145     unsigned short buttons() const { return m_buttons; }
146     const WebCore::IntPoint& position() const { return m_position; }
147     const WebCore::IntPoint& globalPosition() const { return m_globalPosition; }
148     float deltaX() const { return m_deltaX; }
149     float deltaY() const { return m_deltaY; }
150     float deltaZ() const { return m_deltaZ; }
151     int32_t clickCount() const { return m_clickCount; }
152 #if PLATFORM(MAC)
153     int32_t eventNumber() const { return m_eventNumber; }
154     int32_t menuTypeForEvent() const { return m_menuTypeForEvent; }
155 #endif
156     double force() const { return m_force; }
157     SyntheticClickType syntheticClickType() const { return static_cast<SyntheticClickType>(m_syntheticClickType); }
158
159     void encode(IPC::Encoder&) const;
160     static bool decode(IPC::Decoder&, WebMouseEvent&);
161
162 private:
163     static bool isMouseEventType(Type);
164
165     uint32_t m_button;
166     unsigned short m_buttons { 0 };
167     WebCore::IntPoint m_position;
168     WebCore::IntPoint m_globalPosition;
169     float m_deltaX;
170     float m_deltaY;
171     float m_deltaZ;
172     int32_t m_clickCount;
173 #if PLATFORM(MAC)
174     int32_t m_eventNumber;
175     int32_t m_menuTypeForEvent;
176 #endif
177     double m_force { 0 };
178     uint32_t m_syntheticClickType { NoTap };
179 };
180
181 // FIXME: Move this class to its own header file.
182 class WebWheelEvent : public WebEvent {
183 public:
184     enum Granularity {
185         ScrollByPageWheelEvent,
186         ScrollByPixelWheelEvent
187     };
188
189 #if PLATFORM(COCOA) || PLATFORM(GTK)
190     enum Phase {
191         PhaseNone        = 0,
192         PhaseBegan       = 1 << 0,
193         PhaseStationary  = 1 << 1,
194         PhaseChanged     = 1 << 2,
195         PhaseEnded       = 1 << 3,
196         PhaseCancelled   = 1 << 4,
197         PhaseMayBegin    = 1 << 5,
198     };
199 #endif
200
201     WebWheelEvent() { }
202
203     WebWheelEvent(Type, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, const WebCore::FloatSize& delta, const WebCore::FloatSize& wheelTicks, Granularity, Modifiers, WallTime timestamp);
204 #if PLATFORM(COCOA)
205     WebWheelEvent(Type, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, const WebCore::FloatSize& delta, const WebCore::FloatSize& wheelTicks, Granularity, bool directionInvertedFromDevice, Phase, Phase momentumPhase, bool hasPreciseScrollingDeltas, uint32_t scrollCount, const WebCore::FloatSize& unacceleratedScrollingDelta, Modifiers, WallTime timestamp);
206 #elif PLATFORM(GTK)
207     WebWheelEvent(Type, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, const WebCore::FloatSize& delta, const WebCore::FloatSize& wheelTicks, Phase, Phase momentumPhase, Granularity, Modifiers, WallTime timestamp);
208 #endif
209
210     const WebCore::IntPoint position() const { return m_position; }
211     const WebCore::IntPoint globalPosition() const { return m_globalPosition; }
212     const WebCore::FloatSize delta() const { return m_delta; }
213     const WebCore::FloatSize wheelTicks() const { return m_wheelTicks; }
214     Granularity granularity() const { return static_cast<Granularity>(m_granularity); }
215     bool directionInvertedFromDevice() const { return m_directionInvertedFromDevice; }
216 #if PLATFORM(COCOA) || PLATFORM(GTK)
217     Phase phase() const { return static_cast<Phase>(m_phase); }
218     Phase momentumPhase() const { return static_cast<Phase>(m_momentumPhase); }
219 #endif
220 #if PLATFORM(COCOA)
221     bool hasPreciseScrollingDeltas() const { return m_hasPreciseScrollingDeltas; }
222     uint32_t scrollCount() const { return m_scrollCount; }
223     const WebCore::FloatSize& unacceleratedScrollingDelta() const { return m_unacceleratedScrollingDelta; }
224 #endif
225
226     void encode(IPC::Encoder&) const;
227     static bool decode(IPC::Decoder&, WebWheelEvent&);
228
229 private:
230     static bool isWheelEventType(Type);
231
232     WebCore::IntPoint m_position;
233     WebCore::IntPoint m_globalPosition;
234     WebCore::FloatSize m_delta;
235     WebCore::FloatSize m_wheelTicks;
236     uint32_t m_granularity; // Granularity
237     bool m_directionInvertedFromDevice;
238 #if PLATFORM(COCOA) || PLATFORM(GTK)
239     uint32_t m_phase { Phase::PhaseNone };
240     uint32_t m_momentumPhase { Phase::PhaseNone };
241 #endif
242 #if PLATFORM(COCOA)
243     bool m_hasPreciseScrollingDeltas;
244     uint32_t m_scrollCount;
245     WebCore::FloatSize m_unacceleratedScrollingDelta;
246 #endif
247 };
248
249 // FIXME: Move this class to its own header file.
250 class WebKeyboardEvent : public WebEvent {
251 public:
252     WebKeyboardEvent();
253     ~WebKeyboardEvent();
254
255 #if USE(APPKIT)
256     WebKeyboardEvent(Type, const String& text, const String& unmodifiedText, const String& key, const String& code, const String& keyIdentifier, int windowsVirtualKeyCode, int nativeVirtualKeyCode, int macCharCode, bool handledByInputMethod, const Vector<WebCore::KeypressCommand>&, bool isAutoRepeat, bool isKeypad, bool isSystemKey, Modifiers, WallTime timestamp);
257 #elif PLATFORM(GTK)
258     WebKeyboardEvent(Type, const String& text, const String& key, const String& code, const String& keyIdentifier, int windowsVirtualKeyCode, int nativeVirtualKeyCode, bool handledByInputMethod, Vector<String>&& commands, bool isKeypad, Modifiers, WallTime timestamp);
259 #elif PLATFORM(IOS_FAMILY)
260     WebKeyboardEvent(Type, const String& text, const String& unmodifiedText, const String& key, const String& code, const String& keyIdentifier, int windowsVirtualKeyCode, int nativeVirtualKeyCode, int macCharCode, bool isAutoRepeat, bool isKeypad, bool isSystemKey, Modifiers, WallTime timestamp);
261 #elif USE(LIBWPE)
262     WebKeyboardEvent(Type, const String& text, const String& key, const String& code, const String& keyIdentifier, int windowsVirtualKeyCode, int nativeVirtualKeyCode, bool isKeypad, Modifiers, WallTime timestamp);
263 #else
264     WebKeyboardEvent(Type, const String& text, const String& unmodifiedText, const String& keyIdentifier, int windowsVirtualKeyCode, int nativeVirtualKeyCode, int macCharCode, bool isAutoRepeat, bool isKeypad, bool isSystemKey, Modifiers, WallTime timestamp);
265 #endif
266
267     const String& text() const { return m_text; }
268     const String& unmodifiedText() const { return m_unmodifiedText; }
269 #if ENABLE(KEYBOARD_KEY_ATTRIBUTE)
270     const String& key() const { return m_key; }
271 #endif
272 #if ENABLE(KEYBOARD_CODE_ATTRIBUTE)
273     const String& code() const { return m_code; }
274 #endif
275     const String& keyIdentifier() const { return m_keyIdentifier; }
276     int32_t windowsVirtualKeyCode() const { return m_windowsVirtualKeyCode; }
277     int32_t nativeVirtualKeyCode() const { return m_nativeVirtualKeyCode; }
278     int32_t macCharCode() const { return m_macCharCode; }
279 #if USE(APPKIT) || PLATFORM(GTK)
280     bool handledByInputMethod() const { return m_handledByInputMethod; }
281 #endif
282 #if USE(APPKIT)
283     const Vector<WebCore::KeypressCommand>& commands() const { return m_commands; }
284 #elif PLATFORM(GTK)
285     const Vector<String>& commands() const { return m_commands; }
286 #endif
287     bool isAutoRepeat() const { return m_isAutoRepeat; }
288     bool isKeypad() const { return m_isKeypad; }
289     bool isSystemKey() const { return m_isSystemKey; }
290
291     void encode(IPC::Encoder&) const;
292     static bool decode(IPC::Decoder&, WebKeyboardEvent&);
293
294     static bool isKeyboardEventType(Type);
295
296 private:
297     String m_text;
298     String m_unmodifiedText;
299 #if ENABLE(KEYBOARD_KEY_ATTRIBUTE)
300     String m_key;
301 #endif
302 #if ENABLE(KEYBOARD_CODE_ATTRIBUTE)
303     String m_code;
304 #endif
305     String m_keyIdentifier;
306     int32_t m_windowsVirtualKeyCode;
307     int32_t m_nativeVirtualKeyCode;
308     int32_t m_macCharCode;
309 #if USE(APPKIT) || PLATFORM(GTK)
310     bool m_handledByInputMethod;
311 #endif
312 #if USE(APPKIT)
313     Vector<WebCore::KeypressCommand> m_commands;
314 #elif PLATFORM(GTK)
315     Vector<String> m_commands;
316 #endif
317     bool m_isAutoRepeat;
318     bool m_isKeypad;
319     bool m_isSystemKey;
320 };
321
322 #if ENABLE(TOUCH_EVENTS)
323 #if PLATFORM(IOS_FAMILY)
324 class WebPlatformTouchPoint {
325 public:
326     enum TouchPointState {
327         TouchReleased,
328         TouchPressed,
329         TouchMoved,
330         TouchStationary,
331         TouchCancelled
332     };
333
334     enum class TouchType {
335         Direct,
336         Stylus
337     };
338
339     WebPlatformTouchPoint() { }
340     WebPlatformTouchPoint(unsigned identifier, WebCore::IntPoint location, TouchPointState phase)
341         : m_identifier(identifier)
342         , m_location(location)
343         , m_phase(phase)
344     {
345     }
346
347     unsigned identifier() const { return m_identifier; }
348     WebCore::IntPoint location() const { return m_location; }
349     TouchPointState phase() const { return static_cast<TouchPointState>(m_phase); }
350     TouchPointState state() const { return phase(); }
351
352 #if ENABLE(IOS_TOUCH_EVENTS)
353     void setRadiusX(double radiusX) { m_radiusX = radiusX; }
354     double radiusX() const { return m_radiusX; }
355     void setRadiusY(double radiusY) { m_radiusY = radiusY; }
356     double radiusY() const { return m_radiusY; }
357     void setRotationAngle(double rotationAngle) { m_rotationAngle = rotationAngle; }
358     double rotationAngle() const { return m_rotationAngle; }
359     void setForce(double force) { m_force = force; }
360     double force() const { return m_force; }
361     void setAltitudeAngle(double altitudeAngle) { m_altitudeAngle = altitudeAngle; }
362     double altitudeAngle() const { return m_altitudeAngle; }
363     void setAzimuthAngle(double azimuthAngle) { m_azimuthAngle = azimuthAngle; }
364     double azimuthAngle() const { return m_azimuthAngle; }
365     void setTouchType(TouchType touchType) { m_touchType = static_cast<uint32_t>(touchType); }
366     TouchType touchType() const { return static_cast<TouchType>(m_touchType); }
367 #endif
368
369     void encode(IPC::Encoder&) const;
370     static std::optional<WebPlatformTouchPoint> decode(IPC::Decoder&);
371
372 private:
373     unsigned m_identifier;
374     WebCore::IntPoint m_location;
375     uint32_t m_phase;
376 #if ENABLE(IOS_TOUCH_EVENTS)
377     double m_radiusX { 0 };
378     double m_radiusY { 0 };
379     double m_rotationAngle { 0 };
380     double m_force { 0 };
381     double m_altitudeAngle { 0 };
382     double m_azimuthAngle { 0 };
383     uint32_t m_touchType { static_cast<uint32_t>(TouchType::Direct) };
384 #endif
385 };
386
387 class WebTouchEvent : public WebEvent {
388 public:
389     WebTouchEvent() { }
390     WebTouchEvent(WebEvent::Type type, Modifiers modifiers, WallTime timestamp, const Vector<WebPlatformTouchPoint>& touchPoints, WebCore::IntPoint position, bool isPotentialTap, bool isGesture, float gestureScale, float gestureRotation)
391         : WebEvent(type, modifiers, timestamp)
392         , m_touchPoints(touchPoints)
393         , m_position(position)
394         , m_canPreventNativeGestures(true)
395         , m_isPotentialTap(isPotentialTap)
396         , m_isGesture(isGesture)
397         , m_gestureScale(gestureScale)
398         , m_gestureRotation(gestureRotation)
399     {
400         ASSERT(type == TouchStart || type == TouchMove || type == TouchEnd || type == TouchCancel);
401     }
402
403     const Vector<WebPlatformTouchPoint>& touchPoints() const { return m_touchPoints; }
404
405     WebCore::IntPoint position() const { return m_position; }
406
407     bool isPotentialTap() const { return m_isPotentialTap; }
408
409     bool isGesture() const { return m_isGesture; }
410     float gestureScale() const { return m_gestureScale; }
411     float gestureRotation() const { return m_gestureRotation; }
412
413     bool canPreventNativeGestures() const { return m_canPreventNativeGestures; }
414     void setCanPreventNativeGestures(bool canPreventNativeGestures) { m_canPreventNativeGestures = canPreventNativeGestures; }
415
416     bool allTouchPointsAreReleased() const;
417
418     void encode(IPC::Encoder&) const;
419     static bool decode(IPC::Decoder&, WebTouchEvent&);
420     
421 private:
422     Vector<WebPlatformTouchPoint> m_touchPoints;
423     
424     WebCore::IntPoint m_position;
425     bool m_canPreventNativeGestures;
426     bool m_isPotentialTap;
427     bool m_isGesture;
428     float m_gestureScale;
429     float m_gestureRotation;
430 };
431 #else
432 // FIXME: Move this class to its own header file.
433 // FIXME: Having "Platform" in the name makes it sound like this event is platform-specific or low-
434 // level in some way. That doesn't seem to be the case.
435 class WebPlatformTouchPoint {
436 public:
437     enum TouchPointState {
438         TouchReleased,
439         TouchPressed,
440         TouchMoved,
441         TouchStationary,
442         TouchCancelled
443     };
444
445     WebPlatformTouchPoint() : m_rotationAngle(0.0), m_force(0.0) { }
446
447     WebPlatformTouchPoint(uint32_t id, TouchPointState, const WebCore::IntPoint& screenPosition, const WebCore::IntPoint& position);
448
449     WebPlatformTouchPoint(uint32_t id, TouchPointState, const WebCore::IntPoint& screenPosition, const WebCore::IntPoint& position, const WebCore::IntSize& radius, float rotationAngle = 0.0, float force = 0.0);
450     
451     uint32_t id() const { return m_id; }
452     TouchPointState state() const { return static_cast<TouchPointState>(m_state); }
453
454     const WebCore::IntPoint& screenPosition() const { return m_screenPosition; }
455     const WebCore::IntPoint& position() const { return m_position; }
456     const WebCore::IntSize& radius() const { return m_radius; }
457     float rotationAngle() const { return m_rotationAngle; }
458     float force() const { return m_force; }
459
460     void setState(TouchPointState state) { m_state = state; }
461
462     void encode(IPC::Encoder&) const;
463     static std::optional<WebPlatformTouchPoint> decode(IPC::Decoder&);
464
465 private:
466     uint32_t m_id;
467     uint32_t m_state;
468     WebCore::IntPoint m_screenPosition;
469     WebCore::IntPoint m_position;
470     WebCore::IntSize m_radius;
471     float m_rotationAngle;
472     float m_force;
473 };
474
475 // FIXME: Move this class to its own header file.
476 class WebTouchEvent : public WebEvent {
477 public:
478     WebTouchEvent() { }
479     WebTouchEvent(Type, Vector<WebPlatformTouchPoint>&&, Modifiers, WallTime timestamp);
480
481     const Vector<WebPlatformTouchPoint>& touchPoints() const { return m_touchPoints; }
482
483     bool allTouchPointsAreReleased() const;
484
485     void encode(IPC::Encoder&) const;
486     static bool decode(IPC::Decoder&, WebTouchEvent&);
487   
488 private:
489     static bool isTouchEventType(Type);
490
491     Vector<WebPlatformTouchPoint> m_touchPoints;
492 };
493
494 #endif // PLATFORM(IOS_FAMILY)
495 #endif // ENABLE(TOUCH_EVENTS)
496
497 } // namespace WebKit
498
499 #endif // WebEvent_h