mirrors/Bochs
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

- add key mapping for SDL gui, to demonstrate/verify that key mapping is not

Browse Source 
specific to X windows.  I changed a few names of variables and methods to
  sound less X windows specific, for example in the BXKeyEntry struct
  the "xwinKey" field is now called "hostKey".
- remove the hacks in bx_keymap_c::loadKeymap that checked that every
  keysym started with "XK_".  Now I can still make that check, but it
  is done in x.cc's convertStringToXKeysym() instead.
- in sdl.cc, load the keymap in specific_init function.  I had to
  create a conversion function from SDL key names to SDLkey values.
  I created a table of key names and associated values, and I just
  do a strcmp on each name.  It's not a fast algorithm obviously but this
  conversion only has to be done for maybe 200 keys at startup time.
- added a key map file for SDL called sdl-pc-us.map.  Since this has
  basically all the SDLK_* symbols defined, it is a good starting point
  if you need to make any other keymaps.
- modified: gui/keymap.cc gui/keymap.h gui/sdl.cc gui/x.cc iodev/keyboard.cc
- added: gui/sdlkeys.h gui/keymaps/sdl-pc-us.map
This commit is contained in:
Bryce Denney 2002-10-08 06:14:53 +00:00
parent b8d7f5c88e
commit c74b8c55fc
7 changed files with 558 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
bochs/gui/keymap.cc
View File

@ -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; i<keymapCount; i++) {
if (keymapTable[i].xwinKey == key) {
BX_DEBUG (("key 0x%02x matches xwinKey for entry #%d", key, i));
if (keymapTable[i].hostKey == key) {
BX_DEBUG (("key 0x%02x matches hostKey for entry #%d", key, i));
return &keymapTable[i];
}
}
@ -307,10 +305,10 @@ bx_keymap_c::getKeyXwin(Bit32u key)
}
BXKeyEntry *
bx_keymap_c::getKeyASCII(Bit8u ch)
bx_keymap_c::findAsciiChar(Bit8u ch)
{
Bit16u i;
BX_DEBUG (("getKeyASCII (0x%02x)", ch));
BX_DEBUG (("findAsciiChar (0x%02x)", ch));
// We look through the keymap table to find the searched key
for (i=0; i<keymapCount; i++) {

17
bochs/gui/keymap.h
View File

@ -1,5 +1,5 @@
/////////////////////////////////////////////////////////////////////////
// $Id: keymap.h,v 1.5 2002-04-01 22:43:01 cbothamy Exp $
// $Id: keymap.h,v 1.6 2002-10-08 06:14:52 bdenney Exp $
/////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2002 MandrakeSoft S.A.
@ -36,11 +36,12 @@
// - convertStringToBXKey
// convert a null-terminate string to a BX_KEY code
//
// - getKeyXwin(Bit32u key)
// - getKeyASCII(Bit8u ch)
// - findHostKey(Bit32u key)
// - findAsciiChar(Bit8u ch)
// Each of these methods returns a pointer to a BXKeyEntry structure
// corresponding to a key. getKeyXwin() uses an X windows keysym to find the
// structure, and getKeyASCII() uses an ASCII code to find the structure.
// corresponding to a key. findHostKey() finds an entry whose hostKey
// value matches the target value, and findAsciiChar() finds an entry
// whose ASCII code matches the search value.
// In case of unknown symbol
#define BX_KEYMAP_UNKNOWN 0xFFFFFFFF
@ -50,7 +51,7 @@ typedef struct {
Bit32u baseKey; // base key
Bit32u modKey; // modifier key that must be held down
Bit32s ascii; // ascii equivalent, if any
Bit32u xwinKey; // X windows value
Bit32u hostKey; // value that the host's OS or library recognizes
} BXKeyEntry;
class bx_keymap_c : public logfunctions {
@ -62,8 +63,8 @@ public:
void loadKeymap(Bit32u(*)(const char*),const char *filename);
Boolean isKeymapLoaded ();
BXKeyEntry *getKeyXwin(Bit32u xwin_key);
BXKeyEntry *getKeyASCII(Bit8u ascii);
BXKeyEntry *findHostKey(Bit32u hostkeynum);
BXKeyEntry *findAsciiChar(Bit8u ascii);
private:
Bit32u convertStringToBXKey(const char *);

211
bochs/gui/keymaps/sdl-pc-us.map Normal file
View File

@ -0,0 +1,211 @@
# Bochs Keymap file
# $Id: sdl-pc-us.map,v 1.1 2002-10-08 06:14:53 bdenney Exp $
# Target: PC(x86) keyboard, US keymap, SDL gui
# Author: Bryce Denney
#
# The keymap file describes the layout of a keyboard, and how it translates
# into Bochs key codes.
#
# Format:
# BX_Keysym ASCII_equivalent Host_key_name
#
# Or, for keys that require modifiers:
# BX_Keysym+BX_Modifier ASCII_equivalent Host_key_name
#
# BX_Keysym and BX_Modifier must be present in the bx_key_symbol[] list in
# gui/keymap.cc. The BX_Modifier is usually a shift key press, but it
# could be any key. Presently a maximum of one modifier is supported, but this
# could be changed in keymap.h (structure def has only one slot for modifier),
# keymap.cc (parsing code), and iodev/keyboard.cc (simulate keypresses for >1
# 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

56
bochs/gui/sdl.cc
View File

@ -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;
}

257
bochs/gui/sdlkeys.h Normal file
View File

@ -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 <SDL/SDL_keysym.h>.
// 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
// <SDL/SDL_keysym.h>. 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 )

8
bochs/gui/x.cc
View File

@ -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;

8
bochs/iodev/keyboard.cc
View File

@ -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 {