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