WinCairo build fails to link.
[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 "../../../Platform/chromium/public/WebCommon.h"
35 #include "../../../Platform/chromium/public/WebRect.h"
36 #include "WebTouchPoint.h"
37
38 #include <string.h>
39
40 namespace WebKit {
41
42 // The classes defined in this file are intended to be used with
43 // WebWidget's handleInputEvent method.  These event types are cross-
44 // platform and correspond closely to WebCore's Platform*Event classes.
45 //
46 // WARNING! These classes must remain PODs (plain old data).  They are
47 // intended to be "serializable" by copying their raw bytes, so they must
48 // not contain any non-bit-copyable member variables!
49 //
50 // Furthermore, the class members need to be packed so they are aligned
51 // properly and don't have paddings/gaps, otherwise memory check tools
52 // like Valgrind will complain about uninitialized memory usage when
53 // transferring these classes over the wire.
54
55 #pragma pack(push, 4)
56
57 // WebInputEvent --------------------------------------------------------------
58
59 class WebInputEvent {
60 public:
61     WebInputEvent(unsigned sizeParam = sizeof(WebInputEvent))
62     {
63         memset(this, 0, sizeParam);
64         timeStampSeconds = 0.0;
65         size = sizeParam;
66         type = Undefined;
67         modifiers = 0;
68     }
69
70     // When we use an input method (or an input method editor), we receive
71     // two events for a keypress. The former event is a keydown, which
72     // provides a keycode, and the latter is a textinput, which provides
73     // a character processed by an input method. (The mapping from a
74     // keycode to a character code is not trivial for non-English
75     // keyboards.)
76     // To support input methods, Safari sends keydown events to WebKit for
77     // filtering. WebKit sends filtered keydown events back to Safari,
78     // which sends them to input methods.
79     // Unfortunately, it is hard to apply this design to Chrome because of
80     // our multiprocess architecture. An input method is running in a
81     // browser process. On the other hand, WebKit is running in a renderer
82     // process. So, this design results in increasing IPC messages.
83     // To support input methods without increasing IPC messages, Chrome
84     // handles keyboard events in a browser process and send asynchronous
85     // input events (to be translated to DOM events) to a renderer
86     // process.
87     // This design is mostly the same as the one of Windows and Mac Carbon.
88     // So, for what it's worth, our Linux and Mac front-ends emulate our
89     // Windows front-end. To emulate our Windows front-end, we can share
90     // our back-end code among Windows, Linux, and Mac.
91     // TODO(hbono): Issue 18064: remove the KeyDown type since it isn't
92     // used in Chrome any longer.
93
94     enum Type {
95         Undefined = -1,
96
97         // WebMouseEvent
98         MouseDown,
99         MouseUp,
100         MouseMove,
101         MouseEnter,
102         MouseLeave,
103         ContextMenu,
104
105         // WebMouseWheelEvent
106         MouseWheel,
107
108         // WebKeyboardEvent
109         RawKeyDown,
110         KeyDown,
111         KeyUp,
112         Char,
113
114         // WebGestureEvent
115         GestureScrollBegin,
116         GestureScrollEnd,
117         GestureScrollUpdate,
118         GestureScrollUpdateWithoutPropagation,
119         GestureFlingStart,
120         GestureFlingCancel,
121         GestureTap,
122         GestureTapDown,
123         GestureTapCancel,
124         GestureDoubleTap,
125         GestureTwoFingerTap,
126         GestureLongPress,
127         GestureLongTap,
128         GesturePinchBegin,
129         GesturePinchEnd,
130         GesturePinchUpdate,
131
132         // WebTouchEvent
133         TouchStart,
134         TouchMove,
135         TouchEnd,
136         TouchCancel,
137     };
138
139     enum Modifiers {
140         // modifiers for all events:
141         ShiftKey         = 1 << 0,
142         ControlKey       = 1 << 1,
143         AltKey           = 1 << 2,
144         MetaKey          = 1 << 3,
145
146         // modifiers for keyboard events:
147         IsKeyPad         = 1 << 4,
148         IsAutoRepeat     = 1 << 5,
149
150         // modifiers for mouse events:
151         LeftButtonDown   = 1 << 6,
152         MiddleButtonDown = 1 << 7,
153         RightButtonDown  = 1 << 8,
154
155         // Toggle modifiers for all events. Danger: these are not reflected
156         // into WebCore, so round-tripping from WebInputEvent to a WebCore
157         // event and back will not preserve these flags.
158         CapsLockOn       = 1 << 9,
159         NumLockOn        = 1 << 10,
160
161         // Left/right modifiers for keyboard events.
162         IsLeft           = 1 << 11,
163         IsRight          = 1 << 12,
164
165         // Last input event to be sent for the current vsync interval. If this
166         // flag is set, the sender guarantees that no more input events will be
167         // delivered until the next vsync and the receiver can schedule
168         // rendering accordingly. If it isn't set, the receiver should not make
169         // any assumptions about the delivery times of future input events
170         // w.r.t. vsync.
171         IsLastInputEventForCurrentVSync = 1 << 13,
172     };
173
174     static const int InputModifiers = ShiftKey | ControlKey | AltKey | MetaKey;
175
176     double timeStampSeconds; // Seconds since epoch.
177     unsigned size; // The size of this structure, for serialization.
178     Type type;
179     int modifiers;
180
181     // Returns true if the WebInputEvent |type| is a mouse event.
182     static bool isMouseEventType(int type)
183     {
184         return type == MouseDown
185             || type == MouseUp
186             || type == MouseMove
187             || type == MouseEnter
188             || type == MouseLeave
189             || type == ContextMenu;
190     }
191
192     // Returns true if the WebInputEvent |type| is a keyboard event.
193     static bool isKeyboardEventType(int type)
194     {
195         return type == RawKeyDown
196             || type == KeyDown
197             || type == KeyUp
198             || type == Char;
199     }
200
201     // Returns true if the WebInputEvent |type| is a touch event.
202     static bool isTouchEventType(int type)
203     {
204         return type == TouchStart
205             || type == TouchMove
206             || type == TouchEnd
207             || type == TouchCancel;
208     }
209
210     // Returns true if the WebInputEvent |type| should be handled as user gesture.
211     static bool isUserGestureEventType(int type)
212     {
213         return isKeyboardEventType(type)
214             || type == MouseDown
215             || type == MouseUp
216             || type == TouchStart
217             || type == TouchEnd;
218     }
219
220     // Returns true if the WebInputEvent is a gesture event.
221     static bool isGestureEventType(int type)
222     {
223         return type == GestureScrollBegin
224             || type == GestureScrollEnd
225             || type == GestureScrollUpdate
226             || type == GestureScrollUpdateWithoutPropagation
227             || type == GestureFlingStart
228             || type == GestureFlingCancel
229             || type == GesturePinchBegin
230             || type == GesturePinchEnd
231             || type == GesturePinchUpdate
232             || type == GestureTap
233             || type == GestureTapDown
234             || type == GestureTapCancel
235             || type == GestureDoubleTap
236             || type == GestureTwoFingerTap
237             || type == GestureLongPress
238             || type == GestureLongTap;
239     }
240 };
241
242 // WebKeyboardEvent -----------------------------------------------------------
243
244 class WebKeyboardEvent : public WebInputEvent {
245 public:
246     // Caps on string lengths so we can make them static arrays and keep
247     // them PODs.
248     static const size_t textLengthCap = 4;
249
250     // http://www.w3.org/TR/DOM-Level-3-Events/keyset.html lists the
251     // identifiers.  The longest is 18 characters, so we round up to the
252     // next multiple of 4.
253     static const size_t keyIdentifierLengthCap = 20;
254
255     // |windowsKeyCode| is the Windows key code associated with this key
256     // event.  Sometimes it's direct from the event (i.e. on Windows),
257     // sometimes it's via a mapping function.  If you want a list, see
258     // WebCore/platform/chromium/KeyboardCodes* . Note that this should
259     // ALWAYS store the non-locational version of a keycode as this is
260     // what is returned by the Windows API. For example, it should
261     // store VK_SHIFT instead of VK_RSHIFT. The location information
262     // should be stored in |modifiers|.
263     int windowsKeyCode;
264
265     // The actual key code genenerated by the platform.  The DOM spec runs
266     // on Windows-equivalent codes (thus |windowsKeyCode| above) but it
267     // doesn't hurt to have this one around.
268     int nativeKeyCode;
269
270     // This identifies whether this event was tagged by the system as being
271     // a "system key" event (see
272     // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx for
273     // details). Other platforms don't have this concept, but it's just
274     // easier to leave it always false than ifdef.
275     // See comment at the top of the file for why an int is used here.
276     bool isSystemKey;
277
278     // |text| is the text generated by this keystroke.  |unmodifiedText| is
279     // |text|, but unmodified by an concurrently-held modifiers (except
280     // shift).  This is useful for working out shortcut keys.  Linux and
281     // Windows guarantee one character per event.  The Mac does not, but in
282     // reality that's all it ever gives.  We're generous, and cap it a bit
283     // longer.
284     WebUChar text[textLengthCap];
285     WebUChar unmodifiedText[textLengthCap];
286
287     // This is a string identifying the key pressed.
288     char keyIdentifier[keyIdentifierLengthCap];
289
290     WebKeyboardEvent(unsigned sizeParam = sizeof(WebKeyboardEvent))
291         : WebInputEvent(sizeParam)
292         , windowsKeyCode(0)
293         , nativeKeyCode(0)
294         , isSystemKey(false)
295     {
296         memset(&text, 0, sizeof(text));
297         memset(&unmodifiedText, 0, sizeof(unmodifiedText));
298         memset(&keyIdentifier, 0, sizeof(keyIdentifier));
299     }
300
301     // Sets keyIdentifier based on the value of windowsKeyCode.  This is
302     // handy for generating synthetic keyboard events.
303     WEBKIT_EXPORT void setKeyIdentifierFromWindowsKeyCode();
304
305     static int windowsKeyCodeWithoutLocation(int keycode);
306     static int locationModifiersFromWindowsKeyCode(int keycode);
307 };
308
309 // WebMouseEvent --------------------------------------------------------------
310
311 class WebMouseEvent : public WebInputEvent {
312 public:
313     // These values defined for WebCore::MouseButton
314     enum Button {
315         ButtonNone = -1,
316         ButtonLeft,
317         ButtonMiddle,
318         ButtonRight
319     };
320
321     Button button;
322     int x;
323     int y;
324     int windowX;
325     int windowY;
326     int globalX;
327     int globalY;
328     int movementX;
329     int movementY;
330     int clickCount;
331
332     WebMouseEvent(unsigned sizeParam = sizeof(WebMouseEvent))
333         : WebInputEvent(sizeParam)
334         , button(ButtonNone)
335         , x(0)
336         , y(0)
337         , windowX(0)
338         , windowY(0)
339         , globalX(0)
340         , globalY(0)
341         , movementX(0)
342         , movementY(0)
343         , clickCount(0)
344     {
345     }
346 };
347
348 // WebMouseWheelEvent ---------------------------------------------------------
349
350 class WebMouseWheelEvent : public WebMouseEvent {
351 public:
352     enum Phase {
353         PhaseNone        = 0,
354         PhaseBegan       = 1 << 0,
355         PhaseStationary  = 1 << 1,
356         PhaseChanged     = 1 << 2,
357         PhaseEnded       = 1 << 3,
358         PhaseCancelled   = 1 << 4,
359         PhaseMayBegin    = 1 << 5,
360     };
361
362     float deltaX;
363     float deltaY;
364     float wheelTicksX;
365     float wheelTicksY;
366
367     float accelerationRatioX;
368     float accelerationRatioY;
369
370     // See comment at the top of the file for why an int is used here.
371     int scrollByPage;
372
373     // See comment at the top of the file for why an int is used here.
374     int hasPreciseScrollingDeltas;
375     Phase phase;
376     Phase momentumPhase;
377
378     WebMouseWheelEvent(unsigned sizeParam = sizeof(WebMouseWheelEvent))
379         : WebMouseEvent(sizeParam)
380         , deltaX(0.0f)
381         , deltaY(0.0f)
382         , wheelTicksX(0.0f)
383         , wheelTicksY(0.0f)
384         , accelerationRatioX(1.0f)
385         , accelerationRatioY(1.0f)
386         , scrollByPage(false)
387         , hasPreciseScrollingDeltas(false)
388         , phase(PhaseNone)
389         , momentumPhase(PhaseNone)
390     {
391     }
392 };
393
394 // WebGestureEvent --------------------------------------------------------------
395
396 class WebGestureEvent : public WebInputEvent {
397 public:
398     enum SourceDevice {
399         Touchpad,
400         Touchscreen,
401     };
402
403     int x;
404     int y;
405     int globalX;
406     int globalY;
407     SourceDevice sourceDevice;
408
409     union {
410         struct {
411             int tapCount;
412             float width;
413             float height;
414         } tap;
415
416         struct {
417             float width;
418             float height;
419         } tapDown;
420
421         struct {
422             float width;
423             float height;
424         } longPress;
425
426         struct {
427             float firstFingerWidth;
428             float firstFingerHeight;
429         } twoFingerTap;
430
431         struct {
432             float deltaX;
433             float deltaY;
434             float velocityX;
435             float velocityY;
436         } scrollUpdate;
437
438         struct {
439             float velocityX;
440             float velocityY;
441         } flingStart;
442
443         struct {
444             float scale;
445         } pinchUpdate;
446     } data;
447
448     WebGestureEvent(unsigned sizeParam = sizeof(WebGestureEvent))
449         : WebInputEvent(sizeParam)
450         , x(0)
451         , y(0)
452         , globalX(0)
453         , globalY(0)
454     {
455         memset(&data, 0, sizeof(data));
456     }
457 };
458
459 // WebTouchEvent --------------------------------------------------------------
460
461 class WebTouchEvent : public WebInputEvent {
462 public:
463     // Maximum number of simultaneous touches supported on
464     // Ash/Aura.
465     enum { touchesLengthCap = 12 };
466
467     unsigned touchesLength;
468     // List of all touches which are currently down.
469     WebTouchPoint touches[touchesLengthCap];
470
471     unsigned changedTouchesLength;
472     // List of all touches whose state has changed since the last WebTouchEvent
473     WebTouchPoint changedTouches[touchesLengthCap];
474
475     unsigned targetTouchesLength;
476     // List of all touches which are currently down and are targeting the event recipient.
477     WebTouchPoint targetTouches[touchesLengthCap];
478
479     WebTouchEvent(unsigned sizeParam = sizeof(WebTouchEvent))
480         : WebInputEvent(sizeParam)
481         , touchesLength(0)
482         , changedTouchesLength(0)
483         , targetTouchesLength(0)
484     {
485     }
486 };
487
488 #pragma pack(pop)
489
490 } // namespace WebKit
491
492 #endif