[sdl_omap.git] / src / video / omapdss / osdl_input.c

/*
 * (C) notaz, 2010
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING file in the top-level directory.
 */

#include <strings.h>
#include <SDL/SDL.h>
#include <linux/input.h>

#include "omapsdl.h"
#include "common/input.h"

static short pmsdl_map[KEY_CNT] = {
	[KEY_0]		= SDLK_0,
	[KEY_1]		= SDLK_1,
	[KEY_2]		= SDLK_2,
	[KEY_3]		= SDLK_3,
	[KEY_4]		= SDLK_4,
	[KEY_5]		= SDLK_5,
	[KEY_6]		= SDLK_6,
	[KEY_7]		= SDLK_7,
	[KEY_8]		= SDLK_8,
	[KEY_9]		= SDLK_9,
	[KEY_A]		= SDLK_a,
	[KEY_B]		= SDLK_b,
	[KEY_C]		= SDLK_c,
	[KEY_D]		= SDLK_d,
	[KEY_E]		= SDLK_e,
	[KEY_F]		= SDLK_f,
	[KEY_G]		= SDLK_g,
	[KEY_H]		= SDLK_h,
	[KEY_I]		= SDLK_i,
	[KEY_J]		= SDLK_j,
	[KEY_K]		= SDLK_k,
	[KEY_L]		= SDLK_l,
	[KEY_M]		= SDLK_m,
	[KEY_N]		= SDLK_n,
	[KEY_O]		= SDLK_o,
	[KEY_P]		= SDLK_p,
	[KEY_Q]		= SDLK_q,
	[KEY_R]		= SDLK_r,
	[KEY_S]		= SDLK_s,
	[KEY_T]		= SDLK_t,
	[KEY_U]		= SDLK_u,
	[KEY_V]		= SDLK_v,
	[KEY_W]		= SDLK_w,
	[KEY_X]		= SDLK_x,
	[KEY_Y]		= SDLK_y,
	[KEY_Z]		= SDLK_z,
	[KEY_SPACE]	= SDLK_SPACE,
	[KEY_BACKSPACE]	= SDLK_BACKSPACE,
	[KEY_FN]	= SDLK_MODE,
	[KEY_DOT]	= SDLK_PERIOD,
	[KEY_ENTER]	= SDLK_RETURN,
	[KEY_LEFTSHIFT]	= SDLK_LSHIFT,
	[KEY_COMMA]	= SDLK_COMMA,
//	[KEY_BRIGHTNESSUP]	=
//	[KEY_BRIGHTNESSDOWN]	=
//	[KEY_GRAVE]	=
	[KEY_TAB]	= SDLK_TAB,
	[KEY_INSERT]	= SDLK_INSERT,
	[KEY_EQUAL]	= SDLK_EQUALS,
	[KEY_KPPLUS]	= SDLK_KP_PLUS,
	[KEY_BACKSLASH]	= SDLK_BACKSLASH,
	[KEY_RIGHTBRACE]= SDLK_RIGHTBRACKET,
	[KEY_KPMINUS]	= SDLK_KP_MINUS,
	[KEY_QUESTION]	= SDLK_QUESTION,
	[KEY_LEFTBRACE]	= SDLK_LEFTBRACKET,
	[KEY_SLASH]	= SDLK_SLASH,
//	[KEY_YEN]	=
	[KEY_APOSTROPHE]= SDLK_QUOTE,
	[KEY_ESC]	= SDLK_ESCAPE,
	[KEY_CAPSLOCK]	= SDLK_CAPSLOCK,
	[KEY_SEMICOLON]	= SDLK_SEMICOLON,
	[KEY_F1]	= SDLK_F1,
	[KEY_F2]	= SDLK_F2,
	[KEY_F3]	= SDLK_F3,
	[KEY_F4]	= SDLK_F4,
	[KEY_F5]	= SDLK_F5,
	[KEY_F6]	= SDLK_F6,
	[KEY_F7]	= SDLK_F7,
	[KEY_F8]	= SDLK_F8,
	[KEY_F9]	= SDLK_F9,
	[KEY_F10]	= KEY_F10,
	[KEY_F11]	= KEY_F11,
	[KEY_F12]	= KEY_F12,
	[KEY_F13]	= KEY_F13,	/* apostrophe, differs from Fn-A? */
	[KEY_F14]	= KEY_F14,	/* pipe/bar */
	[KEY_F15]	= KEY_F15,	/* dash */
	[KEY_F16]	= SDLK_HASH,	/* # (pound/hash) */
	[KEY_F17]	= SDLK_EXCLAIM,	/* ! */
//	[KEY_F18]	=		/* £ (pound) */
	[KEY_F19]	= SDLK_QUOTEDBL,/* " */
	[KEY_F20]	= SDLK_AT,	/* @ */
	[KEY_F21]	= SDLK_SEMICOLON,/* : */
//	[KEY_F22]	=
//	[KEY_F23]	=

	[KEY_UP]	= SDLK_UP,
	[KEY_DOWN]	= SDLK_DOWN,
	[KEY_LEFT]	= SDLK_LEFT,
	[KEY_RIGHT]	= SDLK_RIGHT,
	[KEY_HOME]	= SDLK_HOME,
	[KEY_END]	= SDLK_END,
	[KEY_PAGEUP]	= SDLK_PAGEUP,
	[KEY_PAGEDOWN]	= SDLK_PAGEDOWN,
	[KEY_LEFTALT]	= SDLK_LALT,
	[KEY_LEFTCTRL]	= SDLK_LCTRL,
//	[KEY_MENU]	=
	[KEY_RIGHTSHIFT]= SDLK_RSHIFT,
	[KEY_RIGHTCTRL]	= SDLK_RCTRL,
};

#define DNKEY(x) [SDLK_##x] = #x
static const char *sdl_keynames[SDLK_LAST] = {
	DNKEY(BACKSPACE),
	DNKEY(TAB),
	DNKEY(RETURN),
	DNKEY(ESCAPE),
	DNKEY(SPACE),
	DNKEY(EXCLAIM),
	DNKEY(QUOTEDBL),
	DNKEY(HASH),
	DNKEY(DOLLAR),
	DNKEY(AMPERSAND),
	DNKEY(QUOTE),
	DNKEY(LEFTPAREN),
	DNKEY(RIGHTPAREN),
	DNKEY(ASTERISK),
	DNKEY(PLUS),
	DNKEY(COMMA),
	DNKEY(MINUS),
	DNKEY(PERIOD),
	DNKEY(SLASH),
	DNKEY(0),
	DNKEY(1),
	DNKEY(2),
	DNKEY(3),
	DNKEY(4),
	DNKEY(5),
	DNKEY(6),
	DNKEY(7),
	DNKEY(8),
	DNKEY(9),
	DNKEY(COLON),
	DNKEY(SEMICOLON),
	DNKEY(LESS),
	DNKEY(EQUALS),
	DNKEY(GREATER),
	DNKEY(QUESTION),
	DNKEY(AT),
	DNKEY(LEFTBRACKET),
	DNKEY(BACKSLASH),
	DNKEY(RIGHTBRACKET),
	DNKEY(CARET),
	DNKEY(UNDERSCORE),
	DNKEY(BACKQUOTE),
	DNKEY(a),
	DNKEY(b),
	DNKEY(c),
	DNKEY(d),
	DNKEY(e),
	DNKEY(f),
	DNKEY(g),
	DNKEY(h),
	DNKEY(i),
	DNKEY(j),
	DNKEY(k),
	DNKEY(l),
	DNKEY(m),
	DNKEY(n),
	DNKEY(o),
	DNKEY(p),
	DNKEY(q),
	DNKEY(r),
	DNKEY(s),
	DNKEY(t),
	DNKEY(u),
	DNKEY(v),
	DNKEY(w),
	DNKEY(x),
	DNKEY(y),
	DNKEY(z),
	DNKEY(DELETE),
	DNKEY(WORLD_0),
	DNKEY(WORLD_1),
	DNKEY(WORLD_2),
	DNKEY(WORLD_3),
	DNKEY(WORLD_4),
	DNKEY(WORLD_5),
	DNKEY(WORLD_6),
	DNKEY(WORLD_7),
	DNKEY(WORLD_8),
	DNKEY(WORLD_9),
	DNKEY(WORLD_10),
	DNKEY(WORLD_11),
	DNKEY(WORLD_12),
	DNKEY(WORLD_13),
	DNKEY(WORLD_14),
	DNKEY(WORLD_15),
	DNKEY(WORLD_16),
	DNKEY(WORLD_17),
	DNKEY(WORLD_18),
	DNKEY(WORLD_19),
	DNKEY(WORLD_20),
	DNKEY(WORLD_21),
	DNKEY(WORLD_22),
	DNKEY(WORLD_23),
	DNKEY(WORLD_24),
	DNKEY(WORLD_25),
	DNKEY(WORLD_26),
	DNKEY(WORLD_27),
	DNKEY(WORLD_28),
	DNKEY(WORLD_29),
	DNKEY(WORLD_30),
	DNKEY(WORLD_31),
	DNKEY(WORLD_32),
	DNKEY(WORLD_33),
	DNKEY(WORLD_34),
	DNKEY(WORLD_35),
	DNKEY(WORLD_36),
	DNKEY(WORLD_37),
	DNKEY(WORLD_38),
	DNKEY(WORLD_39),
	DNKEY(WORLD_40),
	DNKEY(WORLD_41),
	DNKEY(WORLD_42),
	DNKEY(WORLD_43),
	DNKEY(WORLD_44),
	DNKEY(WORLD_45),
	DNKEY(WORLD_46),
	DNKEY(WORLD_47),
	DNKEY(WORLD_48),
	DNKEY(WORLD_49),
	DNKEY(WORLD_50),
	DNKEY(WORLD_51),
	DNKEY(WORLD_52),
	DNKEY(WORLD_53),
	DNKEY(WORLD_54),
	DNKEY(WORLD_55),
	DNKEY(WORLD_56),
	DNKEY(WORLD_57),
	DNKEY(WORLD_58),
	DNKEY(WORLD_59),
	DNKEY(WORLD_60),
	DNKEY(WORLD_61),
	DNKEY(WORLD_62),
	DNKEY(WORLD_63),
	DNKEY(WORLD_64),
	DNKEY(WORLD_65),
	DNKEY(WORLD_66),
	DNKEY(WORLD_67),
	DNKEY(WORLD_68),
	DNKEY(WORLD_69),
	DNKEY(WORLD_70),
	DNKEY(WORLD_71),
	DNKEY(WORLD_72),
	DNKEY(WORLD_73),
	DNKEY(WORLD_74),
	DNKEY(WORLD_75),
	DNKEY(WORLD_76),
	DNKEY(WORLD_77),
	DNKEY(WORLD_78),
	DNKEY(WORLD_79),
	DNKEY(WORLD_80),
	DNKEY(WORLD_81),
	DNKEY(WORLD_82),
	DNKEY(WORLD_83),
	DNKEY(WORLD_84),
	DNKEY(WORLD_85),
	DNKEY(WORLD_86),
	DNKEY(WORLD_87),
	DNKEY(WORLD_88),
	DNKEY(WORLD_89),
	DNKEY(WORLD_90),
	DNKEY(WORLD_91),
	DNKEY(WORLD_92),
	DNKEY(WORLD_93),
	DNKEY(WORLD_94),
	DNKEY(WORLD_95),
	DNKEY(KP0),
	DNKEY(KP1),
	DNKEY(KP2),
	DNKEY(KP3),
	DNKEY(KP4),
	DNKEY(KP5),
	DNKEY(KP6),
	DNKEY(KP7),
	DNKEY(KP8),
	DNKEY(KP9),
	DNKEY(KP_PERIOD),
	DNKEY(KP_DIVIDE),
	DNKEY(KP_MULTIPLY),
	DNKEY(KP_MINUS),
	DNKEY(KP_PLUS),
	DNKEY(KP_ENTER),
	DNKEY(KP_EQUALS),
	DNKEY(UP),
	DNKEY(DOWN),
	DNKEY(RIGHT),
	DNKEY(LEFT),
	DNKEY(INSERT),
	DNKEY(HOME),
	DNKEY(END),
	DNKEY(PAGEUP),
	DNKEY(PAGEDOWN),
	DNKEY(F1),
	DNKEY(F2),
	DNKEY(F3),
	DNKEY(F4),
	DNKEY(F5),
	DNKEY(F6),
	DNKEY(F7),
	DNKEY(F8),
	DNKEY(F9),
	DNKEY(F10),
	DNKEY(F11),
	DNKEY(F12),
	DNKEY(F13),
	DNKEY(F14),
	DNKEY(F15),
	DNKEY(NUMLOCK),
	DNKEY(CAPSLOCK),
	DNKEY(SCROLLOCK),
	DNKEY(RSHIFT),
	DNKEY(LSHIFT),
	DNKEY(RCTRL),
	DNKEY(LCTRL),
	DNKEY(RALT),
	DNKEY(LALT),
	DNKEY(RMETA),
	DNKEY(LMETA),
	DNKEY(LSUPER),
	DNKEY(RSUPER),
	DNKEY(MODE),
	DNKEY(COMPOSE),
};

void omapsdl_input_bind(const char *kname, const char *sdlname)
{
	int i, kc;

	kc = in_get_key_code(-1, kname);
	if (kc < 0) {
		err("can't resolve key '%s'", kname);
		return;
	}

	if (sdlname == NULL || strncasecmp(sdlname, "SDLK_", 5) != 0)
		goto bad_sdlkey;

	for (i = 0; i < SDLK_LAST; i++) {
		if (sdl_keynames[i] == NULL)
			continue;
		if (strcasecmp(sdl_keynames[i], sdlname + 5) == 0)
			break;
	}

	if (i >= SDLK_LAST)
		goto bad_sdlkey;

	pmsdl_map[kc] = i;
	return;

bad_sdlkey:
	err("can't resolve SDL key '%s'", sdlname);
}

void omapsdl_input_init(void)
{
	in_init();
	in_probe();
}

int omapsdl_input_get_event(int *is_down, int timeout)
{
	int key;

	while (1) {
		int kc;

		*is_down = 0;
		kc = in_update_keycode(NULL, is_down, timeout);
		if (kc < 0 || kc > KEY_MAX)
			return -1;

		key = pmsdl_map[kc];
		if (key != 0)
			break;
	}

	return key;
}

/* SDL */
#ifdef STANDALONE

static unsigned char g_keystate[SDLK_LAST];

static int do_event(SDL_Event *event, int timeout)
{
	int key, is_down;

	key = omapsdl_input_get_event(&is_down, timeout);
	if (key < 0)
		return 0;

	g_keystate[key] = is_down;

	if (event == NULL)
		return 1; // FIXME: ..but the event is lost

	memset(event, 0, sizeof(event->key));
	event->type = is_down ? SDL_KEYDOWN : SDL_KEYUP;
	// event->key.which =
	event->key.state = is_down ? SDL_PRESSED : SDL_RELEASED;
	event->key.keysym.sym = key;
	// event->key.keysym.mod

	return 1;
}

DECLSPEC int SDLCALL
SDL_WaitEvent(SDL_Event *event)
{
	trace("%p", event);

	return do_event(event, -1);
}

DECLSPEC int SDLCALL
SDL_PollEvent(SDL_Event *event)
{
	trace("%p", event);

	return do_event(event, 0);
}

DECLSPEC Uint8 * SDLCALL
SDL_GetKeyState(int *numkeys)
{
	trace("%p", numkeys);

	if (numkeys != NULL)
		*numkeys = ARRAY_SIZE(g_keystate);
	return g_keystate;
}

DECLSPEC char * SDLCALL
SDL_GetKeyName(SDLKey key)
{
	trace("%d", key);

	if ((unsigned int)key < ARRAY_SIZE(sdl_keynames))
		return (char *)sdl_keynames[key];
	else
		return "";
}

DECLSPEC int SDLCALL
SDL_EnableUNICODE(int enable)
{
	trace("%d", enable);

	if (enable > 0)
		not_supported();

	return 0;
}

DECLSPEC int SDLCALL
SDL_EnableKeyRepeat(int delay, int interval)
{
	trace("%d, %d", delay, interval);

	if (delay)
		not_supported();
	return 0;
}

DECLSPEC void SDLCALL
SDL_GetKeyRepeat(int *delay, int *interval)
{
	trace("%p, %p", delay, interval);

	if (delay)
		*delay = 0;
	if (interval)
		*interval = 0;
}

DECLSPEC SDLMod SDLCALL
SDL_GetModState(void)
{
	static const short syms[] = { SDLK_LSHIFT, SDLK_RSHIFT, SDLK_LCTRL, SDLK_RCTRL, SDLK_LALT,
				SDLK_RALT, SDLK_LMETA, SDLK_RMETA, SDLK_NUMLOCK, SDLK_CAPSLOCK, SDLK_MODE };
	static const short mods[] = { KMOD_LSHIFT, KMOD_RSHIFT, KMOD_LCTRL, KMOD_RCTRL, KMOD_LALT,
				KMOD_RALT, KMOD_LMETA, KMOD_RMETA, KMOD_NUM, KMOD_CAPS, KMOD_MODE };
	SDLMod ret = KMOD_NONE;
	int i;

	trace("");

	for (i = 0; i < ARRAY_SIZE(syms); i++)
		if (g_keystate[syms[i]])
			ret |= mods[i];

	return ret;
}

/* Joysticks */
DECLSPEC int SDLCALL
SDL_NumJoysticks(void)
{
	trace("");
	return 0;
}

DECLSPEC SDL_Joystick * SDLCALL
SDL_JoystickOpen(int device_index)
{
	trace("%d", device_index);
	return NULL;
}

#endif // STANDALONE
Commit	Line	Data
b78828bf	1	/*
	2	* (C) notaz, 2010
	3	*
	4	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	5	* See the COPYING file in the top-level directory.
	6	*/
	7
3cb98c5e	8	#include <strings.h>
	9	#include <SDL/SDL.h>
	10	#include <linux/input.h>
	11
b78828bf	12	#include "omapsdl.h"
3cb98c5e	13	#include "common/input.h"
3cb98c5e	14
3cb98c5e	15	static short pmsdl_map[KEY_CNT] = {
	16	[KEY_0] = SDLK_0,
	17	[KEY_1] = SDLK_1,
	18	[KEY_2] = SDLK_2,
	19	[KEY_3] = SDLK_3,
	20	[KEY_4] = SDLK_4,
	21	[KEY_5] = SDLK_5,
	22	[KEY_6] = SDLK_6,
	23	[KEY_7] = SDLK_7,
	24	[KEY_8] = SDLK_8,
	25	[KEY_9] = SDLK_9,
	26	[KEY_A] = SDLK_a,
	27	[KEY_B] = SDLK_b,
	28	[KEY_C] = SDLK_c,
	29	[KEY_D] = SDLK_d,
	30	[KEY_E] = SDLK_e,
	31	[KEY_F] = SDLK_f,
	32	[KEY_G] = SDLK_g,
	33	[KEY_H] = SDLK_h,
	34	[KEY_I] = SDLK_i,
	35	[KEY_J] = SDLK_j,
	36	[KEY_K] = SDLK_k,
	37	[KEY_L] = SDLK_l,
	38	[KEY_M] = SDLK_m,
	39	[KEY_N] = SDLK_n,
	40	[KEY_O] = SDLK_o,
	41	[KEY_P] = SDLK_p,
	42	[KEY_Q] = SDLK_q,
	43	[KEY_R] = SDLK_r,
	44	[KEY_S] = SDLK_s,
	45	[KEY_T] = SDLK_t,
	46	[KEY_U] = SDLK_u,
	47	[KEY_V] = SDLK_v,
	48	[KEY_W] = SDLK_w,
	49	[KEY_X] = SDLK_x,
	50	[KEY_Y] = SDLK_y,
	51	[KEY_Z] = SDLK_z,
	52	[KEY_SPACE] = SDLK_SPACE,
	53	[KEY_BACKSPACE] = SDLK_BACKSPACE,
	54	[KEY_FN] = SDLK_MODE,
	55	[KEY_DOT] = SDLK_PERIOD,
	56	[KEY_ENTER] = SDLK_RETURN,
	57	[KEY_LEFTSHIFT] = SDLK_LSHIFT,
	58	[KEY_COMMA] = SDLK_COMMA,
	59	// [KEY_BRIGHTNESSUP] =
	60	// [KEY_BRIGHTNESSDOWN] =
	61	// [KEY_GRAVE] =
	62	[KEY_TAB] = SDLK_TAB,
	63	[KEY_INSERT] = SDLK_INSERT,
	64	[KEY_EQUAL] = SDLK_EQUALS,
	65	[KEY_KPPLUS] = SDLK_KP_PLUS,
	66	[KEY_BACKSLASH] = SDLK_BACKSLASH,
	67	[KEY_RIGHTBRACE]= SDLK_RIGHTBRACKET,
	68	[KEY_KPMINUS] = SDLK_KP_MINUS,
	69	[KEY_QUESTION] = SDLK_QUESTION,
	70	[KEY_LEFTBRACE] = SDLK_LEFTBRACKET,
	71	[KEY_SLASH] = SDLK_SLASH,
	72	// [KEY_YEN] =
	73	[KEY_APOSTROPHE]= SDLK_QUOTE,
	74	[KEY_ESC] = SDLK_ESCAPE,
	75	[KEY_CAPSLOCK] = SDLK_CAPSLOCK,
	76	[KEY_SEMICOLON] = SDLK_SEMICOLON,
	77	[KEY_F1] = SDLK_F1,
	78	[KEY_F2] = SDLK_F2,
79	[KEY_F3] = SDLK_F3,
80	[KEY_F4] = SDLK_F4,
81	[KEY_F5] = SDLK_F5,
82	[KEY_F6] = SDLK_F6,
83	[KEY_F7] = SDLK_F7,
84	[KEY_F8] = SDLK_F8,
85	[KEY_F9] = SDLK_F9,
86	[KEY_F10] = KEY_F10,
87	[KEY_F11] = KEY_F11,
88	[KEY_F12] = KEY_F12,
89	[KEY_F13] = KEY_F13, /* apostrophe, differs from Fn-A? */
90	[KEY_F14] = KEY_F14, /* pipe/bar */
91	[KEY_F15] = KEY_F15, /* dash */
92	[KEY_F16] = SDLK_HASH, /* # (pound/hash) */
93	[KEY_F17] = SDLK_EXCLAIM, /* ! */
94	// [KEY_F18] = /* £ (pound) */
95	[KEY_F19] = SDLK_QUOTEDBL,/* " */
96	[KEY_F20] = SDLK_AT, /* @ */
97	[KEY_F21] = SDLK_SEMICOLON,/* : */
98	// [KEY_F22] =
99	// [KEY_F23] =
100
101	[KEY_UP] = SDLK_UP,
102	[KEY_DOWN] = SDLK_DOWN,
103	[KEY_LEFT] = SDLK_LEFT,
104	[KEY_RIGHT] = SDLK_RIGHT,
105	[KEY_HOME] = SDLK_HOME,
106	[KEY_END] = SDLK_END,
107	[KEY_PAGEUP] = SDLK_PAGEUP,
108	[KEY_PAGEDOWN] = SDLK_PAGEDOWN,
109	[KEY_LEFTALT] = SDLK_LALT,
110	[KEY_LEFTCTRL] = SDLK_LCTRL,
111	// [KEY_MENU] =
112	[KEY_RIGHTSHIFT]= SDLK_RSHIFT,
113	[KEY_RIGHTCTRL] = SDLK_RCTRL,
114	};
115
116	#define DNKEY(x) [SDLK_##x] = #x
117	static const char *sdl_keynames[SDLK_LAST] = {
118	DNKEY(BACKSPACE),
119	DNKEY(TAB),
120	DNKEY(RETURN),
121	DNKEY(ESCAPE),
122	DNKEY(SPACE),
123	DNKEY(EXCLAIM),
124	DNKEY(QUOTEDBL),
125	DNKEY(HASH),
126	DNKEY(DOLLAR),
127	DNKEY(AMPERSAND),
128	DNKEY(QUOTE),
129	DNKEY(LEFTPAREN),
130	DNKEY(RIGHTPAREN),
131	DNKEY(ASTERISK),
132	DNKEY(PLUS),
133	DNKEY(COMMA),
134	DNKEY(MINUS),
135	DNKEY(PERIOD),
136	DNKEY(SLASH),
137	DNKEY(0),
138	DNKEY(1),
139	DNKEY(2),
140	DNKEY(3),
141	DNKEY(4),
142	DNKEY(5),
143	DNKEY(6),
144	DNKEY(7),
145	DNKEY(8),
146	DNKEY(9),
147	DNKEY(COLON),
148	DNKEY(SEMICOLON),
149	DNKEY(LESS),
150	DNKEY(EQUALS),
151	DNKEY(GREATER),
152	DNKEY(QUESTION),
153	DNKEY(AT),
154	DNKEY(LEFTBRACKET),
155	DNKEY(BACKSLASH),
156	DNKEY(RIGHTBRACKET),
157	DNKEY(CARET),
158	DNKEY(UNDERSCORE),
159	DNKEY(BACKQUOTE),
160	DNKEY(a),
161	DNKEY(b),
162	DNKEY(c),
163	DNKEY(d),
164	DNKEY(e),
165	DNKEY(f),
166	DNKEY(g),
167	DNKEY(h),
168	DNKEY(i),
169	DNKEY(j),
170	DNKEY(k),
171	DNKEY(l),
172	DNKEY(m),
173	DNKEY(n),
174	DNKEY(o),
175	DNKEY(p),
176	DNKEY(q),
177	DNKEY(r),
178	DNKEY(s),
179	DNKEY(t),
180	DNKEY(u),
181	DNKEY(v),
182	DNKEY(w),
183	DNKEY(x),
184	DNKEY(y),
185	DNKEY(z),
186	DNKEY(DELETE),
187	DNKEY(WORLD_0),
188	DNKEY(WORLD_1),
189	DNKEY(WORLD_2),
190	DNKEY(WORLD_3),
191	DNKEY(WORLD_4),
192	DNKEY(WORLD_5),
193	DNKEY(WORLD_6),
194	DNKEY(WORLD_7),
195	DNKEY(WORLD_8),
196	DNKEY(WORLD_9),
197	DNKEY(WORLD_10),
198	DNKEY(WORLD_11),
199	DNKEY(WORLD_12),
200	DNKEY(WORLD_13),
201	DNKEY(WORLD_14),
202	DNKEY(WORLD_15),
203	DNKEY(WORLD_16),
204	DNKEY(WORLD_17),
205	DNKEY(WORLD_18),
206	DNKEY(WORLD_19),
207	DNKEY(WORLD_20),
208	DNKEY(WORLD_21),
209	DNKEY(WORLD_22),
210	DNKEY(WORLD_23),
211	DNKEY(WORLD_24),
212	DNKEY(WORLD_25),
213	DNKEY(WORLD_26),
214	DNKEY(WORLD_27),
215	DNKEY(WORLD_28),
216	DNKEY(WORLD_29),
217	DNKEY(WORLD_30),
218	DNKEY(WORLD_31),
219	DNKEY(WORLD_32),
220	DNKEY(WORLD_33),
221	DNKEY(WORLD_34),
222	DNKEY(WORLD_35),
223	DNKEY(WORLD_36),
224	DNKEY(WORLD_37),
225	DNKEY(WORLD_38),
226	DNKEY(WORLD_39),
227	DNKEY(WORLD_40),
228	DNKEY(WORLD_41),
229	DNKEY(WORLD_42),
230	DNKEY(WORLD_43),
231	DNKEY(WORLD_44),
232	DNKEY(WORLD_45),
233	DNKEY(WORLD_46),
234	DNKEY(WORLD_47),
235	DNKEY(WORLD_48),
236	DNKEY(WORLD_49),
237	DNKEY(WORLD_50),
238	DNKEY(WORLD_51),
239	DNKEY(WORLD_52),
240	DNKEY(WORLD_53),
241	DNKEY(WORLD_54),
242	DNKEY(WORLD_55),
243	DNKEY(WORLD_56),
244	DNKEY(WORLD_57),
245	DNKEY(WORLD_58),
246	DNKEY(WORLD_59),
247	DNKEY(WORLD_60),
248	DNKEY(WORLD_61),
249	DNKEY(WORLD_62),
250	DNKEY(WORLD_63),
251	DNKEY(WORLD_64),
252	DNKEY(WORLD_65),
253	DNKEY(WORLD_66),
254	DNKEY(WORLD_67),
255	DNKEY(WORLD_68),
256	DNKEY(WORLD_69),
257	DNKEY(WORLD_70),
258	DNKEY(WORLD_71),
259	DNKEY(WORLD_72),
260	DNKEY(WORLD_73),
261	DNKEY(WORLD_74),
262	DNKEY(WORLD_75),
263	DNKEY(WORLD_76),
264	DNKEY(WORLD_77),
265	DNKEY(WORLD_78),
266	DNKEY(WORLD_79),
267	DNKEY(WORLD_80),
268	DNKEY(WORLD_81),
269	DNKEY(WORLD_82),
270	DNKEY(WORLD_83),
271	DNKEY(WORLD_84),
272	DNKEY(WORLD_85),
273	DNKEY(WORLD_86),
274	DNKEY(WORLD_87),
275	DNKEY(WORLD_88),
276	DNKEY(WORLD_89),
277	DNKEY(WORLD_90),
278	DNKEY(WORLD_91),
279	DNKEY(WORLD_92),
280	DNKEY(WORLD_93),
281	DNKEY(WORLD_94),
282	DNKEY(WORLD_95),
283	DNKEY(KP0),
284	DNKEY(KP1),
285	DNKEY(KP2),
286	DNKEY(KP3),
287	DNKEY(KP4),
288	DNKEY(KP5),
289	DNKEY(KP6),
290	DNKEY(KP7),
291	DNKEY(KP8),
292	DNKEY(KP9),
293	DNKEY(KP_PERIOD),
294	DNKEY(KP_DIVIDE),
295	DNKEY(KP_MULTIPLY),
296	DNKEY(KP_MINUS),
297	DNKEY(KP_PLUS),
298	DNKEY(KP_ENTER),
299	DNKEY(KP_EQUALS),
300	DNKEY(UP),
301	DNKEY(DOWN),
302	DNKEY(RIGHT),
303	DNKEY(LEFT),
304	DNKEY(INSERT),
305	DNKEY(HOME),
306	DNKEY(END),
307	DNKEY(PAGEUP),
308	DNKEY(PAGEDOWN),
309	DNKEY(F1),
310	DNKEY(F2),
311	DNKEY(F3),
312	DNKEY(F4),
313	DNKEY(F5),
314	DNKEY(F6),
315	DNKEY(F7),
316	DNKEY(F8),
317	DNKEY(F9),
318	DNKEY(F10),
319	DNKEY(F11),
320	DNKEY(F12),
321	DNKEY(F13),
322	DNKEY(F14),
323	DNKEY(F15),
324	DNKEY(NUMLOCK),
325	DNKEY(CAPSLOCK),
326	DNKEY(SCROLLOCK),
327	DNKEY(RSHIFT),
328	DNKEY(LSHIFT),
329	DNKEY(RCTRL),
330	DNKEY(LCTRL),
331	DNKEY(RALT),
332	DNKEY(LALT),
333	DNKEY(RMETA),
334	DNKEY(LMETA),
335	DNKEY(LSUPER),
336	DNKEY(RSUPER),
337	DNKEY(MODE),
338	DNKEY(COMPOSE),
339	};
340
b78828bf	341	void omapsdl_input_bind(const char kname, const char sdlname)
3cb98c5e	342	{
	343	int i, kc;
	344
	345	kc = in_get_key_code(-1, kname);
	346	if (kc < 0) {
	347	err("can't resolve key '%s'", kname);
	348	return;
	349	}
	350
	351	if (sdlname == NULL \|\| strncasecmp(sdlname, "SDLK_", 5) != 0)
	352	goto bad_sdlkey;
	353
	354	for (i = 0; i < SDLK_LAST; i++) {
	355	if (sdl_keynames[i] == NULL)
	356	continue;
	357	if (strcasecmp(sdl_keynames[i], sdlname + 5) == 0)
	358	break;
	359	}
	360
	361	if (i >= SDLK_LAST)
	362	goto bad_sdlkey;
	363
	364	pmsdl_map[kc] = i;
	365	return;
	366
	367	bad_sdlkey:
	368	err("can't resolve SDL key '%s'", sdlname);
	369	}
	370
b78828bf	371	void omapsdl_input_init(void)
3cb98c5e	372	{
	373	in_init();
	374	in_probe();
	375	}
	376
0aab059f	377	int omapsdl_input_get_event(int *is_down, int timeout)
3cb98c5e	378	{
0aab059f	379	int key;
3cb98c5e	380
	381	while (1) {
	382	int kc;
	383
0aab059f	384	*is_down = 0;
0aab059f	385	kc = in_update_keycode(NULL, is_down, timeout);
3cb98c5e	386	if (kc < 0 \|\| kc > KEY_MAX)
0aab059f	387	return -1;
3cb98c5e	388
	389	key = pmsdl_map[kc];
	390	if (key != 0)
	391	break;
	392	}
	393
0aab059f	394	return key;
	395	}
	396
	397	/* SDL */
	398	#ifdef STANDALONE
	399
	400	static unsigned char g_keystate[SDLK_LAST];
	401
	402	static int do_event(SDL_Event *event, int timeout)
	403	{
	404	int key, is_down;
	405
	406	key = omapsdl_input_get_event(&is_down, timeout);
	407	if (key < 0)
	408	return 0;
	409
3cb98c5e	410	g_keystate[key] = is_down;
	411
	412	if (event == NULL)
	413	return 1; // FIXME: ..but the event is lost
	414
	415	memset(event, 0, sizeof(event->key));
	416	event->type = is_down ? SDL_KEYDOWN : SDL_KEYUP;
	417	// event->key.which =
	418	event->key.state = is_down ? SDL_PRESSED : SDL_RELEASED;
	419	event->key.keysym.sym = key;
	420	// event->key.keysym.mod
	421
	422	return 1;
	423	}
	424
3cb98c5e	425	DECLSPEC int SDLCALL
	426	SDL_WaitEvent(SDL_Event *event)
	427	{
	428	trace("%p", event);
	429
0aab059f	430	return do_event(event, -1);
3cb98c5e	431	}
	432
	433	DECLSPEC int SDLCALL
	434	SDL_PollEvent(SDL_Event *event)
	435	{
	436	trace("%p", event);
	437
0aab059f	438	return do_event(event, 0);
3cb98c5e	439	}
	440
	441	DECLSPEC Uint8 * SDLCALL
	442	SDL_GetKeyState(int *numkeys)
	443	{
	444	trace("%p", numkeys);
	445
	446	if (numkeys != NULL)
	447	*numkeys = ARRAY_SIZE(g_keystate);
	448	return g_keystate;
	449	}
	450
	451	DECLSPEC char * SDLCALL
	452	SDL_GetKeyName(SDLKey key)
	453	{
	454	trace("%d", key);
	455
	456	if ((unsigned int)key < ARRAY_SIZE(sdl_keynames))
	457	return (char *)sdl_keynames[key];
	458	else
	459	return "";
	460	}
	461
	462	DECLSPEC int SDLCALL
	463	SDL_EnableUNICODE(int enable)
	464	{
	465	trace("%d", enable);
	466
	467	if (enable > 0)
	468	not_supported();
	469
	470	return 0;
	471	}
	472
	473	DECLSPEC int SDLCALL
	474	SDL_EnableKeyRepeat(int delay, int interval)
	475	{
	476	trace("%d, %d", delay, interval);
	477
	478	if (delay)
	479	not_supported();
	480	return 0;
	481	}
	482
	483	DECLSPEC void SDLCALL
	484	SDL_GetKeyRepeat(int delay, int interval)
	485	{
	486	trace("%p, %p", delay, interval);
	487
	488	if (delay)
	489	*delay = 0;
	490	if (interval)
	491	*interval = 0;
	492	}
	493
	494	DECLSPEC SDLMod SDLCALL
	495	SDL_GetModState(void)
	496	{
	497	static const short syms[] = { SDLK_LSHIFT, SDLK_RSHIFT, SDLK_LCTRL, SDLK_RCTRL, SDLK_LALT,
	498	SDLK_RALT, SDLK_LMETA, SDLK_RMETA, SDLK_NUMLOCK, SDLK_CAPSLOCK, SDLK_MODE };
	499	static const short mods[] = { KMOD_LSHIFT, KMOD_RSHIFT, KMOD_LCTRL, KMOD_RCTRL, KMOD_LALT,
	500	KMOD_RALT, KMOD_LMETA, KMOD_RMETA, KMOD_NUM, KMOD_CAPS, KMOD_MODE };
	501	SDLMod ret = KMOD_NONE;
	502	int i;
503
504	trace("");
505
506	for (i = 0; i < ARRAY_SIZE(syms); i++)
507	if (g_keystate[syms[i]])
508	ret \|= mods[i];
509
510	return ret;
511	}
512
513	/* Joysticks */
514	DECLSPEC int SDLCALL
515	SDL_NumJoysticks(void)
516	{
517	trace("");
518	return 0;
519	}
520
521	DECLSPEC SDL_Joystick * SDLCALL
522	SDL_JoystickOpen(int device_index)
523	{
524	trace("%d", device_index);
525	return NULL;
526	}
527
b78828bf	528	#endif // STANDALONE