https://bugs.webkit.org/show_bug.cgi?id=66133
[WebKit-https.git] / Source / WebKit / chromium / public / WebInputEvent.h
1 /*
2  * Copyright (C) 2009 Google 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 are
6  * met:
7  *
8  *     * Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  *     * Redistributions in binary form must reproduce the above
11  * copyright notice, this list of conditions and the following disclaimer
12  * in the documentation and/or other materials provided with the
13  * distribution.
14  *     * Neither the name of Google Inc. nor the names of its
15  * contributors may be used to endorse or promote products derived from
16  * this software without specific prior written permission.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #ifndef WebInputEvent_h
32 #define WebInputEvent_h
33
34 #include "WebCommon.h"
35 #include "WebTouchPoint.h"
36
37 #include <string.h>
38
39 namespace WebKit {
40
41 // The classes defined in this file are intended to be used with
42 // WebWidget's handleInputEvent method.  These event types are cross-
43 // platform and correspond closely to WebCore's Platform*Event classes.
44 //
45 // WARNING! These classes must remain PODs (plain old data).  They are
46 // intended to be "serializable" by copying their raw bytes, so they must
47 // not contain any non-bit-copyable member variables!
48
49 // WebInputEvent --------------------------------------------------------------
50
51 class WebInputEvent {
52 public:
53     WebInputEvent(unsigned sizeParam = sizeof(WebInputEvent))
54         : size(sizeParam)
55         , type(Undefined)
56         , modifiers(0)
57         , timeStampSeconds(0.0) { }
58
59     // When we use an input method (or an input method editor), we receive
60     // two events for a keypress. The former event is a keydown, which
61     // provides a keycode, and the latter is a textinput, which provides
62     // a character processed by an input method. (The mapping from a
63     // keycode to a character code is not trivial for non-English
64     // keyboards.)
65     // To support input methods, Safari sends keydown events to WebKit for
66     // filtering. WebKit sends filtered keydown events back to Safari,
67     // which sends them to input methods.
68     // Unfortunately, it is hard to apply this design to Chrome because of
69     // our multiprocess architecture. An input method is running in a
70     // browser process. On the other hand, WebKit is running in a renderer
71     // process. So, this design results in increasing IPC messages.
72     // To support input methods without increasing IPC messages, Chrome
73     // handles keyboard events in a browser process and send asynchronous
74     // input events (to be translated to DOM events) to a renderer
75     // process.
76     // This design is mostly the same as the one of Windows and Mac Carbon.
77     // So, for what it's worth, our Linux and Mac front-ends emulate our
78     // Windows front-end. To emulate our Windows front-end, we can share
79     // our back-end code among Windows, Linux, and Mac.
80     // TODO(hbono): Issue 18064: remove the KeyDown type since it isn't
81     // used in Chrome any longer.
82
83     enum Type {
84         Undefined = -1,
85
86         // WebMouseEvent
87         MouseDown,
88         MouseUp,
89         MouseMove,
90         MouseEnter,
91         MouseLeave,
92         ContextMenu,
93
94         // WebMouseWheelEvent
95         MouseWheel,
96
97         // WebKeyboardEvent
98         RawKeyDown,
99         KeyDown,
100         KeyUp,
101         Char,
102
103         // WebGestureEvent
104         GestureScrollBegin,
105         GestureScrollEnd,
106
107         // WebTouchEvent
108         TouchStart,
109         TouchMove,
110         TouchEnd,
111         TouchCancel,
112     };
113
114     enum Modifiers {
115         // modifiers for all events:
116         ShiftKey         = 1 << 0,
117         ControlKey       = 1 << 1,
118         AltKey           = 1 << 2,
119         MetaKey          = 1 << 3,
120
121         // modifiers for keyboard events:
122         IsKeyPad         = 1 << 4,
123         IsAutoRepeat     = 1 << 5,
124
125         // modifiers for mouse events:
126         LeftButtonDown   = 1 << 6,
127         MiddleButtonDown = 1 << 7,
128         RightButtonDown  = 1 << 8,
129
130         // Toggle modifiers for all events. Danger: these are not reflected
131         // into WebCore, so round-tripping from WebInputEvent to a WebCore
132         // event and back will not preserve these flags.
133         CapsLockOn       = 1 << 9,
134         NumLockOn        = 1 << 10,
135     };
136
137     static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
138
139     unsigned size;   // The size of this structure, for serialization.
140     Type type;
141     int modifiers;
142     double timeStampSeconds;   // Seconds since epoch.
143
144     // Returns true if the WebInputEvent |type| is a mouse event.
145     static bool isMouseEventType(int type)
146     {
147         return type == MouseDown
148             || type == MouseUp
149             || type == MouseMove
150             || type == MouseEnter
151             || type == MouseLeave
152             || type == ContextMenu;
153     }
154
155     // Returns true if the WebInputEvent |type| is a keyboard event.
156     static bool isKeyboardEventType(int type)
157     {
158         return type == RawKeyDown
159             || type == KeyDown
160             || type == KeyUp
161             || type == Char;
162     }
163
164     // Returns true if the WebInputEvent |type| is a touch event.
165     static bool isTouchEventType(int type)
166     {
167         return type == TouchStart
168             || type == TouchMove
169             || type == TouchEnd
170             || type == TouchCancel;
171     }
172
173     // Returns true if the WebInputEvent |type| should be handled as user gesture.
174     static bool isUserGestureEventType(int type)
175     {
176         return isKeyboardEventType(type)
177             || type == MouseDown
178             || type == MouseUp
179             || type == TouchStart
180             || type == TouchEnd;
181     }
182 };
183
184 // WebKeyboardEvent -----------------------------------------------------------
185
186 class WebKeyboardEvent : public WebInputEvent {
187 public:
188     // Caps on string lengths so we can make them static arrays and keep
189     // them PODs.
190     static const size_t textLengthCap = 4;
191
192     // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html lists the
193     // identifiers.  The longest is 18 characters, so we round up to the
194     // next multiple of 4.
195     static const size_t keyIdentifierLengthCap = 20;
196
197     // |windowsKeyCode| is the Windows key code associated with this key
198     // event.  Sometimes it's direct from the event (i.e. on Windows),
199     // sometimes it's via a mapping function.  If you want a list, see
200     // WebCore/platform/chromium/KeyboardCodes* .
201     int windowsKeyCode;
202
203     // The actual key code genenerated by the platform.  The DOM spec runs
204     // on Windows-equivalent codes (thus |windowsKeyCode| above) but it
205     // doesn't hurt to have this one around.
206     int nativeKeyCode;
207
208     // |text| is the text generated by this keystroke.  |unmodifiedText| is
209     // |text|, but unmodified by an concurrently-held modifiers (except
210     // shift).  This is useful for working out shortcut keys.  Linux and
211     // Windows guarantee one character per event.  The Mac does not, but in
212     // reality that's all it ever gives.  We're generous, and cap it a bit
213     // longer.
214     WebUChar text[textLengthCap];
215     WebUChar unmodifiedText[textLengthCap];
216
217     // This is a string identifying the key pressed.
218     char keyIdentifier[keyIdentifierLengthCap];
219
220     // This identifies whether this event was tagged by the system as being
221     // a "system key" event (see
222     // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for
223     // details).  Other platforms don't have this concept, but it's just
224     // easier to leave it always false than ifdef.
225     // int is used instead of bool to ensure the size of this structure is
226     // strictly aligned to a factor of 4 bytes, otherwise memory check tools
227     // like valgrind may complain about uninitialized memory usage when
228     // transfering it over the wire.
229     int isSystemKey;
230
231     WebKeyboardEvent(unsigned sizeParam = sizeof(WebKeyboardEvent))
232         : WebInputEvent(sizeParam)
233         , windowsKeyCode(0)
234         , nativeKeyCode(0)
235         , isSystemKey(false)
236     {
237         memset(&text, 0, sizeof(text));
238         memset(&unmodifiedText, 0, sizeof(unmodifiedText));
239         memset(&keyIdentifier, 0, sizeof(keyIdentifier));
240     }
241
242     // Sets keyIdentifier based on the value of windowsKeyCode.  This is
243     // handy for generating synthetic keyboard events.
244     WEBKIT_EXPORT void setKeyIdentifierFromWindowsKeyCode();
245 };
246
247 // WebMouseEvent --------------------------------------------------------------
248
249 class WebMouseEvent : public WebInputEvent {
250 public:
251     // These values defined for WebCore::MouseButton
252     enum Button {
253         ButtonNone = -1,
254         ButtonLeft,
255         ButtonMiddle,
256         ButtonRight
257     };
258
259     Button button;
260     int x;
261     int y;
262     int windowX;
263     int windowY;
264     int globalX;
265     int globalY;
266     int clickCount;
267
268     WebMouseEvent(unsigned sizeParam = sizeof(WebMouseEvent))
269         : WebInputEvent(sizeParam)
270         , button(ButtonNone)
271         , x(0)
272         , y(0)
273         , windowX(0)
274         , windowY(0)
275         , globalX(0)
276         , globalY(0)
277         , clickCount(0)
278     {
279     }
280 };
281
282 // WebMouseWheelEvent ---------------------------------------------------------
283
284 class WebMouseWheelEvent : public WebMouseEvent {
285 public:
286     enum Phase {
287         PhaseNone        = 0,
288         PhaseBegan       = 1 << 1,
289         PhaseStationary  = 1 << 2,
290         PhaseChanged     = 1 << 3,
291         PhaseEnded       = 1 << 4,
292         PhaseCancelled   = 1 << 5,
293     };
294
295     float deltaX;
296     float deltaY;
297     float wheelTicksX;
298     float wheelTicksY;
299
300     // int is used instead of bool to ensure the size of this structure is
301     // strictly aligned to a factor of 4 bytes, otherwise memory check tools
302     // like valgrind may complain about uninitialized memory usage when
303     // transfering it over the wire.
304     int scrollByPage;
305
306     bool hasPreciseScrollingDeltas;
307     Phase phase;
308     Phase momentumPhase;
309
310     WebMouseWheelEvent(unsigned sizeParam = sizeof(WebMouseWheelEvent))
311         : WebMouseEvent(sizeParam)
312         , deltaX(0.0f)
313         , deltaY(0.0f)
314         , wheelTicksX(0.0f)
315         , wheelTicksY(0.0f)
316         , scrollByPage(false)
317         , hasPreciseScrollingDeltas(false)
318         , phase(PhaseNone)
319         , momentumPhase(PhaseNone)
320     {
321     }
322 };
323
324 // WebGestureEvent --------------------------------------------------------------
325
326 class WebGestureEvent : public WebInputEvent {
327 public:
328     int x;
329     int y;
330     int globalX;
331     int globalY;
332
333     WebGestureEvent(unsigned sizeParam = sizeof(WebGestureEvent))
334         : x(0)
335         , y(0)
336         , globalX(0)
337         , globalY(0)
338     {
339     }
340 };
341
342 // WebTouchEvent --------------------------------------------------------------
343
344 class WebTouchEvent : public WebInputEvent {
345 public:
346     static const int touchPointsLengthCap = 4;
347
348     int touchPointsLength;
349     WebTouchPoint touchPoints[touchPointsLengthCap];
350
351     WebTouchEvent(unsigned sizeParam = sizeof(WebTouchEvent))
352         : WebInputEvent(sizeParam)
353         , touchPointsLength(0)
354     {
355     }
356 };
357
358 } // namespace WebKit
359
360 #endif