Unreviewed, rolling out r94635.
[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         GestureTap,
107
108         // WebTouchEvent
109         TouchStart,
110         TouchMove,
111         TouchEnd,
112         TouchCancel,
113     };
114
115     enum Modifiers {
116         // modifiers for all events:
117         ShiftKey         = 1 << 0,
118         ControlKey       = 1 << 1,
119         AltKey           = 1 << 2,
120         MetaKey          = 1 << 3,
121
122         // modifiers for keyboard events:
123         IsKeyPad         = 1 << 4,
124         IsAutoRepeat     = 1 << 5,
125
126         // modifiers for mouse events:
127         LeftButtonDown   = 1 << 6,
128         MiddleButtonDown = 1 << 7,
129         RightButtonDown  = 1 << 8,
130
131         // Toggle modifiers for all events. Danger: these are not reflected
132         // into WebCore, so round-tripping from WebInputEvent to a WebCore
133         // event and back will not preserve these flags.
134         CapsLockOn       = 1 << 9,
135         NumLockOn        = 1 << 10,
136     };
137
138     static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
139
140     unsigned size;   // The size of this structure, for serialization.
141     Type type;
142     int modifiers;
143     double timeStampSeconds;   // Seconds since epoch.
144
145     // Returns true if the WebInputEvent |type| is a mouse event.
146     static bool isMouseEventType(int type)
147     {
148         return type == MouseDown
149             || type == MouseUp
150             || type == MouseMove
151             || type == MouseEnter
152             || type == MouseLeave
153             || type == ContextMenu;
154     }
155
156     // Returns true if the WebInputEvent |type| is a keyboard event.
157     static bool isKeyboardEventType(int type)
158     {
159         return type == RawKeyDown
160             || type == KeyDown
161             || type == KeyUp
162             || type == Char;
163     }
164
165     // Returns true if the WebInputEvent |type| is a touch event.
166     static bool isTouchEventType(int type)
167     {
168         return type == TouchStart
169             || type == TouchMove
170             || type == TouchEnd
171             || type == TouchCancel;
172     }
173
174     // Returns true if the WebInputEvent |type| should be handled as user gesture.
175     static bool isUserGestureEventType(int type)
176     {
177         return isKeyboardEventType(type)
178             || type == MouseDown
179             || type == MouseUp
180             || type == TouchStart
181             || type == TouchEnd;
182     }
183 };
184
185 // WebKeyboardEvent -----------------------------------------------------------
186
187 class WebKeyboardEvent : public WebInputEvent {
188 public:
189     // Caps on string lengths so we can make them static arrays and keep
190     // them PODs.
191     static const size_t textLengthCap = 4;
192
193     // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html lists the
194     // identifiers.  The longest is 18 characters, so we round up to the
195     // next multiple of 4.
196     static const size_t keyIdentifierLengthCap = 20;
197
198     // |windowsKeyCode| is the Windows key code associated with this key
199     // event.  Sometimes it's direct from the event (i.e. on Windows),
200     // sometimes it's via a mapping function.  If you want a list, see
201     // WebCore/platform/chromium/KeyboardCodes* .
202     int windowsKeyCode;
203
204     // The actual key code genenerated by the platform.  The DOM spec runs
205     // on Windows-equivalent codes (thus |windowsKeyCode| above) but it
206     // doesn't hurt to have this one around.
207     int nativeKeyCode;
208
209     // |text| is the text generated by this keystroke.  |unmodifiedText| is
210     // |text|, but unmodified by an concurrently-held modifiers (except
211     // shift).  This is useful for working out shortcut keys.  Linux and
212     // Windows guarantee one character per event.  The Mac does not, but in
213     // reality that's all it ever gives.  We're generous, and cap it a bit
214     // longer.
215     WebUChar text[textLengthCap];
216     WebUChar unmodifiedText[textLengthCap];
217
218     // This is a string identifying the key pressed.
219     char keyIdentifier[keyIdentifierLengthCap];
220
221     // This identifies whether this event was tagged by the system as being
222     // a "system key" event (see
223     // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for
224     // details).  Other platforms don't have this concept, but it's just
225     // easier to leave it always false than ifdef.
226     // int is used instead of bool to ensure the size of this structure is
227     // strictly aligned to a factor of 4 bytes, otherwise memory check tools
228     // like valgrind may complain about uninitialized memory usage when
229     // transfering it over the wire.
230     int isSystemKey;
231
232     WebKeyboardEvent(unsigned sizeParam = sizeof(WebKeyboardEvent))
233         : WebInputEvent(sizeParam)
234         , windowsKeyCode(0)
235         , nativeKeyCode(0)
236         , isSystemKey(false)
237     {
238         memset(&text, 0, sizeof(text));
239         memset(&unmodifiedText, 0, sizeof(unmodifiedText));
240         memset(&keyIdentifier, 0, sizeof(keyIdentifier));
241     }
242
243     // Sets keyIdentifier based on the value of windowsKeyCode.  This is
244     // handy for generating synthetic keyboard events.
245     WEBKIT_EXPORT void setKeyIdentifierFromWindowsKeyCode();
246 };
247
248 // WebMouseEvent --------------------------------------------------------------
249
250 class WebMouseEvent : public WebInputEvent {
251 public:
252     // These values defined for WebCore::MouseButton
253     enum Button {
254         ButtonNone = -1,
255         ButtonLeft,
256         ButtonMiddle,
257         ButtonRight
258     };
259
260     Button button;
261     int x;
262     int y;
263     int windowX;
264     int windowY;
265     int globalX;
266     int globalY;
267     int clickCount;
268
269     WebMouseEvent(unsigned sizeParam = sizeof(WebMouseEvent))
270         : WebInputEvent(sizeParam)
271         , button(ButtonNone)
272         , x(0)
273         , y(0)
274         , windowX(0)
275         , windowY(0)
276         , globalX(0)
277         , globalY(0)
278         , clickCount(0)
279     {
280     }
281 };
282
283 // WebMouseWheelEvent ---------------------------------------------------------
284
285 class WebMouseWheelEvent : public WebMouseEvent {
286 public:
287     enum Phase {
288         PhaseNone        = 0,
289         PhaseBegan       = 1 << 1,
290         PhaseStationary  = 1 << 2,
291         PhaseChanged     = 1 << 3,
292         PhaseEnded       = 1 << 4,
293         PhaseCancelled   = 1 << 5,
294     };
295
296     float deltaX;
297     float deltaY;
298     float wheelTicksX;
299     float wheelTicksY;
300
301     // int is used instead of bool to ensure the size of this structure is
302     // strictly aligned to a factor of 4 bytes, otherwise memory check tools
303     // like valgrind may complain about uninitialized memory usage when
304     // transfering it over the wire.
305     int scrollByPage;
306
307     bool hasPreciseScrollingDeltas;
308     Phase phase;
309     Phase momentumPhase;
310
311     WebMouseWheelEvent(unsigned sizeParam = sizeof(WebMouseWheelEvent))
312         : WebMouseEvent(sizeParam)
313         , deltaX(0.0f)
314         , deltaY(0.0f)
315         , wheelTicksX(0.0f)
316         , wheelTicksY(0.0f)
317         , scrollByPage(false)
318         , hasPreciseScrollingDeltas(false)
319         , phase(PhaseNone)
320         , momentumPhase(PhaseNone)
321     {
322     }
323 };
324
325 // WebGestureEvent --------------------------------------------------------------
326
327 class WebGestureEvent : public WebInputEvent {
328 public:
329     int x;
330     int y;
331     int globalX;
332     int globalY;
333
334     WebGestureEvent(unsigned sizeParam = sizeof(WebGestureEvent))
335         : x(0)
336         , y(0)
337         , globalX(0)
338         , globalY(0)
339     {
340     }
341 };
342
343 // WebTouchEvent --------------------------------------------------------------
344
345 class WebTouchEvent : public WebInputEvent {
346 public:
347     static const int touchPointsLengthCap = 4;
348
349     int touchPointsLength;
350     WebTouchPoint touchPoints[touchPointsLengthCap];
351
352     WebTouchEvent(unsigned sizeParam = sizeof(WebTouchEvent))
353         : WebInputEvent(sizeParam)
354         , touchPointsLength(0)
355     {
356     }
357 };
358
359 } // namespace WebKit
360
361 #endif