[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)

#ifndef ARRAY_SIZE
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
#endif

struct in_sdl_state {
	const in_drv_t *drv;
	SDL_Joystick *joy;
	int joy_id;
	int joy_numaxes;
	int joy_numbuttons;
	int *joy_axis_keydown;
	int joy_hat_down;
	unsigned int joy_axis_as_btn; // bitmask; vs axes of centered sticks
	unsigned int redraw:1;
	unsigned int abs_to_udlr:1;
	unsigned int hat_warned:1;
	SDL_Event revent;
	SDL_Event mevent; // last mouse event
	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",

	// gamepad buttons
	#define B(x) [SDLK_WORLD_##x] = "b"#x
	B(0), B(1), B(2), B(3), B(4), B(5), B(6), B(7),
	B(8), B(9), B(10), B(11), B(12), B(13), B(14), B(15),
	B(16), B(17), B(18), B(19), B(20), B(21), B(22), B(23),
	B(24), B(25), B(26), B(27), B(28), B(29), B(30), B(31),
	B(32), B(33), B(34), B(35), B(36), B(37), B(38), B(39),
	#undef B

	[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 struct in_sdl_state *state_alloc(int joy_numaxes)
{
	struct in_sdl_state *state;

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

	if (joy_numaxes) {
		state->abs_to_udlr = 1;
		state->joy_numaxes = joy_numaxes;
		state->joy_axis_keydown = malloc(joy_numaxes * sizeof(state->joy_axis_keydown[0]));
		if (!state->joy_axis_keydown) {
			free(state);
			return NULL;
		}
		memset(state->joy_axis_keydown, 0xff, joy_numaxes * sizeof(state->joy_axis_keydown[0]));
	}
	return state;
}

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, a, joycount;
	char name[256];

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

	if (!(state = state_alloc(0)))
		return;

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

	/* 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;

		if (!(state = state_alloc(SDL_JoystickNumAxes(joy))))
			break;
		state->joy = joy;
		state->joy_id = i;
		state->joy_numbuttons = SDL_JoystickNumButtons(joy);
		state->drv = drv;
		for (a = 0; a < state->joy_numaxes; a++)
			if (SDL_JoystickGetAxis(joy, a) < -16384)
				state->joy_axis_as_btn |= 1u << a;

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

		printf("  %s: %d buttons %d axes %d hat(s), "
			"guessed axis_as_btn mask: %x\n",
			name, state->joy_numbuttons, state->joy_numaxes,
			SDL_JoystickNumHats(joy), state->joy_axis_as_btn);
	}

	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->joy_axis_keydown);
		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)
{
	static const int hat2uldr[4] = { SDLK_UP, SDLK_RIGHT, SDLK_DOWN, SDLK_LEFT };
	int kc = -1, kc_prev = -1, down = 0, emu = 0, ret = 0, i, val, xor;
	int kc_button_base = SDLK_WORLD_0;
	int kc_axis_base = kc_button_base + state->joy_numbuttons;
	int kc_hat_base = kc_axis_base + state->joy_numaxes;

	switch (event->type) {
	case SDL_JOYAXISMOTION:
		if ((unsigned)event->jaxis.axis >= (unsigned)state->joy_numaxes)
			return 1;
		if (event->jaxis.which != state->joy_id)
			return -2;
		if (event->jaxis.value < -16384) {
			if (state->abs_to_udlr && event->jaxis.axis < 2)
				kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
			// some pressure sensitive buttons appear as an axis that goes
			// from -32768 (released) to 32767 (pressed) and there is no
			// way to distinguish from ones centered at 0? :(
			else if (!(state->joy_axis_as_btn & (1u << event->jaxis.axis)))
				kc = kc_axis_base + event->jaxis.axis * 2;
			down = 1;
		}
		else if (event->jaxis.value > 16384) {
			if (state->abs_to_udlr && event->jaxis.axis < 2)
				kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
			else
				kc = kc_axis_base + event->jaxis.axis * 2 + 1;
			down = 1;
		}
		kc_prev = state->joy_axis_keydown[event->jaxis.axis];
		state->joy_axis_keydown[event->jaxis.axis] = kc;
		if (kc == kc_prev)
			return -1; // no simulated key change
		if (kc >= 0 && kc_prev >= 0) {
			// must release the old key first
			state->joy_axis_keydown[event->jaxis.axis] = -1;
			kc = kc_prev;
			down = 0;
		}
		else if (kc_prev >= 0)
			kc = kc_prev;
		ret = 1;
		break;

	case SDL_JOYBUTTONDOWN:
	case SDL_JOYBUTTONUP:
		if (event->jbutton.which != state->joy_id)
			return -2;
		kc = kc_button_base + (int)event->jbutton.button;
		down = event->jbutton.state == SDL_PRESSED;
		ret = 1;
		break;
	case SDL_JOYHATMOTION:
		if (event->jhat.which != state->joy_id)
			return -2;
		xor = event->jhat.value ^ state->joy_hat_down;
		val = state->joy_hat_down = event->jhat.value;
		for (i = 0; i < 4; i++, xor >>= 1, val >>= 1) {
			if (xor & 1) {
				if (event->jhat.hat)
					kc = kc_hat_base + event->jhat.hat * 4 + i;
				else
					kc = hat2uldr[i];
				down = val & 1;
				ret = 1;
				break;
			}
		}
		if ((!ret || (xor >> ret)) && !state->hat_warned) {
			// none, more than 1, or upper bits changed
			fprintf(stderr, "in_sdl: unexpected hat behavior\n");
			state->hat_warned = 1;
		}
		break;
	default:
		//printf("joy ev %d\n", event->type);
		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[8];
	Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
	int count, maxcount, is_emukey = 0;
	int i = 0, ret = 0, retval = 0;
	SDL_Event *event;

	SDL_PumpEvents();

	maxcount = ARRAY_SIZE(events);
	if ((count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask)) > 0) {
		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 (event->type == SDL_VIDEORESIZE) {
							state->redraw = 1;
							state->revent = *event;
						} else if (event->type == SDL_VIDEOEXPOSE) {
							if (state->revent.type == SDL_NOEVENT) {
								state->redraw = 1;
								state->revent.type = SDL_VIDEOEXPOSE;
							}
						} else
						if ((event->type == SDL_MOUSEBUTTONDOWN) ||
						    (event->type == SDL_MOUSEBUTTONUP)) {
							int mask = SDL_BUTTON(event->button.button);
							if (event->button.state == SDL_PRESSED)
								state->mevent.motion.state |= mask;
							else	state->mevent.motion.state &= ~mask;
						} else if (event->type == SDL_MOUSEMOTION) {
							event->motion.xrel += state->mevent.motion.xrel;
							event->motion.yrel += state->mevent.motion.yrel;
							state->mevent = *event;
						}
						else if (ext_event_handler != NULL)
							ext_event_handler(event);
						break;
				}
				continue;
			}

			retval |= ret;
			if ((is_emukey || one_kc != NULL) && retval)
			{
				break;
			}
		}
	}

	// if the event queue has been emptied and resize/expose events were in it
	if (state->redraw && count == 0) {
		if (ext_event_handler != NULL)
			ext_event_handler(&state->revent);
		state->redraw = 0;
		state->revent.type = SDL_NOEVENT;
		// dummy key event to force returning from the key loop,
		// so the application has a chance to redraw the window
		if (one_kc != NULL) {
			*one_kc = SDLK_UNKNOWN;
			retval |= 1;
		}
		if (one_down != NULL)
			*one_down = 1;
	} else
		i++;
	// don't lose events other devices might want to handle
	if (i < count)
		SDL_PeepEvents(events+i, count-i, SDL_ADDEVENT, mask);
	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_kbd(void *drv_data, const int *binds, int *result)
{
	struct in_sdl_state *state = drv_data;
	keybits_t mask;
	int i, sym, bit, b = 0;

	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;
			result[b++] = binds[sym];
		}
	}

	return b;
}

static int in_sdl_update_analog(void *drv_data, int axis_id, int *result)
{
	struct in_sdl_state *state = drv_data;
	int v;

	if (!state || !state->joy || !result)
		return -1;
	if ((unsigned)axis_id >= (unsigned)state->joy_numaxes)
		return -1;

	v = SDL_JoystickGetAxis(state->joy, axis_id);

	// -32768...32767 -> -IN_ABS_RANGE...IN_ABS_RANGE
	*result = (v + ((v >> 31) | 1)) / (32768 / IN_ABS_RANGE);
	return 0;
}

static int in_sdl_update_pointer(void *drv_data, int id, int *result)
{
	struct in_sdl_state *state = drv_data;
	int max;

	*result = 0;

	switch (id) {
	// absolute position, clipped at the window/screen border
	case 0:	if ((max = state->revent.resize.w))
			*result = state->mevent.motion.x * 2*1024/max - 1024;
		break;
	case 1:	if ((max = state->revent.resize.h))
			*result = state->mevent.motion.y * 2*1024/max - 1024;
		break;
	// relative mouse movements since last query
	case 2:	if ((max = state->revent.resize.w))
			*result = state->mevent.motion.xrel * 2*1024/max;
		state->mevent.motion.xrel = 0;
		break;
	case 3:	if ((max = state->revent.resize.h))
			*result = state->mevent.motion.yrel * 2*1024/max;
		state->mevent.motion.yrel = 0;
		break;
	// buttons
	case -1: *result = state->mevent.motion.state;
		break;
	default: return -1;
	}

	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
	{
		if (keycode == SDLK_UNKNOWN)
			ret = PBTN_RDRAW;
		else
		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_binds)
{
	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++) {
			int offs = IN_BIND_OFFS(i, t);
			if (state->joy && i < SDLK_WORLD_0)
				binds[offs] = def_binds[offs] = 0;
			if (binds[offs]) {
				if (t == IN_BINDTYPE_EMU)
					update_keystate(state->emu_keys, i, 1);
				cnt ++;
			}
		}
	}

	return cnt;
}

static int in_sdl_get_config(void *drv_data, enum in_cfg_opt what, int *val)
{
	struct in_sdl_state *state = drv_data;

	switch (what) {
	case IN_CFG_ABS_AXIS_COUNT:
		*val = state->joy_numaxes;
		break;
	case IN_CFG_ANALOG_MAP_ULDR:
		*val = state->abs_to_udlr;
		break;
	default:
		return -1;
	}

	return 0;
}

static int in_sdl_set_config(void *drv_data, enum in_cfg_opt what, int val)
{
	struct in_sdl_state *state = drv_data;
	size_t i;

	switch (what) {
	case IN_CFG_ANALOG_MAP_ULDR:
		state->abs_to_udlr = val ? 1 : 0;
		for (i = 0; !val && i < state->joy_numaxes; i++) {
			if (state->joy_axis_keydown[i] < 0)
				continue;
			update_keystate(state->keystate, state->joy_axis_keydown[i], 0);
			state->joy_axis_keydown[i] = -1;
		}
		break;
	default:
		return -1;
	}

	return 0;
}

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_kbd      = in_sdl_update_kbd,
	.update_analog   = in_sdl_update_analog,
	.update_pointer  = in_sdl_update_pointer,
	.update_keycode  = in_sdl_update_keycode,
	.menu_translate  = in_sdl_menu_translate,
	.clean_binds     = in_sdl_clean_binds,
	.get_config      = in_sdl_get_config,
	.set_config      = in_sdl_set_config,
};

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->kbd_map, pdata);
	ext_event_handler = handler;
	return 0;
}
Commit	Line	Data
	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	#ifndef ARRAY_SIZE
	23	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
	24	#endif
	25
	26	struct in_sdl_state {
	27	const in_drv_t *drv;
	28	SDL_Joystick *joy;
	29	int joy_id;
	30	int joy_numaxes;
	31	int joy_numbuttons;
	32	int *joy_axis_keydown;
	33	int joy_hat_down;
	34	unsigned int joy_axis_as_btn; // bitmask; vs axes of centered sticks
	35	unsigned int redraw:1;
	36	unsigned int abs_to_udlr:1;
	37	unsigned int hat_warned:1;
	38	SDL_Event revent;
	39	SDL_Event mevent; // last mouse event
	40	keybits_t keystate[SDLK_LAST / KEYBITS_WORD_BITS + 1];
	41	// emulator keys should always be processed immediately lest one is lost
	42	keybits_t emu_keys[SDLK_LAST / KEYBITS_WORD_BITS + 1];
	43	};
	44
	45	static void (ext_event_handler)(void event);
	46
	47	static const char * const in_sdl_keys[SDLK_LAST] = {
	48	[SDLK_BACKSPACE] = "backspace",
	49	[SDLK_TAB] = "tab",
	50	[SDLK_CLEAR] = "clear",
	51	[SDLK_RETURN] = "return",
	52	[SDLK_PAUSE] = "pause",
	53	[SDLK_ESCAPE] = "escape",
	54	[SDLK_SPACE] = "space",
	55	[SDLK_EXCLAIM] = "!",
	56	[SDLK_QUOTEDBL] = "\"",
	57	[SDLK_HASH] = "#",
	58	[SDLK_DOLLAR] = "$",
	59	[SDLK_AMPERSAND] = "&",
	60	[SDLK_QUOTE] = "'",
	61	[SDLK_LEFTPAREN] = "(",
	62	[SDLK_RIGHTPAREN] = ")",
	63	[SDLK_ASTERISK] = "*",
	64	[SDLK_PLUS] = "+",
	65	[SDLK_COMMA] = ",",
	66	[SDLK_MINUS] = "-",
	67	[SDLK_PERIOD] = ".",
	68	[SDLK_SLASH] = "/",
	69	[SDLK_0] = "0",
	70	[SDLK_1] = "1",
	71	[SDLK_2] = "2",
	72	[SDLK_3] = "3",
	73	[SDLK_4] = "4",
	74	[SDLK_5] = "5",
	75	[SDLK_6] = "6",
	76	[SDLK_7] = "7",
	77	[SDLK_8] = "8",
	78	[SDLK_9] = "9",
	79	[SDLK_COLON] = ":",
	80	[SDLK_SEMICOLON] = ";",
	81	[SDLK_LESS] = "<",
	82	[SDLK_EQUALS] = "=",
	83	[SDLK_GREATER] = ">",
	84	[SDLK_QUESTION] = "?",
	85	[SDLK_AT] = "@",
	86	[SDLK_LEFTBRACKET] = "[",
	87	[SDLK_BACKSLASH] = "\\",
	88	[SDLK_RIGHTBRACKET] = "]",
	89	[SDLK_CARET] = "^",
	90	[SDLK_UNDERSCORE] = "_",
	91	[SDLK_BACKQUOTE] = "`",
	92	[SDLK_a] = "a",
	93	[SDLK_b] = "b",
	94	[SDLK_c] = "c",
	95	[SDLK_d] = "d",
	96	[SDLK_e] = "e",
	97	[SDLK_f] = "f",
	98	[SDLK_g] = "g",
	99	[SDLK_h] = "h",
	100	[SDLK_i] = "i",
	101	[SDLK_j] = "j",
	102	[SDLK_k] = "k",
	103	[SDLK_l] = "l",
	104	[SDLK_m] = "m",
	105	[SDLK_n] = "n",
	106	[SDLK_o] = "o",
	107	[SDLK_p] = "p",
	108	[SDLK_q] = "q",
	109	[SDLK_r] = "r",
	110	[SDLK_s] = "s",
	111	[SDLK_t] = "t",
	112	[SDLK_u] = "u",
	113	[SDLK_v] = "v",
	114	[SDLK_w] = "w",
	115	[SDLK_x] = "x",
	116	[SDLK_y] = "y",
	117	[SDLK_z] = "z",
	118	[SDLK_DELETE] = "delete",
	119
	120	// gamepad buttons
	121	#define B(x) [SDLK_WORLD_##x] = "b"#x
	122	B(0), B(1), B(2), B(3), B(4), B(5), B(6), B(7),
	123	B(8), B(9), B(10), B(11), B(12), B(13), B(14), B(15),
	124	B(16), B(17), B(18), B(19), B(20), B(21), B(22), B(23),
	125	B(24), B(25), B(26), B(27), B(28), B(29), B(30), B(31),
	126	B(32), B(33), B(34), B(35), B(36), B(37), B(38), B(39),
	127	#undef B
	128
	129	[SDLK_KP0] = "[0]",
	130	[SDLK_KP1] = "[1]",
	131	[SDLK_KP2] = "[2]",
	132	[SDLK_KP3] = "[3]",
	133	[SDLK_KP4] = "[4]",
	134	[SDLK_KP5] = "[5]",
	135	[SDLK_KP6] = "[6]",
	136	[SDLK_KP7] = "[7]",
	137	[SDLK_KP8] = "[8]",
	138	[SDLK_KP9] = "[9]",
	139	[SDLK_KP_PERIOD] = "[.]",
	140	[SDLK_KP_DIVIDE] = "[/]",
	141	[SDLK_KP_MULTIPLY] = "[*]",
	142	[SDLK_KP_MINUS] = "[-]",
	143	[SDLK_KP_PLUS] = "[+]",
	144	[SDLK_KP_ENTER] = "enter",
	145	[SDLK_KP_EQUALS] = "equals",
	146
	147	[SDLK_UP] = "up",
	148	[SDLK_DOWN] = "down",
	149	[SDLK_RIGHT] = "right",
	150	[SDLK_LEFT] = "left",
	151	[SDLK_INSERT] = "insert",
	152	[SDLK_HOME] = "home",
	153	[SDLK_END] = "end",
	154	[SDLK_PAGEUP] = "page up",
	155	[SDLK_PAGEDOWN] = "page down",
	156
	157	[SDLK_F1] = "f1",
	158	[SDLK_F2] = "f2",
	159	[SDLK_F3] = "f3",
	160	[SDLK_F4] = "f4",
	161	[SDLK_F5] = "f5",
	162	[SDLK_F6] = "f6",
	163	[SDLK_F7] = "f7",
	164	[SDLK_F8] = "f8",
	165	[SDLK_F9] = "f9",
	166	[SDLK_F10] = "f10",
	167	[SDLK_F11] = "f11",
	168	[SDLK_F12] = "f12",
	169	[SDLK_F13] = "f13",
	170	[SDLK_F14] = "f14",
	171	[SDLK_F15] = "f15",
	172
	173	[SDLK_NUMLOCK] = "numlock",
	174	[SDLK_CAPSLOCK] = "caps lock",
	175	[SDLK_SCROLLOCK] = "scroll lock",
	176	[SDLK_RSHIFT] = "right shift",
	177	[SDLK_LSHIFT] = "left shift",
	178	[SDLK_RCTRL] = "right ctrl",
	179	[SDLK_LCTRL] = "left ctrl",
	180	[SDLK_RALT] = "right alt",
	181	[SDLK_LALT] = "left alt",
	182	[SDLK_RMETA] = "right meta",
	183	[SDLK_LMETA] = "left meta",
	184	[SDLK_LSUPER] = "left super", /* "Windows" keys */
	185	[SDLK_RSUPER] = "right super",
	186	[SDLK_MODE] = "alt gr",
	187	[SDLK_COMPOSE] = "compose",
	188	};
	189
	190	static struct in_sdl_state *state_alloc(int joy_numaxes)
	191	{
	192	struct in_sdl_state *state;
	193
	194	state = calloc(1, sizeof(*state));
	195	if (state == NULL) {
	196	fprintf(stderr, "in_sdl: OOM\n");
	197	return NULL;
	198	}
	199
	200	if (joy_numaxes) {
	201	state->abs_to_udlr = 1;
	202	state->joy_numaxes = joy_numaxes;
	203	state->joy_axis_keydown = malloc(joy_numaxes * sizeof(state->joy_axis_keydown[0]));
	204	if (!state->joy_axis_keydown) {
	205	free(state);
	206	return NULL;
	207	}
	208	memset(state->joy_axis_keydown, 0xff, joy_numaxes * sizeof(state->joy_axis_keydown[0]));
	209	}
	210	return state;
	211	}
	212
	213	static void in_sdl_probe(const in_drv_t *drv)
	214	{
	215	const struct in_pdata *pdata = drv->pdata;
	216	const char * const * key_names = in_sdl_keys;
	217	struct in_sdl_state *state;
	218	SDL_Joystick *joy;
	219	int i, a, joycount;
	220	char name[256];
	221
	222	if (pdata->key_names)
	223	key_names = pdata->key_names;
	224
	225	if (!(state = state_alloc(0)))
	226	return;
	227
	228	state->drv = drv;
	229	in_register(IN_SDL_PREFIX "keys", -1, state, SDLK_LAST,
	230	key_names, 0);
	231	//SDL_EnableUNICODE(1);
	232
	233	/* joysticks go here too */
	234	SDL_InitSubSystem(SDL_INIT_JOYSTICK);
	235
	236	joycount = SDL_NumJoysticks();
	237	for (i = 0; i < joycount; i++) {
	238	joy = SDL_JoystickOpen(i);
	239	if (joy == NULL)
	240	continue;
	241
	242	if (!(state = state_alloc(SDL_JoystickNumAxes(joy))))
	243	break;
	244	state->joy = joy;
	245	state->joy_id = i;
	246	state->joy_numbuttons = SDL_JoystickNumButtons(joy);
	247	state->drv = drv;
	248	for (a = 0; a < state->joy_numaxes; a++)
	249	if (SDL_JoystickGetAxis(joy, a) < -16384)
	250	state->joy_axis_as_btn \|= 1u << a;
	251
	252	snprintf(name, sizeof(name), IN_SDL_PREFIX "%s", SDL_JoystickName(i));
	253	in_register(name, -1, state, SDLK_LAST, key_names, 0);
	254
	255	printf(" %s: %d buttons %d axes %d hat(s), "
	256	"guessed axis_as_btn mask: %x\n",
	257	name, state->joy_numbuttons, state->joy_numaxes,
	258	SDL_JoystickNumHats(joy), state->joy_axis_as_btn);
	259	}
	260
	261	if (joycount > 0)
	262	SDL_JoystickEventState(SDL_ENABLE);
	263	}
	264
	265	static void in_sdl_free(void *drv_data)
	266	{
	267	struct in_sdl_state *state = drv_data;
	268
	269	if (state != NULL) {
	270	if (state->joy != NULL)
	271	SDL_JoystickClose(state->joy);
	272	free(state->joy_axis_keydown);
	273	free(state);
	274	}
	275	}
	276
	277	static const char * const *
	278	in_sdl_get_key_names(const in_drv_t drv, int count)
	279	{
	280	const struct in_pdata *pdata = drv->pdata;
	281	*count = SDLK_LAST;
	282
	283	if (pdata->key_names)
	284	return pdata->key_names;
	285	return in_sdl_keys;
	286	}
	287
	288	/* could use SDL_GetKeyState, but this gives better packing */
	289	static void update_keystate(keybits_t *keystate, int sym, int is_down)
	290	{
	291	keybits_t *ks_word, mask;
	292
	293	mask = 1;
	294	mask <<= sym & (KEYBITS_WORD_BITS - 1);
	295	ks_word = keystate + sym / KEYBITS_WORD_BITS;
	296	if (is_down)
	297	*ks_word \|= mask;
	298	else
	299	*ks_word &= ~mask;
	300	}
	301
	302	static int get_keystate(keybits_t *keystate, int sym)
	303	{
	304	keybits_t *ks_word, mask;
	305
	306	mask = 1;
	307	mask <<= sym & (KEYBITS_WORD_BITS - 1);
	308	ks_word = keystate + sym / KEYBITS_WORD_BITS;
	309	return !!(*ks_word & mask);
	310	}
	311
	312	static int handle_event(struct in_sdl_state state, SDL_Event event,
	313	int kc_out, int down_out, int *emu_out)
	314	{
	315	int emu;
	316
	317	if (event->type != SDL_KEYDOWN && event->type != SDL_KEYUP)
	318	return -1;
	319
	320	emu = get_keystate(state->emu_keys, event->key.keysym.sym);
	321	update_keystate(state->keystate, event->key.keysym.sym,
	322	event->type == SDL_KEYDOWN);
	323	if (kc_out != NULL)
	324	*kc_out = event->key.keysym.sym;
	325	if (down_out != NULL)
	326	*down_out = event->type == SDL_KEYDOWN;
	327	if (emu_out != NULL)
	328	*emu_out = emu;
	329
	330	return 1;
	331	}
	332
	333	static int handle_joy_event(struct in_sdl_state state, SDL_Event event,
	334	int kc_out, int down_out, int *emu_out)
	335	{
	336	static const int hat2uldr[4] = { SDLK_UP, SDLK_RIGHT, SDLK_DOWN, SDLK_LEFT };
	337	int kc = -1, kc_prev = -1, down = 0, emu = 0, ret = 0, i, val, xor;
	338	int kc_button_base = SDLK_WORLD_0;
	339	int kc_axis_base = kc_button_base + state->joy_numbuttons;
	340	int kc_hat_base = kc_axis_base + state->joy_numaxes;
	341
	342	switch (event->type) {
	343	case SDL_JOYAXISMOTION:
	344	if ((unsigned)event->jaxis.axis >= (unsigned)state->joy_numaxes)
	345	return 1;
	346	if (event->jaxis.which != state->joy_id)
	347	return -2;
	348	if (event->jaxis.value < -16384) {
	349	if (state->abs_to_udlr && event->jaxis.axis < 2)
	350	kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
	351	// some pressure sensitive buttons appear as an axis that goes
	352	// from -32768 (released) to 32767 (pressed) and there is no
	353	// way to distinguish from ones centered at 0? :(
	354	else if (!(state->joy_axis_as_btn & (1u << event->jaxis.axis)))
	355	kc = kc_axis_base + event->jaxis.axis * 2;
	356	down = 1;
	357	}
	358	else if (event->jaxis.value > 16384) {
	359	if (state->abs_to_udlr && event->jaxis.axis < 2)
	360	kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
	361	else
	362	kc = kc_axis_base + event->jaxis.axis * 2 + 1;
	363	down = 1;
	364	}
	365	kc_prev = state->joy_axis_keydown[event->jaxis.axis];
	366	state->joy_axis_keydown[event->jaxis.axis] = kc;
	367	if (kc == kc_prev)
	368	return -1; // no simulated key change
	369	if (kc >= 0 && kc_prev >= 0) {
	370	// must release the old key first
	371	state->joy_axis_keydown[event->jaxis.axis] = -1;
	372	kc = kc_prev;
	373	down = 0;
	374	}
	375	else if (kc_prev >= 0)
	376	kc = kc_prev;
	377	ret = 1;
	378	break;
	379
	380	case SDL_JOYBUTTONDOWN:
	381	case SDL_JOYBUTTONUP:
	382	if (event->jbutton.which != state->joy_id)
	383	return -2;
	384	kc = kc_button_base + (int)event->jbutton.button;
	385	down = event->jbutton.state == SDL_PRESSED;
	386	ret = 1;
	387	break;
	388	case SDL_JOYHATMOTION:
	389	if (event->jhat.which != state->joy_id)
	390	return -2;
	391	xor = event->jhat.value ^ state->joy_hat_down;
	392	val = state->joy_hat_down = event->jhat.value;
	393	for (i = 0; i < 4; i++, xor >>= 1, val >>= 1) {
	394	if (xor & 1) {
	395	if (event->jhat.hat)
	396	kc = kc_hat_base + event->jhat.hat * 4 + i;
	397	else
	398	kc = hat2uldr[i];
	399	down = val & 1;
	400	ret = 1;
	401	break;
	402	}
	403	}
	404	if ((!ret \|\| (xor >> ret)) && !state->hat_warned) {
	405	// none, more than 1, or upper bits changed
	406	fprintf(stderr, "in_sdl: unexpected hat behavior\n");
	407	state->hat_warned = 1;
	408	}
	409	break;
	410	default:
	411	//printf("joy ev %d\n", event->type);
	412	return -1;
	413	}
	414
	415	if (ret) {
	416	emu \|= get_keystate(state->emu_keys, kc);
	417	update_keystate(state->keystate, kc, down);
	418	}
	419	if (kc_out != NULL)
	420	*kc_out = kc;
	421	if (down_out != NULL)
	422	*down_out = down;
	423	if (emu_out != 0)
	424	*emu_out = emu;
	425
	426	return ret;
	427	}
	428
	429	#define JOY_EVENTS (SDL_JOYAXISMOTIONMASK \| SDL_JOYBALLMOTIONMASK \| SDL_JOYHATMOTIONMASK \
	430	\| SDL_JOYBUTTONDOWNMASK \| SDL_JOYBUTTONUPMASK)
	431
	432	static int collect_events(struct in_sdl_state state, int one_kc, int *one_down)
	433	{
	434	SDL_Event events[8];
	435	Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
	436	int count, maxcount, is_emukey = 0;
	437	int i = 0, ret = 0, retval = 0;
	438	SDL_Event *event;
	439
	440	SDL_PumpEvents();
	441
	442	maxcount = ARRAY_SIZE(events);
	443	if ((count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask)) > 0) {
	444	for (i = 0; i < count; i++) {
	445	event = &events[i];
	446	if (state->joy) {
	447	ret = handle_joy_event(state,
	448	event, one_kc, one_down, &is_emukey);
	449	} else {
	450	ret = handle_event(state,
	451	event, one_kc, one_down, &is_emukey);
	452	}
	453	if (ret < 0) {
	454	switch (ret) {
	455	case -2:
	456	SDL_PushEvent(event);
	457	break;
	458	default:
	459	if (event->type == SDL_VIDEORESIZE) {
	460	state->redraw = 1;
	461	state->revent = *event;
	462	} else if (event->type == SDL_VIDEOEXPOSE) {
	463	if (state->revent.type == SDL_NOEVENT) {
	464	state->redraw = 1;
	465	state->revent.type = SDL_VIDEOEXPOSE;
	466	}
	467	} else
	468	if ((event->type == SDL_MOUSEBUTTONDOWN) \|\|
	469	(event->type == SDL_MOUSEBUTTONUP)) {
	470	int mask = SDL_BUTTON(event->button.button);
	471	if (event->button.state == SDL_PRESSED)
	472	state->mevent.motion.state \|= mask;
	473	else state->mevent.motion.state &= ~mask;
	474	} else if (event->type == SDL_MOUSEMOTION) {
	475	event->motion.xrel += state->mevent.motion.xrel;
	476	event->motion.yrel += state->mevent.motion.yrel;
	477	state->mevent = *event;
	478	}
	479	else if (ext_event_handler != NULL)
	480	ext_event_handler(event);
	481	break;
	482	}
	483	continue;
	484	}
	485
	486	retval \|= ret;
	487	if ((is_emukey \|\| one_kc != NULL) && retval)
	488	{
	489	break;
	490	}
	491	}
	492	}
	493
	494	// if the event queue has been emptied and resize/expose events were in it
	495	if (state->redraw && count == 0) {
	496	if (ext_event_handler != NULL)
	497	ext_event_handler(&state->revent);
	498	state->redraw = 0;
	499	state->revent.type = SDL_NOEVENT;
	500	// dummy key event to force returning from the key loop,
	501	// so the application has a chance to redraw the window
	502	if (one_kc != NULL) {
	503	*one_kc = SDLK_UNKNOWN;
	504	retval \|= 1;
	505	}
	506	if (one_down != NULL)
	507	*one_down = 1;
	508	} else
	509	i++;
	510	// don't lose events other devices might want to handle
	511	if (i < count)
	512	SDL_PeepEvents(events+i, count-i, SDL_ADDEVENT, mask);
	513	return retval;
	514	}
	515
	516	static int in_sdl_update(void drv_data, const int binds, int *result)
	517	{
	518	struct in_sdl_state *state = drv_data;
	519	keybits_t mask;
	520	int i, sym, bit, b;
	521
	522	collect_events(state, NULL, NULL);
	523
	524	for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
	525	mask = state->keystate[i];
	526	if (mask == 0)
	527	continue;
	528	for (bit = 0; mask != 0; bit++, mask >>= 1) {
	529	if ((mask & 1) == 0)
	530	continue;
	531	sym = i * KEYBITS_WORD_BITS + bit;
	532
	533	for (b = 0; b < IN_BINDTYPE_COUNT; b++)
	534	result[b] \|= binds[IN_BIND_OFFS(sym, b)];
	535	}
	536	}
	537
	538	return 0;
	539	}
	540
	541	static int in_sdl_update_kbd(void drv_data, const int binds, int *result)
	542	{
	543	struct in_sdl_state *state = drv_data;
	544	keybits_t mask;
	545	int i, sym, bit, b = 0;
	546
	547	collect_events(state, NULL, NULL);
	548
	549	for (i = 0; i < SDLK_LAST / KEYBITS_WORD_BITS + 1; i++) {
	550	mask = state->keystate[i];
	551	if (mask == 0)
	552	continue;
	553	for (bit = 0; mask != 0; bit++, mask >>= 1) {
	554	if ((mask & 1) == 0)
	555	continue;
	556	sym = i * KEYBITS_WORD_BITS + bit;
	557	result[b++] = binds[sym];
	558	}
	559	}
	560
	561	return b;
	562	}
	563
	564	static int in_sdl_update_analog(void drv_data, int axis_id, int result)
	565	{
	566	struct in_sdl_state *state = drv_data;
	567	int v;
	568
	569	if (!state \|\| !state->joy \|\| !result)
	570	return -1;
	571	if ((unsigned)axis_id >= (unsigned)state->joy_numaxes)
	572	return -1;
	573
	574	v = SDL_JoystickGetAxis(state->joy, axis_id);
	575
	576	// -32768...32767 -> -IN_ABS_RANGE...IN_ABS_RANGE
	577	*result = (v + ((v >> 31) \| 1)) / (32768 / IN_ABS_RANGE);
	578	return 0;
	579	}
	580
	581	static int in_sdl_update_pointer(void drv_data, int id, int result)
	582	{
	583	struct in_sdl_state *state = drv_data;
	584	int max;
	585
	586	*result = 0;
	587
	588	switch (id) {
	589	// absolute position, clipped at the window/screen border
	590	case 0: if ((max = state->revent.resize.w))
	591	result = state->mevent.motion.x 2*1024/max - 1024;
	592	break;
	593	case 1: if ((max = state->revent.resize.h))
	594	result = state->mevent.motion.y 2*1024/max - 1024;
	595	break;
	596	// relative mouse movements since last query
	597	case 2: if ((max = state->revent.resize.w))
	598	result = state->mevent.motion.xrel 2*1024/max;
	599	state->mevent.motion.xrel = 0;
	600	break;
	601	case 3: if ((max = state->revent.resize.h))
	602	result = state->mevent.motion.yrel 2*1024/max;
	603	state->mevent.motion.yrel = 0;
	604	break;
	605	// buttons
	606	case -1: *result = state->mevent.motion.state;
	607	break;
	608	default: return -1;
	609	}
	610
	611	return 0;
	612	}
	613
	614	static int in_sdl_update_keycode(void drv_data, int is_down)
	615	{
	616	struct in_sdl_state *state = drv_data;
	617	int ret_kc = -1, ret_down = 0;
	618
	619	collect_events(state, &ret_kc, &ret_down);
	620
	621	if (is_down != NULL)
	622	*is_down = ret_down;
	623
	624	return ret_kc;
	625	}
	626
	627	static int in_sdl_menu_translate(void drv_data, int keycode, char charcode)
	628	{
	629	struct in_sdl_state *state = drv_data;
	630	const struct in_pdata *pdata = state->drv->pdata;
	631	const char * const * key_names = in_sdl_keys;
	632	const struct menu_keymap *map;
	633	int map_len;
	634	int ret = 0;
	635	int i;
	636
	637	if (pdata->key_names)
	638	key_names = pdata->key_names;
	639
	640	if (state->joy) {
	641	map = pdata->joy_map;
	642	map_len = pdata->jmap_size;
	643	} else {
	644	map = pdata->key_map;
	645	map_len = pdata->kmap_size;
	646	}
	647
	648	if (keycode < 0)
	649	{
	650	/* menu -> kc */
	651	keycode = -keycode;
	652	for (i = 0; i < map_len; i++)
	653	if (map[i].pbtn == keycode)
	654	return map[i].key;
	655	}
	656	else
	657	{
	658	if (keycode == SDLK_UNKNOWN)
	659	ret = PBTN_RDRAW;
	660	else
	661	for (i = 0; i < map_len; i++) {
	662	if (map[i].key == keycode) {
	663	ret = map[i].pbtn;
	664	break;
	665	}
	666	}
	667
	668	if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
	669	key_names[keycode] != NULL && key_names[keycode][1] == 0)
	670	{
	671	ret \|= PBTN_CHAR;
	672	*charcode = key_names[keycode][0];
	673	}
	674	}
	675
	676	return ret;
	677	}
	678
	679	static int in_sdl_clean_binds(void drv_data, int binds, int *def_binds)
	680	{
	681	struct in_sdl_state *state = drv_data;
	682	int i, t, cnt = 0;
	683
	684	memset(state->emu_keys, 0, sizeof(state->emu_keys));
	685	for (t = 0; t < IN_BINDTYPE_COUNT; t++) {
	686	for (i = 0; i < SDLK_LAST; i++) {
	687	int offs = IN_BIND_OFFS(i, t);
	688	if (state->joy && i < SDLK_WORLD_0)
	689	binds[offs] = def_binds[offs] = 0;
	690	if (binds[offs]) {
	691	if (t == IN_BINDTYPE_EMU)
	692	update_keystate(state->emu_keys, i, 1);
	693	cnt ++;
	694	}
	695	}
	696	}
	697
	698	return cnt;
	699	}
	700
	701	static int in_sdl_get_config(void drv_data, enum in_cfg_opt what, int val)
	702	{
	703	struct in_sdl_state *state = drv_data;
	704
	705	switch (what) {
	706	case IN_CFG_ABS_AXIS_COUNT:
	707	*val = state->joy_numaxes;
	708	break;
	709	case IN_CFG_ANALOG_MAP_ULDR:
	710	*val = state->abs_to_udlr;
	711	break;
	712	default:
	713	return -1;
	714	}
	715
	716	return 0;
	717	}
	718
	719	static int in_sdl_set_config(void *drv_data, enum in_cfg_opt what, int val)
	720	{
	721	struct in_sdl_state *state = drv_data;
	722	size_t i;
	723
	724	switch (what) {
	725	case IN_CFG_ANALOG_MAP_ULDR:
	726	state->abs_to_udlr = val ? 1 : 0;
	727	for (i = 0; !val && i < state->joy_numaxes; i++) {
	728	if (state->joy_axis_keydown[i] < 0)
	729	continue;
	730	update_keystate(state->keystate, state->joy_axis_keydown[i], 0);
	731	state->joy_axis_keydown[i] = -1;
	732	}
	733	break;
	734	default:
	735	return -1;
	736	}
	737
	738	return 0;
	739	}
	740
	741	static const in_drv_t in_sdl_drv = {
	742	.prefix = IN_SDL_PREFIX,
	743	.probe = in_sdl_probe,
	744	.free = in_sdl_free,
	745	.get_key_names = in_sdl_get_key_names,
	746	.update = in_sdl_update,
	747	.update_kbd = in_sdl_update_kbd,
	748	.update_analog = in_sdl_update_analog,
	749	.update_pointer = in_sdl_update_pointer,
	750	.update_keycode = in_sdl_update_keycode,
	751	.menu_translate = in_sdl_menu_translate,
	752	.clean_binds = in_sdl_clean_binds,
	753	.get_config = in_sdl_get_config,
	754	.set_config = in_sdl_set_config,
	755	};
	756
	757	int in_sdl_init(const struct in_pdata pdata, void (handler)(void *event))
	758	{
	759	if (!pdata) {
	760	fprintf(stderr, "in_sdl: Missing input platform data\n");
	761	return -1;
	762	}
	763
	764	in_register_driver(&in_sdl_drv, pdata->defbinds, pdata->kbd_map, pdata);
	765	ext_event_handler = handler;
	766	return 0;
	767	}