83e62162dc83b768eb16a96e5b383086f8c1396b
[WebKit-https.git] / Source / WebKit2 / 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/text/WTFString.h>
38
39 namespace CoreIPC {
40     class ArgumentDecoder;
41     class ArgumentEncoder;
42 }
43
44 namespace WebKit {
45
46 class WebEvent {
47 public:
48     enum Type {
49         NoType = -1,
50         
51         // WebMouseEvent
52         MouseDown,
53         MouseUp,
54         MouseMove,
55
56         // WebWheelEvent
57         Wheel,
58
59         // WebKeyboardEvent
60         KeyDown,
61         KeyUp,
62         RawKeyDown,
63         Char,
64
65 #if ENABLE(GESTURE_EVENTS)
66         // WebGestureEvent
67         GestureScrollBegin,
68         GestureScrollEnd,
69         GestureSingleTap,
70 #endif
71
72 #if ENABLE(TOUCH_EVENTS)
73         // WebTouchEvent
74         TouchStart,
75         TouchMove,
76         TouchEnd,
77         TouchCancel,
78 #endif
79     };
80
81     enum Modifiers {
82         ShiftKey    = 1 << 0,
83         ControlKey  = 1 << 1,
84         AltKey      = 1 << 2,
85         MetaKey     = 1 << 3,
86         CapsLockKey = 1 << 4,
87     };
88
89     Type type() const { return static_cast<Type>(m_type); }
90
91     bool shiftKey() const { return m_modifiers & ShiftKey; }
92     bool controlKey() const { return m_modifiers & ControlKey; }
93     bool altKey() const { return m_modifiers & AltKey; }
94     bool metaKey() const { return m_modifiers & MetaKey; }
95     bool capsLockKey() const { return m_modifiers & CapsLockKey; }
96
97     Modifiers modifiers() const { return static_cast<Modifiers>(m_modifiers); }
98
99     double timestamp() const { return m_timestamp; }
100
101 protected:
102     WebEvent();
103
104     WebEvent(Type, Modifiers, double timestamp);
105
106     void encode(CoreIPC::ArgumentEncoder&) const;
107     static bool decode(CoreIPC::ArgumentDecoder*, WebEvent&);
108
109 private:
110     uint32_t m_type; // Type
111     uint32_t m_modifiers; // Modifiers
112     double m_timestamp;
113 };
114
115 // FIXME: Move this class to its own header file.
116 class WebMouseEvent : public WebEvent {
117 public:
118     enum Button {
119         NoButton = -1,
120         LeftButton,
121         MiddleButton,
122         RightButton
123     };
124
125     WebMouseEvent();
126
127     WebMouseEvent(Type, Button, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, float deltaX, float deltaY, float deltaZ, int clickCount, Modifiers, double timestamp);
128
129     Button button() const { return static_cast<Button>(m_button); }
130     const WebCore::IntPoint& position() const { return m_position; }
131     const WebCore::IntPoint& globalPosition() const { return m_globalPosition; }
132     float deltaX() const { return m_deltaX; }
133     float deltaY() const { return m_deltaY; }
134     float deltaZ() const { return m_deltaZ; }
135     int32_t clickCount() const { return m_clickCount; }
136
137     void encode(CoreIPC::ArgumentEncoder&) const;
138     static bool decode(CoreIPC::ArgumentDecoder*, WebMouseEvent&);
139
140 private:
141     static bool isMouseEventType(Type);
142
143     uint32_t m_button;
144     WebCore::IntPoint m_position;
145     WebCore::IntPoint m_globalPosition;
146     float m_deltaX;
147     float m_deltaY;
148     float m_deltaZ;
149     int32_t m_clickCount;
150 };
151
152 // FIXME: Move this class to its own header file.
153 class WebWheelEvent : public WebEvent {
154 public:
155     enum Granularity {
156         ScrollByPageWheelEvent,
157         ScrollByPixelWheelEvent
158     };
159
160 #if PLATFORM(MAC)
161     enum Phase {
162         PhaseNone        = 0,
163         PhaseBegan       = 1 << 0,
164         PhaseStationary  = 1 << 1,
165         PhaseChanged     = 1 << 2,
166         PhaseEnded       = 1 << 3,
167         PhaseCancelled   = 1 << 4,
168         PhaseMayBegin    = 1 << 5,
169     };
170 #endif
171
172     WebWheelEvent() { }
173
174     WebWheelEvent(Type, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, const WebCore::FloatSize& delta, const WebCore::FloatSize& wheelTicks, Granularity, Modifiers, double timestamp);
175 #if PLATFORM(MAC)
176     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, double timestamp);
177 #endif
178
179     const WebCore::IntPoint position() const { return m_position; }
180     const WebCore::IntPoint globalPosition() const { return m_globalPosition; }
181     const WebCore::FloatSize delta() const { return m_delta; }
182     const WebCore::FloatSize wheelTicks() const { return m_wheelTicks; }
183     Granularity granularity() const { return static_cast<Granularity>(m_granularity); }
184     bool directionInvertedFromDevice() const { return m_directionInvertedFromDevice; }
185 #if PLATFORM(MAC)
186     Phase phase() const { return static_cast<Phase>(m_phase); }
187     Phase momentumPhase() const { return static_cast<Phase>(m_momentumPhase); }
188     bool hasPreciseScrollingDeltas() const { return m_hasPreciseScrollingDeltas; }
189     uint32_t scrollCount() const { return m_scrollCount; }
190     const WebCore::FloatSize& unacceleratedScrollingDelta() const { return m_unacceleratedScrollingDelta; }
191 #endif
192
193     void encode(CoreIPC::ArgumentEncoder&) const;
194     static bool decode(CoreIPC::ArgumentDecoder*, WebWheelEvent&);
195
196 private:
197     static bool isWheelEventType(Type);
198
199     WebCore::IntPoint m_position;
200     WebCore::IntPoint m_globalPosition;
201     WebCore::FloatSize m_delta;
202     WebCore::FloatSize m_wheelTicks;
203     uint32_t m_granularity; // Granularity
204     bool m_directionInvertedFromDevice;
205 #if PLATFORM(MAC)
206     uint32_t m_phase; // Phase
207     uint32_t m_momentumPhase; // Phase
208     bool m_hasPreciseScrollingDeltas;
209     uint32_t m_scrollCount;
210     WebCore::FloatSize m_unacceleratedScrollingDelta;
211 #endif
212 };
213
214 // FIXME: Move this class to its own header file.
215 class WebKeyboardEvent : public WebEvent {
216 public:
217     WebKeyboardEvent() { }
218
219     WebKeyboardEvent(Type, const String& text, const String& unmodifiedText, const String& keyIdentifier, int windowsVirtualKeyCode, int nativeVirtualKeyCode, int macCharCode, bool isAutoRepeat, bool isKeypad, bool isSystemKey, Modifiers, double timestamp);
220
221     const String& text() const { return m_text; }
222     const String& unmodifiedText() const { return m_unmodifiedText; }
223     const String& keyIdentifier() const { return m_keyIdentifier; }
224     int32_t windowsVirtualKeyCode() const { return m_windowsVirtualKeyCode; }
225     int32_t nativeVirtualKeyCode() const { return m_nativeVirtualKeyCode; }
226     int32_t macCharCode() const { return m_macCharCode; }
227     bool isAutoRepeat() const { return m_isAutoRepeat; }
228     bool isKeypad() const { return m_isKeypad; }
229     bool isSystemKey() const { return m_isSystemKey; }
230
231     void encode(CoreIPC::ArgumentEncoder&) const;
232     static bool decode(CoreIPC::ArgumentDecoder*, WebKeyboardEvent&);
233
234     static bool isKeyboardEventType(Type);
235
236 private:
237     String m_text;
238     String m_unmodifiedText;
239     String m_keyIdentifier;
240     int32_t m_windowsVirtualKeyCode;
241     int32_t m_nativeVirtualKeyCode;
242     int32_t m_macCharCode;
243     bool m_isAutoRepeat;
244     bool m_isKeypad;
245     bool m_isSystemKey;
246 };
247
248
249 #if ENABLE(GESTURE_EVENTS)
250 // FIXME: Move this class to its own header file.
251 class WebGestureEvent : public WebEvent {
252 public:
253     WebGestureEvent() { }
254     WebGestureEvent(Type, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, Modifiers, double timestamp);
255     WebGestureEvent(Type, const WebCore::IntPoint& position, const WebCore::IntPoint& globalPosition, Modifiers, double timestamp, const WebCore::IntSize& area, const WebCore::FloatPoint& delta);
256
257     const WebCore::IntPoint position() const { return m_position; }
258     const WebCore::IntPoint globalPosition() const { return m_globalPosition; }
259     const WebCore::IntSize area() const { return m_area; }
260     const WebCore::FloatPoint delta() const { return m_delta; }
261
262     void encode(CoreIPC::ArgumentEncoder&) const;
263     static bool decode(CoreIPC::ArgumentDecoder*, WebGestureEvent&);
264
265 private:
266     static bool isGestureEventType(Type);
267
268     WebCore::IntPoint m_position;
269     WebCore::IntPoint m_globalPosition;
270     WebCore::IntSize m_area;
271     WebCore::FloatPoint m_delta;
272 };
273 #endif // ENABLE(GESTURE_EVENTS)
274
275
276 #if ENABLE(TOUCH_EVENTS)
277 // FIXME: Move this class to its own header file.
278 // FIXME: Having "Platform" in the name makes it sound like this event is platform-specific or low-
279 // level in some way. That doesn't seem to be the case.
280 class WebPlatformTouchPoint {
281 public:
282     enum TouchPointState {
283         TouchReleased,
284         TouchPressed,
285         TouchMoved,
286         TouchStationary,
287         TouchCancelled
288     };
289
290     WebPlatformTouchPoint() : m_rotationAngle(0.0), m_force(0.0) { }
291
292     WebPlatformTouchPoint(uint32_t id, TouchPointState, const WebCore::IntPoint& screenPosition, const WebCore::IntPoint& position);
293
294     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);
295     
296     uint32_t id() const { return m_id; }
297     TouchPointState state() const { return static_cast<TouchPointState>(m_state); }
298
299     const WebCore::IntPoint& screenPosition() const { return m_screenPosition; }
300     const WebCore::IntPoint& position() const { return m_position; }
301     const WebCore::IntSize& radius() const { return m_radius; }
302     float rotationAngle() const { return m_rotationAngle; }
303     float force() const { return m_force; }
304
305     void setState(TouchPointState state) { m_state = state; }
306
307     void encode(CoreIPC::ArgumentEncoder&) const;
308     static bool decode(CoreIPC::ArgumentDecoder*, WebPlatformTouchPoint&);
309
310 private:
311     uint32_t m_id;
312     uint32_t m_state;
313     WebCore::IntPoint m_screenPosition;
314     WebCore::IntPoint m_position;
315     WebCore::IntSize m_radius;
316     float m_rotationAngle;
317     float m_force;
318 };
319
320 // FIXME: Move this class to its own header file.
321 class WebTouchEvent : public WebEvent {
322 public:
323     WebTouchEvent() { }
324  
325     // FIXME: It would be nice not to have to copy the Vector here.
326     WebTouchEvent(Type, Vector<WebPlatformTouchPoint>, Modifiers, double timestamp);
327
328     const Vector<WebPlatformTouchPoint>& touchPoints() const { return m_touchPoints; }
329
330     void encode(CoreIPC::ArgumentEncoder&) const;
331     static bool decode(CoreIPC::ArgumentDecoder*, WebTouchEvent&);
332   
333 private:
334     static bool isTouchEventType(Type);
335
336     Vector<WebPlatformTouchPoint> m_touchPoints;
337 };
338
339 #endif // ENABLE(TOUCH_EVENTS)
340
341 } // namespace WebKit
342
343 #endif // WebEvent_h