int SDL_JoystickEventState(int state)
{
#ifdef DISABLE_EVENTS
return SDL_IGNORE;
#else
const Uint8 event_list[] = {
SDL_JOYAXISMOTION, SDL_JOYBALLMOTION, SDL_JOYHATMOTION,
SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP,
};
int i;
switch (state) {
case SDL_QUERY:
state = SDL_IGNORE;
for ( i=0; i<SDL_TABLESIZE(event_list); ++i ) {
state = SDL_EventState(event_list[i],SDL_QUERY);
if ( state == SDL_ENABLE ) {
break;
}
}
break;
default:
for ( i=0; i<SDL_TABLESIZE(event_list); ++i ) {
SDL_EventState(event_list[i], state);
}
break;
}
return(state);
#endif /* DISABLE_EVENTS */
}
void
RunVideoTests()
{
static const struct
{
int w, h, bpp;
} mode_list[] = {
{
640, 480, 8}, {
640, 480, 16}, {
640, 480, 32}, {
800, 600, 8}, {
800, 600, 16}, {
800, 600, 32}, {
1024, 768, 8}, {
1024, 768, 16}, {
1024, 768, 32}
};
static const Uint32 flags[] = {
(SDL_SWSURFACE),
(SDL_SWSURFACE | SDL_FULLSCREEN),
(SDL_HWSURFACE | SDL_FULLSCREEN),
(SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF)
};
int i, j;
SDL_Surface *screen;
/* Test out several different video mode combinations */
SDL_WM_SetCaption("SDL Video Benchmark", "vidtest");
SDL_ShowCursor(0);
for (i = 0; i < SDL_TABLESIZE(mode_list); ++i) {
for (j = 0; j < SDL_TABLESIZE(flags); ++j) {
printf("===================================\n");
printf("Setting video mode: %dx%d at %d bpp, flags: ",
mode_list[i].w, mode_list[i].h, mode_list[i].bpp);
PrintFlags(flags[j]);
printf("\n");
screen = SDL_SetVideoMode(mode_list[i].w,
mode_list[i].h,
mode_list[i].bpp, flags[j]);
if (!screen) {
printf("Setting video mode failed: %s\n", SDL_GetError());
continue;
}
if ((screen->flags & FLAG_MASK) != flags[j]) {
printf("Flags didn't match: ");
PrintFlags(screen->flags);
printf("\n");
continue;
}
if (!RunModeTests(screen)) {
return;
}
}
}
}
void
SDL_WAYLAND_UnloadSymbols(void)
{
/* Don't actually unload if more than one module is using the libs... */
if (wayland_load_refcount > 0) {
if (--wayland_load_refcount == 0) {
#ifdef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
int i;
#endif
/* set all the function pointers to NULL. */
#define SDL_WAYLAND_MODULE(modname) SDL_WAYLAND_HAVE_##modname = 0;
#define SDL_WAYLAND_SYM(rc,fn,params) WAYLAND_##fn = NULL;
#define SDL_WAYLAND_INTERFACE(iface) WAYLAND_##iface = NULL;
#include "SDL_waylandsym.h"
#ifdef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
for (i = 0; i < SDL_TABLESIZE(waylandlibs); i++) {
if (waylandlibs[i].lib != NULL) {
SDL_UnloadObject(waylandlibs[i].lib);
waylandlibs[i].lib = NULL;
}
}
#endif
}
}
}
void
SDL_X11_UnloadSymbols(void)
{
/* Don't actually unload if more than one module is using the libs... */
if (x11_load_refcount > 0) {
if (--x11_load_refcount == 0) {
int i;
/* set all the function pointers to NULL. */
#define SDL_X11_MODULE(modname) SDL_X11_HAVE_##modname = 0;
#define SDL_X11_SYM(rc,fn,params,args,ret) X11_##fn = NULL;
#include "SDL_x11sym.h"
#ifdef X_HAVE_UTF8_STRING
X11_XCreateIC = NULL;
X11_XGetICValues = NULL;
#endif
#ifdef SDL_VIDEO_DRIVER_X11_DYNAMIC
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].lib != NULL) {
SDL_UnloadObject(x11libs[i].lib);
x11libs[i].lib = NULL;
}
}
#endif
}
}
}
void
SDL_MIR_UnloadSymbols(void)
{
/* Don't actually unload if more than one module is using the libs... */
if (mir_load_refcount > 0) {
if (--mir_load_refcount == 0) {
#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC
int i;
#endif
/* set all the function pointers to NULL. */
#define SDL_MIR_MODULE(modname) SDL_MIR_HAVE_##modname = 0;
#define SDL_MIR_SYM(rc,fn,params) MIR_##fn = NULL;
#include "SDL_mirsym.h"
#undef SDL_MIR_MODULE
#undef SDL_MIR_SYM
#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC
for (i = 0; i < SDL_TABLESIZE(mirlibs); i++) {
if (mirlibs[i].lib != NULL) {
SDL_UnloadObject(mirlibs[i].lib);
mirlibs[i].lib = NULL;
}
}
#endif
}
}
}
static void *
X11_GetSym(const char *fnname, int *pHasModule)
{
int i;
void *fn = NULL;
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].lib != NULL) {
fn = SDL_LoadFunction(x11libs[i].lib, fnname);
if (fn != NULL)
break;
}
}
#if DEBUG_DYNAMIC_X11
if (fn != NULL)
printf("X11: Found '%s' in %s (%p)\n", fnname, x11libs[i].libname, fn);
else
printf("X11: Symbol '%s' NOT FOUND!\n", fnname);
#endif
if (fn == NULL)
*pHasModule = 0; /* kill this module. */
return fn;
}
static void *
WAYLAND_GetSym(const char *fnname, int *pHasModule)
{
int i;
void *fn = NULL;
for (i = 0; i < SDL_TABLESIZE(waylandlibs); i++) {
if (waylandlibs[i].lib != NULL) {
fn = SDL_LoadFunction(waylandlibs[i].lib, fnname);
if (fn != NULL)
break;
}
}
#if DEBUG_DYNAMIC_WAYLAND
if (fn != NULL)
SDL_Log("WAYLAND: Found '%s' in %s (%p)\n", fnname, waylandlibs[i].libname, fn);
else
SDL_Log("WAYLAND: Symbol '%s' NOT FOUND!\n", fnname);
#endif
if (fn == NULL)
*pHasModule = 0; /* kill this module. */
return fn;
}
/* returns non-zero if all needed symbols were loaded. */
int
SDL_X11_LoadSymbols(void)
{
int rc = 1; /* always succeed if not using Dynamic X11 stuff. */
#ifdef SDL_VIDEO_DRIVER_X11_DYNAMIC
/* deal with multiple modules (dga, x11, etc) needing these symbols... */
if (x11_load_refcount++ == 0) {
int i;
int *thismod = NULL;
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].libname != NULL) {
x11libs[i].lib = SDL_LoadObject(x11libs[i].libname);
}
}
#define SDL_X11_MODULE(modname) SDL_X11_HAVE_##modname = 1; /* default yes */
#define SDL_X11_SYM(a,fn,x,y,z)
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#define SDL_X11_MODULE(modname) thismod = &SDL_X11_HAVE_##modname;
#define SDL_X11_SYM(a,fn,x,y,z) p##fn = (SDL_DYNX11FN_##fn) X11_GetSym(#fn,thismod);
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#ifdef X_HAVE_UTF8_STRING
pXCreateIC = (SDL_DYNX11FN_XCreateIC)
X11_GetSym("XCreateIC", &SDL_X11_HAVE_UTF8);
pXGetICValues = (SDL_DYNX11FN_XGetICValues)
X11_GetSym("XGetICValues", &SDL_X11_HAVE_UTF8);
#endif
if (SDL_X11_HAVE_BASEXLIB) {
/* all required symbols loaded. */
SDL_ClearError();
} else {
/* in case something got loaded... */
SDL_X11_UnloadSymbols();
rc = 0;
}
}
#else
#define SDL_X11_MODULE(modname) SDL_X11_HAVE_##modname = 1; /* default yes */
#define SDL_X11_SYM(a,fn,x,y,z)
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#ifdef X_HAVE_UTF8_STRING
pXCreateIC = XCreateIC;
pXGetICValues = XGetICValues;
#endif
#endif
return rc;
}
/* returns non-zero if all needed symbols were loaded. */
int
SDL_WAYLAND_LoadSymbols(void)
{
int rc = 1; /* always succeed if not using Dynamic WAYLAND stuff. */
/* deal with multiple modules (dga, wayland, etc) needing these symbols... */
if (wayland_load_refcount++ == 0) {
#ifdef SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC
int i;
int *thismod = NULL;
for (i = 0; i < SDL_TABLESIZE(waylandlibs); i++) {
if (waylandlibs[i].libname != NULL) {
waylandlibs[i].lib = SDL_LoadObject(waylandlibs[i].libname);
}
}
#define SDL_WAYLAND_MODULE(modname) SDL_WAYLAND_HAVE_##modname = 1; /* default yes */
#define SDL_WAYLAND_SYM(rc,fn,params)
#define SDL_WAYLAND_INTERFACE(iface)
#include "SDL_waylandsym.h"
#undef SDL_WAYLAND_MODULE
#undef SDL_WAYLAND_SYM
#undef SDL_WAYLAND_INTERFACE
#define SDL_WAYLAND_MODULE(modname) thismod = &SDL_WAYLAND_HAVE_##modname;
#define SDL_WAYLAND_SYM(rc,fn,params) WAYLAND_##fn = (SDL_DYNWAYLANDFN_##fn) WAYLAND_GetSym(#fn,thismod);
#define SDL_WAYLAND_INTERFACE(iface) WAYLAND_##iface = (struct wl_interface *) WAYLAND_GetSym(#iface,thismod);
#include "SDL_waylandsym.h"
#undef SDL_WAYLAND_MODULE
#undef SDL_WAYLAND_SYM
#undef SDL_WAYLAND_INTERFACE
if (SDL_WAYLAND_HAVE_WAYLAND_CLIENT) {
/* all required symbols loaded. */
SDL_ClearError();
} else {
/* in case something got loaded... */
SDL_WAYLAND_UnloadSymbols();
rc = 0;
}
#else /* no dynamic WAYLAND */
#define SDL_WAYLAND_MODULE(modname) SDL_WAYLAND_HAVE_##modname = 1; /* default yes */
#define SDL_WAYLAND_SYM(rc,fn,params) WAYLAND_##fn = fn;
#define SDL_WAYLAND_INTERFACE(iface) WAYLAND_##iface = &iface;
#include "SDL_waylandsym.h"
#undef SDL_WAYLAND_MODULE
#undef SDL_WAYLAND_SYM
#undef SDL_WAYLAND_INTERFACE
#endif
}
return rc;
}
/* returns non-zero if all needed symbols were loaded. */
int SDL_X11_LoadSymbols(void)
{
int rc = 1; /* always succeed if not using Dynamic X11 stuff. */
#ifdef SDL_VIDEO_DRIVER_X11_DYNAMIC
/* deal with multiple modules (dga, x11, etc) needing these symbols... */
if (x11_load_refcount++ == 0) {
int i;
int *thismod = NULL;
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].libname != NULL) {
x11libs[i].lib = SDL_LoadObject(x11libs[i].libname);
}
}
#define SDL_X11_MODULE(modname) thismod = &SDL_X11_HAVE_##modname;
#define SDL_X11_SYM(rc,fn,params,args,ret) \
p##fn = (rc(*)params) X11_GetSym(#fn, thismod);
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#ifdef X_HAVE_UTF8_STRING
pXCreateIC = (XIC(*)(XIM,...)) X11_GetSym("XCreateIC",
&SDL_X11_HAVE_UTF8);
pXGetICValues = (char * (*)(XIC,...)) X11_GetSym("XGetICValues",
&SDL_X11_HAVE_UTF8);
#endif
/*
* In case we're built with newer Xlib headers, we need to make sure
* that _XGetRequest() is available, even on older systems.
* Otherwise, various Xlib macros we use will call a NULL pointer.
*/
if (!SDL_X11_HAVE_XGETREQUEST) {
p_XGetRequest = SDL_XGetRequest_workaround;
}
if (SDL_X11_HAVE_BASEXLIB) { /* all required symbols loaded. */
SDL_ClearError();
} else {
SDL_X11_UnloadSymbols(); /* in case something got loaded... */
rc = 0;
}
}
#else
#if DEBUG_DYNAMIC_X11
printf("X11: No dynamic X11 support in this build of SDL.\n");
#endif
#ifdef X_HAVE_UTF8_STRING
pXCreateIC = XCreateIC;
pXGetICValues = XGetICValues;
#endif
#endif
return rc;
}
CAMLprim value mlsdlevent_get_enabled(value unit)
{
Uint32 mask = 0;
register int i;
for(i=0; i<SDL_TABLESIZE(evt_type_of_val); i++) {
Uint8 type = evt_type_of_val[i];
if(SDL_EventState(type, SDL_QUERY))
mask |= SDL_EVENTMASK(type);
}
return Val_int(mask);
}
CAMLprim value mlsdlevent_set_state_by_mask(value mask, value state)
{
int c_state = ( state == Val_true ? SDL_ENABLE : SDL_DISABLE ) ;
Uint32 c_mask = Int_val(mask);
int i;
for(i=0; i<SDL_TABLESIZE(evt_type_of_val); i++) {
Uint8 type = evt_type_of_val[i];
if(SDL_EVENTMASK(type) & c_mask)
SDL_EventState(type, c_state);
}
return Val_unit;
}
/* returns non-zero if all needed symbols were loaded. */
int
SDL_MIR_LoadSymbols(void)
{
int rc = 1; /* always succeed if not using Dynamic MIR stuff. */
/* deal with multiple modules (dga, wayland, mir, etc) needing these symbols... */
if (mir_load_refcount++ == 0) {
#ifdef SDL_VIDEO_DRIVER_MIR_DYNAMIC
int i;
int *thismod = NULL;
for (i = 0; i < SDL_TABLESIZE(mirlibs); i++) {
if (mirlibs[i].libname != NULL) {
mirlibs[i].lib = SDL_LoadObject(mirlibs[i].libname);
}
}
#define SDL_MIR_MODULE(modname) SDL_MIR_HAVE_##modname = 1; /* default yes */
#define SDL_MIR_SYM(rc,fn,params)
#include "SDL_mirsym.h"
#undef SDL_MIR_MODULE
#undef SDL_MIR_SYM
#define SDL_MIR_MODULE(modname) thismod = &SDL_MIR_HAVE_##modname;
#define SDL_MIR_SYM(rc,fn,params) MIR_##fn = (SDL_DYNMIRFN_##fn) MIR_GetSym(#fn,thismod);
#include "SDL_mirsym.h"
#undef SDL_MIR_MODULE
#undef SDL_MIR_SYM
if ((SDL_MIR_HAVE_MIR_CLIENT) && (SDL_MIR_HAVE_XKBCOMMON)) {
/* all required symbols loaded. */
SDL_ClearError();
} else {
/* in case something got loaded... */
SDL_MIR_UnloadSymbols();
rc = 0;
}
#else /* no dynamic MIR */
#define SDL_MIR_MODULE(modname) SDL_MIR_HAVE_##modname = 1; /* default yes */
#define SDL_MIR_SYM(rc,fn,params) MIR_##fn = fn;
#include "SDL_mirsym.h"
#undef SDL_MIR_MODULE
#undef SDL_MIR_SYM
#endif
}
return rc;
}
static int LoadARTSLibrary(void)
{
int i, retval = -1;
arts_handle = SDL_LoadObject(arts_library);
if ( arts_handle ) {
arts_loaded = 1;
retval = 0;
for ( i=0; i<SDL_TABLESIZE(arts_functions); ++i ) {
*arts_functions[i].func = SDL_LoadFunction(arts_handle, arts_functions[i].name);
if ( !*arts_functions[i].func ) {
retval = -1;
UnloadARTSLibrary();
break;
}
}
}
return retval;
}
static int LoadESDLibrary(void)
{
int i, retval = -1;
esd_handle = SDL_LoadObject(esd_library);
if ( esd_handle ) {
esd_loaded = 1;
retval = 0;
for ( i=0; i<SDL_TABLESIZE(esd_functions); ++i ) {
*esd_functions[i].func = SDL_LoadFunction(esd_handle, esd_functions[i].name);
if ( !*esd_functions[i].func ) {
retval = -1;
UnloadESDLibrary();
break;
}
}
}
return retval;
}
void AA_InitOSKeymap(_THIS)
{
int i;
static const char *std_keys = " 01234567890&#'()_-|$*+-=/\\:;.,!?<>{}[]@~%^\x9";
const char *std;
/* Initialize the AAlib key translation table */
for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
keymap[AA_ESC] = SDLK_ESCAPE;
keymap[AA_UP] = SDLK_UP;
keymap[AA_DOWN] = SDLK_DOWN;
keymap[AA_LEFT] = SDLK_LEFT;
keymap[AA_RIGHT] = SDLK_RIGHT;
/* Alphabet keys */
for ( i = 0; i<26; ++i ){
keymap['a' + i] = SDLK_a+i;
keymap['A' + i] = SDLK_a+i;
}
/* Function keys */
for ( i = 0; i<12; ++i ){
keymap[334 + i] = SDLK_F1+i;
}
/* Keys that have the same symbols and don't have to be translated */
for( std = std_keys; *std; std ++ ) {
keymap[*std] = *std;
}
keymap[13] = SDLK_RETURN;
keymap[AA_BACKSPACE] = SDLK_BACKSPACE;
keymap[369] = SDLK_LSHIFT;
keymap[370] = SDLK_RSHIFT;
keymap[371] = SDLK_LCTRL;
keymap[372] = SDLK_RCTRL;
keymap[377] = SDLK_LALT;
keymap[270] = SDLK_RALT;
keymap[271] = SDLK_NUMLOCK;
keymap[373] = SDLK_CAPSLOCK;
keymap[164] = SDLK_SCROLLOCK;
keymap[243] = SDLK_INSERT;
keymap[304] = SDLK_DELETE;
keymap[224] = SDLK_HOME;
keymap[231] = SDLK_END;
keymap[229] = SDLK_PAGEUP;
keymap[230] = SDLK_PAGEDOWN;
keymap[241] = SDLK_PRINT;
keymap[163] = SDLK_BREAK;
keymap[302] = SDLK_KP0;
keymap[300] = SDLK_KP1;
keymap[297] = SDLK_KP2;
keymap[299] = SDLK_KP3;
keymap[294] = SDLK_KP4;
keymap[301] = SDLK_KP5;
keymap[296] = SDLK_KP6;
keymap[293] = SDLK_KP7;
keymap[295] = SDLK_KP8;
keymap[298] = SDLK_KP9;
}
void ph_InitKeymap(void)
{
int i;
/* Odd keys used in international keyboards */
for (i=0; i<SDL_TABLESIZE(ODD_keymap); ++i)
{
ODD_keymap[i] = SDLK_UNKNOWN;
}
/* Map the miscellaneous keys */
for (i=0; i<SDL_TABLESIZE(MISC_keymap); ++i)
{
MISC_keymap[i] = SDLK_UNKNOWN;
}
MISC_keymap[Pk_BackSpace&0xFF] = SDLK_BACKSPACE;
MISC_keymap[Pk_Tab&0xFF] = SDLK_TAB;
MISC_keymap[Pk_Clear&0xFF] = SDLK_CLEAR;
MISC_keymap[Pk_Return&0xFF] = SDLK_RETURN;
MISC_keymap[Pk_Pause&0xFF] = SDLK_PAUSE;
MISC_keymap[Pk_Escape&0xFF] = SDLK_ESCAPE;
MISC_keymap[Pk_Delete&0xFF] = SDLK_DELETE;
MISC_keymap[Pk_KP_0&0xFF] = SDLK_KP0;
MISC_keymap[Pk_KP_1&0xFF] = SDLK_KP1;
MISC_keymap[Pk_KP_2&0xFF] = SDLK_KP2;
MISC_keymap[Pk_KP_3&0xFF] = SDLK_KP3;
MISC_keymap[Pk_KP_4&0xFF] = SDLK_KP4;
MISC_keymap[Pk_KP_5&0xFF] = SDLK_KP5;
MISC_keymap[Pk_KP_6&0xFF] = SDLK_KP6;
MISC_keymap[Pk_KP_7&0xFF] = SDLK_KP7;
MISC_keymap[Pk_KP_8&0xFF] = SDLK_KP8;
MISC_keymap[Pk_KP_9&0xFF] = SDLK_KP9;
MISC_keymap[Pk_KP_Decimal&0xFF] = SDLK_KP_PERIOD;
MISC_keymap[Pk_KP_Divide&0xFF] = SDLK_KP_DIVIDE;
MISC_keymap[Pk_KP_Multiply&0xFF] = SDLK_KP_MULTIPLY;
MISC_keymap[Pk_KP_Subtract&0xFF] = SDLK_KP_MINUS;
MISC_keymap[Pk_KP_Add&0xFF] = SDLK_KP_PLUS;
MISC_keymap[Pk_KP_Enter&0xFF] = SDLK_KP_ENTER;
MISC_keymap[Pk_KP_Equal&0xFF] = SDLK_KP_EQUALS;
MISC_keymap[Pk_Up&0xFF] = SDLK_UP;
MISC_keymap[Pk_Down&0xFF] = SDLK_DOWN;
MISC_keymap[Pk_Right&0xFF] = SDLK_RIGHT;
MISC_keymap[Pk_Left&0xFF] = SDLK_LEFT;
MISC_keymap[Pk_Insert&0xFF] = SDLK_INSERT;
MISC_keymap[Pk_Home&0xFF] = SDLK_HOME;
MISC_keymap[Pk_End&0xFF] = SDLK_END;
MISC_keymap[Pk_Pg_Up&0xFF] = SDLK_PAGEUP;
MISC_keymap[Pk_Pg_Down&0xFF] = SDLK_PAGEDOWN;
MISC_keymap[Pk_F1&0xFF] = SDLK_F1;
MISC_keymap[Pk_F2&0xFF] = SDLK_F2;
MISC_keymap[Pk_F3&0xFF] = SDLK_F3;
MISC_keymap[Pk_F4&0xFF] = SDLK_F4;
MISC_keymap[Pk_F5&0xFF] = SDLK_F5;
MISC_keymap[Pk_F6&0xFF] = SDLK_F6;
MISC_keymap[Pk_F7&0xFF] = SDLK_F7;
MISC_keymap[Pk_F8&0xFF] = SDLK_F8;
MISC_keymap[Pk_F9&0xFF] = SDLK_F9;
MISC_keymap[Pk_F10&0xFF] = SDLK_F10;
MISC_keymap[Pk_F11&0xFF] = SDLK_F11;
MISC_keymap[Pk_F12&0xFF] = SDLK_F12;
MISC_keymap[Pk_F13&0xFF] = SDLK_F13;
MISC_keymap[Pk_F14&0xFF] = SDLK_F14;
MISC_keymap[Pk_F15&0xFF] = SDLK_F15;
MISC_keymap[Pk_Num_Lock&0xFF] = SDLK_NUMLOCK;
MISC_keymap[Pk_Caps_Lock&0xFF] = SDLK_CAPSLOCK;
MISC_keymap[Pk_Scroll_Lock&0xFF] = SDLK_SCROLLOCK;
MISC_keymap[Pk_Shift_R&0xFF] = SDLK_RSHIFT;
MISC_keymap[Pk_Shift_L&0xFF] = SDLK_LSHIFT;
MISC_keymap[Pk_Control_R&0xFF] = SDLK_RCTRL;
MISC_keymap[Pk_Control_L&0xFF] = SDLK_LCTRL;
MISC_keymap[Pk_Alt_R&0xFF] = SDLK_RALT;
MISC_keymap[Pk_Alt_L&0xFF] = SDLK_LALT;
MISC_keymap[Pk_Meta_R&0xFF] = SDLK_RMETA;
MISC_keymap[Pk_Meta_L&0xFF] = SDLK_LMETA;
MISC_keymap[Pk_Super_L&0xFF] = SDLK_LSUPER;
MISC_keymap[Pk_Super_R&0xFF] = SDLK_RSUPER;
MISC_keymap[Pk_Mode_switch&0xFF] = SDLK_MODE; /* "Alt Gr" key */
MISC_keymap[Pk_Help&0xFF] = SDLK_HELP;
MISC_keymap[Pk_Print&0xFF] = SDLK_PRINT;
MISC_keymap[Pk_Break&0xFF] = SDLK_BREAK;
MISC_keymap[Pk_Menu&0xFF] = SDLK_MENU; /* Windows "Menu" key */
MISC_keymap[Pk_Hyper_R&0xFF] = SDLK_RSUPER; /* Right "Windows" */
/* Left "Windows" key, but it can't be catched by application */
MISC_keymap[Pk_Hyper_L&0xFF] = SDLK_LSUPER;
}
void X11_InitKeymap(void)
{
int i;
/* Odd keys used in international keyboards */
for ( i=0; i<SDL_TABLESIZE(ODD_keymap); ++i )
ODD_keymap[i] = SDLK_UNKNOWN;
#ifdef XK_dead_circumflex
/* These X keysyms have 0xFE as the high byte */
ODD_keymap[XK_dead_circumflex&0xFF] = SDLK_CARET;
#endif
#ifdef XK_ISO_Level3_Shift
ODD_keymap[XK_ISO_Level3_Shift&0xFF] = SDLK_MODE; /* "Alt Gr" key */
#endif
/* Map the miscellaneous keys */
for ( i=0; i<SDL_TABLESIZE(MISC_keymap); ++i )
MISC_keymap[i] = SDLK_UNKNOWN;
/* These X keysyms have 0xFF as the high byte */
MISC_keymap[XK_BackSpace&0xFF] = SDLK_BACKSPACE;
MISC_keymap[XK_Tab&0xFF] = SDLK_TAB;
MISC_keymap[XK_Clear&0xFF] = SDLK_CLEAR;
MISC_keymap[XK_Return&0xFF] = SDLK_RETURN;
MISC_keymap[XK_Pause&0xFF] = SDLK_PAUSE;
MISC_keymap[XK_Escape&0xFF] = SDLK_ESCAPE;
MISC_keymap[XK_Delete&0xFF] = SDLK_DELETE;
MISC_keymap[XK_KP_0&0xFF] = SDLK_KP0; /* Keypad 0-9 */
MISC_keymap[XK_KP_1&0xFF] = SDLK_KP1;
MISC_keymap[XK_KP_2&0xFF] = SDLK_KP2;
MISC_keymap[XK_KP_3&0xFF] = SDLK_KP3;
MISC_keymap[XK_KP_4&0xFF] = SDLK_KP4;
MISC_keymap[XK_KP_5&0xFF] = SDLK_KP5;
MISC_keymap[XK_KP_6&0xFF] = SDLK_KP6;
MISC_keymap[XK_KP_7&0xFF] = SDLK_KP7;
MISC_keymap[XK_KP_8&0xFF] = SDLK_KP8;
MISC_keymap[XK_KP_9&0xFF] = SDLK_KP9;
MISC_keymap[XK_KP_Insert&0xFF] = SDLK_KP0;
MISC_keymap[XK_KP_End&0xFF] = SDLK_KP1;
MISC_keymap[XK_KP_Down&0xFF] = SDLK_KP2;
MISC_keymap[XK_KP_Page_Down&0xFF] = SDLK_KP3;
MISC_keymap[XK_KP_Left&0xFF] = SDLK_KP4;
MISC_keymap[XK_KP_Begin&0xFF] = SDLK_KP5;
MISC_keymap[XK_KP_Right&0xFF] = SDLK_KP6;
MISC_keymap[XK_KP_Home&0xFF] = SDLK_KP7;
MISC_keymap[XK_KP_Up&0xFF] = SDLK_KP8;
MISC_keymap[XK_KP_Page_Up&0xFF] = SDLK_KP9;
MISC_keymap[XK_KP_Delete&0xFF] = SDLK_KP_PERIOD;
MISC_keymap[XK_KP_Decimal&0xFF] = SDLK_KP_PERIOD;
MISC_keymap[XK_KP_Divide&0xFF] = SDLK_KP_DIVIDE;
MISC_keymap[XK_KP_Multiply&0xFF] = SDLK_KP_MULTIPLY;
MISC_keymap[XK_KP_Subtract&0xFF] = SDLK_KP_MINUS;
MISC_keymap[XK_KP_Add&0xFF] = SDLK_KP_PLUS;
MISC_keymap[XK_KP_Enter&0xFF] = SDLK_KP_ENTER;
MISC_keymap[XK_KP_Equal&0xFF] = SDLK_KP_EQUALS;
MISC_keymap[XK_Up&0xFF] = SDLK_UP;
MISC_keymap[XK_Down&0xFF] = SDLK_DOWN;
MISC_keymap[XK_Right&0xFF] = SDLK_RIGHT;
MISC_keymap[XK_Left&0xFF] = SDLK_LEFT;
MISC_keymap[XK_Insert&0xFF] = SDLK_INSERT;
MISC_keymap[XK_Home&0xFF] = SDLK_HOME;
MISC_keymap[XK_End&0xFF] = SDLK_END;
MISC_keymap[XK_Page_Up&0xFF] = SDLK_PAGEUP;
MISC_keymap[XK_Page_Down&0xFF] = SDLK_PAGEDOWN;
MISC_keymap[XK_F1&0xFF] = SDLK_F1;
MISC_keymap[XK_F2&0xFF] = SDLK_F2;
MISC_keymap[XK_F3&0xFF] = SDLK_F3;
MISC_keymap[XK_F4&0xFF] = SDLK_F4;
MISC_keymap[XK_F5&0xFF] = SDLK_F5;
MISC_keymap[XK_F6&0xFF] = SDLK_F6;
MISC_keymap[XK_F7&0xFF] = SDLK_F7;
MISC_keymap[XK_F8&0xFF] = SDLK_F8;
MISC_keymap[XK_F9&0xFF] = SDLK_F9;
MISC_keymap[XK_F10&0xFF] = SDLK_F10;
MISC_keymap[XK_F11&0xFF] = SDLK_F11;
MISC_keymap[XK_F12&0xFF] = SDLK_F12;
MISC_keymap[XK_F13&0xFF] = SDLK_F13;
MISC_keymap[XK_F14&0xFF] = SDLK_F14;
MISC_keymap[XK_F15&0xFF] = SDLK_F15;
MISC_keymap[XK_Num_Lock&0xFF] = SDLK_NUMLOCK;
MISC_keymap[XK_Caps_Lock&0xFF] = SDLK_CAPSLOCK;
MISC_keymap[XK_Scroll_Lock&0xFF] = SDLK_SCROLLOCK;
MISC_keymap[XK_Shift_R&0xFF] = SDLK_RSHIFT;
MISC_keymap[XK_Shift_L&0xFF] = SDLK_LSHIFT;
MISC_keymap[XK_Control_R&0xFF] = SDLK_RCTRL;
MISC_keymap[XK_Control_L&0xFF] = SDLK_LCTRL;
MISC_keymap[XK_Alt_R&0xFF] = SDLK_RALT;
MISC_keymap[XK_Alt_L&0xFF] = SDLK_LALT;
MISC_keymap[XK_Meta_R&0xFF] = SDLK_RMETA;
MISC_keymap[XK_Meta_L&0xFF] = SDLK_LMETA;
MISC_keymap[XK_Super_L&0xFF] = SDLK_LSUPER; /* Left "Windows" */
MISC_keymap[XK_Super_R&0xFF] = SDLK_RSUPER; /* Right "Windows */
MISC_keymap[XK_Mode_switch&0xFF] = SDLK_MODE; /* "Alt Gr" key */
MISC_keymap[XK_Multi_key&0xFF] = SDLK_COMPOSE; /* Multi-key compose */
MISC_keymap[XK_Help&0xFF] = SDLK_HELP;
MISC_keymap[XK_Print&0xFF] = SDLK_PRINT;
MISC_keymap[XK_Sys_Req&0xFF] = SDLK_SYSREQ;
MISC_keymap[XK_Break&0xFF] = SDLK_BREAK;
MISC_keymap[XK_Menu&0xFF] = SDLK_MENU;
MISC_keymap[XK_Hyper_R&0xFF] = SDLK_MENU; /* Windows "Menu" key */
}
void EPOC_InitOSKeymap(_THIS)
{
int i;
/* Initialize the key translation table */
for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
/* Numbers */
for ( i = 0; i<32; ++i ){
keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
}
/* e.g. Alphabet keys */
for ( i = 0; i<32; ++i ){
keymap['A' + i] = (SDLKey)(SDLK_a+i);
}
keymap[EStdKeyBackspace] = SDLK_BACKSPACE;
keymap[EStdKeyTab] = SDLK_TAB;
keymap[EStdKeyEnter] = SDLK_RETURN;
keymap[EStdKeyEscape] = SDLK_ESCAPE;
keymap[EStdKeySpace] = SDLK_SPACE;
keymap[EStdKeyPause] = SDLK_PAUSE;
keymap[EStdKeyHome] = SDLK_HOME;
keymap[EStdKeyEnd] = SDLK_END;
keymap[EStdKeyPageUp] = SDLK_PAGEUP;
keymap[EStdKeyPageDown] = SDLK_PAGEDOWN;
keymap[EStdKeyDelete] = SDLK_DELETE;
keymap[EStdKeyUpArrow] = SDLK_UP;
keymap[EStdKeyDownArrow] = SDLK_DOWN;
keymap[EStdKeyLeftArrow] = SDLK_LEFT;
keymap[EStdKeyRightArrow] = SDLK_RIGHT;
keymap[EStdKeyCapsLock] = SDLK_CAPSLOCK;
keymap[EStdKeyLeftShift] = SDLK_LSHIFT;
keymap[EStdKeyRightShift] = SDLK_RSHIFT;
keymap[EStdKeyLeftAlt] = SDLK_LALT;
keymap[EStdKeyRightAlt] = SDLK_RALT;
keymap[EStdKeyLeftCtrl] = SDLK_LCTRL;
keymap[EStdKeyRightCtrl] = SDLK_RCTRL;
keymap[EStdKeyLeftFunc] = SDLK_LMETA;
keymap[EStdKeyRightFunc] = SDLK_RMETA;
keymap[EStdKeyInsert] = SDLK_INSERT;
keymap[EStdKeyComma] = SDLK_COMMA;
keymap[EStdKeyFullStop] = SDLK_PERIOD;
keymap[EStdKeyForwardSlash] = SDLK_SLASH;
keymap[EStdKeyBackSlash] = SDLK_BACKSLASH;
keymap[EStdKeySemiColon] = SDLK_SEMICOLON;
keymap[EStdKeySingleQuote] = SDLK_QUOTE;
keymap[EStdKeyHash] = SDLK_HASH;
keymap[EStdKeySquareBracketLeft] = SDLK_LEFTBRACKET;
keymap[EStdKeySquareBracketRight] = SDLK_RIGHTBRACKET;
keymap[EStdKeyMinus] = SDLK_MINUS;
keymap[EStdKeyEquals] = SDLK_EQUALS;
keymap[EStdKeyF1] = SDLK_F1; /* chr + q */
keymap[EStdKeyF2] = SDLK_F2; /* chr + w */
keymap[EStdKeyF3] = SDLK_F3; /* chr + e */
keymap[EStdKeyF4] = SDLK_F4; /* chr + r */
keymap[EStdKeyF5] = SDLK_F5; /* chr + t */
keymap[EStdKeyF6] = SDLK_F6; /* chr + y */
keymap[EStdKeyF7] = SDLK_F7; /* chr + i */
keymap[EStdKeyF8] = SDLK_F8; /* chr + o */
keymap[EStdKeyF9] = SDLK_F9; /* chr + a */
keymap[EStdKeyF10] = SDLK_F10; /* chr + s */
keymap[EStdKeyF11] = SDLK_F11; /* chr + d */
keymap[EStdKeyF12] = SDLK_F12; /* chr + f */
#ifndef SYMBIAN_CRYSTAL
//!!7650 additions
#ifdef __WINS__
keymap[EStdKeyXXX] = SDLK_RETURN; /* "fire" key */
#else
keymap[EStdKeyDevice3] = SDLK_RETURN; /* "fire" key */
#endif
keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK;
keymap[EStdKeyYes] = SDLK_HOME; /* "call" key */
keymap[EStdKeyNo] = SDLK_END; /* "end call" key */
keymap[EStdKeyDevice0] = SDLK_SPACE; /* right menu key */
keymap[EStdKeyDevice1] = SDLK_ESCAPE; /* left menu key */
keymap[EStdKeyDevice2] = SDLK_POWER; /* power key */
#endif
#ifdef SYMBIAN_CRYSTAL
keymap[EStdKeyMenu] = SDLK_ESCAPE; // menu key
keymap[EStdKeyDevice6] = SDLK_LEFT; // Rocker (joystick) left
keymap[EStdKeyDevice7] = SDLK_RIGHT; // Rocker (joystick) right
keymap[EStdKeyDevice8] = SDLK_UP; // Rocker (joystick) up
keymap[EStdKeyDevice9] = SDLK_DOWN; // Rocker (joystick) down
keymap[EStdKeyLeftFunc] = SDLK_LALT; //chr?
keymap[EStdKeyRightFunc] = SDLK_RALT;
keymap[EStdKeyDeviceA] = SDLK_RETURN; /* "fire" key */
#endif
///////////////////////////////////////////////////////////
RFs fs;
if(KErrNone == fs.Connect())
{
RArray<TInt> array;
TRAPD(err, ReadL(fs, array));
if(err == KErrNone && array.Count() > 0)
{
SDLKey temp[MAX_SCANCODE];
Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));
for(TInt k = 0; k < array.Count(); k+= 2)
{
const TInt oldval = array[k];
const TInt newval = array[k + 1];
if(oldval >= 0 && oldval < MAX_SCANCODE && newval >= 0 && newval < MAX_SCANCODE)
{
keymap[oldval] = temp[newval];
}
}
}
array.Close();
}
fs.Close();
///////////////////////////////////////////////////////////
/* !!TODO
EStdKeyNumLock=0x1b,
EStdKeyScrollLock=0x1c,
EStdKeyNkpForwardSlash=0x84,
EStdKeyNkpAsterisk=0x85,
EStdKeyNkpMinus=0x86,
EStdKeyNkpPlus=0x87,
EStdKeyNkpEnter=0x88,
EStdKeyNkp1=0x89,
EStdKeyNkp2=0x8a,
EStdKeyNkp3=0x8b,
EStdKeyNkp4=0x8c,
EStdKeyNkp5=0x8d,
EStdKeyNkp6=0x8e,
EStdKeyNkp7=0x8f,
EStdKeyNkp8=0x90,
EStdKeyNkp9=0x91,
EStdKeyNkp0=0x92,
EStdKeyNkpFullStop=0x93,
EStdKeyMenu=0x94,
EStdKeyBacklightOn=0x95,
EStdKeyBacklightOff=0x96,
EStdKeyBacklightToggle=0x97,
EStdKeyIncContrast=0x98,
EStdKeyDecContrast=0x99,
EStdKeySliderDown=0x9a,
EStdKeySliderUp=0x9b,
EStdKeyDictaphonePlay=0x9c,
EStdKeyDictaphoneStop=0x9d,
EStdKeyDictaphoneRecord=0x9e,
EStdKeyHelp=0x9f,
EStdKeyOff=0xa0,
EStdKeyDial=0xa1,
EStdKeyIncVolume=0xa2,
EStdKeyDecVolume=0xa3,
EStdKeyDevice0=0xa4,
EStdKeyDevice1=0xa5,
EStdKeyDevice2=0xa6,
EStdKeyDevice3=0xa7,
EStdKeyDevice4=0xa8,
EStdKeyDevice5=0xa9,
EStdKeyDevice6=0xaa,
EStdKeyDevice7=0xab,
EStdKeyDevice8=0xac,
EStdKeyDevice9=0xad,
EStdKeyDeviceA=0xae,
EStdKeyDeviceB=0xaf,
EStdKeyDeviceC=0xb0,
EStdKeyDeviceD=0xb1,
EStdKeyDeviceE=0xb2,
EStdKeyDeviceF=0xb3,
EStdKeyApplication0=0xb4,
EStdKeyApplication1=0xb5,
EStdKeyApplication2=0xb6,
EStdKeyApplication3=0xb7,
EStdKeyApplication4=0xb8,
EStdKeyApplication5=0xb9,
EStdKeyApplication6=0xba,
EStdKeyApplication7=0xbb,
EStdKeyApplication8=0xbc,
EStdKeyApplication9=0xbd,
EStdKeyApplicationA=0xbe,
EStdKeyApplicationB=0xbf,
EStdKeyApplicationC=0xc0,
EStdKeyApplicationD=0xc1,
EStdKeyApplicationE=0xc2,
EStdKeyApplicationF=0xc3,
EStdKeyYes=0xc4,
EStdKeyNo=0xc5,
EStdKeyIncBrightness=0xc6,
EStdKeyDecBrightness=0xc7,
EStdKeyCaseOpen=0xc8,
EStdKeyCaseClose=0xc9
*/
}
/* Public functions */
int SDL_KeyboardInit(void)
{
SDL_VideoDevice *video = current_video;
SDL_VideoDevice *this = current_video;
Uint16 i;
/* Set default mode of UNICODE translation */
SDL_EnableUNICODE(DEFAULT_UNICODE_TRANSLATION);
/* Initialize the tables */
SDL_ModState = KMOD_NONE;
for ( i=0; i<SDL_TABLESIZE(keynames); ++i )
keynames[i] = NULL;
for ( i=0; i<SDL_TABLESIZE(SDL_KeyState); ++i )
SDL_KeyState[i] = SDL_RELEASED;
video->InitOSKeymap(this);
SDL_EnableKeyRepeat(0, 0);
/* Fill in the blanks in keynames */
keynames[SDLK_BACKSPACE] = "backspace";
keynames[SDLK_TAB] = "tab";
keynames[SDLK_CLEAR] = "clear";
keynames[SDLK_RETURN] = "return";
keynames[SDLK_PAUSE] = "pause";
keynames[SDLK_ESCAPE] = "escape";
keynames[SDLK_SPACE] = "space";
keynames[SDLK_EXCLAIM] = "!";
keynames[SDLK_QUOTEDBL] = "\"";
keynames[SDLK_HASH] = "#";
keynames[SDLK_DOLLAR] = "$";
keynames[SDLK_AMPERSAND] = "&";
keynames[SDLK_QUOTE] = "'";
keynames[SDLK_LEFTPAREN] = "(";
keynames[SDLK_RIGHTPAREN] = ")";
keynames[SDLK_ASTERISK] = "*";
keynames[SDLK_PLUS] = "+";
keynames[SDLK_COMMA] = ",";
keynames[SDLK_MINUS] = "-";
keynames[SDLK_PERIOD] = ".";
keynames[SDLK_SLASH] = "/";
keynames[SDLK_0] = "0";
keynames[SDLK_1] = "1";
keynames[SDLK_2] = "2";
keynames[SDLK_3] = "3";
keynames[SDLK_4] = "4";
keynames[SDLK_5] = "5";
keynames[SDLK_6] = "6";
keynames[SDLK_7] = "7";
keynames[SDLK_8] = "8";
keynames[SDLK_9] = "9";
keynames[SDLK_COLON] = ":";
keynames[SDLK_SEMICOLON] = ";";
keynames[SDLK_LESS] = "<";
keynames[SDLK_EQUALS] = "=";
keynames[SDLK_GREATER] = ">";
keynames[SDLK_QUESTION] = "?";
keynames[SDLK_AT] = "@";
keynames[SDLK_LEFTBRACKET] = "[";
keynames[SDLK_BACKSLASH] = "\\";
keynames[SDLK_RIGHTBRACKET] = "]";
keynames[SDLK_CARET] = "^";
keynames[SDLK_UNDERSCORE] = "_";
keynames[SDLK_BACKQUOTE] = "`";
keynames[SDLK_a] = "a";
keynames[SDLK_b] = "b";
keynames[SDLK_c] = "c";
keynames[SDLK_d] = "d";
keynames[SDLK_e] = "e";
keynames[SDLK_f] = "f";
keynames[SDLK_g] = "g";
keynames[SDLK_h] = "h";
keynames[SDLK_i] = "i";
keynames[SDLK_j] = "j";
keynames[SDLK_k] = "k";
keynames[SDLK_l] = "l";
keynames[SDLK_m] = "m";
keynames[SDLK_n] = "n";
keynames[SDLK_o] = "o";
keynames[SDLK_p] = "p";
keynames[SDLK_q] = "q";
keynames[SDLK_r] = "r";
keynames[SDLK_s] = "s";
keynames[SDLK_t] = "t";
keynames[SDLK_u] = "u";
keynames[SDLK_v] = "v";
keynames[SDLK_w] = "w";
keynames[SDLK_x] = "x";
keynames[SDLK_y] = "y";
keynames[SDLK_z] = "z";
keynames[SDLK_DELETE] = "delete";
keynames[SDLK_WORLD_0] = "world 0";
keynames[SDLK_WORLD_1] = "world 1";
keynames[SDLK_WORLD_2] = "world 2";
keynames[SDLK_WORLD_3] = "world 3";
keynames[SDLK_WORLD_4] = "world 4";
keynames[SDLK_WORLD_5] = "world 5";
keynames[SDLK_WORLD_6] = "world 6";
keynames[SDLK_WORLD_7] = "world 7";
keynames[SDLK_WORLD_8] = "world 8";
keynames[SDLK_WORLD_9] = "world 9";
keynames[SDLK_WORLD_10] = "world 10";
keynames[SDLK_WORLD_11] = "world 11";
keynames[SDLK_WORLD_12] = "world 12";
keynames[SDLK_WORLD_13] = "world 13";
keynames[SDLK_WORLD_14] = "world 14";
keynames[SDLK_WORLD_15] = "world 15";
keynames[SDLK_WORLD_16] = "world 16";
keynames[SDLK_WORLD_17] = "world 17";
keynames[SDLK_WORLD_18] = "world 18";
keynames[SDLK_WORLD_19] = "world 19";
keynames[SDLK_WORLD_20] = "world 20";
keynames[SDLK_WORLD_21] = "world 21";
keynames[SDLK_WORLD_22] = "world 22";
keynames[SDLK_WORLD_23] = "world 23";
keynames[SDLK_WORLD_24] = "world 24";
keynames[SDLK_WORLD_25] = "world 25";
keynames[SDLK_WORLD_26] = "world 26";
keynames[SDLK_WORLD_27] = "world 27";
keynames[SDLK_WORLD_28] = "world 28";
keynames[SDLK_WORLD_29] = "world 29";
keynames[SDLK_WORLD_30] = "world 30";
keynames[SDLK_WORLD_31] = "world 31";
keynames[SDLK_WORLD_32] = "world 32";
keynames[SDLK_WORLD_33] = "world 33";
keynames[SDLK_WORLD_34] = "world 34";
keynames[SDLK_WORLD_35] = "world 35";
keynames[SDLK_WORLD_36] = "world 36";
keynames[SDLK_WORLD_37] = "world 37";
keynames[SDLK_WORLD_38] = "world 38";
keynames[SDLK_WORLD_39] = "world 39";
keynames[SDLK_WORLD_40] = "world 40";
keynames[SDLK_WORLD_41] = "world 41";
keynames[SDLK_WORLD_42] = "world 42";
keynames[SDLK_WORLD_43] = "world 43";
keynames[SDLK_WORLD_44] = "world 44";
keynames[SDLK_WORLD_45] = "world 45";
keynames[SDLK_WORLD_46] = "world 46";
keynames[SDLK_WORLD_47] = "world 47";
keynames[SDLK_WORLD_48] = "world 48";
keynames[SDLK_WORLD_49] = "world 49";
keynames[SDLK_WORLD_50] = "world 50";
keynames[SDLK_WORLD_51] = "world 51";
keynames[SDLK_WORLD_52] = "world 52";
keynames[SDLK_WORLD_53] = "world 53";
keynames[SDLK_WORLD_54] = "world 54";
keynames[SDLK_WORLD_55] = "world 55";
keynames[SDLK_WORLD_56] = "world 56";
keynames[SDLK_WORLD_57] = "world 57";
keynames[SDLK_WORLD_58] = "world 58";
keynames[SDLK_WORLD_59] = "world 59";
keynames[SDLK_WORLD_60] = "world 60";
keynames[SDLK_WORLD_61] = "world 61";
keynames[SDLK_WORLD_62] = "world 62";
keynames[SDLK_WORLD_63] = "world 63";
keynames[SDLK_WORLD_64] = "world 64";
keynames[SDLK_WORLD_65] = "world 65";
keynames[SDLK_WORLD_66] = "world 66";
keynames[SDLK_WORLD_67] = "world 67";
keynames[SDLK_WORLD_68] = "world 68";
keynames[SDLK_WORLD_69] = "world 69";
keynames[SDLK_WORLD_70] = "world 70";
keynames[SDLK_WORLD_71] = "world 71";
keynames[SDLK_WORLD_72] = "world 72";
keynames[SDLK_WORLD_73] = "world 73";
keynames[SDLK_WORLD_74] = "world 74";
keynames[SDLK_WORLD_75] = "world 75";
keynames[SDLK_WORLD_76] = "world 76";
keynames[SDLK_WORLD_77] = "world 77";
keynames[SDLK_WORLD_78] = "world 78";
keynames[SDLK_WORLD_79] = "world 79";
keynames[SDLK_WORLD_80] = "world 80";
keynames[SDLK_WORLD_81] = "world 81";
keynames[SDLK_WORLD_82] = "world 82";
keynames[SDLK_WORLD_83] = "world 83";
keynames[SDLK_WORLD_84] = "world 84";
keynames[SDLK_WORLD_85] = "world 85";
keynames[SDLK_WORLD_86] = "world 86";
keynames[SDLK_WORLD_87] = "world 87";
keynames[SDLK_WORLD_88] = "world 88";
keynames[SDLK_WORLD_89] = "world 89";
keynames[SDLK_WORLD_90] = "world 90";
keynames[SDLK_WORLD_91] = "world 91";
keynames[SDLK_WORLD_92] = "world 92";
keynames[SDLK_WORLD_93] = "world 93";
keynames[SDLK_WORLD_94] = "world 94";
keynames[SDLK_WORLD_95] = "world 95";
keynames[SDLK_KP0] = "[0]";
keynames[SDLK_KP1] = "[1]";
keynames[SDLK_KP2] = "[2]";
keynames[SDLK_KP3] = "[3]";
keynames[SDLK_KP4] = "[4]";
keynames[SDLK_KP5] = "[5]";
keynames[SDLK_KP6] = "[6]";
keynames[SDLK_KP7] = "[7]";
keynames[SDLK_KP8] = "[8]";
keynames[SDLK_KP9] = "[9]";
keynames[SDLK_KP_PERIOD] = "[.]";
keynames[SDLK_KP_DIVIDE] = "[/]";
keynames[SDLK_KP_MULTIPLY] = "[*]";
keynames[SDLK_KP_MINUS] = "[-]";
keynames[SDLK_KP_PLUS] = "[+]";
keynames[SDLK_KP_ENTER] = "enter";
keynames[SDLK_KP_EQUALS] = "equals";
keynames[SDLK_UP] = "up";
keynames[SDLK_DOWN] = "down";
keynames[SDLK_RIGHT] = "right";
keynames[SDLK_LEFT] = "left";
keynames[SDLK_DOWN] = "down";
keynames[SDLK_INSERT] = "insert";
keynames[SDLK_HOME] = "home";
keynames[SDLK_END] = "end";
keynames[SDLK_PAGEUP] = "page up";
keynames[SDLK_PAGEDOWN] = "page down";
keynames[SDLK_F1] = "f1";
keynames[SDLK_F2] = "f2";
keynames[SDLK_F3] = "f3";
keynames[SDLK_F4] = "f4";
keynames[SDLK_F5] = "f5";
keynames[SDLK_F6] = "f6";
keynames[SDLK_F7] = "f7";
keynames[SDLK_F8] = "f8";
keynames[SDLK_F9] = "f9";
keynames[SDLK_F10] = "f10";
keynames[SDLK_F11] = "f11";
keynames[SDLK_F12] = "f12";
keynames[SDLK_F13] = "f13";
keynames[SDLK_F14] = "f14";
keynames[SDLK_F15] = "f15";
keynames[SDLK_NUMLOCK] = "numlock";
keynames[SDLK_CAPSLOCK] = "caps lock";
keynames[SDLK_SCROLLOCK] = "scroll lock";
keynames[SDLK_RSHIFT] = "right shift";
keynames[SDLK_LSHIFT] = "left shift";
keynames[SDLK_RCTRL] = "right ctrl";
keynames[SDLK_LCTRL] = "left ctrl";
keynames[SDLK_RALT] = "right alt";
keynames[SDLK_LALT] = "left alt";
keynames[SDLK_RMETA] = "right meta";
keynames[SDLK_LMETA] = "left meta";
keynames[SDLK_LSUPER] = "left super"; /* "Windows" keys */
keynames[SDLK_RSUPER] = "right super";
keynames[SDLK_MODE] = "alt gr";
keynames[SDLK_COMPOSE] = "compose";
keynames[SDLK_HELP] = "help";
keynames[SDLK_PRINT] = "print screen";
keynames[SDLK_SYSREQ] = "sys req";
keynames[SDLK_BREAK] = "break";
keynames[SDLK_MENU] = "menu";
keynames[SDLK_POWER] = "power";
keynames[SDLK_EURO] = "euro";
keynames[SDLK_UNDO] = "undo";
/* Done. Whew. */
return(0);
}
void ResetKeyMap()
{
unsigned int i;
/* Initialize the key translation table */
for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
/* Numbers */
for ( i = 0; i<32; ++i ){
keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
}
/* e.g. Alphabet keys */
for ( i = 0; i<32; ++i ){
keymap['A' + i] = (SDLKey)(SDLK_a+i);
}
keymap[EStdKeyBackspace] = SDLK_BACKSPACE;
keymap[EStdKeyTab] = SDLK_TAB;
keymap[EStdKeyEnter] = SDLK_RETURN;
keymap[EStdKeyEscape] = SDLK_ESCAPE;
keymap[EStdKeySpace] = SDLK_SPACE;
keymap[EStdKeyPause] = SDLK_PAUSE;
keymap[EStdKeyHome] = SDLK_HOME;
keymap[EStdKeyEnd] = SDLK_END;
keymap[EStdKeyPageUp] = SDLK_PAGEUP;
keymap[EStdKeyPageDown] = SDLK_PAGEDOWN;
keymap[EStdKeyDelete] = SDLK_DELETE;
keymap[EStdKeyUpArrow] = SDLK_UP;
keymap[EStdKeyDownArrow] = SDLK_DOWN;
keymap[EStdKeyLeftArrow] = SDLK_LEFT;
keymap[EStdKeyRightArrow] = SDLK_RIGHT;
keymap[EStdKeyCapsLock] = SDLK_CAPSLOCK;
keymap[EStdKeyLeftShift] = SDLK_LSHIFT;
keymap[EStdKeyRightShift] = SDLK_RSHIFT;
keymap[EStdKeyLeftAlt] = SDLK_LALT;
keymap[EStdKeyRightAlt] = SDLK_RALT;
keymap[EStdKeyLeftCtrl] = SDLK_LCTRL;
keymap[EStdKeyRightCtrl] = SDLK_RCTRL;
keymap[EStdKeyLeftFunc] = SDLK_LMETA;
keymap[EStdKeyRightFunc] = SDLK_RMETA;
keymap[EStdKeyInsert] = SDLK_INSERT;
keymap[EStdKeyComma] = SDLK_COMMA;
keymap[EStdKeyFullStop] = SDLK_PERIOD;
keymap[EStdKeyForwardSlash] = SDLK_SLASH;
keymap[EStdKeyBackSlash] = SDLK_BACKSLASH;
keymap[EStdKeySemiColon] = SDLK_SEMICOLON;
keymap[EStdKeySingleQuote] = SDLK_QUOTE;
keymap[EStdKeyHash] = SDLK_HASH;
keymap[EStdKeySquareBracketLeft] = SDLK_LEFTBRACKET;
keymap[EStdKeySquareBracketRight] = SDLK_RIGHTBRACKET;
keymap[EStdKeyMinus] = SDLK_MINUS;
keymap[EStdKeyEquals] = SDLK_EQUALS;
keymap[EStdKeyF1] = SDLK_F1;
keymap[EStdKeyF2] = SDLK_F2;
keymap[EStdKeyF3] = SDLK_F3;
keymap[EStdKeyF4] = SDLK_F4;
keymap[EStdKeyF5] = SDLK_F5;
keymap[EStdKeyF6] = SDLK_F6;
keymap[EStdKeyF7] = SDLK_F7;
keymap[EStdKeyF8] = SDLK_F8;
keymap[EStdKeyF9] = SDLK_F9;
keymap[EStdKeyF10] = SDLK_F10;
keymap[EStdKeyF11] = SDLK_F11;
keymap[EStdKeyF12] = SDLK_F12;
keymap[EStdKeyXXX] = SDLK_RETURN; /* "fire" key */
keymap[EStdKeyDevice3] = SDLK_RETURN; /* "fire" key */
keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK;
keymap[EStdKeyYes] = SDLK_HOME; /* "call" key */
keymap[EStdKeyNo] = SDLK_END; /* "end call" key */
keymap[EStdKeyDevice0] = SDLK_SPACE; /* right menu key */
keymap[EStdKeyDevice1] = SDLK_ESCAPE; /* left menu key */
keymap[EStdKeyDevice2] = SDLK_POWER; /* power key */
keymap[EStdKeyMenu] = SDLK_MENU; // menu key
keymap[EStdKeyDevice6] = SDLK_LEFT; // Rocker (joystick) left
keymap[EStdKeyDevice7] = SDLK_RIGHT; // Rocker (joystick) right
keymap[EStdKeyDevice8] = SDLK_UP; // Rocker (joystick) up
keymap[EStdKeyDevice9] = SDLK_DOWN; // Rocker (joystick) down
keymap[EStdKeyLeftFunc] = SDLK_LALT; //chr?
keymap[EStdKeyRightFunc] = SDLK_RALT;
keymap[EStdKeyDeviceA] = SDLK_RETURN; /* "fire" key */
///////////////////////////////////////////////////////////
/*
RFs fs;
if(KErrNone == fs.Connect())
{
RArray<TInt> array;
TRAPD(err, ReadL(fs, array));
if(err == KErrNone && array.Count() > 0)
{
SDLKey temp[MAX_SCANCODE];
Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));
for(TInt k = 0; k < array.Count(); k+= 2)
{
const TInt oldval = array[k];
const TInt newval = array[k + 1];
if(oldval >= 0 && oldval < MAX_SCANCODE && newval >= 0 && newval < MAX_SCANCODE)
{
keymap[oldval] = temp[newval];
}
}
}
array.Close();
}
fs.Close();*/
///////////////////////////////////////////////////////////
keymap[EStdKeyNumLock] = SDLK_NUMLOCK;
keymap[EStdKeyScrollLock] = SDLK_SCROLLOCK;
keymap[EStdKeyNkpForwardSlash] = SDLK_KP_DIVIDE;
keymap[EStdKeyNkpAsterisk] = SDLK_KP_MULTIPLY;
keymap[EStdKeyNkpMinus] = SDLK_KP_MINUS;
keymap[EStdKeyNkpPlus] = SDLK_KP_PLUS;
keymap[EStdKeyNkpEnter] = SDLK_KP_ENTER;
keymap[EStdKeyNkp1] = SDLK_KP1;
keymap[EStdKeyNkp2] = SDLK_KP2;
keymap[EStdKeyNkp3] = SDLK_KP3;
keymap[EStdKeyNkp4] = SDLK_KP4;
keymap[EStdKeyNkp5] = SDLK_KP5;
keymap[EStdKeyNkp6] = SDLK_KP6;
keymap[EStdKeyNkp7] = SDLK_KP7;
keymap[EStdKeyNkp8] = SDLK_KP8;
keymap[EStdKeyNkp9] = SDLK_KP9;
keymap[EStdKeyNkp0] = SDLK_KP0;
keymap[EStdKeyNkpFullStop] = SDLK_KP_PERIOD;
/*
keymap[EStdKeyMenu] = SDLK_MENU; should be, but not yet
keymap[EStdKeyBacklightOn] =
keymap[EStdKeyBacklightOff] =
keymap[EStdKeyBacklightToggle] =
keymap[EStdKeyIncContrast] =
keymap[EStdKeyDecContrast] =
keymap[EStdKeySliderDown] =
keymap[EStdKeySliderUp] =
keymap[EStdKeyDictaphonePlay] =
keymap[EStdKeyDictaphoneStop] =
keymap[EStdKeyDictaphoneRecord] =
keymap[EStdKeyHelp] =
keymap[EStdKeyOff] =
keymap[EStdKeyDial] =
keymap[EStdKeyIncVolume] =
keymap[EStdKeyDecVolume] =
keymap[EStdKeyDevice0] =
keymap[EStdKeyDevice1] =
keymap[EStdKeyDevice2] =
keymap[EStdKeyDevice3] =
keymap[EStdKeyDevice4] =
keymap[EStdKeyDevice5] =
keymap[EStdKeyDevice6] =
keymap[EStdKeyDevice7] =
keymap[EStdKeyDevice8] =
keymap[EStdKeyDevice9] =
keymap[EStdKeyDeviceA] =
keymap[EStdKeyDeviceB] =
keymap[EStdKeyDeviceC] =
keymap[EStdKeyDeviceD] =
keymap[EStdKeyDeviceE] =
keymap[EStdKeyDeviceF] =
keymap[EStdKeyApplication0] =
keymap[EStdKeyApplication1] =
keymap[EStdKeyApplication2] =
keymap[EStdKeyApplication3] =
keymap[EStdKeyApplication4] =
keymap[EStdKeyApplication5] =
keymap[EStdKeyApplication6] =
keymap[EStdKeyApplication7] =
keymap[EStdKeyApplication8] =
keymap[EStdKeyApplication9] =
keymap[EStdKeyApplicationA] =
keymap[EStdKeyApplicationB] =
keymap[EStdKeyApplicationC] =
keymap[EStdKeyApplicationD] =
keymap[EStdKeyApplicationE] =
keymap[EStdKeyApplicationF] =
keymap[EStdKeyYes] =
keymap[EStdKeyNo] =
keymap[EStdKeyIncBrightness] =
keymap[EStdKeyDecBrightness] =
keymap[EStdKeyCaseOpen] =
keymap[EStdKeyCaseClose] = */
}
void DX5_InitOSKeymap(_THIS)
{
#ifndef DIK_PAUSE
#define DIK_PAUSE 0xC5
#endif
#ifndef DIK_OEM_102
#define DIK_OEM_102 0x56 /* < > | on UK/Germany keyboards */
#endif
int i;
/* Map the DIK scancodes to SDL keysyms */
for ( i=0; i<SDL_TABLESIZE(DIK_keymap); ++i )
DIK_keymap[i] = 0;
/* Defined DIK_* constants */
DIK_keymap[DIK_ESCAPE] = SDLK_ESCAPE;
DIK_keymap[DIK_1] = SDLK_1;
DIK_keymap[DIK_2] = SDLK_2;
DIK_keymap[DIK_3] = SDLK_3;
DIK_keymap[DIK_4] = SDLK_4;
DIK_keymap[DIK_5] = SDLK_5;
DIK_keymap[DIK_6] = SDLK_6;
DIK_keymap[DIK_7] = SDLK_7;
DIK_keymap[DIK_8] = SDLK_8;
DIK_keymap[DIK_9] = SDLK_9;
DIK_keymap[DIK_0] = SDLK_0;
DIK_keymap[DIK_MINUS] = SDLK_MINUS;
DIK_keymap[DIK_EQUALS] = SDLK_EQUALS;
DIK_keymap[DIK_BACK] = SDLK_BACKSPACE;
DIK_keymap[DIK_TAB] = SDLK_TAB;
DIK_keymap[DIK_Q] = SDLK_q;
DIK_keymap[DIK_W] = SDLK_w;
DIK_keymap[DIK_E] = SDLK_e;
DIK_keymap[DIK_R] = SDLK_r;
DIK_keymap[DIK_T] = SDLK_t;
DIK_keymap[DIK_Y] = SDLK_y;
DIK_keymap[DIK_U] = SDLK_u;
DIK_keymap[DIK_I] = SDLK_i;
DIK_keymap[DIK_O] = SDLK_o;
DIK_keymap[DIK_P] = SDLK_p;
DIK_keymap[DIK_LBRACKET] = SDLK_LEFTBRACKET;
DIK_keymap[DIK_RBRACKET] = SDLK_RIGHTBRACKET;
DIK_keymap[DIK_RETURN] = SDLK_RETURN;
DIK_keymap[DIK_LCONTROL] = SDLK_LCTRL;
DIK_keymap[DIK_A] = SDLK_a;
DIK_keymap[DIK_S] = SDLK_s;
DIK_keymap[DIK_D] = SDLK_d;
DIK_keymap[DIK_F] = SDLK_f;
DIK_keymap[DIK_G] = SDLK_g;
DIK_keymap[DIK_H] = SDLK_h;
DIK_keymap[DIK_J] = SDLK_j;
DIK_keymap[DIK_K] = SDLK_k;
DIK_keymap[DIK_L] = SDLK_l;
DIK_keymap[DIK_SEMICOLON] = SDLK_SEMICOLON;
DIK_keymap[DIK_APOSTROPHE] = SDLK_QUOTE;
DIK_keymap[DIK_GRAVE] = SDLK_BACKQUOTE;
DIK_keymap[DIK_LSHIFT] = SDLK_LSHIFT;
DIK_keymap[DIK_BACKSLASH] = SDLK_BACKSLASH;
DIK_keymap[DIK_OEM_102] = SDLK_BACKSLASH;
DIK_keymap[DIK_Z] = SDLK_z;
DIK_keymap[DIK_X] = SDLK_x;
DIK_keymap[DIK_C] = SDLK_c;
DIK_keymap[DIK_V] = SDLK_v;
DIK_keymap[DIK_B] = SDLK_b;
DIK_keymap[DIK_N] = SDLK_n;
DIK_keymap[DIK_M] = SDLK_m;
DIK_keymap[DIK_COMMA] = SDLK_COMMA;
DIK_keymap[DIK_PERIOD] = SDLK_PERIOD;
DIK_keymap[DIK_SLASH] = SDLK_SLASH;
DIK_keymap[DIK_RSHIFT] = SDLK_RSHIFT;
DIK_keymap[DIK_MULTIPLY] = SDLK_KP_MULTIPLY;
DIK_keymap[DIK_LMENU] = SDLK_LALT;
DIK_keymap[DIK_SPACE] = SDLK_SPACE;
DIK_keymap[DIK_CAPITAL] = SDLK_CAPSLOCK;
DIK_keymap[DIK_F1] = SDLK_F1;
DIK_keymap[DIK_F2] = SDLK_F2;
DIK_keymap[DIK_F3] = SDLK_F3;
DIK_keymap[DIK_F4] = SDLK_F4;
DIK_keymap[DIK_F5] = SDLK_F5;
DIK_keymap[DIK_F6] = SDLK_F6;
DIK_keymap[DIK_F7] = SDLK_F7;
DIK_keymap[DIK_F8] = SDLK_F8;
DIK_keymap[DIK_F9] = SDLK_F9;
DIK_keymap[DIK_F10] = SDLK_F10;
DIK_keymap[DIK_NUMLOCK] = SDLK_NUMLOCK;
DIK_keymap[DIK_SCROLL] = SDLK_SCROLLOCK;
DIK_keymap[DIK_NUMPAD7] = SDLK_KP7;
DIK_keymap[DIK_NUMPAD8] = SDLK_KP8;
DIK_keymap[DIK_NUMPAD9] = SDLK_KP9;
DIK_keymap[DIK_SUBTRACT] = SDLK_KP_MINUS;
DIK_keymap[DIK_NUMPAD4] = SDLK_KP4;
DIK_keymap[DIK_NUMPAD5] = SDLK_KP5;
DIK_keymap[DIK_NUMPAD6] = SDLK_KP6;
DIK_keymap[DIK_ADD] = SDLK_KP_PLUS;
DIK_keymap[DIK_NUMPAD1] = SDLK_KP1;
DIK_keymap[DIK_NUMPAD2] = SDLK_KP2;
DIK_keymap[DIK_NUMPAD3] = SDLK_KP3;
DIK_keymap[DIK_NUMPAD0] = SDLK_KP0;
DIK_keymap[DIK_DECIMAL] = SDLK_KP_PERIOD;
DIK_keymap[DIK_F11] = SDLK_F11;
DIK_keymap[DIK_F12] = SDLK_F12;
DIK_keymap[DIK_F13] = SDLK_F13;
DIK_keymap[DIK_F14] = SDLK_F14;
DIK_keymap[DIK_F15] = SDLK_F15;
DIK_keymap[DIK_NUMPADEQUALS] = SDLK_KP_EQUALS;
DIK_keymap[DIK_NUMPADENTER] = SDLK_KP_ENTER;
DIK_keymap[DIK_RCONTROL] = SDLK_RCTRL;
DIK_keymap[DIK_DIVIDE] = SDLK_KP_DIVIDE;
DIK_keymap[DIK_SYSRQ] = SDLK_SYSREQ;
DIK_keymap[DIK_RMENU] = SDLK_RALT;
DIK_keymap[DIK_PAUSE] = SDLK_PAUSE;
DIK_keymap[DIK_HOME] = SDLK_HOME;
DIK_keymap[DIK_UP] = SDLK_UP;
DIK_keymap[DIK_PRIOR] = SDLK_PAGEUP;
DIK_keymap[DIK_LEFT] = SDLK_LEFT;
DIK_keymap[DIK_RIGHT] = SDLK_RIGHT;
DIK_keymap[DIK_END] = SDLK_END;
DIK_keymap[DIK_DOWN] = SDLK_DOWN;
DIK_keymap[DIK_NEXT] = SDLK_PAGEDOWN;
DIK_keymap[DIK_INSERT] = SDLK_INSERT;
DIK_keymap[DIK_DELETE] = SDLK_DELETE;
DIK_keymap[DIK_LWIN] = SDLK_LMETA;
DIK_keymap[DIK_RWIN] = SDLK_RMETA;
DIK_keymap[DIK_APPS] = SDLK_MENU;
}
void DIB_InitOSKeymap(_THIS)
{
int i;
/* Map the VK keysyms */
for ( i=0; i<SDL_TABLESIZE(VK_keymap); ++i )
VK_keymap[i] = SDLK_UNKNOWN;
VK_keymap[VK_BACK] = SDLK_BACKSPACE;
VK_keymap[VK_TAB] = SDLK_TAB;
VK_keymap[VK_CLEAR] = SDLK_CLEAR;
VK_keymap[VK_RETURN] = SDLK_RETURN;
VK_keymap[VK_PAUSE] = SDLK_PAUSE;
VK_keymap[VK_ESCAPE] = SDLK_ESCAPE;
VK_keymap[VK_SPACE] = SDLK_SPACE;
VK_keymap[VK_APOSTROPHE] = SDLK_QUOTE;
VK_keymap[VK_COMMA] = SDLK_COMMA;
VK_keymap[VK_MINUS] = SDLK_MINUS;
VK_keymap[VK_PERIOD] = SDLK_PERIOD;
VK_keymap[VK_SLASH] = SDLK_SLASH;
VK_keymap[VK_0] = SDLK_0;
VK_keymap[VK_1] = SDLK_1;
VK_keymap[VK_2] = SDLK_2;
VK_keymap[VK_3] = SDLK_3;
VK_keymap[VK_4] = SDLK_4;
VK_keymap[VK_5] = SDLK_5;
VK_keymap[VK_6] = SDLK_6;
VK_keymap[VK_7] = SDLK_7;
VK_keymap[VK_8] = SDLK_8;
VK_keymap[VK_9] = SDLK_9;
VK_keymap[VK_SEMICOLON] = SDLK_SEMICOLON;
VK_keymap[VK_EQUALS] = SDLK_EQUALS;
VK_keymap[VK_LBRACKET] = SDLK_LEFTBRACKET;
VK_keymap[VK_BACKSLASH] = SDLK_BACKSLASH;
VK_keymap[VK_RBRACKET] = SDLK_RIGHTBRACKET;
VK_keymap[VK_GRAVE] = SDLK_BACKQUOTE;
VK_keymap[VK_BACKTICK] = SDLK_BACKQUOTE;
VK_keymap[VK_A] = SDLK_a;
VK_keymap[VK_B] = SDLK_b;
VK_keymap[VK_C] = SDLK_c;
VK_keymap[VK_D] = SDLK_d;
VK_keymap[VK_E] = SDLK_e;
VK_keymap[VK_F] = SDLK_f;
VK_keymap[VK_G] = SDLK_g;
VK_keymap[VK_H] = SDLK_h;
VK_keymap[VK_I] = SDLK_i;
VK_keymap[VK_J] = SDLK_j;
VK_keymap[VK_K] = SDLK_k;
VK_keymap[VK_L] = SDLK_l;
VK_keymap[VK_M] = SDLK_m;
VK_keymap[VK_N] = SDLK_n;
VK_keymap[VK_O] = SDLK_o;
VK_keymap[VK_P] = SDLK_p;
VK_keymap[VK_Q] = SDLK_q;
VK_keymap[VK_R] = SDLK_r;
VK_keymap[VK_S] = SDLK_s;
VK_keymap[VK_T] = SDLK_t;
VK_keymap[VK_U] = SDLK_u;
VK_keymap[VK_V] = SDLK_v;
VK_keymap[VK_W] = SDLK_w;
VK_keymap[VK_X] = SDLK_x;
VK_keymap[VK_Y] = SDLK_y;
VK_keymap[VK_Z] = SDLK_z;
VK_keymap[VK_DELETE] = SDLK_DELETE;
VK_keymap[VK_NUMPAD0] = SDLK_KP0;
VK_keymap[VK_NUMPAD1] = SDLK_KP1;
VK_keymap[VK_NUMPAD2] = SDLK_KP2;
VK_keymap[VK_NUMPAD3] = SDLK_KP3;
VK_keymap[VK_NUMPAD4] = SDLK_KP4;
VK_keymap[VK_NUMPAD5] = SDLK_KP5;
VK_keymap[VK_NUMPAD6] = SDLK_KP6;
VK_keymap[VK_NUMPAD7] = SDLK_KP7;
VK_keymap[VK_NUMPAD8] = SDLK_KP8;
VK_keymap[VK_NUMPAD9] = SDLK_KP9;
VK_keymap[VK_DECIMAL] = SDLK_KP_PERIOD;
VK_keymap[VK_DIVIDE] = SDLK_KP_DIVIDE;
VK_keymap[VK_MULTIPLY] = SDLK_KP_MULTIPLY;
VK_keymap[VK_SUBTRACT] = SDLK_KP_MINUS;
VK_keymap[VK_ADD] = SDLK_KP_PLUS;
VK_keymap[VK_UP] = SDLK_UP;
VK_keymap[VK_DOWN] = SDLK_DOWN;
VK_keymap[VK_RIGHT] = SDLK_RIGHT;
VK_keymap[VK_LEFT] = SDLK_LEFT;
VK_keymap[VK_INSERT] = SDLK_INSERT;
VK_keymap[VK_HOME] = SDLK_HOME;
VK_keymap[VK_END] = SDLK_END;
VK_keymap[VK_PRIOR] = SDLK_PAGEUP;
VK_keymap[VK_NEXT] = SDLK_PAGEDOWN;
VK_keymap[VK_F1] = SDLK_F1;
VK_keymap[VK_F2] = SDLK_F2;
VK_keymap[VK_F3] = SDLK_F3;
VK_keymap[VK_F4] = SDLK_F4;
VK_keymap[VK_F5] = SDLK_F5;
VK_keymap[VK_F6] = SDLK_F6;
VK_keymap[VK_F7] = SDLK_F7;
VK_keymap[VK_F8] = SDLK_F8;
VK_keymap[VK_F9] = SDLK_F9;
VK_keymap[VK_F10] = SDLK_F10;
VK_keymap[VK_F11] = SDLK_F11;
VK_keymap[VK_F12] = SDLK_F12;
VK_keymap[VK_F13] = SDLK_F13;
VK_keymap[VK_F14] = SDLK_F14;
VK_keymap[VK_F15] = SDLK_F15;
VK_keymap[VK_NUMLOCK] = SDLK_NUMLOCK;
VK_keymap[VK_CAPITAL] = SDLK_CAPSLOCK;
VK_keymap[VK_SCROLL] = SDLK_SCROLLOCK;
VK_keymap[VK_RSHIFT] = SDLK_RSHIFT;
VK_keymap[VK_LSHIFT] = SDLK_LSHIFT;
VK_keymap[VK_RCONTROL] = SDLK_RCTRL;
VK_keymap[VK_LCONTROL] = SDLK_LCTRL;
VK_keymap[VK_RMENU] = SDLK_RALT;
VK_keymap[VK_LMENU] = SDLK_LALT;
VK_keymap[VK_RWIN] = SDLK_RSUPER;
VK_keymap[VK_LWIN] = SDLK_LSUPER;
VK_keymap[VK_HELP] = SDLK_HELP;
#ifdef VK_PRINT
VK_keymap[VK_PRINT] = SDLK_PRINT;
#endif
VK_keymap[VK_SNAPSHOT] = SDLK_PRINT;
VK_keymap[VK_CANCEL] = SDLK_BREAK;
VK_keymap[VK_APPS] = SDLK_MENU;
prev_shiftstates[0] = FALSE;
prev_shiftstates[1] = FALSE;
}
void EPOC_InitOSKeymap(_THIS)
{
int i;
/* Initialize the key translation table */
for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
/* Numbers */
for ( i = 0; i<32; ++i ){
keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
}
/* e.g. Alphabet keys */
for ( i = 0; i<32; ++i ){
keymap['A' + i] = (SDLKey)(SDLK_a+i);
}
keymap[EStdKeyBackspace] = SDLK_BACKSPACE;
keymap[EStdKeyTab] = SDLK_TAB;
keymap[EStdKeyEnter] = SDLK_RETURN;
keymap[EStdKeyEscape] = SDLK_ESCAPE;
keymap[EStdKeySpace] = SDLK_SPACE;
keymap[EStdKeyPause] = SDLK_PAUSE;
keymap[EStdKeyHome] = SDLK_HOME;
keymap[EStdKeyEnd] = SDLK_END;
keymap[EStdKeyPageUp] = SDLK_PAGEUP;
keymap[EStdKeyPageDown] = SDLK_PAGEDOWN;
keymap[EStdKeyDelete] = SDLK_DELETE;
keymap[EStdKeyUpArrow] = SDLK_UP;
keymap[EStdKeyDownArrow] = SDLK_DOWN;
keymap[EStdKeyLeftArrow] = SDLK_LEFT;
keymap[EStdKeyRightArrow] = SDLK_RIGHT;
keymap[EStdKeyCapsLock] = SDLK_CAPSLOCK;
keymap[EStdKeyLeftShift] = SDLK_LSHIFT;
keymap[EStdKeyRightShift] = SDLK_RSHIFT;
keymap[EStdKeyLeftAlt] = SDLK_LALT;
keymap[EStdKeyRightAlt] = SDLK_RALT;
keymap[EStdKeyLeftCtrl] = SDLK_LCTRL;
keymap[EStdKeyRightCtrl] = SDLK_RCTRL;
keymap[EStdKeyLeftFunc] = SDLK_LMETA;
keymap[EStdKeyRightFunc] = SDLK_RMETA;
keymap[EStdKeyInsert] = SDLK_INSERT;
keymap[EStdKeyComma] = SDLK_COMMA;
keymap[EStdKeyFullStop] = SDLK_PERIOD;
keymap[EStdKeyForwardSlash] = SDLK_SLASH;
keymap[EStdKeyBackSlash] = SDLK_BACKSLASH;
keymap[EStdKeySemiColon] = SDLK_SEMICOLON;
keymap[EStdKeySingleQuote] = SDLK_QUOTE;
keymap[EStdKeyHash] = SDLK_HASH;
keymap[EStdKeySquareBracketLeft] = SDLK_LEFTBRACKET;
keymap[EStdKeySquareBracketRight] = SDLK_RIGHTBRACKET;
keymap[EStdKeyMinus] = SDLK_MINUS;
keymap[EStdKeyEquals] = SDLK_EQUALS;
keymap[EStdKeyF1] = SDLK_F1; /* chr + q */
keymap[EStdKeyF2] = SDLK_F2; /* chr + w */
keymap[EStdKeyF3] = SDLK_F3; /* chr + e */
keymap[EStdKeyF4] = SDLK_F4; /* chr + r */
keymap[EStdKeyF5] = SDLK_F5; /* chr + t */
keymap[EStdKeyF6] = SDLK_F6; /* chr + y */
keymap[EStdKeyF7] = SDLK_F7; /* chr + i */
keymap[EStdKeyF8] = SDLK_F8; /* chr + o */
keymap[EStdKeyF9] = SDLK_F9; /* chr + a */
keymap[EStdKeyF10] = SDLK_F10; /* chr + s */
keymap[EStdKeyF11] = SDLK_F11; /* chr + d */
keymap[EStdKeyF12] = SDLK_F12; /* chr + f */
/* !!TODO
EStdKeyNumLock=0x1b,
EStdKeyScrollLock=0x1c,
EStdKeyNkpForwardSlash=0x84,
EStdKeyNkpAsterisk=0x85,
EStdKeyNkpMinus=0x86,
EStdKeyNkpPlus=0x87,
EStdKeyNkpEnter=0x88,
EStdKeyNkp1=0x89,
EStdKeyNkp2=0x8a,
EStdKeyNkp3=0x8b,
EStdKeyNkp4=0x8c,
EStdKeyNkp5=0x8d,
EStdKeyNkp6=0x8e,
EStdKeyNkp7=0x8f,
EStdKeyNkp8=0x90,
EStdKeyNkp9=0x91,
EStdKeyNkp0=0x92,
EStdKeyNkpFullStop=0x93,
EStdKeyMenu=0x94,
EStdKeyBacklightOn=0x95,
EStdKeyBacklightOff=0x96,
EStdKeyBacklightToggle=0x97,
EStdKeyIncContrast=0x98,
EStdKeyDecContrast=0x99,
EStdKeySliderDown=0x9a,
EStdKeySliderUp=0x9b,
EStdKeyDictaphonePlay=0x9c,
EStdKeyDictaphoneStop=0x9d,
EStdKeyDictaphoneRecord=0x9e,
EStdKeyHelp=0x9f,
EStdKeyOff=0xa0,
EStdKeyDial=0xa1,
EStdKeyIncVolume=0xa2,
EStdKeyDecVolume=0xa3,
EStdKeyDevice0=0xa4,
EStdKeyDevice1=0xa5,
EStdKeyDevice2=0xa6,
EStdKeyDevice3=0xa7,
EStdKeyDevice4=0xa8,
EStdKeyDevice5=0xa9,
EStdKeyDevice6=0xaa,
EStdKeyDevice7=0xab,
EStdKeyDevice8=0xac,
EStdKeyDevice9=0xad,
EStdKeyDeviceA=0xae,
EStdKeyDeviceB=0xaf,
EStdKeyDeviceC=0xb0,
EStdKeyDeviceD=0xb1,
EStdKeyDeviceE=0xb2,
EStdKeyDeviceF=0xb3,
EStdKeyApplication0=0xb4,
EStdKeyApplication1=0xb5,
EStdKeyApplication2=0xb6,
EStdKeyApplication3=0xb7,
EStdKeyApplication4=0xb8,
EStdKeyApplication5=0xb9,
EStdKeyApplication6=0xba,
EStdKeyApplication7=0xbb,
EStdKeyApplication8=0xbc,
EStdKeyApplication9=0xbd,
EStdKeyApplicationA=0xbe,
EStdKeyApplicationB=0xbf,
EStdKeyApplicationC=0xc0,
EStdKeyApplicationD=0xc1,
EStdKeyApplicationE=0xc2,
EStdKeyApplicationF=0xc3,
EStdKeyYes=0xc4,
EStdKeyNo=0xc5,
EStdKeyIncBrightness=0xc6,
EStdKeyDecBrightness=0xc7,
EStdKeyCaseOpen=0xc8,
EStdKeyCaseClose=0xc9
*/
}
void DirectFB_InitOSKeymap (_THIS)
{
int i;
/* Initialize the DirectFB key translation table */
for (i=0; i<SDL_TABLESIZE(keymap); ++i)
keymap[i] = SDLK_UNKNOWN;
keymap[DIKI_A - DIKI_UNKNOWN] = SDLK_a;
keymap[DIKI_B - DIKI_UNKNOWN] = SDLK_b;
keymap[DIKI_C - DIKI_UNKNOWN] = SDLK_c;
keymap[DIKI_D - DIKI_UNKNOWN] = SDLK_d;
keymap[DIKI_E - DIKI_UNKNOWN] = SDLK_e;
keymap[DIKI_F - DIKI_UNKNOWN] = SDLK_f;
keymap[DIKI_G - DIKI_UNKNOWN] = SDLK_g;
keymap[DIKI_H - DIKI_UNKNOWN] = SDLK_h;
keymap[DIKI_I - DIKI_UNKNOWN] = SDLK_i;
keymap[DIKI_J - DIKI_UNKNOWN] = SDLK_j;
keymap[DIKI_K - DIKI_UNKNOWN] = SDLK_k;
keymap[DIKI_L - DIKI_UNKNOWN] = SDLK_l;
keymap[DIKI_M - DIKI_UNKNOWN] = SDLK_m;
keymap[DIKI_N - DIKI_UNKNOWN] = SDLK_n;
keymap[DIKI_O - DIKI_UNKNOWN] = SDLK_o;
keymap[DIKI_P - DIKI_UNKNOWN] = SDLK_p;
keymap[DIKI_Q - DIKI_UNKNOWN] = SDLK_q;
keymap[DIKI_R - DIKI_UNKNOWN] = SDLK_r;
keymap[DIKI_S - DIKI_UNKNOWN] = SDLK_s;
keymap[DIKI_T - DIKI_UNKNOWN] = SDLK_t;
keymap[DIKI_U - DIKI_UNKNOWN] = SDLK_u;
keymap[DIKI_V - DIKI_UNKNOWN] = SDLK_v;
keymap[DIKI_W - DIKI_UNKNOWN] = SDLK_w;
keymap[DIKI_X - DIKI_UNKNOWN] = SDLK_x;
keymap[DIKI_Y - DIKI_UNKNOWN] = SDLK_y;
keymap[DIKI_Z - DIKI_UNKNOWN] = SDLK_z;
keymap[DIKI_0 - DIKI_UNKNOWN] = SDLK_0;
keymap[DIKI_1 - DIKI_UNKNOWN] = SDLK_1;
keymap[DIKI_2 - DIKI_UNKNOWN] = SDLK_2;
keymap[DIKI_3 - DIKI_UNKNOWN] = SDLK_3;
keymap[DIKI_4 - DIKI_UNKNOWN] = SDLK_4;
keymap[DIKI_5 - DIKI_UNKNOWN] = SDLK_5;
keymap[DIKI_6 - DIKI_UNKNOWN] = SDLK_6;
keymap[DIKI_7 - DIKI_UNKNOWN] = SDLK_7;
keymap[DIKI_8 - DIKI_UNKNOWN] = SDLK_8;
keymap[DIKI_9 - DIKI_UNKNOWN] = SDLK_9;
keymap[DIKI_F1 - DIKI_UNKNOWN] = SDLK_F1;
keymap[DIKI_F2 - DIKI_UNKNOWN] = SDLK_F2;
keymap[DIKI_F3 - DIKI_UNKNOWN] = SDLK_F3;
keymap[DIKI_F4 - DIKI_UNKNOWN] = SDLK_F4;
keymap[DIKI_F5 - DIKI_UNKNOWN] = SDLK_F5;
keymap[DIKI_F6 - DIKI_UNKNOWN] = SDLK_F6;
keymap[DIKI_F7 - DIKI_UNKNOWN] = SDLK_F7;
keymap[DIKI_F8 - DIKI_UNKNOWN] = SDLK_F8;
keymap[DIKI_F9 - DIKI_UNKNOWN] = SDLK_F9;
keymap[DIKI_F10 - DIKI_UNKNOWN] = SDLK_F10;
keymap[DIKI_F11 - DIKI_UNKNOWN] = SDLK_F11;
keymap[DIKI_F12 - DIKI_UNKNOWN] = SDLK_F12;
keymap[DIKI_ESCAPE - DIKI_UNKNOWN] = SDLK_ESCAPE;
keymap[DIKI_LEFT - DIKI_UNKNOWN] = SDLK_LEFT;
keymap[DIKI_RIGHT - DIKI_UNKNOWN] = SDLK_RIGHT;
keymap[DIKI_UP - DIKI_UNKNOWN] = SDLK_UP;
keymap[DIKI_DOWN - DIKI_UNKNOWN] = SDLK_DOWN;
keymap[DIKI_CONTROL_L - DIKI_UNKNOWN] = SDLK_LCTRL;
keymap[DIKI_CONTROL_R - DIKI_UNKNOWN] = SDLK_RCTRL;
keymap[DIKI_SHIFT_L - DIKI_UNKNOWN] = SDLK_LSHIFT;
keymap[DIKI_SHIFT_R - DIKI_UNKNOWN] = SDLK_RSHIFT;
keymap[DIKI_ALT_L - DIKI_UNKNOWN] = SDLK_LALT;
keymap[DIKI_ALTGR - DIKI_UNKNOWN] = SDLK_RALT;
keymap[DIKI_TAB - DIKI_UNKNOWN] = SDLK_TAB;
keymap[DIKI_ENTER - DIKI_UNKNOWN] = SDLK_RETURN;
keymap[DIKI_SPACE - DIKI_UNKNOWN] = SDLK_SPACE;
keymap[DIKI_BACKSPACE - DIKI_UNKNOWN] = SDLK_BACKSPACE;
keymap[DIKI_INSERT - DIKI_UNKNOWN] = SDLK_INSERT;
keymap[DIKI_DELETE - DIKI_UNKNOWN] = SDLK_DELETE;
keymap[DIKI_HOME - DIKI_UNKNOWN] = SDLK_HOME;
keymap[DIKI_END - DIKI_UNKNOWN] = SDLK_END;
keymap[DIKI_PAGE_UP - DIKI_UNKNOWN] = SDLK_PAGEUP;
keymap[DIKI_PAGE_DOWN - DIKI_UNKNOWN] = SDLK_PAGEDOWN;
keymap[DIKI_CAPS_LOCK - DIKI_UNKNOWN] = SDLK_CAPSLOCK;
keymap[DIKI_NUM_LOCK - DIKI_UNKNOWN] = SDLK_NUMLOCK;
keymap[DIKI_SCROLL_LOCK - DIKI_UNKNOWN] = SDLK_SCROLLOCK;
keymap[DIKI_PRINT - DIKI_UNKNOWN] = SDLK_PRINT;
keymap[DIKI_PAUSE - DIKI_UNKNOWN] = SDLK_PAUSE;
keymap[DIKI_KP_DIV - DIKI_UNKNOWN] = SDLK_KP_DIVIDE;
keymap[DIKI_KP_MULT - DIKI_UNKNOWN] = SDLK_KP_MULTIPLY;
keymap[DIKI_KP_MINUS - DIKI_UNKNOWN] = SDLK_KP_MINUS;
keymap[DIKI_KP_PLUS - DIKI_UNKNOWN] = SDLK_KP_PLUS;
keymap[DIKI_KP_ENTER - DIKI_UNKNOWN] = SDLK_KP_ENTER;
}
void PSP_InitOSKeymap(_THIS)
{
#ifdef PSPIRKEYB
int i;
for (i=0; i<SDL_TABLESIZE(keymap); ++i)
keymap[i] = SDLK_UNKNOWN;
keymap[KEY_ESC] = SDLK_ESCAPE;
keymap[KEY_F1] = SDLK_F1;
keymap[KEY_F2] = SDLK_F2;
keymap[KEY_F3] = SDLK_F3;
keymap[KEY_F4] = SDLK_F4;
keymap[KEY_F5] = SDLK_F5;
keymap[KEY_F6] = SDLK_F6;
keymap[KEY_F7] = SDLK_F7;
keymap[KEY_F8] = SDLK_F8;
keymap[KEY_F9] = SDLK_F9;
keymap[KEY_F10] = SDLK_F10;
keymap[KEY_F11] = SDLK_F11;
keymap[KEY_F12] = SDLK_F12;
keymap[KEY_F13] = SDLK_PRINT;
keymap[KEY_F14] = SDLK_PAUSE;
keymap[KEY_GRAVE] = SDLK_BACKQUOTE;
keymap[KEY_1] = SDLK_1;
keymap[KEY_2] = SDLK_2;
keymap[KEY_3] = SDLK_3;
keymap[KEY_4] = SDLK_4;
keymap[KEY_5] = SDLK_5;
keymap[KEY_6] = SDLK_6;
keymap[KEY_7] = SDLK_7;
keymap[KEY_8] = SDLK_8;
keymap[KEY_9] = SDLK_9;
keymap[KEY_0] = SDLK_0;
keymap[KEY_MINUS] = SDLK_MINUS;
keymap[KEY_EQUAL] = SDLK_EQUALS;
keymap[KEY_BACKSPACE] = SDLK_BACKSPACE;
keymap[KEY_TAB] = SDLK_TAB;
keymap[KEY_Q] = SDLK_q;
keymap[KEY_W] = SDLK_w;
keymap[KEY_E] = SDLK_e;
keymap[KEY_R] = SDLK_r;
keymap[KEY_T] = SDLK_t;
keymap[KEY_Y] = SDLK_y;
keymap[KEY_U] = SDLK_u;
keymap[KEY_I] = SDLK_i;
keymap[KEY_O] = SDLK_o;
keymap[KEY_P] = SDLK_p;
keymap[KEY_LEFTBRACE] = SDLK_LEFTBRACKET;
keymap[KEY_RIGHTBRACE] = SDLK_RIGHTBRACKET;
keymap[KEY_ENTER] = SDLK_RETURN;
keymap[KEY_CAPSLOCK] = SDLK_CAPSLOCK;
keymap[KEY_A] = SDLK_a;
keymap[KEY_S] = SDLK_s;
keymap[KEY_D] = SDLK_d;
keymap[KEY_F] = SDLK_f;
keymap[KEY_G] = SDLK_g;
keymap[KEY_H] = SDLK_h;
keymap[KEY_J] = SDLK_j;
keymap[KEY_K] = SDLK_k;
keymap[KEY_L] = SDLK_l;
keymap[KEY_SEMICOLON] = SDLK_SEMICOLON;
keymap[KEY_APOSTROPHE] = SDLK_QUOTE;
keymap[KEY_BACKSLASH] = SDLK_BACKSLASH;
keymap[KEY_Z] = SDLK_z;
keymap[KEY_X] = SDLK_x;
keymap[KEY_C] = SDLK_c;
keymap[KEY_V] = SDLK_v;
keymap[KEY_B] = SDLK_b;
keymap[KEY_N] = SDLK_n;
keymap[KEY_M] = SDLK_m;
keymap[KEY_COMMA] = SDLK_COMMA;
keymap[KEY_DOT] = SDLK_PERIOD;
keymap[KEY_SLASH] = SDLK_SLASH;
keymap[KEY_SPACE] = SDLK_SPACE;
keymap[KEY_UP] = SDLK_UP;
keymap[KEY_DOWN] = SDLK_DOWN;
keymap[KEY_LEFT] = SDLK_LEFT;
keymap[KEY_RIGHT] = SDLK_RIGHT;
keymap[KEY_HOME] = SDLK_HOME;
keymap[KEY_END] = SDLK_END;
keymap[KEY_INSERT] = SDLK_INSERT;
keymap[KEY_DELETE] = SDLK_DELETE;
keymap[KEY_NUMLOCK] = SDLK_NUMLOCK;
keymap[KEY_LEFTMETA] = SDLK_LSUPER;
keymap[KEY_KPSLASH] = SDLK_KP_DIVIDE;
keymap[KEY_KPASTERISK] = SDLK_KP_MULTIPLY;
keymap[KEY_KPMINUS] = SDLK_KP_MINUS;
keymap[KEY_KPPLUS] = SDLK_KP_PLUS;
keymap[KEY_KPDOT] = SDLK_KP_PERIOD;
keymap[KEY_KPEQUAL] = SDLK_KP_EQUALS;
keymap[KEY_LEFTCTRL] = SDLK_LCTRL;
keymap[KEY_RIGHTCTRL] = SDLK_RCTRL;
keymap[KEY_LEFTALT] = SDLK_LALT;
keymap[KEY_RIGHTALT] = SDLK_RALT;
keymap[KEY_LEFTSHIFT] = SDLK_LSHIFT;
keymap[KEY_RIGHTSHIFT] = SDLK_RSHIFT;
#endif
}
void GGI_InitOSKeymap(_THIS)
{
int i;
/* Initialize the GGI key translation table */
for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
keymap[i] = SDLK_UNKNOWN;
keymap[SCANCODE_ESCAPE] = SDLK_ESCAPE;
keymap[SCANCODE_1] = SDLK_1;
keymap[SCANCODE_2] = SDLK_2;
keymap[SCANCODE_3] = SDLK_3;
keymap[SCANCODE_4] = SDLK_4;
keymap[SCANCODE_5] = SDLK_5;
keymap[SCANCODE_6] = SDLK_6;
keymap[SCANCODE_7] = SDLK_7;
keymap[SCANCODE_8] = SDLK_8;
keymap[SCANCODE_9] = SDLK_9;
keymap[SCANCODE_0] = SDLK_0;
keymap[SCANCODE_MINUS] = SDLK_MINUS;
keymap[SCANCODE_EQUAL] = SDLK_EQUALS;
keymap[SCANCODE_BACKSPACE] = SDLK_BACKSPACE;
keymap[SCANCODE_TAB] = SDLK_TAB;
keymap[SCANCODE_Q] = SDLK_q;
keymap[SCANCODE_W] = SDLK_w;
keymap[SCANCODE_E] = SDLK_e;
keymap[SCANCODE_R] = SDLK_r;
keymap[SCANCODE_T] = SDLK_t;
keymap[SCANCODE_Y] = SDLK_y;
keymap[SCANCODE_U] = SDLK_u;
keymap[SCANCODE_I] = SDLK_i;
keymap[SCANCODE_O] = SDLK_o;
keymap[SCANCODE_P] = SDLK_p;
keymap[SCANCODE_BRACKET_LEFT] = SDLK_LEFTBRACKET;
keymap[SCANCODE_BRACKET_RIGHT] = SDLK_RIGHTBRACKET;
keymap[SCANCODE_ENTER] = SDLK_RETURN;
keymap[SCANCODE_LEFTCONTROL] = SDLK_LCTRL;
keymap[SCANCODE_A] = SDLK_a;
keymap[SCANCODE_S] = SDLK_s;
keymap[SCANCODE_D] = SDLK_d;
keymap[SCANCODE_F] = SDLK_f;
keymap[SCANCODE_G] = SDLK_g;
keymap[SCANCODE_H] = SDLK_h;
keymap[SCANCODE_J] = SDLK_j;
keymap[SCANCODE_K] = SDLK_k;
keymap[SCANCODE_L] = SDLK_l;
keymap[SCANCODE_SEMICOLON] = SDLK_SEMICOLON;
keymap[SCANCODE_APOSTROPHE] = SDLK_QUOTE;
keymap[SCANCODE_GRAVE] = SDLK_BACKQUOTE;
keymap[SCANCODE_LEFTSHIFT] = SDLK_LSHIFT;
keymap[SCANCODE_BACKSLASH] = SDLK_BACKSLASH;
keymap[SCANCODE_Z] = SDLK_z;
keymap[SCANCODE_X] = SDLK_x;
keymap[SCANCODE_C] = SDLK_c;
keymap[SCANCODE_V] = SDLK_v;
keymap[SCANCODE_B] = SDLK_b;
keymap[SCANCODE_N] = SDLK_n;
keymap[SCANCODE_M] = SDLK_m;
keymap[SCANCODE_COMMA] = SDLK_COMMA;
keymap[SCANCODE_PERIOD] = SDLK_PERIOD;
keymap[SCANCODE_SLASH] = SDLK_SLASH;
keymap[SCANCODE_RIGHTSHIFT] = SDLK_RSHIFT;
keymap[SCANCODE_KEYPADMULTIPLY] = SDLK_KP_MULTIPLY;
keymap[SCANCODE_LEFTALT] = SDLK_LALT;
keymap[SCANCODE_SPACE] = SDLK_SPACE;
keymap[SCANCODE_CAPSLOCK] = SDLK_CAPSLOCK;
keymap[SCANCODE_F1] = SDLK_F1;
keymap[SCANCODE_F2] = SDLK_F2;
keymap[SCANCODE_F3] = SDLK_F3;
keymap[SCANCODE_F4] = SDLK_F4;
keymap[SCANCODE_F5] = SDLK_F5;
keymap[SCANCODE_F6] = SDLK_F6;
keymap[SCANCODE_F7] = SDLK_F7;
keymap[SCANCODE_F8] = SDLK_F8;
keymap[SCANCODE_F9] = SDLK_F9;
keymap[SCANCODE_F10] = SDLK_F10;
keymap[SCANCODE_NUMLOCK] = SDLK_NUMLOCK;
keymap[SCANCODE_SCROLLLOCK] = SDLK_SCROLLOCK;
keymap[SCANCODE_KEYPAD7] = SDLK_KP7;
keymap[SCANCODE_CURSORUPLEFT] = SDLK_KP7;
keymap[SCANCODE_KEYPAD8] = SDLK_KP8;
keymap[SCANCODE_CURSORUP] = SDLK_KP8;
keymap[SCANCODE_KEYPAD9] = SDLK_KP9;
keymap[SCANCODE_CURSORUPRIGHT] = SDLK_KP9;
keymap[SCANCODE_KEYPADMINUS] = SDLK_KP_MINUS;
keymap[SCANCODE_KEYPAD4] = SDLK_KP4;
keymap[SCANCODE_CURSORLEFT] = SDLK_KP4;
keymap[SCANCODE_KEYPAD5] = SDLK_KP5;
keymap[SCANCODE_KEYPAD6] = SDLK_KP6;
keymap[SCANCODE_CURSORRIGHT] = SDLK_KP6;
keymap[SCANCODE_KEYPADPLUS] = SDLK_KP_PLUS;
keymap[SCANCODE_KEYPAD1] = SDLK_KP1;
keymap[SCANCODE_CURSORDOWNLEFT] = SDLK_KP1;
keymap[SCANCODE_KEYPAD2] = SDLK_KP2;
keymap[SCANCODE_CURSORDOWN] = SDLK_KP2;
keymap[SCANCODE_KEYPAD3] = SDLK_KP3;
keymap[SCANCODE_CURSORDOWNRIGHT] = SDLK_KP3;
keymap[SCANCODE_KEYPAD0] = SDLK_KP0;
keymap[SCANCODE_KEYPADPERIOD] = SDLK_KP_PERIOD;
keymap[SCANCODE_LESS] = SDLK_LESS;
keymap[SCANCODE_F11] = SDLK_F11;
keymap[SCANCODE_F12] = SDLK_F12;
keymap[SCANCODE_KEYPADENTER] = SDLK_KP_ENTER;
keymap[SCANCODE_RIGHTCONTROL] = SDLK_RCTRL;
keymap[SCANCODE_CONTROL] = SDLK_RCTRL;
keymap[SCANCODE_KEYPADDIVIDE] = SDLK_KP_DIVIDE;
keymap[SCANCODE_PRINTSCREEN] = SDLK_PRINT;
keymap[SCANCODE_RIGHTALT] = SDLK_RALT;
keymap[SCANCODE_BREAK] = SDLK_BREAK;
keymap[SCANCODE_BREAK_ALTERNATIVE] = SDLK_UNKNOWN;
keymap[SCANCODE_HOME] = SDLK_HOME;
keymap[SCANCODE_CURSORBLOCKUP] = SDLK_UP;
keymap[SCANCODE_PAGEUP] = SDLK_PAGEUP;
keymap[SCANCODE_CURSORBLOCKLEFT] = SDLK_LEFT;
keymap[SCANCODE_CURSORBLOCKRIGHT] = SDLK_RIGHT;
keymap[SCANCODE_END] = SDLK_END;
keymap[SCANCODE_CURSORBLOCKDOWN] = SDLK_DOWN;
keymap[SCANCODE_PAGEDOWN] = SDLK_PAGEDOWN;
keymap[SCANCODE_INSERT] = SDLK_INSERT;
keymap[SCANCODE_REMOVE] = SDLK_DELETE;
keymap[119] = SDLK_PAUSE;
keymap[SCANCODE_RIGHTWIN] = SDLK_RSUPER;
keymap[SCANCODE_LEFTWIN] = SDLK_LSUPER;
keymap[127] = SDLK_MENU;
}
