X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=in_sdl.c;h=d8f5ed5a71089fa8120f204be22c37cc606b4c10;hb=HEAD;hp=60f0650e41ad8e4e40e892ca9cd4ea333ed6868e;hpb=d1f5849cf40e92414eddc0bae6bcf3b203af0d0b;p=libpicofe.git

diff --git a/in_sdl.c b/in_sdl.c
index 60f0650..93fe22d 100644
--- a/in_sdl.c
+++ b/in_sdl.c
@@ -19,11 +19,27 @@
 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 axis_keydown[2];
+	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);
@@ -101,6 +117,15 @@ static const char * const in_sdl_keys[SDLK_LAST] = {
 	[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]",
@@ -162,21 +187,48 @@ static const char * const in_sdl_keys[SDLK_LAST] = {
 	[SDLK_COMPOSE] = "compose",
 };
 
-static void in_sdl_probe(void)
+static struct in_sdl_state *state_alloc(int joy_numaxes)
 {
 	struct in_sdl_state *state;
-	SDL_Joystick *joy;
-	int i, joycount;
-	char name[256];
 
 	state = calloc(1, sizeof(*state));
 	if (state == NULL) {
 		fprintf(stderr, "in_sdl: OOM\n");
-		return;
+		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,
-		in_sdl_keys, 0);
+		key_names, 0);
+	//SDL_EnableUNICODE(1);
 
 	/* joysticks go here too */
 	SDL_InitSubSystem(SDL_INIT_JOYSTICK);
@@ -187,16 +239,23 @@ static void in_sdl_probe(void)
 		if (joy == NULL)
 			continue;
 
-		state = calloc(1, sizeof(*state));
-		if (state == NULL) {
-			fprintf(stderr, "in_sdl: OOM\n");
+		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, in_sdl_keys, 0);
+		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)
@@ -210,14 +269,19 @@ static void in_sdl_free(void *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(int *count)
+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;
 }
 
@@ -235,74 +299,129 @@ static void update_keystate(keybits_t *keystate, int sym, int is_down)
 		*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 *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 *kc_out, int *down_out, int *emu_out)
 {
-	int kc = -1, down = 0, ret = 0;
+	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;
 
-	/* FIXME: should ckeck .which */
-	/* TODO: remaining axis */
 	switch (event->type) {
 	case SDL_JOYAXISMOTION:
-		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)
-				update_keystate(state->keystate, kc, 0);
-			kc = event->jaxis.axis ? SDLK_UP : SDLK_LEFT;
-			state->axis_keydown[event->jaxis.axis] = kc;
+		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;
-			ret = 1;
 		}
 		else if (event->jaxis.value > 16384) {
-			kc = state->axis_keydown[event->jaxis.axis];
-			if (kc)
-				update_keystate(state->keystate, kc, 0);
-			kc = event->jaxis.axis ? SDLK_DOWN : SDLK_RIGHT;
-			state->axis_keydown[event->jaxis.axis] = kc;
+			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;
-			ret = 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:
-		kc = (int)event->jbutton.button + SDLK_WORLD_0;
+		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)
+	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;
 }
@@ -312,38 +431,85 @@ static int handle_joy_event(struct in_sdl_state *state, SDL_Event *event,
 
 static int collect_events(struct in_sdl_state *state, int *one_kc, int *one_down)
 {
-	SDL_Event events[4];
+	SDL_Event events[8];
 	Uint32 mask = state->joy ? JOY_EVENTS : (SDL_ALLEVENTS & ~JOY_EVENTS);
-	int count, maxcount;
-	int i, ret, retval = 0;
-
-	maxcount = (one_kc != NULL) ? 1 : sizeof(events) / sizeof(events[0]);
+	int count, maxcount, is_emukey = 0;
+	int i = 0, ret = 0, retval = 0;
+	SDL_Event *event;
 
 	SDL_PumpEvents();
-	while (1) {
-		count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask);
-		if (count <= 0)
-			break;
+
+	maxcount = ARRAY_SIZE(events);
+	if ((count = SDL_PeepEvents(events, maxcount, SDL_GETEVENT, mask)) > 0) {
 		for (i = 0; i < count; i++) {
-			if (state->joy)
+			event = &events[i];
+			if (state->joy) {
 				ret = handle_joy_event(state,
-					&events[i], one_kc, one_down);
-			else
+					event, one_kc, one_down, &is_emukey);
+			} else {
 				ret = handle_event(state,
-					&events[i], one_kc, one_down);
-			if (ret == -1) {
-				if (ext_event_handler != NULL)
-					ext_event_handler(&events[i]);
+					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 (one_kc != NULL && ret)
-				goto out;
+			if ((is_emukey || one_kc != NULL) && retval)
+			{
+				break;
+			}
 		}
 	}
 
-out:
+	// 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;
 }
 
@@ -372,6 +538,79 @@ static int in_sdl_update(void *drv_data, const int *binds, int *result)
 	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;
@@ -385,52 +624,26 @@ static int in_sdl_update_keycode(void *drv_data, int *is_down)
 	return ret_kc;
 }
 
-struct menu_keymap {
-	short key;
-	short pbtn;
-};
-
-static const struct menu_keymap key_pbtn_map[] =
-{
-	{ SDLK_UP,	PBTN_UP },
-	{ SDLK_DOWN,	PBTN_DOWN },
-	{ SDLK_LEFT,	PBTN_LEFT },
-	{ SDLK_RIGHT,	PBTN_RIGHT },
-	/* XXX: maybe better set this from it's plat code somehow */
-	{ SDLK_RETURN,	PBTN_MOK },
-	{ SDLK_ESCAPE,	PBTN_MBACK },
-	{ SDLK_SEMICOLON,    PBTN_MA2 },
-	{ SDLK_QUOTE,        PBTN_MA3 },
-	{ SDLK_BACKSLASH,    PBTN_MENU },
-	{ SDLK_LEFTBRACKET,  PBTN_L },
-	{ SDLK_RIGHTBRACKET, PBTN_R },
-};
-#define KEY_PBTN_MAP_SIZE (sizeof(key_pbtn_map) / sizeof(key_pbtn_map[0]))
-
-static const struct menu_keymap joybtn_pbtn_map[] =
-{
-	{ SDLK_UP,	PBTN_UP },
-	{ SDLK_DOWN,	PBTN_DOWN },
-	{ SDLK_LEFT,	PBTN_LEFT },
-	{ SDLK_RIGHT,	PBTN_RIGHT },
-	/* joystick */
-	{ SDLK_WORLD_0,	PBTN_MOK },
-	{ SDLK_WORLD_1,	PBTN_MBACK },
-	{ SDLK_WORLD_2,	PBTN_MA2 },
-	{ SDLK_WORLD_3,	PBTN_MA3 },
-};
-#define JOYBTN_PBTN_MAP_SIZE (sizeof(joybtn_pbtn_map) / sizeof(joybtn_pbtn_map[0]))
-
 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;
 
-	map = state->joy ? joybtn_pbtn_map : key_pbtn_map;
-	map_len = state->joy ? JOYBTN_PBTN_MAP_SIZE : KEY_PBTN_MAP_SIZE;
+	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)
 	{
@@ -442,6 +655,9 @@ static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
 	}
 	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;
@@ -450,29 +666,102 @@ static int in_sdl_menu_translate(void *drv_data, int keycode, char *charcode)
 		}
 
 		if (charcode != NULL && (unsigned int)keycode < SDLK_LAST &&
-		    in_sdl_keys[keycode] != NULL && in_sdl_keys[keycode][1] == 0)
+		    key_names[keycode] != NULL && key_names[keycode][1] == 0)
 		{
 			ret |= PBTN_CHAR;
-			*charcode = in_sdl_keys[keycode][0];
+			*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_keycode = in_sdl_update_keycode,
-	.menu_translate = in_sdl_menu_translate,
+	.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,
 };
 
-void in_sdl_init(const struct in_default_bind *defbinds,
-		 void (*handler)(void *event))
+int in_sdl_init(const struct in_pdata *pdata, void (*handler)(void *event))
 {
-	in_register_driver(&in_sdl_drv, defbinds);
+	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;
 }