[libpicofe.git] / in_sdl.c

/*
 * (C) Gražvydas "notaz" Ignotas, 2012
 *
 * This work is licensed under the terms of any of these licenses
 * (at your option):
 *  - GNU GPL, version 2 or later.
 *  - GNU LGPL, version 2.1 or later.
 *  - MAME license.
 * See the COPYING file in the top-level directory.
 */

#include <stdio.h>
#include <SDL.h>
#include "input.h"
#include "in_sdl.h"

#define IN_SDL_PREFIX "sdl:"
/* should be machine word for best performace */
typedef unsigned long keybits_t;
#define KEYBITS_WORD_BITS (sizeof(keybits_t) * 8)

struct in_sdl_state {
	const in_drv_t *drv;
	SDL_Joystick *joy;
	int joy_id;
	int axis_keydown[2];
#ifdef SDL_REDRAW_EVT
	int rdraw;
#endif
	keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1];
	// emulator keys should always be processed immediately lest one is lost
	keybits_t emu_keys[SDLK_LAST / KEYBITS_WORD_BITS + 1];
};

static void (*ext_event_handler)(void *event);

static const char * const in_sdl_keys[SDLK_LAST] = {
	[SDLK_BACKSPACE] = "backspace",
	[SDLK_TAB] = "tab",
	[SDLK_CLEAR] = "clear",
	[SDLK_RETURN] = "return",
	[SDLK_PAUSE] = "pause",
	[SDLK_ESCAPE] = "escape",
	[SDLK_SPACE] = "space",
	[SDLK_EXCLAIM]  = "!",
	[SDLK_QUOTEDBL]  = "\"",
	[SDLK_HASH]  = "#",
	[SDLK_DOLLAR]  = "$",
	[SDLK_AMPERSAND]  = "&",
	[SDLK_QUOTE] = "'",
	[SDLK_LEFTPAREN] = "(",
	[SDLK_RIGHTPAREN] = ")",
	[SDLK_ASTERISK] = "*",
	[SDLK_PLUS] = "+",
	[SDLK_COMMA] = ",",
	[SDLK_MINUS] = "-",
	[SDLK_PERIOD] = ".",
	[SDLK_SLASH] = "/",
	[SDLK_0] = "0",
	[SDLK_1] = "1",
	[SDLK_2] = "2",
	[SDLK_3] = "3",
	[SDLK_4] = "4",
	[SDLK_5] = "5",
	[SDLK_6] = "6",
	[SDLK_7] = "7",
	[SDLK_8] = "8",
	[SDLK_9] = "9",
	[SDLK_COLON] = ":",
	[SDLK_SEMICOLON] = ";",
	[SDLK_LESS] = "<",
	[SDLK_EQUALS] = "=",
	[SDLK_GREATER] = ">",
	[SDLK_QUESTION] = "?",
	[SDLK_AT] = "@",
	[SDLK_LEFTBRACKET] = "[",
	[SDLK_BACKSLASH] = "\\",
	[SDLK_RIGHTBRACKET] = "]",
	[SDLK_CARET] = "^",
	[SDLK_UNDERSCORE] = "_",
	[SDLK_BACKQUOTE] = "`",
	[SDLK_a] = "a",
	[SDLK_b] = "b",
	[SDLK_c] = "c",
	[SDLK_d] = "d",
	[SDLK_e] = "e",
	[SDLK_f] = "f",
	[SDLK_g] = "g",
	[SDLK_h] = "h",
	[SDLK_i] = "i",
	[SDLK_j] = "j",
	[SDLK_k] = "k",
	[SDLK_l] = "l",
	[SDLK_m] = "m",
	[SDLK_n] = "n",
	[SDLK_o] = "o",
	[SDLK_p] = "p",
	[SDLK_q] = "q",
	[SDLK_r] = "r",
	[SDLK_s] = "s",
	[SDLK_t] = "t",
	[SDLK_u] = "u",
	[SDLK_v] = "v",
	[SDLK_w] = "w",
	[SDLK_x] = "x",
	[SDLK_y] = "y",
	[SDLK_z] = "z",
	[SDLK_DELETE] = "delete",

	[SDLK_KP0] = "[0]",
	[SDLK_KP1] = "[1]",
	[SDLK_KP2] = "[2]",
	[SDLK_KP3] = "[3]",
	[SDLK_KP4] = "[4]",
	[SDLK_KP5] = "[5]",
	[SDLK_KP6] = "[6]",
	[SDLK_KP7] = "[7]",
	[SDLK_KP8] = "[8]",
	[SDLK_KP9] = "[9]",
	[SDLK_KP_PERIOD] = "[.]",
	[SDLK_KP_DIVIDE] = "[/]",
	[SDLK_KP_MULTIPLY] = "[*]",
	[SDLK_KP_MINUS] = "[-]",
	[SDLK_KP_PLUS] = "[+]",
	[SDLK_KP_ENTER] = "enter",
	[SDLK_KP_EQUALS] = "equals",

	[SDLK_UP] = "up",
	[SDLK_DOWN] = "down",
	[SDLK_RIGHT] = "right",
	[SDLK_LEFT] = "left",
	[SDLK_INSERT] = "insert",
	[SDLK_HOME] = "home",
	[SDLK_END] = "end",
	[SDLK_PAGEUP] = "page up",
	[SDLK_PAGEDOWN] = "page down",

	[SDLK_F1] = "f1",
	[SDLK_F2] = "f2",
	[SDLK_F3] = "f3",
	[SDLK_F4] = "f4",
	[SDLK_F5] = "f5",
	[SDLK_F6] = "f6",
	[SDLK_F7] = "f7",
	[SDLK_F8] = "f8",
	[SDLK_F9] = "f9",
	[SDLK_F10] = "f10",
	[SDLK_F11] = "f11",
	[SDLK_F12] = "f12",
	[SDLK_F13] = "f13",
	[SDLK_F14] = "f14",
	[SDLK_F15] = "f15",

	[SDLK_NUMLOCK] = "numlock",
	[SDLK_CAPSLOCK] = "caps lock",
	[SDLK_SCROLLOCK] = "scroll lock",
	[SDLK_RSHIFT] = "right shift",
	[SDLK_LSHIFT] = "left shift",
	[SDLK_RCTRL] = "right ctrl",
	[SDLK_LCTRL] = "left ctrl",
	[SDLK_RALT] = "right alt",
	[SDLK_LALT] = "left alt",
	[SDLK_RMETA] = "right meta",
	[SDLK_LMETA] = "left meta",
	[SDLK_LSUPER] = "left super",	/* "Windows" keys */
	[SDLK_RSUPER] = "right super",	
	[SDLK_MODE] = "alt gr",
	[SDLK_COMPOSE] = "compose",
};

static void in_sdl_probe(const in_drv_t *drv)
{
	const struct in_pdata *pdata = drv->pdata;
	const char * const * key_names = in_sdl_keys;
	struct in_sdl_state *state;
	SDL_Joystick *joy;
	int i, joycount;
	char name[256];

	if (pdata->key_names)
		key_names = pdata->key_names;

	state = calloc(1, sizeof(*state));
	if (state == NULL) {
		fprintf(stderr, "in_sdl: OOM\n");
		return;
	}

	state->drv = drv;
	in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST,
		key_names, 0);

	/* joysticks go here too */
	SDL_InitSubSystem(SDL_INIT_JOYSTICK);

	joycount = SDL_NumJoysticks();
	for (i = 0; i < joycount; i++) {
		joy = SDL_JoystickOpen(i);
		if (joy == NULL)
			continue;

		state = calloc(1, sizeof(*state));
		if (state == NULL) {
			fprintf(stderr, "in_sdl: OOM\n");
			break;
		}
		state->joy = joy;
		state->joy_id = i;
		state->drv = drv;

		snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
		in_register(name, -1, state, SDLK_LAST, key_names, 0);
	}

	if (joycount > 0)
		SDL_JoystickEventState(SDL_ENABLE);
}

static void in_sdl_free(void *drv_data)
{
	struct in_sdl_state *state = drv_data;

	if (state != NULL) {
		if (state->joy != NULL)
			SDL_JoystickClose(state->joy);
		free(state);
	}
}

static const char * const *
in_sdl_get_key_names(const in_drv_t *drv, int *count)
{
	const struct in_pdata *pdata = drv->pdata;
	*count = SDLK_LAST;

	if (pdata->key_names)
		return pdata->key_names;
	return in_sdl_keys;
}

/* could use SDL_GetKeyState, but this gives better packing */
static void update_keystate(keybits_t *keystate, int sym, int is_down)
{
	keybits_t *ks_word, mask;

	mask = 1;
	mask <<= sym & (KEYBITS_WORD_BITS - 1);
	ks_word = keystate + sym / KEYBITS_WORD_BITS;
	if (is_down)
		*ks_word |= mask;
	else
		*ks_word &= ~mask;
}

static int get_keystate(keybits_t *keystate, int sym)
{
	keybits_t *ks_word, mask;

	mask = 1;
	mask <<= sym & (KEYBITS_WORD_BITS - 1);
	ks_word = keystate + sym / KEYBITS_WORD_BITS;
	return !!(*ks_word & mask);
}

static int handle_event(struct in_sdl_state *state, SDL_Event *event,
	int *kc_out, int *down_out, int *emu_out)
{
	int emu;

	if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP)
		return -1;

	emu = get_keystate(state->emu_keys, event->key.keysym.sym);
	update_keystate(state->keystate, event->key.keysym.sym,
		event->type == SDL_KEYDOWN);
	if (kc_out != NULL)
		*kc_out = event->key.keysym.sym;
	if (down_out != NULL)
		*down_out = event->type == SDL_KEYDOWN;
	if (emu_out != NULL)
		*emu_out = emu;

	return 1;
}

static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
	int *kc_out, int *down_out, int *emu_out)
{
	int kc = -1, down = 0, emu = 0, ret = 0;

	/* TODO: remaining axis */
	switch (event->type) {
	case SDL_JOYAXISMOTION:
		if (event->jaxis.which != state->joy_id)
			return -2;
		if (event->jaxis.axis > 1)
			break;
		if (-16384 <= event->jaxis.value && event->jaxis.value <= 16384) {
			kc = state->axis_keydown[event->jaxis.axis];
			state->axis_keydown[event->jaxis.axis] = 0;
			ret = 1;
		}
		else if (event->jaxis.value < -16384) {
			kc = state->axis_keydown[event->jaxis.axis];
			if (kc) {
				emu |= get_keystate(state->emu_keys, kc);
				update_keystate(state->keystate, kc, 0);
			}
			kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
			state->axis_keydown[event->jaxis.axis] = kc;
			down = 1;
			ret = 1;
		}
		else if (event->jaxis.value > 16384) {
			kc = state->axis_keydown[event->jaxis.axis];
			if (kc) {
				emu |= get_keystate(state->emu_keys, kc);
				update_keystate(state->keystate, kc, 0);
			}
			kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
			state->axis_keydown[event->jaxis.axis] = kc;
			down = 1;
			ret = 1;
		}
		break;

	case SDL_JOYBUTTONDOWN:
	case SDL_JOYBUTTONUP:
		if (event->jbutton.which != state->joy_id)
			return -2;
		kc = (int)event->jbutton.button + SDLK_WORLD_0;
		down = event->jbutton.state == SDL_PRESSED;
		ret = 1;
		break;
	default:
		return -1;
	}

	if (ret) {
		emu |= get_keystate(state->emu_keys, kc);
		update_keystate(state->keystate, kc, down);
	}
	if (kc_out != NULL)
		*kc_out = kc;
	if (down_out != NULL)
		*down_out = down;
	if (emu_out != 0)
		*emu_out = emu;

	return ret;
}

#define JOY_EVENTS (SDL_JOYAXISMOTIONMASK | SDL_JOYBALLMOTIONMASK | SDL_JOYHATMOTIONMASK \
		    | SDL_JOYBUTTONDOWNMASK | SDL_JOYBUTTONUPMASK)

static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
{
	SDL_Event events[4];
	Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
	int count, maxcount, is_emukey = 0;
	int i, ret, retval = 0;
	int num_events, num_peeped_events;
	SDL_Event *event;

#ifdef SDL_REDRAW_EVT
	if (state->rdraw) {
		if (one_kc != NULL)
			*one_kc = SDLK_UNKNOWN;
		if (one_down != NULL)
			*one_down = 0;
		state->rdraw = 0;
		return 1;
	}
#endif
	maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]);

	SDL_PumpEvents();

	num_events = SDL_PeepEvents(NULL, 0, SDL_PEEKEVENT, mask);

	for (num_peeped_events = 0; num_peeped_events < num_events; num_peeped_events += count) {
		count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
		if (count <= 0)
			break;
		for (i = 0; i < count; i++) {
			event = &events[i];
			if (state->joy) {
				ret = handle_joy_event(state,
					event, one_kc, one_down, &is_emukey);
			} else {
				ret = handle_event(state,
					event, one_kc, one_down, &is_emukey);
			}
			if (ret < 0) {
				switch (ret) {
					case -2:
						SDL_PushEvent(event);
						break;
					default:
						if (ext_event_handler != NULL)
							ext_event_handler(event);
						break;
				}
#ifdef SDL_REDRAW_EVT
				if (ret != -2 && event->type == SDL_VIDEORESIZE) {
					if (one_kc != NULL)
						*one_kc = SDLK_UNKNOWN;
					if (one_down != NULL)
						*one_down = 1;
					state->rdraw = 1;
					is_emukey = 1, ret = 1;
				} else
					continue;
#endif
			}

			retval |= ret;
			if ((is_emukey || one_kc != NULL) && retval)
			{
				// don't lose events other devices might want to handle
				if (++i < count)
					SDL_PeepEvents(events+i, count-i, SDL_ADDEVENT, mask);
				goto out;
			}
		}
	}

out:
	return retval;
}

static int in_sdl_update(void *drv_data, const int *binds, int *result)
{
	struct in_sdl_state *state = drv_data;
	keybits_t mask;
	int i, sym, bit, b;

	collect_events(state, NULL, NULL);

	for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
		mask = state->keystate[i];
		if (mask == 0)
			continue;
		for (bit = 0; mask != 0; bit++, mask >>= 1) {
			if ((mask & 1) == 0)
				continue;
			sym = i * KEYBITS_WORD_BITS + bit;

			for (b = 0; b < IN_BINDTYPE_COUNT; b++)
				result[b] |= binds[IN_BIND_OFFS(sym, b)];
		}
	}

	return 0;
}

static int in_sdl_update_keycode(void *drv_data, int *is_down)
{
	struct in_sdl_state *state = drv_data;
	int ret_kc = -1, ret_down = 0;

	collect_events(state, &ret_kc, &ret_down);

	if (is_down != NULL)
		*is_down = ret_down;

	return ret_kc;
}

static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
{
	struct in_sdl_state *state = drv_data;
	const struct in_pdata *pdata = state->drv->pdata;
	const char * const * key_names = in_sdl_keys;
	const struct menu_keymap *map;
	int map_len;
	int ret = 0;
	int i;

	if (pdata->key_names)
		key_names = pdata->key_names;

	if (state->joy) {
		map = pdata->joy_map;
		map_len = pdata->jmap_size;
	} else {
		map = pdata->key_map;
		map_len = pdata->kmap_size;
	}

	if (keycode < 0)
	{
		/* menu -> kc */
		keycode = -keycode;
		for (i = 0; i < map_len; i++)
			if (map[i].pbtn == keycode)
				return map[i].key;
	}
	else
	{
#ifdef SDL_REDRAW_EVT
		if (keycode == SDLK_UNKNOWN)
			ret = PBTN_RDRAW;
		else
#endif
		for (i = 0; i < map_len; i++) {
			if (map[i].key == keycode) {
				ret = map[i].pbtn;
				break;
			}
		}

		if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
		    key_names[keycode] != NULL && key_names[keycode][1] == 0)
		{
			ret |= PBTN_CHAR;
			*charcode = key_names[keycode][0];
		}
	}

	return ret;
}

static int in_sdl_clean_binds(void *drv_data, int *binds, int *def_finds)
{
	struct in_sdl_state *state = drv_data;
	int i, t, cnt = 0;

	memset(state->emu_keys, 0, sizeof(state->emu_keys));
	for (t = 0; t < IN_BINDTYPE_COUNT; t++)
		for (i = 0; i < SDLK_LAST; i++)
			if (binds[IN_BIND_OFFS(i, t)]) {
				if (t == IN_BINDTYPE_EMU)
					update_keystate(state->emu_keys, i, 1);
				cnt ++;
			}

	return cnt;
}

static const in_drv_t in_sdl_drv = {
	.prefix         = IN_SDL_PREFIX,
	.probe          = in_sdl_probe,
	.free           = in_sdl_free,
	.get_key_names  = in_sdl_get_key_names,
	.update         = in_sdl_update,
	.update_keycode = in_sdl_update_keycode,
	.menu_translate = in_sdl_menu_translate,
	.clean_binds    = in_sdl_clean_binds,
};

int in_sdl_init(const struct in_pdata *pdata, void (*handler)(void *event))
{
	if (!pdata) {
		fprintf(stderr, "in_sdl: Missing input platform data\n");
		return -1;
	}

	in_register_driver(&in_sdl_drv, pdata->defbinds, pdata);
	ext_event_handler = handler;
	return 0;
}
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
271f9001	32	keybits_t emu_keys[SDLK_LAST / KEYBITS_WORD_BITS + 1];
6407ad5b	33	};
6407ad5b	34
9227a777	35	static void (ext_event_handler)(void event);
9227a777	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;
d685ce46 PC	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));
6407ad5b	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
6407ad5b	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;
271f9001	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)
18306c32 VL	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) {
271f9001	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) {
271f9001	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)
18306c32 VL	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:
9227a777	336	return -1;
d1dc092f	337	}
d1dc092f	338
271f9001	339	if (ret) {
271f9001	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)
271f9001	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;
18306c32 VL	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);
271f9001	390	} else {
6407ad5b	391	ret = handle_event(state,
271f9001	392	event, one_kc, one_down, &is_emukey);
271f9001	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	}
9227a777	416
6407ad5b	417	retval \|= ret;
bededcb4	418	if ((is_emukey \|\| one_kc != NULL) && retval)
18306c32 VL	419	{
18306c32 VL	420	// don't lose events other devices might want to handle
271f9001	421	if (++i < count)
271f9001	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)
d1dc092f	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;
6407ad5b	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	{
d1dc092f	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	};
d1dc092f	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	}