@kmamal/sdl 0.9.5 → 0.9.6-1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +111 -103
- package/binding.gyp +25 -5
- package/package.json +7 -4
- package/src/javascript/audio/audio-instance.js +9 -6
- package/src/javascript/cleanup.js +1 -1
- package/src/javascript/clipboard/index.js +2 -1
- package/src/javascript/controller/controller-instance.js +7 -4
- package/src/javascript/enums.js +1 -9
- package/src/javascript/events/index.js +293 -305
- package/src/javascript/index.js +1 -1
- package/src/javascript/joystick/device.js +0 -3
- package/src/javascript/joystick/joystick-instance.js +8 -6
- package/src/javascript/keyboard/index.js +3 -3
- package/src/javascript/keyboard/key-mapping.js +14 -6
- package/src/javascript/mouse/index.js +14 -13
- package/src/javascript/power/index.js +1 -8
- package/src/javascript/sensor/sensor-instance.js +1 -5
- package/src/javascript/video/index.js +0 -5
- package/src/javascript/video/window.js +17 -16
- package/src/native/audio.cpp +178 -0
- package/src/native/audio.h +21 -0
- package/src/native/clipboard.cpp +45 -0
- package/src/native/clipboard.h +13 -0
- package/src/native/cocoa-global.h +8 -0
- package/src/native/cocoa-global.mm +8 -0
- package/src/native/cocoa-window.h +9 -4
- package/src/native/cocoa-window.mm +6 -9
- package/src/native/controller.cpp +160 -0
- package/src/native/controller.h +22 -0
- package/src/native/enums.cpp +339 -0
- package/src/native/enums.h +12 -0
- package/src/native/events.cpp +391 -0
- package/src/native/events.h +70 -0
- package/src/native/global.cpp +361 -0
- package/src/native/global.h +15 -0
- package/src/native/joystick.cpp +394 -0
- package/src/native/joystick.h +29 -0
- package/src/native/keyboard.cpp +51 -0
- package/src/native/keyboard.h +18 -0
- package/src/native/module.cpp +98 -0
- package/src/native/mouse.cpp +186 -0
- package/src/native/mouse.h +21 -0
- package/src/native/power.cpp +23 -0
- package/src/native/power.h +17 -0
- package/src/native/sensor.cpp +124 -0
- package/src/native/sensor.h +21 -0
- package/src/native/video.cpp +95 -0
- package/src/native/video.h +16 -0
- package/src/native/window.cpp +755 -0
- package/src/native/window.h +29 -0
- package/src/types/index.d.ts +91 -49
- package/scripts/test.mjs +0 -12
- package/src/native/asprintf.c +0 -47
- package/src/native/asprintf.h +0 -37
- package/src/native/binding.cpp +0 -1680
- package/src/native/sdl-helpers.cpp +0 -2617
- package/src/native/sdl-helpers.h +0 -182
|
@@ -0,0 +1,391 @@
|
|
|
1
|
+
#include "events.h"
|
|
2
|
+
#include "enums.h"
|
|
3
|
+
#include "global.h"
|
|
4
|
+
#include "joystick.h"
|
|
5
|
+
#include "controller.h"
|
|
6
|
+
#include "audio.h"
|
|
7
|
+
#include <SDL.h>
|
|
8
|
+
#include <string>
|
|
9
|
+
#include <sstream>
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
std::string events::families::DISPLAY;
|
|
13
|
+
std::string events::families::WINDOW;
|
|
14
|
+
std::string events::families::DROP;
|
|
15
|
+
std::string events::families::KEYBOARD;
|
|
16
|
+
std::string events::families::TEXT;
|
|
17
|
+
std::string events::families::MOUSE;
|
|
18
|
+
std::string events::families::JOYSTICK_DEVICE;
|
|
19
|
+
std::string events::families::JOYSTICK;
|
|
20
|
+
std::string events::families::CONTROLLER;
|
|
21
|
+
std::string events::families::SENSOR;
|
|
22
|
+
std::string events::families::AUDIO_DEVICE;
|
|
23
|
+
std::string events::families::CLIPBOARD;
|
|
24
|
+
|
|
25
|
+
std::string events::types::DISPLAY_ADD;
|
|
26
|
+
std::string events::types::DISPLAY_REMOVE;
|
|
27
|
+
std::string events::types::DISPLAY_ORIENT;
|
|
28
|
+
std::string events::types::SHOW;
|
|
29
|
+
std::string events::types::HIDE;
|
|
30
|
+
std::string events::types::EXPOSE;
|
|
31
|
+
std::string events::types::MOVE;
|
|
32
|
+
std::string events::types::RESIZE;
|
|
33
|
+
std::string events::types::MINIMIZE;
|
|
34
|
+
std::string events::types::MAXIMIZE;
|
|
35
|
+
std::string events::types::RESTORE;
|
|
36
|
+
std::string events::types::FOCUS;
|
|
37
|
+
std::string events::types::BLUR;
|
|
38
|
+
std::string events::types::HOVER;
|
|
39
|
+
std::string events::types::LEAVE;
|
|
40
|
+
std::string events::types::KEY_DOWN;
|
|
41
|
+
std::string events::types::KEY_UP;
|
|
42
|
+
std::string events::types::TEXT_INPUT;
|
|
43
|
+
std::string events::types::MOUSE_MOVE;
|
|
44
|
+
std::string events::types::MOUSE_BUTTON_DOWN;
|
|
45
|
+
std::string events::types::MOUSE_BUTTON_UP;
|
|
46
|
+
std::string events::types::MOUSE_WHEEL;
|
|
47
|
+
std::string events::types::DROP_BEGIN;
|
|
48
|
+
std::string events::types::DROP_COMPLETE;
|
|
49
|
+
std::string events::types::DROP_FILE;
|
|
50
|
+
std::string events::types::DROP_TEXT;
|
|
51
|
+
std::string events::types::CLOSE;
|
|
52
|
+
std::string events::types::DEVICE_ADD;
|
|
53
|
+
std::string events::types::DEVICE_REMOVE;
|
|
54
|
+
std::string events::types::AXIS_MOTION;
|
|
55
|
+
std::string events::types::BUTTON_DOWN;
|
|
56
|
+
std::string events::types::BUTTON_UP;
|
|
57
|
+
std::string events::types::BALL_MOTION;
|
|
58
|
+
std::string events::types::HAT_MOTION;
|
|
59
|
+
std::string events::types::REMAP;
|
|
60
|
+
std::string events::types::UPDATE;
|
|
61
|
+
|
|
62
|
+
|
|
63
|
+
Napi::Env *poll_env = nullptr;
|
|
64
|
+
Napi::Function *poll_callback = nullptr;
|
|
65
|
+
|
|
66
|
+
Napi::Object
|
|
67
|
+
packageEvent (Napi::Env &env, const SDL_Event &event)
|
|
68
|
+
{
|
|
69
|
+
Napi::Object result = Napi::Object::New(env);
|
|
70
|
+
|
|
71
|
+
switch (event.type) {
|
|
72
|
+
case SDL_DISPLAYEVENT: {
|
|
73
|
+
result.Set("family", events::families::DISPLAY);
|
|
74
|
+
result.Set("displayIndex", Napi::Number::New(env, event.display.display));
|
|
75
|
+
|
|
76
|
+
switch (event.display.event) {
|
|
77
|
+
case SDL_DISPLAYEVENT_CONNECTED: { result.Set("type", events::types::DISPLAY_ADD); break; }
|
|
78
|
+
case SDL_DISPLAYEVENT_DISCONNECTED: { result.Set("type", events::types::DISPLAY_REMOVE); break; }
|
|
79
|
+
case SDL_DISPLAYEVENT_ORIENTATION: { result.Set("type", events::types::DISPLAY_ORIENT); break; }
|
|
80
|
+
}
|
|
81
|
+
break;
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
case SDL_WINDOWEVENT: {
|
|
85
|
+
result.Set("family", events::families::WINDOW);
|
|
86
|
+
result.Set("windowId", Napi::Number::New(env, event.window.windowID));
|
|
87
|
+
|
|
88
|
+
switch (event.window.event) {
|
|
89
|
+
case SDL_WINDOWEVENT_SHOWN: { result.Set("type", events::types::SHOW); break; }
|
|
90
|
+
case SDL_WINDOWEVENT_HIDDEN: { result.Set("type", events::types::HIDE); break; }
|
|
91
|
+
case SDL_WINDOWEVENT_EXPOSED: { result.Set("type", events::types::EXPOSE); break; }
|
|
92
|
+
case SDL_WINDOWEVENT_MOVED: {
|
|
93
|
+
result.Set("type", events::types::MOVE);
|
|
94
|
+
result.Set("x", Napi::Number::New(env, event.window.data1));
|
|
95
|
+
result.Set("y", Napi::Number::New(env, event.window.data2));
|
|
96
|
+
break;
|
|
97
|
+
}
|
|
98
|
+
case SDL_WINDOWEVENT_SIZE_CHANGED: {
|
|
99
|
+
SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
|
|
100
|
+
if (window == nullptr) {
|
|
101
|
+
std::ostringstream message;
|
|
102
|
+
message << "SDL_GetWindowFromID() error: " << SDL_GetError();
|
|
103
|
+
SDL_ClearError();
|
|
104
|
+
throw Napi::Error::New(env, message.str());
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
int pixel_width, pixel_height;
|
|
108
|
+
SDL_GetWindowSizeInPixels(window, &pixel_width, &pixel_height);
|
|
109
|
+
|
|
110
|
+
result.Set("type", events::types::RESIZE);
|
|
111
|
+
result.Set("width", Napi::Number::New(env, event.window.data1));
|
|
112
|
+
result.Set("height", Napi::Number::New(env, event.window.data2));
|
|
113
|
+
result.Set("pixelWidth", Napi::Number::New(env, pixel_width));
|
|
114
|
+
result.Set("pixelHeight", Napi::Number::New(env, pixel_height));
|
|
115
|
+
break;
|
|
116
|
+
}
|
|
117
|
+
case SDL_WINDOWEVENT_MINIMIZED: { result.Set("type", events::types::MINIMIZE); break; }
|
|
118
|
+
case SDL_WINDOWEVENT_MAXIMIZED: { result.Set("type", events::types::MAXIMIZE); break; }
|
|
119
|
+
case SDL_WINDOWEVENT_RESTORED: { result.Set("type", events::types::RESTORE); break; }
|
|
120
|
+
case SDL_WINDOWEVENT_FOCUS_GAINED: { result.Set("type", events::types::FOCUS); break; }
|
|
121
|
+
case SDL_WINDOWEVENT_FOCUS_LOST: { result.Set("type", events::types::BLUR); break; }
|
|
122
|
+
case SDL_WINDOWEVENT_ENTER: { result.Set("type", events::types::HOVER); break; }
|
|
123
|
+
case SDL_WINDOWEVENT_LEAVE: { result.Set("type", events::types::LEAVE); break; }
|
|
124
|
+
case SDL_WINDOWEVENT_CLOSE: { result.Set("type", events::types::CLOSE); break; }
|
|
125
|
+
}
|
|
126
|
+
break;
|
|
127
|
+
}
|
|
128
|
+
|
|
129
|
+
case SDL_DROPBEGIN:
|
|
130
|
+
case SDL_DROPCOMPLETE: {
|
|
131
|
+
result.Set("family", events::families::DROP);
|
|
132
|
+
result.Set("type", event.type == SDL_DROPBEGIN ? events::types::DROP_BEGIN : events::types::DROP_COMPLETE);
|
|
133
|
+
result.Set("windowId", Napi::Number::New(env, event.drop.windowID));
|
|
134
|
+
break;
|
|
135
|
+
}
|
|
136
|
+
case SDL_DROPFILE:
|
|
137
|
+
case SDL_DROPTEXT: {
|
|
138
|
+
result.Set("family", events::families::DROP);
|
|
139
|
+
bool is_file = event.type == SDL_DROPFILE;
|
|
140
|
+
result.Set("type", is_file ? events::types::DROP_FILE : events::types::DROP_TEXT);
|
|
141
|
+
result.Set("windowId", Napi::Number::New(env, event.drop.windowID));
|
|
142
|
+
result.Set(is_file ? "file" : "text", Napi::String::New(env, event.drop.file));
|
|
143
|
+
break;
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
case SDL_KEYDOWN:
|
|
147
|
+
case SDL_KEYUP: {
|
|
148
|
+
result.Set("family", events::families::KEYBOARD);
|
|
149
|
+
result.Set("type", event.type == SDL_KEYDOWN ? events::types::KEY_DOWN : events::types::KEY_UP);
|
|
150
|
+
result.Set("windowId", Napi::Number::New(env, event.key.windowID));
|
|
151
|
+
|
|
152
|
+
SDL_Keysym symbol = event.key.keysym;
|
|
153
|
+
result.Set("scancode", Napi::Number::New(env, symbol.scancode));
|
|
154
|
+
|
|
155
|
+
const char *name = SDL_GetKeyName(symbol.sym);
|
|
156
|
+
if (name[0] != '\0') {
|
|
157
|
+
result.Set("key", Napi::String::New(env, name));
|
|
158
|
+
}
|
|
159
|
+
else {
|
|
160
|
+
result.Set("key", env.Null());
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
if (event.type == SDL_KEYDOWN) {
|
|
164
|
+
result.Set("repeat", Napi::Boolean::New(env, !!event.key.repeat));
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
result.Set("alt", Napi::Boolean::New(env, !!(symbol.mod & KMOD_ALT)));
|
|
168
|
+
result.Set("ctrl", Napi::Boolean::New(env, !!(symbol.mod & KMOD_CTRL)));
|
|
169
|
+
result.Set("shift", Napi::Boolean::New(env, !!(symbol.mod & KMOD_SHIFT)));
|
|
170
|
+
result.Set("super", Napi::Boolean::New(env, !!(symbol.mod & KMOD_GUI)));
|
|
171
|
+
result.Set("altgr", Napi::Boolean::New(env, !!(symbol.mod & KMOD_MODE)));
|
|
172
|
+
result.Set("numlock", Napi::Boolean::New(env, !!(symbol.mod & KMOD_NUM)));
|
|
173
|
+
result.Set("capslock", Napi::Boolean::New(env, !!(symbol.mod & KMOD_CAPS)));
|
|
174
|
+
break;
|
|
175
|
+
}
|
|
176
|
+
|
|
177
|
+
case SDL_TEXTINPUT: {
|
|
178
|
+
result.Set("family", events::families::TEXT);
|
|
179
|
+
result.Set("type", events::types::TEXT_INPUT);
|
|
180
|
+
result.Set("windowId", Napi::Number::New(env, event.text.windowID));
|
|
181
|
+
result.Set("text", Napi::String::New(env, event.text.text));
|
|
182
|
+
break ;
|
|
183
|
+
}
|
|
184
|
+
|
|
185
|
+
case SDL_MOUSEMOTION: {
|
|
186
|
+
result.Set("family", events::families::MOUSE);
|
|
187
|
+
result.Set("type", events::types::MOUSE_MOVE);
|
|
188
|
+
result.Set("windowId", Napi::Number::New(env, event.motion.windowID));
|
|
189
|
+
result.Set("touch", Napi::Boolean::New(env, event.motion.which == SDL_TOUCH_MOUSEID));
|
|
190
|
+
result.Set("x", Napi::Number::New(env, event.motion.x));
|
|
191
|
+
result.Set("y", Napi::Number::New(env, event.motion.y));
|
|
192
|
+
break;
|
|
193
|
+
}
|
|
194
|
+
case SDL_MOUSEBUTTONDOWN:
|
|
195
|
+
case SDL_MOUSEBUTTONUP: {
|
|
196
|
+
result.Set("family", events::families::MOUSE);
|
|
197
|
+
result.Set("type", event.type == SDL_MOUSEBUTTONDOWN ? events::types::MOUSE_BUTTON_DOWN : events::types::MOUSE_BUTTON_UP);
|
|
198
|
+
result.Set("windowId", Napi::Number::New(env, event.button.windowID));
|
|
199
|
+
result.Set("touch", Napi::Boolean::New(env, event.button.which == SDL_TOUCH_MOUSEID));
|
|
200
|
+
result.Set("button", Napi::Number::New(env, event.button.button));
|
|
201
|
+
result.Set("x", Napi::Number::New(env, event.button.x));
|
|
202
|
+
result.Set("y", Napi::Number::New(env, event.button.y));
|
|
203
|
+
break;
|
|
204
|
+
}
|
|
205
|
+
case SDL_MOUSEWHEEL: {
|
|
206
|
+
result.Set("family", events::families::MOUSE);
|
|
207
|
+
result.Set("type", events::types::MOUSE_WHEEL);
|
|
208
|
+
result.Set("windowId", Napi::Number::New(env, event.wheel.windowID));
|
|
209
|
+
result.Set("touch", Napi::Boolean::New(env, event.wheel.which == SDL_TOUCH_MOUSEID));
|
|
210
|
+
|
|
211
|
+
int x, y;
|
|
212
|
+
SDL_GetMouseState(&x, &y);
|
|
213
|
+
result.Set("x", Napi::Number::New(env, x));
|
|
214
|
+
result.Set("y", Napi::Number::New(env, y));
|
|
215
|
+
|
|
216
|
+
result.Set("dx", Napi::Number::New(env, event.wheel.x));
|
|
217
|
+
result.Set("dy", Napi::Number::New(env, event.wheel.y));
|
|
218
|
+
result.Set("flipped", Napi::Boolean::New(env, event.wheel.direction));
|
|
219
|
+
break;
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
case SDL_JOYDEVICEADDED: {
|
|
223
|
+
result.Set("family", events::families::JOYSTICK_DEVICE);
|
|
224
|
+
result.Set("type", events::types::DEVICE_ADD);
|
|
225
|
+
result.Set("devices", joystick::_getDevices(env));
|
|
226
|
+
break;
|
|
227
|
+
}
|
|
228
|
+
case SDL_JOYDEVICEREMOVED: {
|
|
229
|
+
result.Set("family", events::families::JOYSTICK_DEVICE);
|
|
230
|
+
result.Set("type", events::types::DEVICE_REMOVE);
|
|
231
|
+
result.Set("joystickId", Napi::Number::New(env, event.jdevice.which));
|
|
232
|
+
result.Set("devices", joystick::_getDevices(env));
|
|
233
|
+
break;
|
|
234
|
+
}
|
|
235
|
+
|
|
236
|
+
case SDL_JOYAXISMOTION: {
|
|
237
|
+
result.Set("family", events::families::JOYSTICK);
|
|
238
|
+
result.Set("type", events::types::AXIS_MOTION);
|
|
239
|
+
result.Set("joystickId", Napi::Number::New(env, event.jaxis.which));
|
|
240
|
+
result.Set("axis", Napi::Number::New(env, event.jaxis.axis));
|
|
241
|
+
result.Set("value", Napi::Number::New(env, joystick::mapAxis(event.jaxis.value)));
|
|
242
|
+
break ;
|
|
243
|
+
}
|
|
244
|
+
case SDL_JOYBALLMOTION: {
|
|
245
|
+
result.Set("family", events::families::JOYSTICK);
|
|
246
|
+
result.Set("type", events::types::BALL_MOTION);
|
|
247
|
+
result.Set("joystickId", Napi::Number::New(env, event.jball.which));
|
|
248
|
+
result.Set("ball", Napi::Number::New(env, event.jball.ball));
|
|
249
|
+
result.Set("x", Napi::Number::New(env, event.jball.xrel));
|
|
250
|
+
result.Set("y", Napi::Number::New(env, event.jball.yrel));
|
|
251
|
+
break ;
|
|
252
|
+
}
|
|
253
|
+
case SDL_JOYBUTTONDOWN:
|
|
254
|
+
case SDL_JOYBUTTONUP: {
|
|
255
|
+
result.Set("family", events::families::JOYSTICK);
|
|
256
|
+
result.Set("type", event.type == SDL_JOYBUTTONDOWN ? events::types::BUTTON_DOWN : events::types::BUTTON_UP);
|
|
257
|
+
result.Set("joystickId", Napi::Number::New(env, event.jbutton.which));
|
|
258
|
+
result.Set("button", Napi::Number::New(env, event.jbutton.button));
|
|
259
|
+
break ;
|
|
260
|
+
}
|
|
261
|
+
case SDL_JOYHATMOTION: {
|
|
262
|
+
result.Set("family", events::families::JOYSTICK);
|
|
263
|
+
result.Set("type", events::types::HAT_MOTION);
|
|
264
|
+
result.Set("joystickId", Napi::Number::New(env, event.jhat.which));
|
|
265
|
+
result.Set("hat", Napi::Number::New(env, event.jhat.hat));
|
|
266
|
+
result.Set("value", joystick::hat_positions[event.jhat.value]);
|
|
267
|
+
break ;
|
|
268
|
+
}
|
|
269
|
+
|
|
270
|
+
case SDL_CONTROLLERDEVICEREMAPPED: {
|
|
271
|
+
result.Set("family", events::families::CONTROLLER);
|
|
272
|
+
result.Set("type", events::types::REMAP);
|
|
273
|
+
SDL_JoystickID controller_id = event.cdevice.which;
|
|
274
|
+
result.Set("controllerId", Napi::Number::New(env, controller_id));
|
|
275
|
+
|
|
276
|
+
SDL_GameController *controller = SDL_GameControllerFromInstanceID(controller_id);
|
|
277
|
+
if (controller == nullptr) {
|
|
278
|
+
std::ostringstream message;
|
|
279
|
+
message << "SDL_GameControllerFromInstanceID(" << controller_id << ") error: " << SDL_GetError();
|
|
280
|
+
SDL_ClearError();
|
|
281
|
+
throw Napi::Error::New(env, message.str());
|
|
282
|
+
}
|
|
283
|
+
|
|
284
|
+
controller::getState(env, controller, result);
|
|
285
|
+
break;
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
case SDL_CONTROLLERAXISMOTION: {
|
|
289
|
+
result.Set("family", events::families::CONTROLLER);
|
|
290
|
+
result.Set("type", events::types::AXIS_MOTION);
|
|
291
|
+
result.Set("controllerId", Napi::Number::New(env, event.caxis.which));
|
|
292
|
+
result.Set("axis", controller::axes[(SDL_GameControllerAxis) event.caxis.axis]);
|
|
293
|
+
result.Set("value", Napi::Number::New(env, joystick::mapAxis(event.caxis.value)));
|
|
294
|
+
break;
|
|
295
|
+
}
|
|
296
|
+
case SDL_CONTROLLERBUTTONDOWN:
|
|
297
|
+
case SDL_CONTROLLERBUTTONUP: {
|
|
298
|
+
result.Set("family", events::families::CONTROLLER);
|
|
299
|
+
result.Set("type", event.type == SDL_CONTROLLERBUTTONDOWN ? events::types::BUTTON_DOWN : events::types::BUTTON_UP);
|
|
300
|
+
result.Set("controllerId", Napi::Number::New(env, event.cbutton.which));
|
|
301
|
+
result.Set("button", controller::buttons[(SDL_GameControllerButton) event.cbutton.button]);
|
|
302
|
+
break;
|
|
303
|
+
}
|
|
304
|
+
|
|
305
|
+
case SDL_SENSORUPDATE: {
|
|
306
|
+
result.Set("family", events::families::SENSOR);
|
|
307
|
+
result.Set("type", events::types::UPDATE);
|
|
308
|
+
result.Set("sensorId", Napi::Number::New(env, event.sensor.which));
|
|
309
|
+
break;
|
|
310
|
+
}
|
|
311
|
+
|
|
312
|
+
case SDL_AUDIODEVICEADDED: {
|
|
313
|
+
result.Set("family", events::families::AUDIO_DEVICE);
|
|
314
|
+
result.Set("type", events::types::DEVICE_ADD);
|
|
315
|
+
bool is_capture = event.adevice.iscapture;
|
|
316
|
+
result.Set("isRecorder", Napi::Boolean::New(env, is_capture));
|
|
317
|
+
result.Set("devices", audio::_getDevices(env, is_capture));
|
|
318
|
+
break;
|
|
319
|
+
}
|
|
320
|
+
case SDL_AUDIODEVICEREMOVED: {
|
|
321
|
+
result.Set("family", events::families::AUDIO_DEVICE);
|
|
322
|
+
result.Set("type", events::types::DEVICE_REMOVE);
|
|
323
|
+
result.Set("audioId", Napi::Number::New(env, event.adevice.which));
|
|
324
|
+
bool is_capture = event.adevice.iscapture;
|
|
325
|
+
result.Set("isRecorder", Napi::Boolean::New(env, is_capture));
|
|
326
|
+
result.Set("devices", audio::_getDevices(env, is_capture));
|
|
327
|
+
break;
|
|
328
|
+
}
|
|
329
|
+
|
|
330
|
+
case SDL_CLIPBOARDUPDATE: {
|
|
331
|
+
result.Set("family", events::families::CLIPBOARD);
|
|
332
|
+
result.Set("type", events::types::UPDATE);
|
|
333
|
+
break;
|
|
334
|
+
}
|
|
335
|
+
|
|
336
|
+
// case SDL_FINGERUP:
|
|
337
|
+
// case SDL_FINGERDOWN: {
|
|
338
|
+
// SET_STRING(object, "type", event.type == SDL_FINGERUP
|
|
339
|
+
// ? "fingerUp"
|
|
340
|
+
// : "fingerDown");
|
|
341
|
+
// result.Set("touch_id", Napi::Number::New(env, event.tfinger.touchId));
|
|
342
|
+
// result.Set("finger_id", Napi::Number::New(env, event.tfinger.fingerId));
|
|
343
|
+
// result.Set("pressure", Napi::Number::New(env, event.tfinger.pressure));
|
|
344
|
+
// result.Set("x", Napi::Number::New(env, event.tfinger.x));
|
|
345
|
+
// result.Set("y", Napi::Number::New(env, event.tfinger.y));
|
|
346
|
+
// break;
|
|
347
|
+
// }
|
|
348
|
+
// case SDL_FINGERMOTION: {
|
|
349
|
+
// SET_STRING(object, "type", "fingerMotion");
|
|
350
|
+
// result.Set("touch_id", Napi::Number::New(env, event.tfinger.touchId));
|
|
351
|
+
// result.Set("finger_id", Napi::Number::New(env, event.tfinger.fingerId));
|
|
352
|
+
// result.Set("pressure", Napi::Number::New(env, event.tfinger.pressure));
|
|
353
|
+
// result.Set("x", Napi::Number::New(env, event.tfinger.x));
|
|
354
|
+
// result.Set("y", Napi::Number::New(env, event.tfinger.y));
|
|
355
|
+
// result.Set("dx", Napi::Number::New(env, event.tfinger.dx));
|
|
356
|
+
// result.Set("dy", Napi::Number::New(env, event.tfinger.dy));
|
|
357
|
+
// break;
|
|
358
|
+
// }
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
return result;
|
|
362
|
+
}
|
|
363
|
+
|
|
364
|
+
|
|
365
|
+
void
|
|
366
|
+
events::dispatchEvent(const SDL_Event &event)
|
|
367
|
+
{
|
|
368
|
+
if (poll_env == nullptr || poll_callback == nullptr) { return; }
|
|
369
|
+
|
|
370
|
+
Napi::Value packed = packageEvent(*poll_env, event);
|
|
371
|
+
poll_callback->Call(poll_env->Global(), { packed });
|
|
372
|
+
}
|
|
373
|
+
|
|
374
|
+
Napi::Value
|
|
375
|
+
events::poll (const Napi::CallbackInfo &info)
|
|
376
|
+
{
|
|
377
|
+
Napi::Env env = info.Env();
|
|
378
|
+
|
|
379
|
+
Napi::Function callback = info[0].As<Napi::Function>();
|
|
380
|
+
|
|
381
|
+
poll_env = &env;
|
|
382
|
+
poll_callback = &callback;
|
|
383
|
+
|
|
384
|
+
SDL_Event event;
|
|
385
|
+
while (SDL_PollEvent(&event)) { events::dispatchEvent(event); }
|
|
386
|
+
|
|
387
|
+
poll_env = nullptr;
|
|
388
|
+
poll_callback = nullptr;
|
|
389
|
+
|
|
390
|
+
return env.Undefined();
|
|
391
|
+
}
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
#ifndef _EVENTS_H_
|
|
2
|
+
#define _EVENTS_H_
|
|
3
|
+
|
|
4
|
+
#include <napi.h>
|
|
5
|
+
#include <SDL.h>
|
|
6
|
+
#include <string>
|
|
7
|
+
|
|
8
|
+
namespace events {
|
|
9
|
+
|
|
10
|
+
namespace families {
|
|
11
|
+
extern std::string DISPLAY;
|
|
12
|
+
extern std::string WINDOW;
|
|
13
|
+
extern std::string DROP;
|
|
14
|
+
extern std::string KEYBOARD;
|
|
15
|
+
extern std::string TEXT;
|
|
16
|
+
extern std::string MOUSE;
|
|
17
|
+
extern std::string JOYSTICK_DEVICE;
|
|
18
|
+
extern std::string JOYSTICK;
|
|
19
|
+
extern std::string CONTROLLER;
|
|
20
|
+
extern std::string SENSOR;
|
|
21
|
+
extern std::string AUDIO_DEVICE;
|
|
22
|
+
extern std::string CLIPBOARD;
|
|
23
|
+
};
|
|
24
|
+
|
|
25
|
+
namespace types {
|
|
26
|
+
extern std::string DISPLAY_ADD;
|
|
27
|
+
extern std::string DISPLAY_REMOVE;
|
|
28
|
+
extern std::string DISPLAY_ORIENT;
|
|
29
|
+
extern std::string SHOW;
|
|
30
|
+
extern std::string HIDE;
|
|
31
|
+
extern std::string EXPOSE;
|
|
32
|
+
extern std::string MOVE;
|
|
33
|
+
extern std::string RESIZE;
|
|
34
|
+
extern std::string MINIMIZE;
|
|
35
|
+
extern std::string MAXIMIZE;
|
|
36
|
+
extern std::string RESTORE;
|
|
37
|
+
extern std::string FOCUS;
|
|
38
|
+
extern std::string BLUR;
|
|
39
|
+
extern std::string HOVER;
|
|
40
|
+
extern std::string LEAVE;
|
|
41
|
+
extern std::string KEY_DOWN;
|
|
42
|
+
extern std::string KEY_UP;
|
|
43
|
+
extern std::string TEXT_INPUT;
|
|
44
|
+
extern std::string MOUSE_MOVE;
|
|
45
|
+
extern std::string MOUSE_BUTTON_DOWN;
|
|
46
|
+
extern std::string MOUSE_BUTTON_UP;
|
|
47
|
+
extern std::string MOUSE_WHEEL;
|
|
48
|
+
extern std::string DROP_BEGIN;
|
|
49
|
+
extern std::string DROP_COMPLETE;
|
|
50
|
+
extern std::string DROP_FILE;
|
|
51
|
+
extern std::string DROP_TEXT;
|
|
52
|
+
extern std::string CLOSE;
|
|
53
|
+
extern std::string DEVICE_ADD;
|
|
54
|
+
extern std::string DEVICE_REMOVE;
|
|
55
|
+
extern std::string AXIS_MOTION;
|
|
56
|
+
extern std::string BUTTON_DOWN;
|
|
57
|
+
extern std::string BUTTON_UP;
|
|
58
|
+
extern std::string BALL_MOTION;
|
|
59
|
+
extern std::string HAT_MOTION;
|
|
60
|
+
extern std::string REMAP;
|
|
61
|
+
extern std::string UPDATE;
|
|
62
|
+
};
|
|
63
|
+
|
|
64
|
+
void dispatchEvent(const SDL_Event &event);
|
|
65
|
+
|
|
66
|
+
Napi::Value poll(const Napi::CallbackInfo &info);
|
|
67
|
+
|
|
68
|
+
}; // namespace events
|
|
69
|
+
|
|
70
|
+
#endif // _EVENTS_H_
|