Commit | Line | Data |
---|---|---|
d1dc092f | 1 | /* |
2 | * (C) GraÅžvydas "notaz" Ignotas, 2012 | |
3 | * | |
4 | * This work is licensed under the terms of any of these licenses | |
5 | * (at your option): | |
6 | * - GNU GPL, version 2 or later. | |
7 | * - GNU LGPL, version 2.1 or later. | |
f89d8471 | 8 | * - MAME license. |
d1dc092f | 9 | * See the COPYING file in the top-level directory. |
10 | */ | |
11 | ||
12 | #include <stdio.h> | |
13 | #include <SDL.h> | |
14 | #include "input.h" | |
15 | #include "in_sdl.h" | |
16 | ||
17 | #define IN_SDL_PREFIX "sdl:" | |
18 | /* should be machine word for best performace */ | |
19 | typedef unsigned long keybits_t; | |
20 | #define KEYBITS_WORD_BITS (sizeof(keybits_t) * 8) | |
21 | ||
6407ad5b | 22 | struct in_sdl_state { |
c19e28f6 | 23 | const in_drv_t *drv; |
6407ad5b | 24 | SDL_Joystick *joy; |
25 | int joy_id; | |
26 | int axis_keydown[2]; | |
bededcb4 | 27 | #ifdef SDL_REDRAW_EVT |
28 | int rdraw; | |
29 | #endif | |
6407ad5b | 30 | keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1]; |
271f9001 | 31 | // emulator keys should always be processed immediately lest one is lost |
32 | keybits_t emu_keys[SDLK_LAST / KEYBITS_WORD_BITS + 1]; | |
6407ad5b | 33 | }; |
34 | ||
9227a777 | 35 | static void (*ext_event_handler)(void *event); |
36 | ||
d1dc092f | 37 | static const char * const in_sdl_keys[SDLK_LAST] = { |
38 | [SDLK_BACKSPACE] = "backspace", | |
39 | [SDLK_TAB] = "tab", | |
40 | [SDLK_CLEAR] = "clear", | |
41 | [SDLK_RETURN] = "return", | |
42 | [SDLK_PAUSE] = "pause", | |
43 | [SDLK_ESCAPE] = "escape", | |
44 | [SDLK_SPACE] = "space", | |
45 | [SDLK_EXCLAIM] = "!", | |
46 | [SDLK_QUOTEDBL] = "\"", | |
47 | [SDLK_HASH] = "#", | |
48 | [SDLK_DOLLAR] = "$", | |
49 | [SDLK_AMPERSAND] = "&", | |
50 | [SDLK_QUOTE] = "'", | |
51 | [SDLK_LEFTPAREN] = "(", | |
52 | [SDLK_RIGHTPAREN] = ")", | |
53 | [SDLK_ASTERISK] = "*", | |
54 | [SDLK_PLUS] = "+", | |
55 | [SDLK_COMMA] = ",", | |
56 | [SDLK_MINUS] = "-", | |
57 | [SDLK_PERIOD] = ".", | |
58 | [SDLK_SLASH] = "/", | |
59 | [SDLK_0] = "0", | |
60 | [SDLK_1] = "1", | |
61 | [SDLK_2] = "2", | |
62 | [SDLK_3] = "3", | |
63 | [SDLK_4] = "4", | |
64 | [SDLK_5] = "5", | |
65 | [SDLK_6] = "6", | |
66 | [SDLK_7] = "7", | |
67 | [SDLK_8] = "8", | |
68 | [SDLK_9] = "9", | |
69 | [SDLK_COLON] = ":", | |
d1f5849c | 70 | [SDLK_SEMICOLON] = ";", |
d1dc092f | 71 | [SDLK_LESS] = "<", |
72 | [SDLK_EQUALS] = "=", | |
73 | [SDLK_GREATER] = ">", | |
74 | [SDLK_QUESTION] = "?", | |
75 | [SDLK_AT] = "@", | |
76 | [SDLK_LEFTBRACKET] = "[", | |
77 | [SDLK_BACKSLASH] = "\\", | |
78 | [SDLK_RIGHTBRACKET] = "]", | |
79 | [SDLK_CARET] = "^", | |
80 | [SDLK_UNDERSCORE] = "_", | |
81 | [SDLK_BACKQUOTE] = "`", | |
82 | [SDLK_a] = "a", | |
83 | [SDLK_b] = "b", | |
84 | [SDLK_c] = "c", | |
85 | [SDLK_d] = "d", | |
86 | [SDLK_e] = "e", | |
87 | [SDLK_f] = "f", | |
88 | [SDLK_g] = "g", | |
89 | [SDLK_h] = "h", | |
90 | [SDLK_i] = "i", | |
91 | [SDLK_j] = "j", | |
92 | [SDLK_k] = "k", | |
93 | [SDLK_l] = "l", | |
94 | [SDLK_m] = "m", | |
95 | [SDLK_n] = "n", | |
96 | [SDLK_o] = "o", | |
97 | [SDLK_p] = "p", | |
98 | [SDLK_q] = "q", | |
99 | [SDLK_r] = "r", | |
100 | [SDLK_s] = "s", | |
101 | [SDLK_t] = "t", | |
102 | [SDLK_u] = "u", | |
103 | [SDLK_v] = "v", | |
104 | [SDLK_w] = "w", | |
105 | [SDLK_x] = "x", | |
106 | [SDLK_y] = "y", | |
107 | [SDLK_z] = "z", | |
108 | [SDLK_DELETE] = "delete", | |
109 | ||
110 | [SDLK_KP0] = "[0]", | |
111 | [SDLK_KP1] = "[1]", | |
112 | [SDLK_KP2] = "[2]", | |
113 | [SDLK_KP3] = "[3]", | |
114 | [SDLK_KP4] = "[4]", | |
115 | [SDLK_KP5] = "[5]", | |
116 | [SDLK_KP6] = "[6]", | |
117 | [SDLK_KP7] = "[7]", | |
118 | [SDLK_KP8] = "[8]", | |
119 | [SDLK_KP9] = "[9]", | |
120 | [SDLK_KP_PERIOD] = "[.]", | |
121 | [SDLK_KP_DIVIDE] = "[/]", | |
122 | [SDLK_KP_MULTIPLY] = "[*]", | |
123 | [SDLK_KP_MINUS] = "[-]", | |
124 | [SDLK_KP_PLUS] = "[+]", | |
125 | [SDLK_KP_ENTER] = "enter", | |
126 | [SDLK_KP_EQUALS] = "equals", | |
127 | ||
128 | [SDLK_UP] = "up", | |
129 | [SDLK_DOWN] = "down", | |
130 | [SDLK_RIGHT] = "right", | |
131 | [SDLK_LEFT] = "left", | |
d1dc092f | 132 | [SDLK_INSERT] = "insert", |
133 | [SDLK_HOME] = "home", | |
134 | [SDLK_END] = "end", | |
135 | [SDLK_PAGEUP] = "page up", | |
136 | [SDLK_PAGEDOWN] = "page down", | |
137 | ||
138 | [SDLK_F1] = "f1", | |
139 | [SDLK_F2] = "f2", | |
140 | [SDLK_F3] = "f3", | |
141 | [SDLK_F4] = "f4", | |
142 | [SDLK_F5] = "f5", | |
143 | [SDLK_F6] = "f6", | |
144 | [SDLK_F7] = "f7", | |
145 | [SDLK_F8] = "f8", | |
146 | [SDLK_F9] = "f9", | |
147 | [SDLK_F10] = "f10", | |
148 | [SDLK_F11] = "f11", | |
149 | [SDLK_F12] = "f12", | |
150 | [SDLK_F13] = "f13", | |
151 | [SDLK_F14] = "f14", | |
152 | [SDLK_F15] = "f15", | |
153 | ||
154 | [SDLK_NUMLOCK] = "numlock", | |
155 | [SDLK_CAPSLOCK] = "caps lock", | |
156 | [SDLK_SCROLLOCK] = "scroll lock", | |
157 | [SDLK_RSHIFT] = "right shift", | |
158 | [SDLK_LSHIFT] = "left shift", | |
159 | [SDLK_RCTRL] = "right ctrl", | |
160 | [SDLK_LCTRL] = "left ctrl", | |
161 | [SDLK_RALT] = "right alt", | |
162 | [SDLK_LALT] = "left alt", | |
163 | [SDLK_RMETA] = "right meta", | |
164 | [SDLK_LMETA] = "left meta", | |
165 | [SDLK_LSUPER] = "left super", /* "Windows" keys */ | |
166 | [SDLK_RSUPER] = "right super", | |
167 | [SDLK_MODE] = "alt gr", | |
168 | [SDLK_COMPOSE] = "compose", | |
169 | }; | |
170 | ||
c19e28f6 | 171 | static void in_sdl_probe(const in_drv_t *drv) |
d1dc092f | 172 | { |
d685ce46 PC |
173 | const struct in_pdata *pdata = drv->pdata; |
174 | const char * const * key_names = in_sdl_keys; | |
6407ad5b | 175 | struct in_sdl_state *state; |
176 | SDL_Joystick *joy; | |
177 | int i, joycount; | |
178 | char name[256]; | |
d1dc092f | 179 | |
d685ce46 PC |
180 | if (pdata->key_names) |
181 | key_names = pdata->key_names; | |
182 | ||
6407ad5b | 183 | state = calloc(1, sizeof(*state)); |
184 | if (state == NULL) { | |
d1dc092f | 185 | fprintf(stderr, "in_sdl: OOM\n"); |
186 | return; | |
187 | } | |
188 | ||
c19e28f6 | 189 | state->drv = drv; |
6407ad5b | 190 | in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST, |
d685ce46 | 191 | key_names, 0); |
6407ad5b | 192 | |
193 | /* joysticks go here too */ | |
194 | SDL_InitSubSystem(SDL_INIT_JOYSTICK); | |
195 | ||
196 | joycount = SDL_NumJoysticks(); | |
197 | for (i = 0; i < joycount; i++) { | |
198 | joy = SDL_JoystickOpen(i); | |
199 | if (joy == NULL) | |
200 | continue; | |
201 | ||
202 | state = calloc(1, sizeof(*state)); | |
203 | if (state == NULL) { | |
204 | fprintf(stderr, "in_sdl: OOM\n"); | |
205 | break; | |
206 | } | |
207 | state->joy = joy; | |
208 | state->joy_id = i; | |
c19e28f6 | 209 | state->drv = drv; |
6407ad5b | 210 | |
211 | snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i)); | |
d685ce46 | 212 | in_register(name, -1, state, SDLK_LAST, key_names, 0); |
6407ad5b | 213 | } |
214 | ||
215 | if (joycount > 0) | |
216 | SDL_JoystickEventState(SDL_ENABLE); | |
d1dc092f | 217 | } |
218 | ||
219 | static void in_sdl_free(void *drv_data) | |
220 | { | |
6407ad5b | 221 | struct in_sdl_state *state = drv_data; |
d1dc092f | 222 | |
6407ad5b | 223 | if (state != NULL) { |
224 | if (state->joy != NULL) | |
225 | SDL_JoystickClose(state->joy); | |
226 | free(state); | |
227 | } | |
d1dc092f | 228 | } |
229 | ||
230 | static const char * const * | |
d685ce46 | 231 | in_sdl_get_key_names(const in_drv_t *drv, int *count) |
d1dc092f | 232 | { |
d685ce46 | 233 | const struct in_pdata *pdata = drv->pdata; |
d1dc092f | 234 | *count = SDLK_LAST; |
d685ce46 PC |
235 | |
236 | if (pdata->key_names) | |
237 | return pdata->key_names; | |
d1dc092f | 238 | return in_sdl_keys; |
239 | } | |
240 | ||
241 | /* could use SDL_GetKeyState, but this gives better packing */ | |
242 | static void update_keystate(keybits_t *keystate, int sym, int is_down) | |
243 | { | |
244 | keybits_t *ks_word, mask; | |
245 | ||
246 | mask = 1; | |
247 | mask <<= sym & (KEYBITS_WORD_BITS - 1); | |
248 | ks_word = keystate + sym / KEYBITS_WORD_BITS; | |
249 | if (is_down) | |
250 | *ks_word |= mask; | |
251 | else | |
252 | *ks_word &= ~mask; | |
253 | } | |
254 | ||
271f9001 | 255 | static int get_keystate(keybits_t *keystate, int sym) |
256 | { | |
257 | keybits_t *ks_word, mask; | |
258 | ||
259 | mask = 1; | |
260 | mask <<= sym & (KEYBITS_WORD_BITS - 1); | |
261 | ks_word = keystate + sym / KEYBITS_WORD_BITS; | |
262 | return !!(*ks_word & mask); | |
263 | } | |
264 | ||
6407ad5b | 265 | static int handle_event(struct in_sdl_state *state, SDL_Event *event, |
271f9001 | 266 | int *kc_out, int *down_out, int *emu_out) |
d1dc092f | 267 | { |
271f9001 | 268 | int emu; |
269 | ||
6407ad5b | 270 | if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP) |
9227a777 | 271 | return -1; |
d1dc092f | 272 | |
271f9001 | 273 | emu = get_keystate(state->emu_keys, event->key.keysym.sym); |
6407ad5b | 274 | update_keystate(state->keystate, event->key.keysym.sym, |
275 | event->type == SDL_KEYDOWN); | |
276 | if (kc_out != NULL) | |
277 | *kc_out = event->key.keysym.sym; | |
278 | if (down_out != NULL) | |
279 | *down_out = event->type == SDL_KEYDOWN; | |
bededcb4 | 280 | if (emu_out != NULL) |
271f9001 | 281 | *emu_out = emu; |
6407ad5b | 282 | |
283 | return 1; | |
284 | } | |
d1dc092f | 285 | |
6407ad5b | 286 | static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event, |
271f9001 | 287 | int *kc_out, int *down_out, int *emu_out) |
6407ad5b | 288 | { |
271f9001 | 289 | int kc = -1, down = 0, emu = 0, ret = 0; |
6407ad5b | 290 | |
6407ad5b | 291 | /* TODO: remaining axis */ |
292 | switch (event->type) { | |
293 | case SDL_JOYAXISMOTION: | |
18306c32 VL |
294 | if (event->jaxis.which != state->joy_id) |
295 | return -2; | |
6407ad5b | 296 | if (event->jaxis.axis > 1) |
297 | break; | |
298 | if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) { | |
299 | kc = state->axis_keydown[event->jaxis.axis]; | |
300 | state->axis_keydown[event->jaxis.axis] = 0; | |
301 | ret = 1; | |
302 | } | |
303 | else if (event->jaxis.value < -16384) { | |
304 | kc = state->axis_keydown[event->jaxis.axis]; | |
271f9001 | 305 | if (kc) { |
306 | emu |= get_keystate(state->emu_keys, kc); | |
6407ad5b | 307 | update_keystate(state->keystate, kc, 0); |
271f9001 | 308 | } |
6407ad5b | 309 | kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT; |
310 | state->axis_keydown[event->jaxis.axis] = kc; | |
311 | down = 1; | |
312 | ret = 1; | |
313 | } | |
314 | else if (event->jaxis.value > 16384) { | |
315 | kc = state->axis_keydown[event->jaxis.axis]; | |
271f9001 | 316 | if (kc) { |
317 | emu |= get_keystate(state->emu_keys, kc); | |
6407ad5b | 318 | update_keystate(state->keystate, kc, 0); |
271f9001 | 319 | } |
6407ad5b | 320 | kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT; |
321 | state->axis_keydown[event->jaxis.axis] = kc; | |
322 | down = 1; | |
323 | ret = 1; | |
324 | } | |
325 | break; | |
326 | ||
327 | case SDL_JOYBUTTONDOWN: | |
328 | case SDL_JOYBUTTONUP: | |
18306c32 VL |
329 | if (event->jbutton.which != state->joy_id) |
330 | return -2; | |
6407ad5b | 331 | kc = (int)event->jbutton.button + SDLK_WORLD_0; |
332 | down = event->jbutton.state == SDL_PRESSED; | |
333 | ret = 1; | |
334 | break; | |
9227a777 | 335 | default: |
336 | return -1; | |
d1dc092f | 337 | } |
338 | ||
271f9001 | 339 | if (ret) { |
340 | emu |= get_keystate(state->emu_keys, kc); | |
6407ad5b | 341 | update_keystate(state->keystate, kc, down); |
271f9001 | 342 | } |
6407ad5b | 343 | if (kc_out != NULL) |
344 | *kc_out = kc; | |
345 | if (down_out != NULL) | |
346 | *down_out = down; | |
271f9001 | 347 | if (emu_out != 0) |
348 | *emu_out = emu; | |
6407ad5b | 349 | |
350 | return ret; | |
351 | } | |
352 | ||
353 | #define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \ | |
354 | | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK) | |
355 | ||
356 | static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down) | |
357 | { | |
358 | SDL_Event events[4]; | |
359 | Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS); | |
bededcb4 | 360 | int count, maxcount, is_emukey = 0; |
6407ad5b | 361 | int i, ret, retval = 0; |
18306c32 VL |
362 | int num_events, num_peeped_events; |
363 | SDL_Event *event; | |
6407ad5b | 364 | |
bededcb4 | 365 | #ifdef SDL_REDRAW_EVT |
366 | if (state->rdraw) { | |
367 | if (one_kc != NULL) | |
368 | *one_kc = SDLK_UNKNOWN; | |
369 | if (one_down != NULL) | |
370 | *one_down = 0; | |
371 | state->rdraw = 0; | |
372 | return 1; | |
373 | } | |
374 | #endif | |
6407ad5b | 375 | maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]); |
376 | ||
377 | SDL_PumpEvents(); | |
18306c32 VL |
378 | |
379 | num_events = SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, mask); | |
380 | ||
381 | for (num_peeped_events = 0; num_peeped_events < num_events; num_peeped_events += count) { | |
6407ad5b | 382 | count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask); |
383 | if (count <= 0) | |
384 | break; | |
385 | for (i = 0; i < count; i++) { | |
18306c32 | 386 | event = &events[i]; |
271f9001 | 387 | if (state->joy) { |
6407ad5b | 388 | ret = handle_joy_event(state, |
271f9001 | 389 | event, one_kc, one_down, &is_emukey); |
390 | } else { | |
6407ad5b | 391 | ret = handle_event(state, |
271f9001 | 392 | event, one_kc, one_down, &is_emukey); |
393 | } | |
18306c32 VL |
394 | if (ret < 0) { |
395 | switch (ret) { | |
396 | case -2: | |
397 | SDL_PushEvent(event); | |
398 | break; | |
399 | default: | |
400 | if (ext_event_handler != NULL) | |
401 | ext_event_handler(event); | |
402 | break; | |
403 | } | |
bededcb4 | 404 | #ifdef SDL_REDRAW_EVT |
405 | if (ret != -2 && event->type == SDL_VIDEORESIZE) { | |
406 | if (one_kc != NULL) | |
407 | *one_kc = SDLK_UNKNOWN; | |
408 | if (one_down != NULL) | |
409 | *one_down = 1; | |
410 | state->rdraw = 1; | |
411 | is_emukey = 1, ret = 1; | |
412 | } else | |
413 | continue; | |
414 | #endif | |
9227a777 | 415 | } |
416 | ||
6407ad5b | 417 | retval |= ret; |
bededcb4 | 418 | if ((is_emukey || one_kc != NULL) && retval) |
18306c32 VL |
419 | { |
420 | // don't lose events other devices might want to handle | |
271f9001 | 421 | if (++i < count) |
422 | SDL_PeepEvents(events+i, count-i, SDL_ADDEVENT, mask); | |
6407ad5b | 423 | goto out; |
18306c32 | 424 | } |
6407ad5b | 425 | } |
426 | } | |
427 | ||
428 | out: | |
429 | return retval; | |
430 | } | |
431 | ||
432 | static int in_sdl_update(void *drv_data, const int *binds, int *result) | |
433 | { | |
434 | struct in_sdl_state *state = drv_data; | |
435 | keybits_t mask; | |
436 | int i, sym, bit, b; | |
437 | ||
438 | collect_events(state, NULL, NULL); | |
439 | ||
d1dc092f | 440 | for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) { |
6407ad5b | 441 | mask = state->keystate[i]; |
d1dc092f | 442 | if (mask == 0) |
443 | continue; | |
444 | for (bit = 0; mask != 0; bit++, mask >>= 1) { | |
445 | if ((mask & 1) == 0) | |
446 | continue; | |
447 | sym = i * KEYBITS_WORD_BITS + bit; | |
448 | ||
449 | for (b = 0; b < IN_BINDTYPE_COUNT; b++) | |
450 | result[b] |= binds[IN_BIND_OFFS(sym, b)]; | |
451 | } | |
452 | } | |
453 | ||
454 | return 0; | |
455 | } | |
456 | ||
457 | static int in_sdl_update_keycode(void *drv_data, int *is_down) | |
458 | { | |
6407ad5b | 459 | struct in_sdl_state *state = drv_data; |
460 | int ret_kc = -1, ret_down = 0; | |
461 | ||
462 | collect_events(state, &ret_kc, &ret_down); | |
463 | ||
d1dc092f | 464 | if (is_down != NULL) |
465 | *is_down = ret_down; | |
466 | ||
467 | return ret_kc; | |
468 | } | |
469 | ||
d1dc092f | 470 | static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode) |
471 | { | |
6407ad5b | 472 | struct in_sdl_state *state = drv_data; |
c19e28f6 | 473 | const struct in_pdata *pdata = state->drv->pdata; |
d685ce46 | 474 | const char * const * key_names = in_sdl_keys; |
6407ad5b | 475 | const struct menu_keymap *map; |
476 | int map_len; | |
d1dc092f | 477 | int ret = 0; |
478 | int i; | |
479 | ||
d685ce46 PC |
480 | if (pdata->key_names) |
481 | key_names = pdata->key_names; | |
482 | ||
c19e28f6 PC |
483 | if (state->joy) { |
484 | map = pdata->joy_map; | |
485 | map_len = pdata->jmap_size; | |
486 | } else { | |
487 | map = pdata->key_map; | |
488 | map_len = pdata->kmap_size; | |
489 | } | |
6407ad5b | 490 | |
d1dc092f | 491 | if (keycode < 0) |
492 | { | |
493 | /* menu -> kc */ | |
494 | keycode = -keycode; | |
6407ad5b | 495 | for (i = 0; i < map_len; i++) |
496 | if (map[i].pbtn == keycode) | |
497 | return map[i].key; | |
d1dc092f | 498 | } |
499 | else | |
500 | { | |
bededcb4 | 501 | #ifdef SDL_REDRAW_EVT |
502 | if (keycode == SDLK_UNKNOWN) | |
503 | ret = PBTN_RDRAW; | |
504 | else | |
505 | #endif | |
6407ad5b | 506 | for (i = 0; i < map_len; i++) { |
507 | if (map[i].key == keycode) { | |
508 | ret = map[i].pbtn; | |
d1dc092f | 509 | break; |
510 | } | |
511 | } | |
512 | ||
513 | if (charcode != NULL && (unsigned int)keycode < SDLK_LAST && | |
d685ce46 | 514 | key_names[keycode] != NULL && key_names[keycode][1] == 0) |
d1dc092f | 515 | { |
516 | ret |= PBTN_CHAR; | |
d685ce46 | 517 | *charcode = key_names[keycode][0]; |
d1dc092f | 518 | } |
519 | } | |
520 | ||
521 | return ret; | |
522 | } | |
523 | ||
271f9001 | 524 | static int in_sdl_clean_binds(void *drv_data, int *binds, int *def_finds) |
525 | { | |
526 | struct in_sdl_state *state = drv_data; | |
527 | int i, t, cnt = 0; | |
528 | ||
529 | memset(state->emu_keys, 0, sizeof(state->emu_keys)); | |
530 | for (t = 0; t < IN_BINDTYPE_COUNT; t++) | |
531 | for (i = 0; i < SDLK_LAST; i++) | |
532 | if (binds[IN_BIND_OFFS(i, t)]) { | |
533 | if (t == IN_BINDTYPE_EMU) | |
534 | update_keystate(state->emu_keys, i, 1); | |
535 | cnt ++; | |
536 | } | |
537 | ||
538 | return cnt; | |
539 | } | |
540 | ||
d1dc092f | 541 | static const in_drv_t in_sdl_drv = { |
542 | .prefix = IN_SDL_PREFIX, | |
543 | .probe = in_sdl_probe, | |
544 | .free = in_sdl_free, | |
545 | .get_key_names = in_sdl_get_key_names, | |
546 | .update = in_sdl_update, | |
547 | .update_keycode = in_sdl_update_keycode, | |
548 | .menu_translate = in_sdl_menu_translate, | |
271f9001 | 549 | .clean_binds = in_sdl_clean_binds, |
d1dc092f | 550 | }; |
551 | ||
c19e28f6 | 552 | int in_sdl_init(const struct in_pdata *pdata, void (*handler)(void *event)) |
d1dc092f | 553 | { |
c19e28f6 PC |
554 | if (!pdata) { |
555 | fprintf(stderr, "in_sdl: Missing input platform data\n"); | |
556 | return -1; | |
557 | } | |
558 | ||
559 | in_register_driver(&in_sdl_drv, pdata->defbinds, pdata); | |
9227a777 | 560 | ext_event_handler = handler; |
c19e28f6 | 561 | return 0; |
d1dc092f | 562 | } |