diff --git a/bochs/gui/keymap.cc b/bochs/gui/keymap.cc index 852527e19..0470d84ee 100644 --- a/bochs/gui/keymap.cc +++ b/bochs/gui/keymap.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: keymap.cc,v 1.10 2002-09-25 13:01:30 bdenney Exp $ +// $Id: keymap.cc,v 1.11 2002-10-08 06:14:52 bdenney Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -154,7 +154,7 @@ get_next_word (char *output) } static Bit32s -get_next_keymap_line (FILE *fp, char *bxsym, char *modsym, Bit32s *ascii, char *xwinsym) +get_next_keymap_line (FILE *fp, char *bxsym, char *modsym, Bit32s *ascii, char *hostsym) { char line[256]; char buf[256]; @@ -192,7 +192,7 @@ get_next_keymap_line (FILE *fp, char *bxsym, char *modsym, Bit32s *ascii, char * } else { BX_PANIC (("keymap line %d: ascii equivalent is \"%s\" but it must be char constant like 'x', or one of space,tab,return,none", lineCount, buf)); } - if (get_next_word (xwinsym) < 0) { + if (get_next_word (hostsym) < 0) { BX_PANIC (("keymap line %d: expected 3 columns", lineCount)); return -1; } @@ -206,9 +206,9 @@ get_next_keymap_line (FILE *fp, char *bxsym, char *modsym, Bit32s *ascii, char * bx_keymap_c::loadKeymap(Bit32u stringToSymbol(const char*), const char* filename) { FILE *keymapFile; - char baseSym[256], modSym[256], xwinSym[256]; + char baseSym[256], modSym[256], hostSym[256]; Bit32s ascii; - Bit32u baseKey, modKey, xwinKey; + Bit32u baseKey, modKey, hostKey; struct stat status; if (stat(filename, &status)) { @@ -229,28 +229,26 @@ bx_keymap_c::loadKeymap(Bit32u stringToSymbol(const char*), const char* filename // Read keymap file one line at a time while(1) { if (get_next_keymap_line (keymapFile, - baseSym, modSym, &ascii, xwinSym) < 0) { break; } + baseSym, modSym, &ascii, hostSym) < 0) { break; } - BX_DEBUG (("bxsym='%s', modSym='%s', ascii=%d, guisym='%s'", baseSym, modSym, ascii, xwinSym)); // convert X_KEY_* symbols to values baseKey = convertStringToBXKey(baseSym); - if (strncmp ("XK_", xwinSym, 3) != 0) { - BX_PANIC (("keymap line %d: X windows symbol '%s' must start with XK_", lineCount, xwinSym)); - } modKey = convertStringToBXKey(modSym); - xwinKey = 0; - if (stringToSymbol != NULL) - xwinKey = stringToSymbol(xwinSym + 3); // skip over the "XK_" - + hostKey = 0; + if (stringToSymbol != NULL) + hostKey = stringToSymbol(hostSym); + + BX_DEBUG (("baseKey='%s' (%d), modSym='%s' (%d), ascii=%d, guisym='%s' (%d)", baseSym, baseKey, modSym, modKey, ascii, hostSym, hostKey)); + // Check if data is valid if( baseKey==BX_KEYMAP_UNKNOWN ) { BX_PANIC (("line %d: unknown BX_KEY constant '%s'",lineCount,baseSym)); continue; } - if( xwinKey==BX_KEYMAP_UNKNOWN ) { - BX_PANIC (("line %d: unknown GUI constant '%s'",lineCount,xwinSym)); + if( hostKey==BX_KEYMAP_UNKNOWN ) { + BX_PANIC (("line %d: unknown host key name '%s'",lineCount,hostSym)); continue; } @@ -262,7 +260,7 @@ bx_keymap_c::loadKeymap(Bit32u stringToSymbol(const char*), const char* filename keymapTable[keymapCount].baseKey=baseKey; keymapTable[keymapCount].modKey=modKey; keymapTable[keymapCount].ascii=ascii; - keymapTable[keymapCount].xwinKey=xwinKey; + keymapTable[keymapCount].hostKey=hostKey; keymapCount++; } @@ -289,14 +287,14 @@ bx_keymap_c::convertStringToBXKey(const char* string) } BXKeyEntry * -bx_keymap_c::getKeyXwin(Bit32u key) +bx_keymap_c::findHostKey(Bit32u key) { Bit16u i; // We look through the keymap table to find the searched key for (i=0; i1 +# modifier). +# +# The ASCII_equivalent must be either apostrophe + one character + apostrophe, +# or one of these keywords: space, return, tab, backslash, apostrophe, none. +# This format is designed to look like a char constant in C, but it's a very +# simple parser. There's no concept of backslash being an escape char. The +# backslash and apostrophe entries are provided for aesthetic purposes only: no +# C++ programmer wants to see '\' or '''. The parser doesn't care, but they are +# ugly. +# +# Host_key_name is the name of the key combination according to the gui library +# (X windows, SDL, etc). Each GUI module must provide a function that converts +# these host key names into numbers. A pointer to the conversion function is +# passed to loadKeymap(), and it is used when parsing the keymap file. As the +# keymap file is parsed, the conversion function is called for each host key +# name, to convert it into a number. Only the number is stored. If the host +# key name is not found, the conversion function returns BX_KEYMAP_UNKNOWN, and +# the keymap code will panic, like this: +# +# [KMAP ] line 51: unknown host key name 'SDLK_PAREN_RIGHT' +# +# If this happens, you must edit the keymap file, and either correct the host +# key name or comment out that line. +# + +BX_KEY_0 '0' SDLK_0 +BX_KEY_0+BX_KEY_SHIFT_L ')' SDLK_RIGHTPAREN +BX_KEY_1 '1' SDLK_1 +BX_KEY_1+BX_KEY_SHIFT_L '!' SDLK_EXCLAIM +BX_KEY_2 '2' SDLK_2 +BX_KEY_2+BX_KEY_SHIFT_L '@' SDLK_AT +BX_KEY_3 '3' SDLK_3 +BX_KEY_3+BX_KEY_SHIFT_L '#' SDLK_HASH +BX_KEY_4 '4' SDLK_4 +BX_KEY_4+BX_KEY_SHIFT_L '$' SDLK_DOLLAR +BX_KEY_5 '5' SDLK_5 +#BX_KEY_5+BX_KEY_SHIFT_L '%' SDLK_PERCENT +BX_KEY_6 '6' SDLK_6 +BX_KEY_6+BX_KEY_SHIFT_L '^' SDLK_CARET +BX_KEY_7 '7' SDLK_7 +BX_KEY_7+BX_KEY_SHIFT_L '&' SDLK_AMPERSAND +BX_KEY_8 '8' SDLK_8 +BX_KEY_8+BX_KEY_SHIFT_L '*' SDLK_ASTERISK +BX_KEY_9 '9' SDLK_9 +BX_KEY_9+BX_KEY_SHIFT_L '(' SDLK_LEFTPAREN +BX_KEY_A+BX_KEY_SHIFT_L 'A' SDLK_a +BX_KEY_A 'a' SDLK_a +BX_KEY_B+BX_KEY_SHIFT_L 'B' SDLK_b +BX_KEY_B 'b' SDLK_b +BX_KEY_C+BX_KEY_SHIFT_L 'C' SDLK_c +BX_KEY_C 'c' SDLK_c +BX_KEY_D+BX_KEY_SHIFT_L 'D' SDLK_d +BX_KEY_D 'd' SDLK_d +BX_KEY_E+BX_KEY_SHIFT_L 'E' SDLK_e +BX_KEY_E 'e' SDLK_e +BX_KEY_F+BX_KEY_SHIFT_L 'F' SDLK_f +BX_KEY_F 'f' SDLK_f +BX_KEY_G+BX_KEY_SHIFT_L 'G' SDLK_g +BX_KEY_G 'g' SDLK_g +BX_KEY_H+BX_KEY_SHIFT_L 'H' SDLK_h +BX_KEY_H 'h' SDLK_h +BX_KEY_I+BX_KEY_SHIFT_L 'I' SDLK_i +BX_KEY_I 'i' SDLK_i +BX_KEY_J+BX_KEY_SHIFT_L 'J' SDLK_j +BX_KEY_J 'j' SDLK_j +BX_KEY_K+BX_KEY_SHIFT_L 'K' SDLK_k +BX_KEY_K 'k' SDLK_k +BX_KEY_L+BX_KEY_SHIFT_L 'L' SDLK_l +BX_KEY_L 'l' SDLK_l +BX_KEY_M+BX_KEY_SHIFT_L 'M' SDLK_m +BX_KEY_M 'm' SDLK_m +BX_KEY_N+BX_KEY_SHIFT_L 'N' SDLK_n +BX_KEY_N 'n' SDLK_n +BX_KEY_O+BX_KEY_SHIFT_L 'O' SDLK_o +BX_KEY_O 'o' SDLK_o +BX_KEY_P+BX_KEY_SHIFT_L 'P' SDLK_p +BX_KEY_P 'p' SDLK_p +BX_KEY_Q+BX_KEY_SHIFT_L 'Q' SDLK_q +BX_KEY_Q 'q' SDLK_q +BX_KEY_R+BX_KEY_SHIFT_L 'R' SDLK_r +BX_KEY_R 'r' SDLK_r +BX_KEY_S+BX_KEY_SHIFT_L 'S' SDLK_s +BX_KEY_S 's' SDLK_s +BX_KEY_T+BX_KEY_SHIFT_L 'T' SDLK_t +BX_KEY_T 't' SDLK_t +BX_KEY_U+BX_KEY_SHIFT_L 'U' SDLK_u +BX_KEY_U 'u' SDLK_u +BX_KEY_V+BX_KEY_SHIFT_L 'V' SDLK_v +BX_KEY_V 'v' SDLK_v +BX_KEY_W+BX_KEY_SHIFT_L 'W' SDLK_w +BX_KEY_W 'w' SDLK_w +BX_KEY_X+BX_KEY_SHIFT_L 'X' SDLK_x +BX_KEY_X 'x' SDLK_x +BX_KEY_Y+BX_KEY_SHIFT_L 'Y' SDLK_y +BX_KEY_Y 'y' SDLK_y +BX_KEY_Z+BX_KEY_SHIFT_L 'Z' SDLK_z +BX_KEY_Z 'z' SDLK_z +BX_KEY_F1 none SDLK_F1 +BX_KEY_F2 none SDLK_F2 +BX_KEY_F3 none SDLK_F3 +BX_KEY_F4 none SDLK_F4 +BX_KEY_F5 none SDLK_F5 +BX_KEY_F6 none SDLK_F6 +BX_KEY_F7 none SDLK_F7 +BX_KEY_F8 none SDLK_F8 +BX_KEY_F9 none SDLK_F9 +BX_KEY_F10 none SDLK_F10 +BX_KEY_F11 none SDLK_F11 +BX_KEY_F12 none SDLK_F12 +BX_KEY_ALT_L none SDLK_LALT +BX_KEY_ALT_L none SDLK_LMETA +BX_KEY_ALT_R none SDLK_MODE +#BX_KEY_ALT_R none SDLK_Multi_key +BX_KEY_BACKSLASH backslash SDLK_BACKSLASH +#BX_KEY_BACKSLASH+BX_KEY_SHIFT_L '|' SDLK_bar +BX_KEY_BACKSPACE none SDLK_BACKSPACE +BX_KEY_CAPS_LOCK none SDLK_CAPSLOCK +BX_KEY_COMMA ',' SDLK_COMMA +BX_KEY_COMMA+BX_KEY_SHIFT_L '<' SDLK_LESS +BX_KEY_CTRL_L none SDLK_LCTRL +BX_KEY_CTRL_R none SDLK_RCTRL +BX_KEY_DELETE none SDLK_DELETE +BX_KEY_DOWN none SDLK_DOWN +BX_KEY_END none SDLK_END +BX_KEY_ENTER return SDLK_RETURN +BX_KEY_EQUALS '=' SDLK_EQUALS +BX_KEY_EQUALS+BX_KEY_SHIFT_L '+' SDLK_PLUS +BX_KEY_ESC none SDLK_ESCAPE +#BX_KEY_GRAVE+BX_KEY_SHIFT_L '~' SDLK_asciitilde +BX_KEY_GRAVE '`' SDLK_BACKQUOTE +BX_KEY_HOME none SDLK_HOME +BX_KEY_INSERT none SDLK_INSERT +BX_KEY_KP_5 none SDLK_KP5 +#BX_KEY_KP_5 none SDLK_KP_BEGIN +BX_KEY_KP_ADD none SDLK_KP_PLUS +BX_KEY_KP_DELETE none SDLK_KP_PERIOD +#BX_KEY_KP_DELETE none SDLK_KP_DELETE +BX_KEY_KP_DIVIDE none SDLK_KP_DIVIDE +BX_KEY_KP_DOWN none SDLK_KP2 +#BX_KEY_KP_DOWN none SDLK_KP_DOWN +BX_KEY_KP_END none SDLK_KP1 +#BX_KEY_KP_END none SDLK_KP_END +BX_KEY_KP_ENTER none SDLK_KP_ENTER +BX_KEY_KP_HOME none SDLK_KP7 +#BX_KEY_KP_HOME none SDLK_KP_HOME +BX_KEY_KP_INSERT none SDLK_KP0 +#BX_KEY_KP_INSERT none SDLK_KP_INSERT +BX_KEY_KP_LEFT none SDLK_KP4 +#BX_KEY_KP_LEFT none SDLK_KP_LEFT +BX_KEY_KP_MULTIPLY none SDLK_KP_MULTIPLY +BX_KEY_KP_PAGE_DOWN none SDLK_KP3 +#BX_KEY_KP_PAGE_DOWN none SDLK_KP_PAGE_DOWN +BX_KEY_KP_PAGE_UP none SDLK_KP9 +#BX_KEY_KP_PAGE_UP none SDLK_KP_PAGE_UP +BX_KEY_KP_RIGHT none SDLK_KP6 +#BX_KEY_KP_RIGHT none SDLK_KP_Right +BX_KEY_KP_SUBTRACT none SDLK_KP_MINUS +BX_KEY_KP_UP none SDLK_KP8 +#BX_KEY_KP_UP none SDLK_KP_Up +BX_KEY_LEFT none SDLK_LEFT +#BX_KEY_LEFT_BRACKET+BX_KEY_SHIFT_L '{' SDLK_BRACELEFT +BX_KEY_LEFT_BRACKET '[' SDLK_LEFTBRACKET +BX_KEY_MENU none SDLK_MENU +BX_KEY_MINUS '-' SDLK_MINUS +BX_KEY_MINUS+BX_KEY_SHIFT_L '_' SDLK_UNDERSCORE +BX_KEY_NUM_LOCK none SDLK_NUMLOCK +BX_KEY_PAGE_DOWN none SDLK_PAGEDOWN +BX_KEY_PAGE_UP none SDLK_PAGEUP +BX_KEY_PAUSE none SDLK_BREAK +BX_KEY_PAUSE none SDLK_PAUSE +BX_KEY_PERIOD+BX_KEY_SHIFT_L '>' SDLK_GREATER +BX_KEY_PERIOD '.' SDLK_PERIOD +BX_KEY_PRINT none SDLK_PRINT +BX_KEY_PRINT none SDLK_SYSREQ +BX_KEY_RIGHT none SDLK_RIGHT +#BX_KEY_RIGHT_BRACKET+BX_KEY_SHIFT_L '}' SDLK_BRACERIGHT +BX_KEY_RIGHT_BRACKET ']' SDLK_RIGHTBRACKET +BX_KEY_SCRL_LOCK none SDLK_SCROLLOCK +BX_KEY_SEMICOLON+BX_KEY_SHIFT_L ':' SDLK_COLON +BX_KEY_SEMICOLON ';' SDLK_SEMICOLON +BX_KEY_SHIFT_L none SDLK_LSHIFT +BX_KEY_SHIFT_R none SDLK_RSHIFT +BX_KEY_SINGLE_QUOTE apostrophe SDLK_QUOTE +BX_KEY_SINGLE_QUOTE+BX_KEY_SHIFT_L '"' SDLK_QUOTEDBL +BX_KEY_SLASH+BX_KEY_SHIFT_L '?' SDLK_QUESTION +BX_KEY_SLASH '/' SDLK_SLASH +BX_KEY_SPACE space SDLK_SPACE +#BX_KEY_TAB none SDLK_ISO_LEFT_TAB +BX_KEY_TAB tab SDLK_TAB +BX_KEY_UP none SDLK_UP +BX_KEY_WIN_L none SDLK_LSUPER +BX_KEY_WIN_R none SDLK_LSUPER diff --git a/bochs/gui/sdl.cc b/bochs/gui/sdl.cc index 89654c21d..fefe5524e 100644 --- a/bochs/gui/sdl.cc +++ b/bochs/gui/sdl.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: sdl.cc,v 1.24 2002-10-06 17:17:14 bdenney Exp $ +// $Id: sdl.cc,v 1.25 2002-10-08 06:14:52 bdenney Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -48,6 +48,7 @@ void we_are_here(void) static unsigned prev_cursor_x=0; static unsigned prev_cursor_y=0; +static Bit32u convertStringToSDLKey (const char *string); #define MAX_SDL_BITMAPS 32 struct bitmaps { @@ -182,7 +183,6 @@ void switch_to_fullscreen(void) sdl_grab = 1; } - void bx_gui_c::specific_init( bx_gui_c *th, int argc, @@ -235,6 +235,11 @@ void bx_gui_c::specific_init( #endif "Bochs" ); SDL_WarpMouse(half_res_x, half_res_y); + + // load keymap for sdl + if(bx_options.keyboard.OuseMapping->get()) { + bx_keymap.loadKeymap(convertStringToSDLKey); + } } void bx_gui_c::text_update( @@ -669,8 +674,20 @@ void bx_gui_c::handle_events(void) // convert sym->bochs code if( sdl_event.key.keysym.sym > SDLK_LAST ) break; - key_event = sdl_sym_to_bx_key (sdl_event.key.keysym.sym); - BX_DEBUG (("keypress scancode=%d, sym=%d, bx_key = %d", sdl_event.key.keysym.scancode, sdl_event.key.keysym.sym, key_event)); + if (!bx_options.keyboard.OuseMapping->get()) { + key_event = sdl_sym_to_bx_key (sdl_event.key.keysym.sym); + BX_DEBUG (("keypress scancode=%d, sym=%d, bx_key = %d", sdl_event.key.keysym.scancode, sdl_event.key.keysym.sym, key_event)); + } else { + /* use mapping */ + BXKeyEntry *entry = bx_keymap.findHostKey (sdl_event.key.keysym.sym); + if (!entry) { + BX_ERROR(( "host key %d (0x%x) not mapped!", + (unsigned) sdl_event.key.keysym.sym, + (unsigned) sdl_event.key.keysym.sym)); + break; + } + key_event = entry->baseKey; + } if( key_event == BX_KEY_UNHANDLED ) break; bx_devices.keyboard->gen_scancode( key_event ); break; @@ -1072,3 +1089,34 @@ void bx_gui_c::exit(void) } } +/// key mapping for SDL +typedef struct keyTableEntry { + const char *name; + Bit32u value; +}; + +#define DEF_SDL_KEY(key) \ + { #key, key }, + +keyTableEntry keytable[] = { + // this include provides all the entries. +#include "sdlkeys.h" + // one final entry to mark the end + { NULL, 0 } +}; + +// function to convert key names into SDLKey values. +// This first try will be horribly inefficient, but it only has +// to be done while loading a keymap. Once the simulation starts, +// this function won't be called. +static Bit32u convertStringToSDLKey (const char *string) +{ + keyTableEntry *ptr; + for (ptr = &keytable[0]; ptr->name != NULL; ptr++) { + //BX_DEBUG (("comparing string '%s' to SDL key '%s'", string, ptr->name)); + if (!strcmp (string, ptr->name)) + return ptr->value; + } + return BX_KEYMAP_UNKNOWN; +} + diff --git a/bochs/gui/sdlkeys.h b/bochs/gui/sdlkeys.h new file mode 100644 index 000000000..366827d8a --- /dev/null +++ b/bochs/gui/sdlkeys.h @@ -0,0 +1,257 @@ +///////////////////////////////////////////////////////////////////////// +// $Id: sdlkeys.h,v 1.1 2002-10-08 06:14:52 bdenney Exp $ +///////////////////////////////////////////////////////////////////////// +// +// This file is simply a list of SDL key symbols taken from . +// The order in this file is not important. In sdl.cc, DEF_SDL_KEY() is +// defined as a macro and then it includes this file to fill in all the data in +// its key mapping table. +// +// The symbols, such as SDLK_RETURN, are used for two purposes. They +// are converted into a string (by the # operator in processor), which is +// compared to the host key name in the keymap file. Also, the value of +// the symbol is inserted into the key mapping table. Then the value is +// compared with the keysym field of each key up/down event as it arrives. +// +// If you get undefined symbol errors in this file, it must mean that +// your SDL library version doesn't define those same SDLK_* symbols in +// . You can't fix it with #ifdef SDLK_SYM because +// they are enums, so you'll just have to comment out the offending line. +// The list was generated using symbols from SDL 1.2.3. + +DEF_SDL_KEY( SDLK_UNKNOWN ) +DEF_SDL_KEY( SDLK_FIRST ) +DEF_SDL_KEY( SDLK_BACKSPACE ) +DEF_SDL_KEY( SDLK_TAB ) +DEF_SDL_KEY( SDLK_CLEAR ) +DEF_SDL_KEY( SDLK_RETURN ) +DEF_SDL_KEY( SDLK_PAUSE ) +DEF_SDL_KEY( SDLK_ESCAPE ) +DEF_SDL_KEY( SDLK_SPACE ) +DEF_SDL_KEY( SDLK_EXCLAIM ) +DEF_SDL_KEY( SDLK_QUOTEDBL ) +DEF_SDL_KEY( SDLK_HASH ) +DEF_SDL_KEY( SDLK_DOLLAR ) +DEF_SDL_KEY( SDLK_AMPERSAND ) +DEF_SDL_KEY( SDLK_QUOTE ) +DEF_SDL_KEY( SDLK_LEFTPAREN ) +DEF_SDL_KEY( SDLK_RIGHTPAREN ) +DEF_SDL_KEY( SDLK_ASTERISK ) +DEF_SDL_KEY( SDLK_PLUS ) +DEF_SDL_KEY( SDLK_COMMA ) +DEF_SDL_KEY( SDLK_MINUS ) +DEF_SDL_KEY( SDLK_PERIOD ) +DEF_SDL_KEY( SDLK_SLASH ) +DEF_SDL_KEY( SDLK_0 ) +DEF_SDL_KEY( SDLK_1 ) +DEF_SDL_KEY( SDLK_2 ) +DEF_SDL_KEY( SDLK_3 ) +DEF_SDL_KEY( SDLK_4 ) +DEF_SDL_KEY( SDLK_5 ) +DEF_SDL_KEY( SDLK_6 ) +DEF_SDL_KEY( SDLK_7 ) +DEF_SDL_KEY( SDLK_8 ) +DEF_SDL_KEY( SDLK_9 ) +DEF_SDL_KEY( SDLK_COLON ) +DEF_SDL_KEY( SDLK_SEMICOLON ) +DEF_SDL_KEY( SDLK_LESS ) +DEF_SDL_KEY( SDLK_EQUALS ) +DEF_SDL_KEY( SDLK_GREATER ) +DEF_SDL_KEY( SDLK_QUESTION ) +DEF_SDL_KEY( SDLK_AT ) +DEF_SDL_KEY( /* ) +DEF_SDL_KEY( Skip uppercase letters ) +DEF_SDL_KEY( */ ) +DEF_SDL_KEY( SDLK_LEFTBRACKET ) +DEF_SDL_KEY( SDLK_BACKSLASH ) +DEF_SDL_KEY( SDLK_RIGHTBRACKET ) +DEF_SDL_KEY( SDLK_CARET ) +DEF_SDL_KEY( SDLK_UNDERSCORE ) +DEF_SDL_KEY( SDLK_BACKQUOTE ) +DEF_SDL_KEY( SDLK_a ) +DEF_SDL_KEY( SDLK_b ) +DEF_SDL_KEY( SDLK_c ) +DEF_SDL_KEY( SDLK_d ) +DEF_SDL_KEY( SDLK_e ) +DEF_SDL_KEY( SDLK_f ) +DEF_SDL_KEY( SDLK_g ) +DEF_SDL_KEY( SDLK_h ) +DEF_SDL_KEY( SDLK_i ) +DEF_SDL_KEY( SDLK_j ) +DEF_SDL_KEY( SDLK_k ) +DEF_SDL_KEY( SDLK_l ) +DEF_SDL_KEY( SDLK_m ) +DEF_SDL_KEY( SDLK_n ) +DEF_SDL_KEY( SDLK_o ) +DEF_SDL_KEY( SDLK_p ) +DEF_SDL_KEY( SDLK_q ) +DEF_SDL_KEY( SDLK_r ) +DEF_SDL_KEY( SDLK_s ) +DEF_SDL_KEY( SDLK_t ) +DEF_SDL_KEY( SDLK_u ) +DEF_SDL_KEY( SDLK_v ) +DEF_SDL_KEY( SDLK_w ) +DEF_SDL_KEY( SDLK_x ) +DEF_SDL_KEY( SDLK_y ) +DEF_SDL_KEY( SDLK_z ) +DEF_SDL_KEY( SDLK_DELETE ) +DEF_SDL_KEY( SDLK_WORLD_0 ) +DEF_SDL_KEY( SDLK_WORLD_1 ) +DEF_SDL_KEY( SDLK_WORLD_2 ) +DEF_SDL_KEY( SDLK_WORLD_3 ) +DEF_SDL_KEY( SDLK_WORLD_4 ) +DEF_SDL_KEY( SDLK_WORLD_5 ) +DEF_SDL_KEY( SDLK_WORLD_6 ) +DEF_SDL_KEY( SDLK_WORLD_7 ) +DEF_SDL_KEY( SDLK_WORLD_8 ) +DEF_SDL_KEY( SDLK_WORLD_9 ) +DEF_SDL_KEY( SDLK_WORLD_10 ) +DEF_SDL_KEY( SDLK_WORLD_11 ) +DEF_SDL_KEY( SDLK_WORLD_12 ) +DEF_SDL_KEY( SDLK_WORLD_13 ) +DEF_SDL_KEY( SDLK_WORLD_14 ) +DEF_SDL_KEY( SDLK_WORLD_15 ) +DEF_SDL_KEY( SDLK_WORLD_16 ) +DEF_SDL_KEY( SDLK_WORLD_17 ) +DEF_SDL_KEY( SDLK_WORLD_18 ) +DEF_SDL_KEY( SDLK_WORLD_19 ) +DEF_SDL_KEY( SDLK_WORLD_20 ) +DEF_SDL_KEY( SDLK_WORLD_21 ) +DEF_SDL_KEY( SDLK_WORLD_22 ) +DEF_SDL_KEY( SDLK_WORLD_23 ) +DEF_SDL_KEY( SDLK_WORLD_24 ) +DEF_SDL_KEY( SDLK_WORLD_25 ) +DEF_SDL_KEY( SDLK_WORLD_26 ) +DEF_SDL_KEY( SDLK_WORLD_27 ) +DEF_SDL_KEY( SDLK_WORLD_28 ) +DEF_SDL_KEY( SDLK_WORLD_29 ) +DEF_SDL_KEY( SDLK_WORLD_30 ) +DEF_SDL_KEY( SDLK_WORLD_31 ) +DEF_SDL_KEY( SDLK_WORLD_32 ) +DEF_SDL_KEY( SDLK_WORLD_33 ) +DEF_SDL_KEY( SDLK_WORLD_34 ) +DEF_SDL_KEY( SDLK_WORLD_35 ) +DEF_SDL_KEY( SDLK_WORLD_36 ) +DEF_SDL_KEY( SDLK_WORLD_37 ) +DEF_SDL_KEY( SDLK_WORLD_38 ) +DEF_SDL_KEY( SDLK_WORLD_39 ) +DEF_SDL_KEY( SDLK_WORLD_40 ) +DEF_SDL_KEY( SDLK_WORLD_41 ) +DEF_SDL_KEY( SDLK_WORLD_42 ) +DEF_SDL_KEY( SDLK_WORLD_43 ) +DEF_SDL_KEY( SDLK_WORLD_44 ) +DEF_SDL_KEY( SDLK_WORLD_45 ) +DEF_SDL_KEY( SDLK_WORLD_46 ) +DEF_SDL_KEY( SDLK_WORLD_47 ) +DEF_SDL_KEY( SDLK_WORLD_48 ) +DEF_SDL_KEY( SDLK_WORLD_49 ) +DEF_SDL_KEY( SDLK_WORLD_50 ) +DEF_SDL_KEY( SDLK_WORLD_51 ) +DEF_SDL_KEY( SDLK_WORLD_52 ) +DEF_SDL_KEY( SDLK_WORLD_53 ) +DEF_SDL_KEY( SDLK_WORLD_54 ) +DEF_SDL_KEY( SDLK_WORLD_55 ) +DEF_SDL_KEY( SDLK_WORLD_56 ) +DEF_SDL_KEY( SDLK_WORLD_57 ) +DEF_SDL_KEY( SDLK_WORLD_58 ) +DEF_SDL_KEY( SDLK_WORLD_59 ) +DEF_SDL_KEY( SDLK_WORLD_60 ) +DEF_SDL_KEY( SDLK_WORLD_61 ) +DEF_SDL_KEY( SDLK_WORLD_62 ) +DEF_SDL_KEY( SDLK_WORLD_63 ) +DEF_SDL_KEY( SDLK_WORLD_64 ) +DEF_SDL_KEY( SDLK_WORLD_65 ) +DEF_SDL_KEY( SDLK_WORLD_66 ) +DEF_SDL_KEY( SDLK_WORLD_67 ) +DEF_SDL_KEY( SDLK_WORLD_68 ) +DEF_SDL_KEY( SDLK_WORLD_69 ) +DEF_SDL_KEY( SDLK_WORLD_70 ) +DEF_SDL_KEY( SDLK_WORLD_71 ) +DEF_SDL_KEY( SDLK_WORLD_72 ) +DEF_SDL_KEY( SDLK_WORLD_73 ) +DEF_SDL_KEY( SDLK_WORLD_74 ) +DEF_SDL_KEY( SDLK_WORLD_75 ) +DEF_SDL_KEY( SDLK_WORLD_76 ) +DEF_SDL_KEY( SDLK_WORLD_77 ) +DEF_SDL_KEY( SDLK_WORLD_78 ) +DEF_SDL_KEY( SDLK_WORLD_79 ) +DEF_SDL_KEY( SDLK_WORLD_80 ) +DEF_SDL_KEY( SDLK_WORLD_81 ) +DEF_SDL_KEY( SDLK_WORLD_82 ) +DEF_SDL_KEY( SDLK_WORLD_83 ) +DEF_SDL_KEY( SDLK_WORLD_84 ) +DEF_SDL_KEY( SDLK_WORLD_85 ) +DEF_SDL_KEY( SDLK_WORLD_86 ) +DEF_SDL_KEY( SDLK_WORLD_87 ) +DEF_SDL_KEY( SDLK_WORLD_88 ) +DEF_SDL_KEY( SDLK_WORLD_89 ) +DEF_SDL_KEY( SDLK_WORLD_90 ) +DEF_SDL_KEY( SDLK_WORLD_91 ) +DEF_SDL_KEY( SDLK_WORLD_92 ) +DEF_SDL_KEY( SDLK_WORLD_93 ) +DEF_SDL_KEY( SDLK_WORLD_94 ) +DEF_SDL_KEY( SDLK_WORLD_95 ) +DEF_SDL_KEY( SDLK_KP0 ) +DEF_SDL_KEY( SDLK_KP1 ) +DEF_SDL_KEY( SDLK_KP2 ) +DEF_SDL_KEY( SDLK_KP3 ) +DEF_SDL_KEY( SDLK_KP4 ) +DEF_SDL_KEY( SDLK_KP5 ) +DEF_SDL_KEY( SDLK_KP6 ) +DEF_SDL_KEY( SDLK_KP7 ) +DEF_SDL_KEY( SDLK_KP8 ) +DEF_SDL_KEY( SDLK_KP9 ) +DEF_SDL_KEY( SDLK_KP_PERIOD ) +DEF_SDL_KEY( SDLK_KP_DIVIDE ) +DEF_SDL_KEY( SDLK_KP_MULTIPLY ) +DEF_SDL_KEY( SDLK_KP_MINUS ) +DEF_SDL_KEY( SDLK_KP_PLUS ) +DEF_SDL_KEY( SDLK_KP_ENTER ) +DEF_SDL_KEY( SDLK_KP_EQUALS ) +DEF_SDL_KEY( SDLK_UP ) +DEF_SDL_KEY( SDLK_DOWN ) +DEF_SDL_KEY( SDLK_RIGHT ) +DEF_SDL_KEY( SDLK_LEFT ) +DEF_SDL_KEY( SDLK_INSERT ) +DEF_SDL_KEY( SDLK_HOME ) +DEF_SDL_KEY( SDLK_END ) +DEF_SDL_KEY( SDLK_PAGEUP ) +DEF_SDL_KEY( SDLK_PAGEDOWN ) +DEF_SDL_KEY( SDLK_F1 ) +DEF_SDL_KEY( SDLK_F2 ) +DEF_SDL_KEY( SDLK_F3 ) +DEF_SDL_KEY( SDLK_F4 ) +DEF_SDL_KEY( SDLK_F5 ) +DEF_SDL_KEY( SDLK_F6 ) +DEF_SDL_KEY( SDLK_F7 ) +DEF_SDL_KEY( SDLK_F8 ) +DEF_SDL_KEY( SDLK_F9 ) +DEF_SDL_KEY( SDLK_F10 ) +DEF_SDL_KEY( SDLK_F11 ) +DEF_SDL_KEY( SDLK_F12 ) +DEF_SDL_KEY( SDLK_F13 ) +DEF_SDL_KEY( SDLK_F14 ) +DEF_SDL_KEY( SDLK_F15 ) +DEF_SDL_KEY( SDLK_NUMLOCK ) +DEF_SDL_KEY( SDLK_CAPSLOCK ) +DEF_SDL_KEY( SDLK_SCROLLOCK ) +DEF_SDL_KEY( SDLK_RSHIFT ) +DEF_SDL_KEY( SDLK_LSHIFT ) +DEF_SDL_KEY( SDLK_RCTRL ) +DEF_SDL_KEY( SDLK_LCTRL ) +DEF_SDL_KEY( SDLK_RALT ) +DEF_SDL_KEY( SDLK_LALT ) +DEF_SDL_KEY( SDLK_RMETA ) +DEF_SDL_KEY( SDLK_LMETA ) +DEF_SDL_KEY( SDLK_LSUPER ) +DEF_SDL_KEY( SDLK_RSUPER ) +DEF_SDL_KEY( SDLK_MODE ) +DEF_SDL_KEY( SDLK_COMPOSE ) +DEF_SDL_KEY( SDLK_HELP ) +DEF_SDL_KEY( SDLK_PRINT ) +DEF_SDL_KEY( SDLK_SYSREQ ) +DEF_SDL_KEY( SDLK_BREAK ) +DEF_SDL_KEY( SDLK_MENU ) +DEF_SDL_KEY( SDLK_POWER ) +DEF_SDL_KEY( SDLK_EURO ) +DEF_SDL_KEY( SDLK_UNDO ) diff --git a/bochs/gui/x.cc b/bochs/gui/x.cc index 018fb46cc..368aa5e0a 100644 --- a/bochs/gui/x.cc +++ b/bochs/gui/x.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: x.cc,v 1.49 2002-10-02 02:52:24 bdenney Exp $ +// $Id: x.cc,v 1.50 2002-10-08 06:14:52 bdenney Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -1000,7 +1000,7 @@ xkeypress(KeySym keysym, int press_release) } else { /* use mapping */ - BXKeyEntry *entry = bx_keymap.getKeyXwin (keysym); + BXKeyEntry *entry = bx_keymap.findHostKey (keysym); if (!entry) { BX_ERROR(( "xkeypress(): keysym %x unhandled!", (unsigned) keysym )); return; @@ -1456,7 +1456,9 @@ static void enable_cursor () */ static Bit32u convertStringToXKeysym (const char *string) { - KeySym keysym=XStringToKeysym(string); + if (strncmp ("XK_", string, 3) != 0) + return BX_KEYMAP_UNKNOWN; + KeySym keysym=XStringToKeysym(string+3); // failure, return unknown if(keysym==NoSymbol) return BX_KEYMAP_UNKNOWN; diff --git a/bochs/iodev/keyboard.cc b/bochs/iodev/keyboard.cc index d5fb62a12..d53a9aa5e 100644 --- a/bochs/iodev/keyboard.cc +++ b/bochs/iodev/keyboard.cc @@ -1,5 +1,5 @@ ///////////////////////////////////////////////////////////////////////// -// $Id: keyboard.cc,v 1.67 2002-09-30 22:23:57 bdenney Exp $ +// $Id: keyboard.cc,v 1.68 2002-10-08 06:14:53 bdenney Exp $ ///////////////////////////////////////////////////////////////////////// // // Copyright (C) 2002 MandrakeSoft S.A. @@ -70,7 +70,7 @@ bx_keyb_c::bx_keyb_c(void) memset( &s, 0, sizeof(s) ); BX_KEY_THIS put("KBD"); BX_KEY_THIS settype(KBDLOG); - BX_DEBUG(("Init $Id: keyboard.cc,v 1.67 2002-09-30 22:23:57 bdenney Exp $")); + BX_DEBUG(("Init $Id: keyboard.cc,v 1.68 2002-10-08 06:14:53 bdenney Exp $")); } bx_keyb_c::~bx_keyb_c(void) @@ -110,7 +110,7 @@ bx_keyb_c::resetinternals(Boolean powerup) void bx_keyb_c::init(bx_devices_c *d, bx_cmos_c *cmos) { - BX_DEBUG(("Init $Id: keyboard.cc,v 1.67 2002-09-30 22:23:57 bdenney Exp $")); + BX_DEBUG(("Init $Id: keyboard.cc,v 1.68 2002-10-08 06:14:53 bdenney Exp $")); Bit32u i; BX_KEY_THIS devices = d; @@ -672,7 +672,7 @@ bx_keyb_c::service_paste_buf () // there room in the buffer for a keypress and a key release. // send one keypress and a key release. Bit8u byte = BX_KEY_THIS pastebuf[BX_KEY_THIS pastebuf_ptr]; - BXKeyEntry *entry = bx_keymap.getKeyASCII (byte); + BXKeyEntry *entry = bx_keymap.findAsciiChar (byte); if (!entry) { BX_ERROR (("paste character 0x%02x ignored", byte)); } else {