in_sdl.c

   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.
   8  *  - MAME license.
   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
  22 struct in_sdl_state {
  23         SDL_Joystick *joy;
  24         int joy_id;
  25         int axis_keydown[2];
  26         keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1];
  27 };
  28
  29 static void (*ext_event_handler)(void *event);
  30
  31 static const char * const in_sdl_keys[SDLK_LAST] = {
  32         [SDLK_BACKSPACE] = "backspace",
  33         [SDLK_TAB] = "tab",
  34         [SDLK_CLEAR] = "clear",
  35         [SDLK_RETURN] = "return",
  36         [SDLK_PAUSE] = "pause",
  37         [SDLK_ESCAPE] = "escape",
  38         [SDLK_SPACE] = "space",
  39         [SDLK_EXCLAIM]  = "!",
  40         [SDLK_QUOTEDBL]  = "\"",
  41         [SDLK_HASH]  = "#",
  42         [SDLK_DOLLAR]  = "$",
  43         [SDLK_AMPERSAND]  = "&",
  44         [SDLK_QUOTE] = "'",
  45         [SDLK_LEFTPAREN] = "(",
  46         [SDLK_RIGHTPAREN] = ")",
  47         [SDLK_ASTERISK] = "*",
  48         [SDLK_PLUS] = "+",
  49         [SDLK_COMMA] = ",",
  50         [SDLK_MINUS] = "-",
  51         [SDLK_PERIOD] = ".",
  52         [SDLK_SLASH] = "/",
  53         [SDLK_0] = "0",
  54         [SDLK_1] = "1",
  55         [SDLK_2] = "2",
  56         [SDLK_3] = "3",
  57         [SDLK_4] = "4",
  58         [SDLK_5] = "5",
  59         [SDLK_6] = "6",
  60         [SDLK_7] = "7",
  61         [SDLK_8] = "8",
  62         [SDLK_9] = "9",
  63         [SDLK_COLON] = ":",
  64         [SDLK_SEMICOLON] = ",",
  65         [SDLK_LESS] = "<",
  66         [SDLK_EQUALS] = "=",
  67         [SDLK_GREATER] = ">",
  68         [SDLK_QUESTION] = "?",
  69         [SDLK_AT] = "@",
  70         [SDLK_LEFTBRACKET] = "[",
  71         [SDLK_BACKSLASH] = "\\",
  72         [SDLK_RIGHTBRACKET] = "]",
  73         [SDLK_CARET] = "^",
  74         [SDLK_UNDERSCORE] = "_",
  75         [SDLK_BACKQUOTE] = "`",
  76         [SDLK_a] = "a",
  77         [SDLK_b] = "b",
  78         [SDLK_c] = "c",
  79         [SDLK_d] = "d",
  80         [SDLK_e] = "e",
  81         [SDLK_f] = "f",
  82         [SDLK_g] = "g",
  83         [SDLK_h] = "h",
  84         [SDLK_i] = "i",
  85         [SDLK_j] = "j",
  86         [SDLK_k] = "k",
  87         [SDLK_l] = "l",
  88         [SDLK_m] = "m",
  89         [SDLK_n] = "n",
  90         [SDLK_o] = "o",
  91         [SDLK_p] = "p",
  92         [SDLK_q] = "q",
  93         [SDLK_r] = "r",
  94         [SDLK_s] = "s",
  95         [SDLK_t] = "t",
  96         [SDLK_u] = "u",
  97         [SDLK_v] = "v",
  98         [SDLK_w] = "w",
  99         [SDLK_x] = "x",
 100         [SDLK_y] = "y",
 101         [SDLK_z] = "z",
 102         [SDLK_DELETE] = "delete",
 103
 104         [SDLK_KP0] = "[0]",
 105         [SDLK_KP1] = "[1]",
 106         [SDLK_KP2] = "[2]",
 107         [SDLK_KP3] = "[3]",
 108         [SDLK_KP4] = "[4]",
 109         [SDLK_KP5] = "[5]",
 110         [SDLK_KP6] = "[6]",
 111         [SDLK_KP7] = "[7]",
 112         [SDLK_KP8] = "[8]",
 113         [SDLK_KP9] = "[9]",
 114         [SDLK_KP_PERIOD] = "[.]",
 115         [SDLK_KP_DIVIDE] = "[/]",
 116         [SDLK_KP_MULTIPLY] = "[*]",
 117         [SDLK_KP_MINUS] = "[-]",
 118         [SDLK_KP_PLUS] = "[+]",
 119         [SDLK_KP_ENTER] = "enter",
 120         [SDLK_KP_EQUALS] = "equals",
 121
 122         [SDLK_UP] = "up",
 123         [SDLK_DOWN] = "down",
 124         [SDLK_RIGHT] = "right",
 125         [SDLK_LEFT] = "left",
 126         [SDLK_DOWN] = "down",
 127         [SDLK_INSERT] = "insert",
 128         [SDLK_HOME] = "home",
 129         [SDLK_END] = "end",
 130         [SDLK_PAGEUP] = "page up",
 131         [SDLK_PAGEDOWN] = "page down",
 132
 133         [SDLK_F1] = "f1",
 134         [SDLK_F2] = "f2",
 135         [SDLK_F3] = "f3",
 136         [SDLK_F4] = "f4",
 137         [SDLK_F5] = "f5",
 138         [SDLK_F6] = "f6",
 139         [SDLK_F7] = "f7",
 140         [SDLK_F8] = "f8",
 141         [SDLK_F9] = "f9",
 142         [SDLK_F10] = "f10",
 143         [SDLK_F11] = "f11",
 144         [SDLK_F12] = "f12",
 145         [SDLK_F13] = "f13",
 146         [SDLK_F14] = "f14",
 147         [SDLK_F15] = "f15",
 148
 149         [SDLK_NUMLOCK] = "numlock",
 150         [SDLK_CAPSLOCK] = "caps lock",
 151         [SDLK_SCROLLOCK] = "scroll lock",
 152         [SDLK_RSHIFT] = "right shift",
 153         [SDLK_LSHIFT] = "left shift",
 154         [SDLK_RCTRL] = "right ctrl",
 155         [SDLK_LCTRL] = "left ctrl",
 156         [SDLK_RALT] = "right alt",
 157         [SDLK_LALT] = "left alt",
 158         [SDLK_RMETA] = "right meta",
 159         [SDLK_LMETA] = "left meta",
 160         [SDLK_LSUPER] = "left super",   /* "Windows" keys */
 161         [SDLK_RSUPER] = "right super",
 162         [SDLK_MODE] = "alt gr",
 163         [SDLK_COMPOSE] = "compose",
 164 };
 165
 166 static void in_sdl_probe(void)
 167 {
 168         struct in_sdl_state *state;
 169         SDL_Joystick *joy;
 170         int i, joycount;
 171         char name[256];
 172
 173         state = calloc(1, sizeof(*state));
 174         if (state == NULL) {
 175                 fprintf(stderr, "in_sdl: OOM\n");
 176                 return;
 177         }
 178
 179         in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST,
 180                 in_sdl_keys, 0);
 181
 182         /* joysticks go here too */
 183         SDL_InitSubSystem(SDL_INIT_JOYSTICK);
 184
 185         joycount = SDL_NumJoysticks();
 186         for (i = 0; i < joycount; i++) {
 187                 joy = SDL_JoystickOpen(i);
 188                 if (joy == NULL)
 189                         continue;
 190
 191                 state = calloc(1, sizeof(*state));
 192                 if (state == NULL) {
 193                         fprintf(stderr, "in_sdl: OOM\n");
 194                         break;
 195                 }
 196                 state->joy = joy;
 197                 state->joy_id = i;
 198
 199                 snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
 200                 in_register(name, -1, state, SDLK_LAST, in_sdl_keys, 0);
 201         }
 202
 203         if (joycount > 0)
 204                 SDL_JoystickEventState(SDL_ENABLE);
 205 }
 206
 207 static void in_sdl_free(void *drv_data)
 208 {
 209         struct in_sdl_state *state = drv_data;
 210
 211         if (state != NULL) {
 212                 if (state->joy != NULL)
 213                         SDL_JoystickClose(state->joy);
 214                 free(state);
 215         }
 216 }
 217
 218 static const char * const *
 219 in_sdl_get_key_names(int *count)
 220 {
 221         *count = SDLK_LAST;
 222         return in_sdl_keys;
 223 }
 224
 225 /* could use SDL_GetKeyState, but this gives better packing */
 226 static void update_keystate(keybits_t *keystate, int sym, int is_down)
 227 {
 228         keybits_t *ks_word, mask;
 229
 230         mask = 1;
 231         mask <<= sym & (KEYBITS_WORD_BITS - 1);
 232         ks_word = keystate + sym / KEYBITS_WORD_BITS;
 233         if (is_down)
 234                 *ks_word |= mask;
 235         else
 236                 *ks_word &= ~mask;
 237 }
 238
 239 static int handle_event(struct in_sdl_state *state, SDL_Event *event,
 240         int *kc_out, int *down_out)
 241 {
 242         if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP)
 243                 return -1;
 244
 245         update_keystate(state->keystate, event->key.keysym.sym,
 246                 event->type == SDL_KEYDOWN);
 247         if (kc_out != NULL)
 248                 *kc_out = event->key.keysym.sym;
 249         if (down_out != NULL)
 250                 *down_out = event->type == SDL_KEYDOWN;
 251
 252         return 1;
 253 }
 254
 255 static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
 256         int *kc_out, int *down_out)
 257 {
 258         int kc = -1, down = 0, ret = 0;
 259
 260         /* FIXME: should ckeck .which */
 261         /* TODO: remaining axis */
 262         switch (event->type) {
 263         case SDL_JOYAXISMOTION:
 264                 if (event->jaxis.axis > 1)
 265                         break;
 266                 if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) {
 267                         kc = state->axis_keydown[event->jaxis.axis];
 268                         state->axis_keydown[event->jaxis.axis] = 0;
 269                         ret = 1;
 270                 }
 271                 else if (event->jaxis.value < -16384) {
 272                         kc = state->axis_keydown[event->jaxis.axis];
 273                         if (kc)
 274                                 update_keystate(state->keystate, kc, 0);
 275                         kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
 276                         state->axis_keydown[event->jaxis.axis] = kc;
 277                         down = 1;
 278                         ret = 1;
 279                 }
 280                 else if (event->jaxis.value > 16384) {
 281                         kc = state->axis_keydown[event->jaxis.axis];
 282                         if (kc)
 283                                 update_keystate(state->keystate, kc, 0);
 284                         kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
 285                         state->axis_keydown[event->jaxis.axis] = kc;
 286                         down = 1;
 287                         ret = 1;
 288                 }
 289                 break;
 290
 291         case SDL_JOYBUTTONDOWN:
 292         case SDL_JOYBUTTONUP:
 293                 kc = (int)event->jbutton.button + SDLK_WORLD_0;
 294                 down = event->jbutton.state == SDL_PRESSED;
 295                 ret = 1;
 296                 break;
 297         default:
 298                 return -1;
 299         }
 300
 301         if (ret)
 302                 update_keystate(state->keystate, kc, down);
 303         if (kc_out != NULL)
 304                 *kc_out = kc;
 305         if (down_out != NULL)
 306                 *down_out = down;
 307
 308         return ret;
 309 }
 310
 311 #define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \
 312                     | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK)
 313
 314 static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
 315 {
 316         SDL_Event events[4];
 317         Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
 318         int count, maxcount;
 319         int i, ret, retval = 0;
 320
 321         maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]);
 322
 323         SDL_PumpEvents();
 324         while (1) {
 325                 count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
 326                 if (count <= 0)
 327                         break;
 328                 for (i = 0; i < count; i++) {
 329                         if (state->joy)
 330                                 ret = handle_joy_event(state,
 331                                         &events[i], one_kc, one_down);
 332                         else
 333                                 ret = handle_event(state,
 334                                         &events[i], one_kc, one_down);
 335                         if (ret == -1) {
 336                                 if (ext_event_handler != NULL)
 337                                         ext_event_handler(&events[i]);
 338                                 continue;
 339                         }
 340
 341                         retval |= ret;
 342                         if (one_kc != NULL && ret)
 343                                 goto out;
 344                 }
 345         }
 346
 347 out:
 348         return retval;
 349 }
 350
 351 static int in_sdl_update(void *drv_data, const int *binds, int *result)
 352 {
 353         struct in_sdl_state *state = drv_data;
 354         keybits_t mask;
 355         int i, sym, bit, b;
 356
 357         collect_events(state, NULL, NULL);
 358
 359         for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
 360                 mask = state->keystate[i];
 361                 if (mask == 0)
 362                         continue;
 363                 for (bit = 0; mask != 0; bit++, mask >>= 1) {
 364                         if ((mask & 1) == 0)
 365                                 continue;
 366                         sym = i * KEYBITS_WORD_BITS + bit;
 367
 368                         for (b = 0; b < IN_BINDTYPE_COUNT; b++)
 369                                 result[b] |= binds[IN_BIND_OFFS(sym, b)];
 370                 }
 371         }
 372
 373         return 0;
 374 }
 375
 376 static int in_sdl_update_keycode(void *drv_data, int *is_down)
 377 {
 378         struct in_sdl_state *state = drv_data;
 379         int ret_kc = -1, ret_down = 0;
 380
 381         collect_events(state, &ret_kc, &ret_down);
 382
 383         if (is_down != NULL)
 384                 *is_down = ret_down;
 385
 386         return ret_kc;
 387 }
 388
 389 struct menu_keymap {
 390         short key;
 391         short pbtn;
 392 };
 393
 394 static const struct menu_keymap key_pbtn_map[] =
 395 {
 396         { SDLK_UP,      PBTN_UP },
 397         { SDLK_DOWN,    PBTN_DOWN },
 398         { SDLK_LEFT,    PBTN_LEFT },
 399         { SDLK_RIGHT,   PBTN_RIGHT },
 400         /* XXX: maybe better set this from it's plat code somehow */
 401         { SDLK_RETURN,  PBTN_MOK },
 402         { SDLK_ESCAPE,  PBTN_MBACK },
 403         { SDLK_a,       PBTN_MA2 },
 404         { SDLK_s,       PBTN_MA3 },
 405         { SDLK_BACKSLASH,    PBTN_MENU },
 406         { SDLK_LEFTBRACKET,  PBTN_L },
 407         { SDLK_RIGHTBRACKET, PBTN_R },
 408 };
 409 #define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0]))
 410
 411 static const struct menu_keymap joybtn_pbtn_map[] =
 412 {
 413         { SDLK_UP,      PBTN_UP },
 414         { SDLK_DOWN,    PBTN_DOWN },
 415         { SDLK_LEFT,    PBTN_LEFT },
 416         { SDLK_RIGHT,   PBTN_RIGHT },
 417         /* joystick */
 418         { SDLK_WORLD_0, PBTN_MOK },
 419         { SDLK_WORLD_1, PBTN_MBACK },
 420         { SDLK_WORLD_2, PBTN_MA2 },
 421         { SDLK_WORLD_3, PBTN_MA3 },
 422 };
 423 #define JOYBTN_PBTN_MAP_SIZE (sizeof(joybtn_pbtn_map) / sizeof(joybtn_pbtn_map[0]))
 424
 425 static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
 426 {
 427         struct in_sdl_state *state = drv_data;
 428         const struct menu_keymap *map;
 429         int map_len;
 430         int ret = 0;
 431         int i;
 432
 433         map = state->joy ? joybtn_pbtn_map : key_pbtn_map;
 434         map_len = state->joy ? JOYBTN_PBTN_MAP_SIZE : KEY_PBTN_MAP_SIZE;
 435
 436         if (keycode < 0)
 437         {
 438                 /* menu -> kc */
 439                 keycode = -keycode;
 440                 for (i = 0; i < map_len; i++)
 441                         if (map[i].pbtn == keycode)
 442                                 return map[i].key;
 443         }
 444         else
 445         {
 446                 for (i = 0; i < map_len; i++) {
 447                         if (map[i].key == keycode) {
 448                                 ret = map[i].pbtn;
 449                                 break;
 450                         }
 451                 }
 452
 453                 if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
 454                     in_sdl_keys[keycode] != NULL && in_sdl_keys[keycode][1] == 0)
 455                 {
 456                         ret |= PBTN_CHAR;
 457                         *charcode = in_sdl_keys[keycode][0];
 458                 }
 459         }
 460
 461         return ret;
 462 }
 463
 464 static const in_drv_t in_sdl_drv = {
 465         .prefix         = IN_SDL_PREFIX,
 466         .probe          = in_sdl_probe,
 467         .free           = in_sdl_free,
 468         .get_key_names  = in_sdl_get_key_names,
 469         .update         = in_sdl_update,
 470         .update_keycode = in_sdl_update_keycode,
 471         .menu_translate = in_sdl_menu_translate,
 472 };
 473
 474 void in_sdl_init(const struct in_default_bind *defbinds,
 475                  void (*handler)(void *event))
 476 {
 477         in_register_driver(&in_sdl_drv, defbinds);
 478         ext_event_handler = handler;
 479 }