@kmamal/sdl 0.9.6-0 → 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.
@@ -8,6 +8,58 @@
8
8
  #include <string>
9
9
  #include <sstream>
10
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
+
11
63
  Napi::Env *poll_env = nullptr;
12
64
  Napi::Function *poll_callback = nullptr;
13
65
 
@@ -18,27 +70,27 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
18
70
 
19
71
  switch (event.type) {
20
72
  case SDL_DISPLAYEVENT: {
21
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::DISPLAY));
73
+ result.Set("family", events::families::DISPLAY);
22
74
  result.Set("displayIndex", Napi::Number::New(env, event.display.display));
23
75
 
24
76
  switch (event.display.event) {
25
- case SDL_DISPLAYEVENT_CONNECTED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::DISPLAY_ADD)); break; }
26
- case SDL_DISPLAYEVENT_DISCONNECTED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::DISPLAY_REMOVE)); break; }
27
- case SDL_DISPLAYEVENT_ORIENTATION: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::DISPLAY_ORIENT)); break; }
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; }
28
80
  }
29
81
  break;
30
82
  }
31
83
 
32
84
  case SDL_WINDOWEVENT: {
33
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::WINDOW));
85
+ result.Set("family", events::families::WINDOW);
34
86
  result.Set("windowId", Napi::Number::New(env, event.window.windowID));
35
87
 
36
88
  switch (event.window.event) {
37
- case SDL_WINDOWEVENT_SHOWN: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::SHOW)); break; }
38
- case SDL_WINDOWEVENT_HIDDEN: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::HIDE)); break; }
39
- case SDL_WINDOWEVENT_EXPOSED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::EXPOSE)); break; }
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; }
40
92
  case SDL_WINDOWEVENT_MOVED: {
41
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::MOVE));
93
+ result.Set("type", events::types::MOVE);
42
94
  result.Set("x", Napi::Number::New(env, event.window.data1));
43
95
  result.Set("y", Napi::Number::New(env, event.window.data2));
44
96
  break;
@@ -55,37 +107,37 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
55
107
  int pixel_width, pixel_height;
56
108
  SDL_GetWindowSizeInPixels(window, &pixel_width, &pixel_height);
57
109
 
58
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::RESIZE));
110
+ result.Set("type", events::types::RESIZE);
59
111
  result.Set("width", Napi::Number::New(env, event.window.data1));
60
112
  result.Set("height", Napi::Number::New(env, event.window.data2));
61
113
  result.Set("pixelWidth", Napi::Number::New(env, pixel_width));
62
114
  result.Set("pixelHeight", Napi::Number::New(env, pixel_height));
63
115
  break;
64
116
  }
65
- case SDL_WINDOWEVENT_MINIMIZED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::MINIMIZE)); break; }
66
- case SDL_WINDOWEVENT_MAXIMIZED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::MAXIMIZE)); break; }
67
- case SDL_WINDOWEVENT_RESTORED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::RESTORE)); break; }
68
- case SDL_WINDOWEVENT_FOCUS_GAINED: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::FOCUS)); break; }
69
- case SDL_WINDOWEVENT_FOCUS_LOST: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::BLUR)); break; }
70
- case SDL_WINDOWEVENT_ENTER: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::HOVER)); break; }
71
- case SDL_WINDOWEVENT_LEAVE: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::LEAVE)); break; }
72
- case SDL_WINDOWEVENT_CLOSE: { result.Set("type", Napi::Number::New(env, (int) enums::EventType::CLOSE)); break; }
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; }
73
125
  }
74
126
  break;
75
127
  }
76
128
 
77
129
  case SDL_DROPBEGIN:
78
130
  case SDL_DROPCOMPLETE: {
79
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::DROP));
80
- result.Set("type", Napi::Number::New(env, (int) (event.type == SDL_DROPBEGIN ? enums::EventType::DROP_BEGIN : enums::EventType::DROP_COMPLETE)));
131
+ result.Set("family", events::families::DROP);
132
+ result.Set("type", event.type == SDL_DROPBEGIN ? events::types::DROP_BEGIN : events::types::DROP_COMPLETE);
81
133
  result.Set("windowId", Napi::Number::New(env, event.drop.windowID));
82
134
  break;
83
135
  }
84
136
  case SDL_DROPFILE:
85
137
  case SDL_DROPTEXT: {
86
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::DROP));
138
+ result.Set("family", events::families::DROP);
87
139
  bool is_file = event.type == SDL_DROPFILE;
88
- result.Set("type", Napi::Number::New(env, (int) (is_file ? enums::EventType::DROP_FILE : enums::EventType::DROP_TEXT)));
140
+ result.Set("type", is_file ? events::types::DROP_FILE : events::types::DROP_TEXT);
89
141
  result.Set("windowId", Napi::Number::New(env, event.drop.windowID));
90
142
  result.Set(is_file ? "file" : "text", Napi::String::New(env, event.drop.file));
91
143
  break;
@@ -93,8 +145,8 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
93
145
 
94
146
  case SDL_KEYDOWN:
95
147
  case SDL_KEYUP: {
96
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::KEYBOARD));
97
- result.Set("type", Napi::Number::New(env, (int) (event.type == SDL_KEYDOWN ? enums::EventType::KEY_DOWN : enums::EventType::KEY_UP)));
148
+ result.Set("family", events::families::KEYBOARD);
149
+ result.Set("type", event.type == SDL_KEYDOWN ? events::types::KEY_DOWN : events::types::KEY_UP);
98
150
  result.Set("windowId", Napi::Number::New(env, event.key.windowID));
99
151
 
100
152
  SDL_Keysym symbol = event.key.keysym;
@@ -123,16 +175,16 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
123
175
  }
124
176
 
125
177
  case SDL_TEXTINPUT: {
126
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::TEXT));
127
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::TEXT_INPUT));
178
+ result.Set("family", events::families::TEXT);
179
+ result.Set("type", events::types::TEXT_INPUT);
128
180
  result.Set("windowId", Napi::Number::New(env, event.text.windowID));
129
181
  result.Set("text", Napi::String::New(env, event.text.text));
130
182
  break ;
131
183
  }
132
184
 
133
185
  case SDL_MOUSEMOTION: {
134
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::MOUSE));
135
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::MOUSE_MOVE));
186
+ result.Set("family", events::families::MOUSE);
187
+ result.Set("type", events::types::MOUSE_MOVE);
136
188
  result.Set("windowId", Napi::Number::New(env, event.motion.windowID));
137
189
  result.Set("touch", Napi::Boolean::New(env, event.motion.which == SDL_TOUCH_MOUSEID));
138
190
  result.Set("x", Napi::Number::New(env, event.motion.x));
@@ -141,8 +193,8 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
141
193
  }
142
194
  case SDL_MOUSEBUTTONDOWN:
143
195
  case SDL_MOUSEBUTTONUP: {
144
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::MOUSE));
145
- result.Set("type", Napi::Number::New(env, (int) (event.type == SDL_MOUSEBUTTONDOWN ? enums::EventType::MOUSE_BUTTON_DOWN : enums::EventType::MOUSE_BUTTON_UP)));
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);
146
198
  result.Set("windowId", Napi::Number::New(env, event.button.windowID));
147
199
  result.Set("touch", Napi::Boolean::New(env, event.button.which == SDL_TOUCH_MOUSEID));
148
200
  result.Set("button", Napi::Number::New(env, event.button.button));
@@ -151,8 +203,8 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
151
203
  break;
152
204
  }
153
205
  case SDL_MOUSEWHEEL: {
154
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::MOUSE));
155
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::MOUSE_WHEEL));
206
+ result.Set("family", events::families::MOUSE);
207
+ result.Set("type", events::types::MOUSE_WHEEL);
156
208
  result.Set("windowId", Napi::Number::New(env, event.wheel.windowID));
157
209
  result.Set("touch", Napi::Boolean::New(env, event.wheel.which == SDL_TOUCH_MOUSEID));
158
210
 
@@ -168,30 +220,30 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
168
220
  }
169
221
 
170
222
  case SDL_JOYDEVICEADDED: {
171
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::JOYSTICK_DEVICE));
172
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::DEVICE_ADD));
223
+ result.Set("family", events::families::JOYSTICK_DEVICE);
224
+ result.Set("type", events::types::DEVICE_ADD);
173
225
  result.Set("devices", joystick::_getDevices(env));
174
226
  break;
175
227
  }
176
228
  case SDL_JOYDEVICEREMOVED: {
177
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::JOYSTICK_DEVICE));
178
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::DEVICE_REMOVE));
229
+ result.Set("family", events::families::JOYSTICK_DEVICE);
230
+ result.Set("type", events::types::DEVICE_REMOVE);
179
231
  result.Set("joystickId", Napi::Number::New(env, event.jdevice.which));
180
232
  result.Set("devices", joystick::_getDevices(env));
181
233
  break;
182
234
  }
183
235
 
184
236
  case SDL_JOYAXISMOTION: {
185
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::JOYSTICK));
186
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::AXIS_MOTION));
237
+ result.Set("family", events::families::JOYSTICK);
238
+ result.Set("type", events::types::AXIS_MOTION);
187
239
  result.Set("joystickId", Napi::Number::New(env, event.jaxis.which));
188
240
  result.Set("axis", Napi::Number::New(env, event.jaxis.axis));
189
241
  result.Set("value", Napi::Number::New(env, joystick::mapAxis(event.jaxis.value)));
190
242
  break ;
191
243
  }
192
244
  case SDL_JOYBALLMOTION: {
193
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::JOYSTICK));
194
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::BALL_MOTION));
245
+ result.Set("family", events::families::JOYSTICK);
246
+ result.Set("type", events::types::BALL_MOTION);
195
247
  result.Set("joystickId", Napi::Number::New(env, event.jball.which));
196
248
  result.Set("ball", Napi::Number::New(env, event.jball.ball));
197
249
  result.Set("x", Napi::Number::New(env, event.jball.xrel));
@@ -200,24 +252,24 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
200
252
  }
201
253
  case SDL_JOYBUTTONDOWN:
202
254
  case SDL_JOYBUTTONUP: {
203
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::JOYSTICK));
204
- result.Set("type", Napi::Number::New(env, (int) (event.type == SDL_JOYBUTTONDOWN ? enums::EventType::BUTTON_DOWN : enums::EventType::BUTTON_UP)));
255
+ result.Set("family", events::families::JOYSTICK);
256
+ result.Set("type", event.type == SDL_JOYBUTTONDOWN ? events::types::BUTTON_DOWN : events::types::BUTTON_UP);
205
257
  result.Set("joystickId", Napi::Number::New(env, event.jbutton.which));
206
258
  result.Set("button", Napi::Number::New(env, event.jbutton.button));
207
259
  break ;
208
260
  }
209
261
  case SDL_JOYHATMOTION: {
210
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::JOYSTICK));
211
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::HAT_MOTION));
262
+ result.Set("family", events::families::JOYSTICK);
263
+ result.Set("type", events::types::HAT_MOTION);
212
264
  result.Set("joystickId", Napi::Number::New(env, event.jhat.which));
213
265
  result.Set("hat", Napi::Number::New(env, event.jhat.hat));
214
- result.Set("value", Napi::Number::New(env, event.jhat.value));
266
+ result.Set("value", joystick::hat_positions[event.jhat.value]);
215
267
  break ;
216
268
  }
217
269
 
218
270
  case SDL_CONTROLLERDEVICEREMAPPED: {
219
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::CONTROLLER));
220
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::REMAP));
271
+ result.Set("family", events::families::CONTROLLER);
272
+ result.Set("type", events::types::REMAP);
221
273
  SDL_JoystickID controller_id = event.cdevice.which;
222
274
  result.Set("controllerId", Napi::Number::New(env, controller_id));
223
275
 
@@ -234,40 +286,40 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
234
286
  }
235
287
 
236
288
  case SDL_CONTROLLERAXISMOTION: {
237
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::CONTROLLER));
238
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::AXIS_MOTION));
289
+ result.Set("family", events::families::CONTROLLER);
290
+ result.Set("type", events::types::AXIS_MOTION);
239
291
  result.Set("controllerId", Napi::Number::New(env, event.caxis.which));
240
- result.Set("axis", Napi::Number::New(env, event.caxis.axis));
292
+ result.Set("axis", controller::axes[(SDL_GameControllerAxis) event.caxis.axis]);
241
293
  result.Set("value", Napi::Number::New(env, joystick::mapAxis(event.caxis.value)));
242
294
  break;
243
295
  }
244
296
  case SDL_CONTROLLERBUTTONDOWN:
245
297
  case SDL_CONTROLLERBUTTONUP: {
246
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::CONTROLLER));
247
- result.Set("type", Napi::Number::New(env, (int) (event.type == SDL_CONTROLLERBUTTONDOWN ? enums::EventType::BUTTON_DOWN : enums::EventType::BUTTON_UP)));
298
+ result.Set("family", events::families::CONTROLLER);
299
+ result.Set("type", event.type == SDL_CONTROLLERBUTTONDOWN ? events::types::BUTTON_DOWN : events::types::BUTTON_UP);
248
300
  result.Set("controllerId", Napi::Number::New(env, event.cbutton.which));
249
- result.Set("button", Napi::Number::New(env, event.cbutton.button));
301
+ result.Set("button", controller::buttons[(SDL_GameControllerButton) event.cbutton.button]);
250
302
  break;
251
303
  }
252
304
 
253
305
  case SDL_SENSORUPDATE: {
254
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::SENSOR));
255
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::UPDATE));
306
+ result.Set("family", events::families::SENSOR);
307
+ result.Set("type", events::types::UPDATE);
256
308
  result.Set("sensorId", Napi::Number::New(env, event.sensor.which));
257
309
  break;
258
310
  }
259
311
 
260
312
  case SDL_AUDIODEVICEADDED: {
261
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::AUDIO_DEVICE));
262
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::DEVICE_ADD));
313
+ result.Set("family", events::families::AUDIO_DEVICE);
314
+ result.Set("type", events::types::DEVICE_ADD);
263
315
  bool is_capture = event.adevice.iscapture;
264
316
  result.Set("isRecorder", Napi::Boolean::New(env, is_capture));
265
317
  result.Set("devices", audio::_getDevices(env, is_capture));
266
318
  break;
267
319
  }
268
320
  case SDL_AUDIODEVICEREMOVED: {
269
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::AUDIO_DEVICE));
270
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::DEVICE_REMOVE));
321
+ result.Set("family", events::families::AUDIO_DEVICE);
322
+ result.Set("type", events::types::DEVICE_REMOVE);
271
323
  result.Set("audioId", Napi::Number::New(env, event.adevice.which));
272
324
  bool is_capture = event.adevice.iscapture;
273
325
  result.Set("isRecorder", Napi::Boolean::New(env, is_capture));
@@ -276,8 +328,8 @@ packageEvent (Napi::Env &env, const SDL_Event &event)
276
328
  }
277
329
 
278
330
  case SDL_CLIPBOARDUPDATE: {
279
- result.Set("family", Napi::Number::New(env, (int) enums::EventFamily::CLIPBOARD));
280
- result.Set("type", Napi::Number::New(env, (int) enums::EventType::UPDATE));
331
+ result.Set("family", events::families::CLIPBOARD);
332
+ result.Set("type", events::types::UPDATE);
281
333
  break;
282
334
  }
283
335
 
@@ -3,9 +3,64 @@
3
3
 
4
4
  #include <napi.h>
5
5
  #include <SDL.h>
6
+ #include <string>
6
7
 
7
8
  namespace events {
8
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
+
9
64
  void dispatchEvent(const SDL_Event &event);
10
65
 
11
66
  Napi::Value poll(const Napi::CallbackInfo &info);
@@ -1,9 +1,15 @@
1
1
  #include "global.h"
2
2
  #include "events.h"
3
3
  #include "keyboard.h"
4
+ #include "video.h"
5
+ #include "joystick.h"
6
+ #include "controller.h"
7
+ #include "sensor.h"
8
+ #include "power.h"
4
9
  #include <SDL.h>
5
10
  #include <string>
6
11
  #include <sstream>
12
+ #include <vector>
7
13
 
8
14
  #if defined(__MACOSX__)
9
15
  #include "cocoa-global.h"
@@ -20,7 +26,7 @@ int filterEvents(void*, SDL_Event *event) {
20
26
  int window_event_type = event->window.event;
21
27
  if (true
22
28
  && window_event_type != SDL_WINDOWEVENT_MOVED
23
- && window_event_type != SDL_WINDOWEVENT_RESIZED
29
+ && window_event_type != SDL_WINDOWEVENT_SIZE_CHANGED
24
30
  ) { return 1; }
25
31
 
26
32
  events::dispatchEvent(*event);
@@ -31,11 +37,179 @@ int filterEvents(void*, SDL_Event *event) {
31
37
 
32
38
  const char *global::no_error = nullptr;
33
39
 
40
+
34
41
  Napi::Value
35
42
  global::initialize(const Napi::CallbackInfo &info)
36
43
  {
37
44
  Napi::Env env = info.Env();
38
45
 
46
+
47
+ events::families::DISPLAY = "display";
48
+ events::families::WINDOW = "window";
49
+ events::families::DROP = "drop";
50
+ events::families::KEYBOARD = "keyboard";
51
+ events::families::TEXT = "text";
52
+ events::families::MOUSE = "mouse";
53
+ events::families::JOYSTICK_DEVICE = "joystickDevice";
54
+ events::families::JOYSTICK = "joystick";
55
+ events::families::CONTROLLER = "controller";
56
+ events::families::SENSOR = "sensor";
57
+ events::families::AUDIO_DEVICE = "audioDevice";
58
+ events::families::CLIPBOARD = "clipboard";
59
+
60
+ events::types::DISPLAY_ADD = "displayAdd";
61
+ events::types::DISPLAY_REMOVE = "displayRemove";
62
+ events::types::DISPLAY_ORIENT = "displayOrient";
63
+ events::types::SHOW = "show";
64
+ events::types::HIDE = "hide";
65
+ events::types::EXPOSE = "expose";
66
+ events::types::MOVE = "move";
67
+ events::types::RESIZE = "resize";
68
+ events::types::MINIMIZE = "minimize";
69
+ events::types::MAXIMIZE = "maximize";
70
+ events::types::RESTORE = "restore";
71
+ events::types::FOCUS = "focus";
72
+ events::types::BLUR = "blur";
73
+ events::types::HOVER = "hover";
74
+ events::types::LEAVE = "leave";
75
+ events::types::KEY_DOWN = "keyDown";
76
+ events::types::KEY_UP = "keyUp";
77
+ events::types::TEXT_INPUT = "textInput";
78
+ events::types::MOUSE_MOVE = "mouseMove";
79
+ events::types::MOUSE_BUTTON_DOWN = "mouseButtonDown";
80
+ events::types::MOUSE_BUTTON_UP = "mouseButtonUp";
81
+ events::types::MOUSE_WHEEL = "mouseWheel";
82
+ events::types::DROP_BEGIN = "dropBegin";
83
+ events::types::DROP_COMPLETE = "dropComplete";
84
+ events::types::DROP_FILE = "dropFile";
85
+ events::types::DROP_TEXT = "dropText";
86
+ events::types::CLOSE = "close";
87
+ events::types::DEVICE_ADD = "deviceAdd";
88
+ events::types::DEVICE_REMOVE = "deviceRemove";
89
+ events::types::AXIS_MOTION = "axisMotion";
90
+ events::types::BUTTON_DOWN = "buttonDown";
91
+ events::types::BUTTON_UP = "buttonUp";
92
+ events::types::BALL_MOTION = "ballMotion";
93
+ events::types::HAT_MOTION = "hatMotion";
94
+ events::types::REMAP = "remap";
95
+ events::types::UPDATE = "update";
96
+
97
+ video::formats[SDL_PIXELFORMAT_RGB332] = "rgb332";
98
+ video::formats[SDL_PIXELFORMAT_RGB444] = "rgb444";
99
+ video::formats[SDL_PIXELFORMAT_RGB555] = "rgb555";
100
+ video::formats[SDL_PIXELFORMAT_BGR555] = "bgr555";
101
+ video::formats[SDL_PIXELFORMAT_ARGB4444] = "argb4444";
102
+ video::formats[SDL_PIXELFORMAT_RGBA4444] = "rgba4444";
103
+ video::formats[SDL_PIXELFORMAT_ABGR4444] = "abgr4444";
104
+ video::formats[SDL_PIXELFORMAT_BGRA4444] = "bgra4444";
105
+ video::formats[SDL_PIXELFORMAT_ARGB1555] = "argb1555";
106
+ video::formats[SDL_PIXELFORMAT_RGBA5551] = "rgba5551";
107
+ video::formats[SDL_PIXELFORMAT_ABGR1555] = "abgr1555";
108
+ video::formats[SDL_PIXELFORMAT_BGRA5551] = "bgra5551";
109
+ video::formats[SDL_PIXELFORMAT_RGB565] = "rgb565";
110
+ video::formats[SDL_PIXELFORMAT_BGR565] = "bgr565";
111
+ video::formats[SDL_PIXELFORMAT_RGB24] = "rgb24";
112
+ video::formats[SDL_PIXELFORMAT_BGR24] = "bgr24";
113
+ video::formats[SDL_PIXELFORMAT_RGB888] = "rgb888";
114
+ video::formats[SDL_PIXELFORMAT_RGBX8888] = "rgbx8888";
115
+ video::formats[SDL_PIXELFORMAT_BGR888] = "bgr888";
116
+ video::formats[SDL_PIXELFORMAT_BGRX8888] = "bgrx8888";
117
+ video::formats[SDL_PIXELFORMAT_ARGB8888] = "argb8888";
118
+ video::formats[SDL_PIXELFORMAT_RGBA8888] = "rgba8888";
119
+ video::formats[SDL_PIXELFORMAT_ABGR8888] = "abgr8888";
120
+ video::formats[SDL_PIXELFORMAT_BGRA8888] = "bgra8888";
121
+ video::formats[SDL_PIXELFORMAT_ARGB2101010] = "argb2101010";
122
+ video::formats[SDL_PIXELFORMAT_RGBA32] = "rgba32";
123
+ video::formats[SDL_PIXELFORMAT_ARGB32] = "argb32";
124
+ video::formats[SDL_PIXELFORMAT_BGRA32] = "bgra32";
125
+ video::formats[SDL_PIXELFORMAT_ABGR32] = "abgr32";
126
+ video::formats[SDL_PIXELFORMAT_YV12] = "yv12";
127
+ video::formats[SDL_PIXELFORMAT_IYUV] = "iyuv";
128
+ video::formats[SDL_PIXELFORMAT_YUY2] = "yuy2";
129
+ video::formats[SDL_PIXELFORMAT_UYVY] = "uyvy";
130
+ video::formats[SDL_PIXELFORMAT_YVYU] = "yvyu";
131
+ video::formats[SDL_PIXELFORMAT_NV12] = "nv12";
132
+ video::formats[SDL_PIXELFORMAT_NV21] = "nv21";
133
+
134
+ // joystick::power_levels[SDL_JOYSTICK_POWER_UNKNOWN] = nullptr;
135
+ joystick::power_levels[SDL_JOYSTICK_POWER_EMPTY] = "empty";
136
+ joystick::power_levels[SDL_JOYSTICK_POWER_LOW] = "low";
137
+ joystick::power_levels[SDL_JOYSTICK_POWER_MEDIUM] = "medium";
138
+ joystick::power_levels[SDL_JOYSTICK_POWER_FULL] = "full";
139
+ joystick::power_levels[SDL_JOYSTICK_POWER_WIRED] = "wired";
140
+ joystick::power_levels[SDL_JOYSTICK_POWER_MAX] = "max";
141
+
142
+ // joystick::joystick_types[SDL_JOYSTICK_TYPE_UNKNOWN] = nullptr; // Only possible on error
143
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_GAMECONTROLLER] = "gamecontroller";
144
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_WHEEL] = "wheel";
145
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_ARCADE_STICK] = "arcadestick";
146
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_FLIGHT_STICK] = "flightstick";
147
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_DANCE_PAD] = "dancepad";
148
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_GUITAR] = "guitar";
149
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_DRUM_KIT] = "drumkit";
150
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_ARCADE_PAD] = "arcadepad";
151
+ joystick::joystick_types[SDL_JOYSTICK_TYPE_THROTTLE] = "throttle";
152
+
153
+ joystick::hat_positions[SDL_HAT_CENTERED] = "centered";
154
+ joystick::hat_positions[SDL_HAT_UP] = "up";
155
+ joystick::hat_positions[SDL_HAT_RIGHT] = "right";
156
+ joystick::hat_positions[SDL_HAT_DOWN] = "down";
157
+ joystick::hat_positions[SDL_HAT_LEFT] = "left";
158
+ joystick::hat_positions[SDL_HAT_RIGHTUP] = "rightup";
159
+ joystick::hat_positions[SDL_HAT_RIGHTDOWN] = "rightdown";
160
+ joystick::hat_positions[SDL_HAT_LEFTUP] = "leftup";
161
+ joystick::hat_positions[SDL_HAT_LEFTDOWN] = "leftdown";
162
+
163
+ controller::axes[SDL_CONTROLLER_AXIS_LEFTX] = "leftStickX";
164
+ controller::axes[SDL_CONTROLLER_AXIS_LEFTY] = "leftStickY";
165
+ controller::axes[SDL_CONTROLLER_AXIS_RIGHTX] = "rightStickX";
166
+ controller::axes[SDL_CONTROLLER_AXIS_RIGHTY] = "rightStickY";
167
+ controller::axes[SDL_CONTROLLER_AXIS_TRIGGERLEFT] = "leftTrigger";
168
+ controller::axes[SDL_CONTROLLER_AXIS_TRIGGERRIGHT] = "rightTrigger";
169
+
170
+ controller::buttons[SDL_CONTROLLER_BUTTON_DPAD_LEFT] = "dpadLeft";
171
+ controller::buttons[SDL_CONTROLLER_BUTTON_DPAD_RIGHT] = "dpadRight";
172
+ controller::buttons[SDL_CONTROLLER_BUTTON_DPAD_UP] = "dpadUp";
173
+ controller::buttons[SDL_CONTROLLER_BUTTON_DPAD_DOWN] = "dpadDown";
174
+ controller::buttons[SDL_CONTROLLER_BUTTON_A] = "a";
175
+ controller::buttons[SDL_CONTROLLER_BUTTON_B] = "b";
176
+ controller::buttons[SDL_CONTROLLER_BUTTON_X] = "x";
177
+ controller::buttons[SDL_CONTROLLER_BUTTON_Y] = "y";
178
+ controller::buttons[SDL_CONTROLLER_BUTTON_GUIDE] = "guide";
179
+ controller::buttons[SDL_CONTROLLER_BUTTON_BACK] = "back";
180
+ controller::buttons[SDL_CONTROLLER_BUTTON_START] = "start";
181
+ controller::buttons[SDL_CONTROLLER_BUTTON_LEFTSTICK] = "leftStick";
182
+ controller::buttons[SDL_CONTROLLER_BUTTON_RIGHTSTICK] = "rightStick";
183
+ controller::buttons[SDL_CONTROLLER_BUTTON_LEFTSHOULDER] = "leftShoulder";
184
+ controller::buttons[SDL_CONTROLLER_BUTTON_RIGHTSHOULDER] = "rightShoulder";
185
+ controller::buttons[SDL_CONTROLLER_BUTTON_PADDLE1] = "paddle1";
186
+ controller::buttons[SDL_CONTROLLER_BUTTON_PADDLE2] = "paddle2";
187
+ controller::buttons[SDL_CONTROLLER_BUTTON_PADDLE3] = "paddle3";
188
+ controller::buttons[SDL_CONTROLLER_BUTTON_PADDLE4] = "paddle4";
189
+
190
+ // sensor::types[SDL_SENSOR_UNKNOWN] = nullptr;
191
+ sensor::types[SDL_SENSOR_ACCEL] = "accelerometer";
192
+ sensor::types[SDL_SENSOR_GYRO] = "gyroscope";
193
+ sensor::types[SDL_SENSOR_ACCEL_L] = "accelerometer";
194
+ sensor::types[SDL_SENSOR_GYRO_L] = "gyroscope";
195
+ sensor::types[SDL_SENSOR_ACCEL_R] = "accelerometer";
196
+ sensor::types[SDL_SENSOR_GYRO_R] = "gyroscope";
197
+
198
+ // sensor::sides[SDL_SENSOR_UNKNOWN] = nullptr;
199
+ // sensor::sides[SDL_SENSOR_ACCEL] = nullptr;
200
+ // sensor::sides[SDL_SENSOR_GYRO] = nullptr;
201
+ sensor::sides[SDL_SENSOR_ACCEL_L] = "left";
202
+ sensor::sides[SDL_SENSOR_GYRO_L] = "left";
203
+ sensor::sides[SDL_SENSOR_ACCEL_R] = "right";
204
+ sensor::sides[SDL_SENSOR_GYRO_R] = "right";
205
+
206
+ // power::states[SDL_POWERSTATE_UNKNOWN] = nullptr;
207
+ power::states[SDL_POWERSTATE_NO_BATTERY] = "noBattery";
208
+ power::states[SDL_POWERSTATE_ON_BATTERY] = "battery";
209
+ power::states[SDL_POWERSTATE_CHARGING] = "charging";
210
+ power::states[SDL_POWERSTATE_CHARGED] = "charged";
211
+
212
+
39
213
  SDL_SetHint(SDL_HINT_FRAMEBUFFER_ACCELERATION, "0");
40
214
 
41
215
  if (SDL_Init(0
@@ -3,6 +3,12 @@
3
3
  #include <SDL.h>
4
4
  #include <string>
5
5
  #include <sstream>
6
+ #include <map>
7
+
8
+
9
+ std::map<Uint8, std::string> joystick::hat_positions;
10
+ std::map<SDL_JoystickType, std::string> joystick::joystick_types;
11
+ std::map<SDL_JoystickPowerLevel, std::string> joystick::power_levels;
6
12
 
7
13
 
8
14
  double
@@ -33,7 +39,7 @@ joystick::_getDevices (Napi::Env &env)
33
39
  throw Napi::Error::New(env, message.str());
34
40
  }
35
41
 
36
- int type = SDL_JoystickGetDeviceType(i);
42
+ SDL_JoystickType type = SDL_JoystickGetDeviceType(i);
37
43
  // This function can only error if the index is invalid.
38
44
 
39
45
  const char *name = SDL_JoystickNameForIndex(i);
@@ -89,7 +95,7 @@ joystick::_getDevices (Napi::Env &env)
89
95
  Napi::Object device = Napi::Object::New(env);
90
96
  device.Set("_index", Napi::Number::New(env, i));
91
97
  device.Set("id", Napi::Number::New(env, id));
92
- device.Set("type", Napi::Number::New(env, type));
98
+ device.Set("type", joystick::joystick_types[type]);
93
99
  device.Set("name", Napi::String::New(env, name));
94
100
  device.Set("path", Napi::String::New(env, path));
95
101
  device.Set("guid", Napi::String::New(env, guid_string));
@@ -222,8 +228,8 @@ joystick::open (const Napi::CallbackInfo &info)
222
228
  Napi::Array hats = Napi::Array::New(env, num_hats);
223
229
 
224
230
  for (int i = 0; i < num_hats; i++) {
225
- int position = SDL_JoystickGetHat(joystick, i);
226
- hats.Set(i, Napi::Number::New(env, position));
231
+ int hat_position = SDL_JoystickGetHat(joystick, i);
232
+ hats.Set(i, joystick::hat_positions[hat_position]);
227
233
  }
228
234
 
229
235
  Napi::Object result = Napi::Object::New(env);
@@ -256,10 +262,10 @@ joystick::getPower (const Napi::CallbackInfo &info)
256
262
  throw Napi::Error::New(env, message.str());
257
263
  }
258
264
 
259
- SDL_JoystickPowerLevel power = SDL_JoystickCurrentPowerLevel(joystick);
260
- if (power == SDL_JOYSTICK_POWER_UNKNOWN) { return env.Null(); }
265
+ SDL_JoystickPowerLevel power_level = SDL_JoystickCurrentPowerLevel(joystick);
266
+ if (power_level == SDL_JOYSTICK_POWER_UNKNOWN) { return env.Null(); }
261
267
 
262
- return Napi::Number::New(env, power);
268
+ return Napi::String::New(env, joystick::power_levels[power_level]);
263
269
  }
264
270
 
265
271
  Napi::Value