1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef PPAPI_C_PP_INPUT_EVENT_H_
#define PPAPI_C_PP_INPUT_EVENT_H_
/**
* @file
* Defines the API ...
*
* @addtogroup PP
* @{
*/
#include "ppapi/c/pp_bool.h"
#include "ppapi/c/pp_stdint.h"
#include "ppapi/c/pp_time.h"
typedef enum {
PP_INPUTEVENT_MOUSEBUTTON_NONE = -1,
PP_INPUTEVENT_MOUSEBUTTON_LEFT = 0,
PP_INPUTEVENT_MOUSEBUTTON_MIDDLE = 1,
PP_INPUTEVENT_MOUSEBUTTON_RIGHT = 2
} PP_InputEvent_MouseButton;
typedef enum {
PP_INPUTEVENT_TYPE_UNDEFINED = -1,
PP_INPUTEVENT_TYPE_MOUSEDOWN = 0,
PP_INPUTEVENT_TYPE_MOUSEUP = 1,
PP_INPUTEVENT_TYPE_MOUSEMOVE = 2,
PP_INPUTEVENT_TYPE_MOUSEENTER = 3,
PP_INPUTEVENT_TYPE_MOUSELEAVE = 4,
PP_INPUTEVENT_TYPE_MOUSEWHEEL = 5,
PP_INPUTEVENT_TYPE_RAWKEYDOWN = 6,
PP_INPUTEVENT_TYPE_KEYDOWN = 7,
PP_INPUTEVENT_TYPE_KEYUP = 8,
PP_INPUTEVENT_TYPE_CHAR = 9
} PP_InputEvent_Type;
typedef enum {
PP_INPUTEVENT_MODIFIER_SHIFTKEY = 1 << 0,
PP_INPUTEVENT_MODIFIER_CONTROLKEY = 1 << 1,
PP_INPUTEVENT_MODIFIER_ALTKEY = 1 << 2,
PP_INPUTEVENT_MODIFIER_METAKEY = 1 << 3,
PP_INPUTEVENT_MODIFIER_ISKEYPAD = 1 << 4,
PP_INPUTEVENT_MODIFIER_ISAUTOREPEAT = 1 << 5,
PP_INPUTEVENT_MODIFIER_LEFTBUTTONDOWN = 1 << 6,
PP_INPUTEVENT_MODIFIER_MIDDLEBUTTONDOWN = 1 << 7,
PP_INPUTEVENT_MODIFIER_RIGHTBUTTONDOWN = 1 << 8,
PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY = 1 << 9,
PP_INPUTEVENT_MODIFIER_NUMLOCKKEY = 1 << 10
} PP_InputEvent_Modifier;
/**
* An event representing a key up or down event.
*
* Key up and down events correspond to physical keys on the keyboard. The
* actual character that the user typed (if any) will be delivered in a
* "character" event.
*
* If the user kills focus on the plugin while a key is down, you may not get
* a key up event. For example, if the plugin has focus and the user presses
* and holds shift, the plugin will see a "shift down" message. Then if they
* click elsewhere on the web page, the plugin focus will be lost and no more
* input events will be delivered. If you depend on getting key up events, you
* will also want to handle "lost focus" as the equivalent of "all keys up."
*/
struct PP_InputEvent_Key {
/** A combination of the EVENT_MODIFIER flags. */
uint32_t modifier;
/**
* The key code.
*
* TODO(brettw) define what these actually are.
*/
uint32_t key_code;
};
/**
* An event representing a typed character.
*
* Normally, the program will receive a key down event, followed by a character
* event, followed by a key up event. The character event will have any
* modifier keys applied. Obvious examples are symbols, where Shift-5 gives you
* a '%'. The key down and up events will give you the scan code for the "5"
* key, and the character event will give you the '%' character.
*
* You may not get a character event for all key down if the key doesn't
* generate a character. Likewise, you may actually get multiple character
* events in a row. For example, some locales have an accent key that modifies
* the next character typed. You might get this stream of events: accent down,
* accent up (it didn't generate a character), letter key down, letter with
* accent character event (it was modified by the previous accent key), letter
* key up. If the letter can't be combined with the accent, like an umlaut and
* an 'R', the system might send unlaut down, umlaut up, 'R' key down, umlaut
* character ("whoops, I can't combine it with 'R', I better just send the raw
* unlaut so it isn't lost"), 'R' character event, 'R' key up.
*/
struct PP_InputEvent_Character {
/** A combination of the EVENT_MODIFIER flags. */
uint32_t modifier;
/**
* The character the user typed, as a single null-terminated UTF-8 character.
* Any unused bytes will be filled with null bytes. Since the maximum UTF-8
* character is 4 bytes, there will always be at least one null at the end
* so you can treat this as a null-termianted UTF-8 string.
*/
char text[5];
};
/** Represents a mouse event for everything other than the mouse wheel. */
struct PP_InputEvent_Mouse {
/** A combination of the EVENT_MODIFIER flags. */
uint32_t modifier;
/**
* Which button changed in the case of mouse down or up events. For mouse
* move, enter, and leave events, this will be PP_EVENT_MOUSEBUTTON_NONE.
*/
PP_InputEvent_MouseButton button;
/**
* The coordinates of the mouse when the event occurred.
*
* In most cases these coordinates will just be integers, but they may not
* be in some cases. For example, the plugin element might be arbitrarily
* scaled or transformed in the DOM, and translating a mouse event into the
* coordinate space of the plugin will give non-integer values.
*/
float x;
float y;
/** TODO(brettw) figure out exactly what this means. */
int32_t click_count;
};
struct PP_InputEvent_Wheel {
/** A combination of the EVENT_MODIFIER flags. */
uint32_t modifier;
float delta_x;
float delta_y;
float wheel_ticks_x;
float wheel_ticks_y;
PP_Bool scroll_by_page;
};
struct PP_InputEvent {
/** Identifies the type of the event. */
PP_InputEvent_Type type;
/**
* When this event was generated. This is not relative to any particular
* epoch, the most you can do is compare time stamps.
*/
PP_TimeTicks time_stamp;
/** Event-specific data. */
union {
struct PP_InputEvent_Key key;
struct PP_InputEvent_Character character;
struct PP_InputEvent_Mouse mouse;
struct PP_InputEvent_Wheel wheel;
/**
* Allows new events to be added without changing the size of this
* struct.
*/
char padding[64];
} u;
};
/**
* @}
* End of addtogroup PP
*/
#endif // PPAPI_C_PP_INPUT_EVENT_H_
|
