From: Holger Schemel <info@artsoft.org>
Date: Fri, 21 Jul 2000 21:22:58 +0000 (+0200)
Subject: rnd-20000721-1-src
X-Git-Tag: 2.0.0^2~54
X-Git-Url: https://git.artsoft.org/?p=rocksndiamonds.git;a=commitdiff_plain;h=b9c7e4a42762c8526702726f1404d3e75dbc29f5

rnd-20000721-1-src
---

diff --git a/src/buttons.c b/src/buttons.c
index 9f9a78df..c6996e71 100644
--- a/src/buttons.c
+++ b/src/buttons.c
@@ -1280,7 +1280,7 @@ void HandleGadgets(int mx, int my, int button)
   }
 }
 
-void HandleGadgetsKeyInput(KeySym key)
+void HandleGadgetsKeyInput(Key key)
 {
   struct GadgetInfo *gi = last_gi;
   char text[MAX_GADGET_TEXTSIZE];
@@ -1294,7 +1294,7 @@ void HandleGadgetsKeyInput(KeySym key)
 
   text_length = strlen(gi->text.value);
   cursor_pos = gi->text.cursor_position;
-  letter = getCharFromKeySym(key);
+  letter = getCharFromKey(key);
   legal_letter = (gi->type == GD_TYPE_TEXTINPUT_NUMERIC ?
 		  letter >= '0' && letter <= '9' :
 		  letter != 0);
@@ -1307,30 +1307,30 @@ void HandleGadgetsKeyInput(KeySym key)
     gi->text.cursor_position++;
     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
   }
-  else if (key == XK_Left && cursor_pos > 0)
+  else if (key == KEY_Left && cursor_pos > 0)
   {
     gi->text.cursor_position--;
     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
   }
-  else if (key == XK_Right && cursor_pos < text_length)
+  else if (key == KEY_Right && cursor_pos < text_length)
   {
     gi->text.cursor_position++;
     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
   }
-  else if (key == XK_BackSpace && cursor_pos > 0)
+  else if (key == KEY_BackSpace && cursor_pos > 0)
   {
     strcpy(text, gi->text.value);
     strcpy(&gi->text.value[cursor_pos - 1], &text[cursor_pos]);
     gi->text.cursor_position--;
     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
   }
-  else if (key == XK_Delete && cursor_pos < text_length)
+  else if (key == KEY_Delete && cursor_pos < text_length)
   {
     strcpy(text, gi->text.value);
     strcpy(&gi->text.value[cursor_pos], &text[cursor_pos + 1]);
     DrawGadget(gi, DG_PRESSED, DG_DIRECT);
   }
-  else if (key == XK_Return)
+  else if (key == KEY_Return)
   {
     CheckRangeOfNumericInputGadget(gi);
     DrawGadget(gi, DG_UNPRESSED, DG_DIRECT);
diff --git a/src/buttons.h b/src/buttons.h
index 85b38b53..368fa9ee 100644
--- a/src/buttons.h
+++ b/src/buttons.h
@@ -260,6 +260,6 @@ boolean anyTextGadgetActive();
 void ClickOnGadget(struct GadgetInfo *, int);
 
 void HandleGadgets(int, int, int);
-void HandleGadgetsKeyInput(KeySym);
+void HandleGadgetsKeyInput(Key);
 
 #endif
diff --git a/src/editor.c b/src/editor.c
index 618c272f..bb729811 100644
--- a/src/editor.c
+++ b/src/editor.c
@@ -3959,9 +3959,9 @@ static void HandleControlButtons(struct GadgetInfo *gi)
   }
 }
 
-void HandleLevelEditorKeyInput(KeySym key)
+void HandleLevelEditorKeyInput(Key key)
 {
-  char letter = getCharFromKeySym(key);
+  char letter = getCharFromKey(key);
   int button = MB_LEFT;
 
   if (drawing_function == GADGET_ID_TEXT &&
@@ -3969,9 +3969,9 @@ void HandleLevelEditorKeyInput(KeySym key)
   {
     if (letter)
       DrawLevelText(0, 0, letter, TEXT_WRITECHAR);
-    else if (key == XK_Delete || key == XK_BackSpace)
+    else if (key == KEY_Delete || key == KEY_BackSpace)
       DrawLevelText(0, 0, 0, TEXT_BACKSPACE);
-    else if (key == XK_Return)
+    else if (key == KEY_Return)
       DrawLevelText(0, 0, 0, TEXT_NEWLINE);
   }
   else if (button_status == MB_RELEASED)
@@ -3980,23 +3980,23 @@ void HandleLevelEditorKeyInput(KeySym key)
 
     switch (key)
     {
-      case XK_Left:
+      case KEY_Left:
 	id = GADGET_ID_SCROLL_LEFT;
 	break;
-      case XK_Right:
+      case KEY_Right:
 	id = GADGET_ID_SCROLL_RIGHT;
 	break;
-      case XK_Up:
+      case KEY_Up:
 	id = GADGET_ID_SCROLL_UP;
 	break;
-      case XK_Down:
+      case KEY_Down:
 	id = GADGET_ID_SCROLL_DOWN;
 	break;
-      case XK_Page_Up:
+      case KEY_Page_Up:
 	id = GADGET_ID_SCROLL_LIST_UP;
 	button = 3;
 	break;
-      case XK_Page_Down:
+      case KEY_Page_Down:
 	id = GADGET_ID_SCROLL_LIST_DOWN;
 	button = 3;
 	break;
@@ -4010,7 +4010,7 @@ void HandleLevelEditorKeyInput(KeySym key)
       ClickOnGadget(level_editor_gadget[id], button);
     else if (letter == '.')
       ClickOnGadget(level_editor_gadget[GADGET_ID_SINGLE_ITEMS], button);
-    else if (key == XK_space || key == XK_Return)
+    else if (key == KEY_space || key == KEY_Return)
       ClickOnGadget(level_editor_gadget[GADGET_ID_TEST], button);
     else
       for (i=0; i<ED_NUM_CTRL_BUTTONS; i++)
diff --git a/src/editor.h b/src/editor.h
index c77fef7e..5864d0d4 100644
--- a/src/editor.h
+++ b/src/editor.h
@@ -27,7 +27,7 @@ extern int elements_in_list;
 void CreateLevelEditorGadgets();
 void UnmapLevelEditorGadgets();
 void DrawLevelEd(void);
-void HandleLevelEditorKeyInput(KeySym);
+void HandleLevelEditorKeyInput(Key);
 void HandleEditorGadgetInfoText(void *ptr);
 
 #endif
diff --git a/src/events.c b/src/events.c
index 32e0013b..85ae4d61 100644
--- a/src/events.c
+++ b/src/events.c
@@ -241,24 +241,8 @@ void HandleMotionEvent(MotionEvent *event)
 void HandleKeyEvent(KeyEvent *event)
 {
   int key_status = (event->type==EVENT_KEYPRESS ? KEY_PRESSED : KEY_RELEASED);
-  KeySym key;
-
-  if (game_status == PLAYING)
-  {
-    /* use '0' instead of 'event->state' to get the key without modifiers */
-    key = XLookupKeysym(event, 0);
-  }
-  else
-  {
-    /* get the key with all modifiers */
-    char buffer[10];
-    int buffer_size = 10;
-    XComposeStatus compose;
-    int char_count;
-
-    char_count = XLookupString(event, buffer, buffer_size, &key, &compose);
-    buffer[char_count] = '\0';
-  }
+  boolean with_modifiers = (game_status == PLAYING ? FALSE : TRUE);
+  Key key = GetEventKey(event, with_modifiers);
 
   HandleKey(key, key_status);
 }
@@ -346,7 +330,7 @@ void HandleButton(int mx, int my, int button)
       break;
 
     case TYPENAME:
-      HandleTypeName(0, XK_Return);
+      HandleTypeName(0, KEY_Return);
       break;
 
     case CHOOSELEVEL:
@@ -407,14 +391,14 @@ void HandleButton(int mx, int my, int button)
   }
 }
 
-void HandleKey(KeySym key, int key_status)
+void HandleKey(Key key, int key_status)
 {
   int joy = 0;
   static struct SetupKeyboardInfo custom_key;
   static struct
   {
-    KeySym *keysym_custom;
-    KeySym keysym_default;
+    Key *key_custom;
+    Key key_default;
     byte action;
   } key_info[] =
   {
@@ -441,7 +425,7 @@ void HandleKey(KeySym key, int key_status)
       custom_key = setup.input[pnr].key;
 
       for (i=0; i<6; i++)
-	if (key == *key_info[i].keysym_custom)
+	if (key == *key_info[i].key_custom)
 	  key_action |= key_info[i].action;
 
       if (key_status == KEY_PRESSED)
@@ -455,7 +439,7 @@ void HandleKey(KeySym key, int key_status)
     int i;
 
     for (i=0; i<6; i++)
-      if (key == key_info[i].keysym_default)
+      if (key == key_info[i].key_default)
 	joy |= key_info[i].action;
   }
 
@@ -475,7 +459,7 @@ void HandleKey(KeySym key, int key_status)
   if (key_status == KEY_RELEASED)
     return;
 
-  if ((key == XK_Return || key == XK_space) &&
+  if ((key == KEY_Return || key == KEY_space) &&
       game_status == PLAYING && AllPlayersGone)
   {
     CloseDoor(DOOR_CLOSE_1);
@@ -485,7 +469,7 @@ void HandleKey(KeySym key, int key_status)
   }
 
   /* allow quick escape to the main menu with the Escape key */
-  if (key == XK_Escape && game_status != MAINMENU)
+  if (key == KEY_Escape && game_status != MAINMENU)
   {
     CloseDoor(DOOR_CLOSE_1 | DOOR_OPEN_2 | DOOR_NO_DELAY);
     game_status = MAINMENU;
@@ -518,8 +502,8 @@ void HandleKey(KeySym key, int key_status)
     case SETUPINPUT:
       switch(key)
       {
-	case XK_Return:
-	case XK_space:
+	case KEY_Return:
+	case KEY_space:
 	  if (game_status == MAINMENU)
 	    HandleMainMenu(0,0, 0,0, MB_MENU_CHOICE);
           else if (game_status == CHOOSELEVEL)
@@ -530,12 +514,12 @@ void HandleKey(KeySym key, int key_status)
 	    HandleSetupInputScreen(0,0, 0,0, MB_MENU_CHOICE);
 	  break;
 
-        case XK_Page_Up:
+        case KEY_Page_Up:
           if (game_status == CHOOSELEVEL)
             HandleChooseLevel(0,0, 0,-SCR_FIELDY, MB_MENU_MARK);
 	  break;
 
-        case XK_Page_Down:
+        case KEY_Page_Down:
           if (game_status == CHOOSELEVEL)
             HandleChooseLevel(0,0, 0,SCR_FIELDY, MB_MENU_MARK);
 	  break;
@@ -552,18 +536,18 @@ void HandleKey(KeySym key, int key_status)
     case HALLOFFAME:
       switch(key)
       {
-	case XK_Return:
-	case XK_space:
+	case KEY_Return:
+	case KEY_space:
 	  game_status = MAINMENU;
 	  DrawMainMenu();
 	  BackToFront();
 	  break;
 
-        case XK_Page_Up:
+        case KEY_Page_Up:
 	  HandleHallOfFame(0,0, 0,-SCR_FIELDY, MB_MENU_MARK);
 	  break;
 
-        case XK_Page_Down:
+        case KEY_Page_Down:
 	  HandleHallOfFame(0,0, 0,SCR_FIELDY, MB_MENU_MARK);
 	  break;
 
@@ -582,17 +566,17 @@ void HandleKey(KeySym key, int key_status)
       {
 
 #ifdef DEBUG
-	case XK_0:
-	case XK_1:
-	case XK_2:
-	case XK_3:
-	case XK_4:
-	case XK_5:
-	case XK_6:
-	case XK_7:
-	case XK_8:
-	case XK_9:
-	  if (key == XK_0)
+	case KEY_0:
+	case KEY_1:
+	case KEY_2:
+	case KEY_3:
+	case KEY_4:
+	case KEY_5:
+	case KEY_6:
+	case KEY_7:
+	case KEY_8:
+	case KEY_9:
+	  if (key == KEY_0)
 	  {
 	    if (GameFrameDelay == 500)
 	      GameFrameDelay = GAME_FRAME_DELAY;
@@ -600,14 +584,14 @@ void HandleKey(KeySym key, int key_status)
 	      GameFrameDelay = 500;
 	  }
 	  else
-	    GameFrameDelay = (key - XK_0) * 10;
+	    GameFrameDelay = (key - KEY_0) * 10;
 	  printf("Game speed == %d%% (%d ms delay between two frames)\n",
 		 GAME_FRAME_DELAY * 100 / GameFrameDelay, GameFrameDelay);
 	  break;
 
 
 #if 0
-	case XK_a:
+	case KEY_a:
 	  if (ScrollStepSize == TILEX/8)
 	    ScrollStepSize = TILEX/4;
 	  else
@@ -617,7 +601,7 @@ void HandleKey(KeySym key, int key_status)
 #endif
 
 #if 0
-	case XK_m:
+	case KEY_m:
 	  if (MoveSpeed == 8)
 	  {
 	    MoveSpeed = 4;
@@ -632,30 +616,30 @@ void HandleKey(KeySym key, int key_status)
 	  break;
 #endif
 
-	case XK_f:
+	case KEY_f:
 	  ScrollStepSize = TILEX/8;
 	  printf("ScrollStepSize == %d (1/8)\n", ScrollStepSize);
 	  break;
 
-	case XK_g:
+	case KEY_g:
 	  ScrollStepSize = TILEX/4;
 	  printf("ScrollStepSize == %d (1/4)\n", ScrollStepSize);
 	  break;
 
-	case XK_h:
+	case KEY_h:
 	  ScrollStepSize = TILEX/2;
 	  printf("ScrollStepSize == %d (1/2)\n", ScrollStepSize);
 	  break;
 
-	case XK_l:
+	case KEY_l:
 	  ScrollStepSize = TILEX;
 	  printf("ScrollStepSize == %d (1/1)\n", ScrollStepSize);
 	  break;
 
 #ifndef MSDOS
-	case XK_Q:
+	case KEY_Q:
 #endif
-	case XK_q:
+	case KEY_q:
 	  local_player->dynamite = 1000;
 	  break;
 
@@ -663,7 +647,7 @@ void HandleKey(KeySym key, int key_status)
 
 #if 0
 
-	case XK_z:
+	case KEY_z:
 	  {
 	    int i;
 
diff --git a/src/events.h b/src/events.h
index bf3276e2..931aa7ce 100644
--- a/src/events.h
+++ b/src/events.h
@@ -31,7 +31,7 @@ void HandleClientMessageEvent(ClientMessageEvent *event);
 void HandleNoXEvent(void);
 
 void HandleButton(int, int, int);
-void HandleKey(KeySym, int);
+void HandleKey(Key, int);
 void HandleJoystick();
 
 #endif
diff --git a/src/files.c b/src/files.c
index ce0aff38..d04e0fb2 100644
--- a/src/files.c
+++ b/src/files.c
@@ -1093,7 +1093,7 @@ void SaveScore(int level_nr)
 
 #define TYPE_BOOLEAN			1
 #define TYPE_SWITCH			2
-#define TYPE_KEYSYM			3
+#define TYPE_KEY			3
 #define TYPE_INTEGER			4
 #define TYPE_STRING			5
 
@@ -1139,12 +1139,12 @@ static struct
   { TYPE_INTEGER, &sii.joy.ylower,	".joy.ylower"			},
   { TYPE_INTEGER, &sii.joy.snap,	".joy.snap_field"		},
   { TYPE_INTEGER, &sii.joy.bomb,	".joy.place_bomb"		},
-  { TYPE_KEYSYM,  &sii.key.left,	".key.move_left"		},
-  { TYPE_KEYSYM,  &sii.key.right,	".key.move_right"		},
-  { TYPE_KEYSYM,  &sii.key.up,		".key.move_up"			},
-  { TYPE_KEYSYM,  &sii.key.down,	".key.move_down"		},
-  { TYPE_KEYSYM,  &sii.key.snap,	".key.snap_field"		},
-  { TYPE_KEYSYM,  &sii.key.bomb,	".key.place_bomb"		},
+  { TYPE_KEY,     &sii.key.left,	".key.move_left"		},
+  { TYPE_KEY,     &sii.key.right,	".key.move_right"		},
+  { TYPE_KEY,     &sii.key.up,		".key.move_up"			},
+  { TYPE_KEY,     &sii.key.down,	".key.move_down"		},
+  { TYPE_KEY,     &sii.key.snap,	".key.snap_field"		},
+  { TYPE_KEY,     &sii.key.bomb,	".key.place_bomb"		},
 
   /* level directory info */
   { TYPE_STRING,  &ldi.name,		"name"				},
@@ -1513,12 +1513,12 @@ static void setSetupInfoToDefaults(struct SetupInfo *si)
     si->input[i].joy.ylower  = JOYSTICK_YLOWER;
     si->input[i].joy.snap  = (i == 0 ? JOY_BUTTON_1 : 0);
     si->input[i].joy.bomb  = (i == 0 ? JOY_BUTTON_2 : 0);
-    si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KEY_UNDEFINDED);
-    si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KEY_UNDEFINDED);
-    si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KEY_UNDEFINDED);
-    si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KEY_UNDEFINDED);
-    si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KEY_UNDEFINDED);
-    si->input[i].key.bomb  = (i == 0 ? DEFAULT_KEY_BOMB  : KEY_UNDEFINDED);
+    si->input[i].key.left  = (i == 0 ? DEFAULT_KEY_LEFT  : KEY_UNDEFINED);
+    si->input[i].key.right = (i == 0 ? DEFAULT_KEY_RIGHT : KEY_UNDEFINED);
+    si->input[i].key.up    = (i == 0 ? DEFAULT_KEY_UP    : KEY_UNDEFINED);
+    si->input[i].key.down  = (i == 0 ? DEFAULT_KEY_DOWN  : KEY_UNDEFINED);
+    si->input[i].key.snap  = (i == 0 ? DEFAULT_KEY_SNAP  : KEY_UNDEFINED);
+    si->input[i].key.bomb  = (i == 0 ? DEFAULT_KEY_BOMB  : KEY_UNDEFINED);
   }
 }
 
@@ -1538,8 +1538,8 @@ static void setSetupInfo(int token_nr, char *token_value)
       *(boolean *)setup_value = get_string_boolean_value(token_value);
       break;
 
-    case TYPE_KEYSYM:
-      *(KeySym *)setup_value = getKeySymFromX11KeyName(token_value);
+    case TYPE_KEY:
+      *(Key *)setup_value = getKeyFromX11KeyName(token_value);
       break;
 
     case TYPE_INTEGER:
@@ -1884,12 +1884,12 @@ static char *getSetupLine(char *prefix, int token_nr)
       strcat(entry, (*(boolean *)setup_value ? "on" : "off"));
       break;
 
-    case TYPE_KEYSYM:
+    case TYPE_KEY:
       {
-	KeySym keysym = *(KeySym *)setup_value;
-	char *keyname = getKeyNameFromKeySym(keysym);
+	Key key = *(Key *)setup_value;
+	char *keyname = getKeyNameFromKey(key);
 
-	strcat(entry, getX11KeyNameFromKeySym(keysym));
+	strcat(entry, getX11KeyNameFromKey(key));
 	for (i=strlen(entry); i<50; i++)
 	  strcat(entry, " ");
 
diff --git a/src/main.h b/src/main.h
index adf82efa..f808f754 100644
--- a/src/main.h
+++ b/src/main.h
@@ -278,12 +278,12 @@ struct SetupJoystickInfo
 
 struct SetupKeyboardInfo
 {
-  KeySym left;
-  KeySym right;
-  KeySym up;
-  KeySym down;
-  KeySym snap;
-  KeySym bomb;
+  Key left;
+  Key right;
+  Key up;
+  Key down;
+  Key snap;
+  Key bomb;
 };
 
 struct SetupInputInfo
@@ -1608,15 +1608,14 @@ extern char		*element_info[];
 #define NUM_SOUNDS		62
 
 /* default input keys */
-#define KEY_UNDEFINDED		XK_VoidSymbol
-#define DEFAULT_KEY_LEFT	XK_Left
-#define DEFAULT_KEY_RIGHT	XK_Right
-#define DEFAULT_KEY_UP		XK_Up
-#define DEFAULT_KEY_DOWN	XK_Down
-#define DEFAULT_KEY_SNAP	XK_Shift_L
-#define DEFAULT_KEY_BOMB	XK_Shift_R
-#define DEFAULT_KEY_OKAY	XK_Return
-#define DEFAULT_KEY_CANCEL	XK_Escape
+#define DEFAULT_KEY_LEFT	KEY_Left
+#define DEFAULT_KEY_RIGHT	KEY_Right
+#define DEFAULT_KEY_UP		KEY_Up
+#define DEFAULT_KEY_DOWN	KEY_Down
+#define DEFAULT_KEY_SNAP	KEY_Shift_L
+#define DEFAULT_KEY_BOMB	KEY_Shift_R
+#define DEFAULT_KEY_OKAY	KEY_Return
+#define DEFAULT_KEY_CANCEL	KEY_Escape
 
 /* directions for moving */
 #define MV_NO_MOVING		0
diff --git a/src/misc.c b/src/misc.c
index e1badb59..5e4dc358 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -677,112 +677,112 @@ void putFileChunk(FILE *file, char *chunk_name, int chunk_length,
   putFile32BitInteger(file, chunk_length, byte_order);
 }
 
-#define TRANSLATE_KEYSYM_TO_KEYNAME	0
-#define TRANSLATE_KEYSYM_TO_X11KEYNAME	1
-#define TRANSLATE_X11KEYNAME_TO_KEYSYM	2
+#define TRANSLATE_KEY_TO_KEYNAME	0
+#define TRANSLATE_KEY_TO_X11KEYNAME	1
+#define TRANSLATE_X11KEYNAME_TO_KEY	2
 
-void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
+void translate_keyname(Key *keysym, char **x11name, char **name, int mode)
 {
   static struct
   {
-    KeySym keysym;
+    Key key;
     char *x11name;
     char *name;
   } translate_key[] =
   {
     /* normal cursor keys */
-    { XK_Left,		"XK_Left",		"cursor left" },
-    { XK_Right,		"XK_Right",		"cursor right" },
-    { XK_Up,		"XK_Up",		"cursor up" },
-    { XK_Down,		"XK_Down",		"cursor down" },
+    { KEY_Left,		"XK_Left",		"cursor left" },
+    { KEY_Right,	"XK_Right",		"cursor right" },
+    { KEY_Up,		"XK_Up",		"cursor up" },
+    { KEY_Down,		"XK_Down",		"cursor down" },
 
     /* keypad cursor keys */
-#ifdef XK_KP_Left
-    { XK_KP_Left,	"XK_KP_Left",		"keypad left" },
-    { XK_KP_Right,	"XK_KP_Right",		"keypad right" },
-    { XK_KP_Up,		"XK_KP_Up",		"keypad up" },
-    { XK_KP_Down,	"XK_KP_Down",		"keypad down" },
+#ifdef KEY_KP_Left
+    { KEY_KP_Left,	"XK_KP_Left",		"keypad left" },
+    { KEY_KP_Right,	"XK_KP_Right",		"keypad right" },
+    { KEY_KP_Up,	"XK_KP_Up",		"keypad up" },
+    { KEY_KP_Down,	"XK_KP_Down",		"keypad down" },
 #endif
 
     /* other keypad keys */
-#ifdef XK_KP_Enter
-    { XK_KP_Enter,	"XK_KP_Enter",		"keypad enter" },
-    { XK_KP_Add,	"XK_KP_Add",		"keypad +" },
-    { XK_KP_Subtract,	"XK_KP_Subtract",	"keypad -" },
-    { XK_KP_Multiply,	"XK_KP_Multiply",	"keypad mltply" },
-    { XK_KP_Divide,	"XK_KP_Divide",		"keypad /" },
-    { XK_KP_Separator,	"XK_KP_Separator",	"keypad ," },
+#ifdef KEY_KP_Enter
+    { KEY_KP_Enter,	"XK_KP_Enter",		"keypad enter" },
+    { KEY_KP_Add,	"XK_KP_Add",		"keypad +" },
+    { KEY_KP_Subtract,	"XK_KP_Subtract",	"keypad -" },
+    { KEY_KP_Multiply,	"XK_KP_Multiply",	"keypad mltply" },
+    { KEY_KP_Divide,	"XK_KP_Divide",		"keypad /" },
+    { KEY_KP_Separator,	"XK_KP_Separator",	"keypad ," },
 #endif
 
     /* modifier keys */
-    { XK_Shift_L,	"XK_Shift_L",		"left shift" },
-    { XK_Shift_R,	"XK_Shift_R",		"right shift" },
-    { XK_Control_L,	"XK_Control_L",		"left control" },
-    { XK_Control_R,	"XK_Control_R",		"right control" },
-    { XK_Meta_L,	"XK_Meta_L",		"left meta" },
-    { XK_Meta_R,	"XK_Meta_R",		"right meta" },
-    { XK_Alt_L,		"XK_Alt_L",		"left alt" },
-    { XK_Alt_R,		"XK_Alt_R",		"right alt" },
-    { XK_Mode_switch,	"XK_Mode_switch",	"mode switch" },
-    { XK_Multi_key,	"XK_Multi_key",		"multi key" },
+    { KEY_Shift_L,	"XK_Shift_L",		"left shift" },
+    { KEY_Shift_R,	"XK_Shift_R",		"right shift" },
+    { KEY_Control_L,	"XK_Control_L",		"left control" },
+    { KEY_Control_R,	"XK_Control_R",		"right control" },
+    { KEY_Meta_L,	"XK_Meta_L",		"left meta" },
+    { KEY_Meta_R,	"XK_Meta_R",		"right meta" },
+    { KEY_Alt_L,	"XK_Alt_L",		"left alt" },
+    { KEY_Alt_R,	"XK_Alt_R",		"right alt" },
+    { KEY_Mode_switch,	"XK_Mode_switch",	"mode switch" },
+    { KEY_Multi_key,	"XK_Multi_key",		"multi key" },
 
     /* some special keys */
-    { XK_BackSpace,	"XK_BackSpace",		"backspace" },
-    { XK_Delete,	"XK_Delete",		"delete" },
-    { XK_Insert,	"XK_Insert",		"insert" },
-    { XK_Tab,		"XK_Tab",		"tab" },
-    { XK_Home,		"XK_Home",		"home" },
-    { XK_End,		"XK_End",		"end" },
-    { XK_Page_Up,	"XK_Page_Up",		"page up" },
-    { XK_Page_Down,	"XK_Page_Down",		"page down" },
+    { KEY_BackSpace,	"XK_BackSpace",		"backspace" },
+    { KEY_Delete,	"XK_Delete",		"delete" },
+    { KEY_Insert,	"XK_Insert",		"insert" },
+    { KEY_Tab,		"XK_Tab",		"tab" },
+    { KEY_Home,		"XK_Home",		"home" },
+    { KEY_End,		"XK_End",		"end" },
+    { KEY_Page_Up,	"XK_Page_Up",		"page up" },
+    { KEY_Page_Down,	"XK_Page_Down",		"page down" },
 
 
     /* ASCII 0x20 to 0x40 keys (except numbers) */
-    { XK_space,		"XK_space",		"space" },
-    { XK_exclam,	"XK_exclam",		"!" },
-    { XK_quotedbl,	"XK_quotedbl",		"\"" },
-    { XK_numbersign,	"XK_numbersign",	"#" },
-    { XK_dollar,	"XK_dollar",		"$" },
-    { XK_percent,	"XK_percent",		"%" },
-    { XK_ampersand,	"XK_ampersand",		"&" },
-    { XK_apostrophe,	"XK_apostrophe",	"'" },
-    { XK_parenleft,	"XK_parenleft",		"(" },
-    { XK_parenright,	"XK_parenright",	")" },
-    { XK_asterisk,	"XK_asterisk",		"*" },
-    { XK_plus,		"XK_plus",		"+" },
-    { XK_comma,		"XK_comma",		"," },
-    { XK_minus,		"XK_minus",		"-" },
-    { XK_period,	"XK_period",		"." },
-    { XK_slash,		"XK_slash",		"/" },
-    { XK_colon,		"XK_colon",		":" },
-    { XK_semicolon,	"XK_semicolon",		";" },
-    { XK_less,		"XK_less",		"<" },
-    { XK_equal,		"XK_equal",		"=" },
-    { XK_greater,	"XK_greater",		">" },
-    { XK_question,	"XK_question",		"?" },
-    { XK_at,		"XK_at",		"@" },
+    { KEY_space,	"XK_space",		"space" },
+    { KEY_exclam,	"XK_exclam",		"!" },
+    { KEY_quotedbl,	"XK_quotedbl",		"\"" },
+    { KEY_numbersign,	"XK_numbersign",	"#" },
+    { KEY_dollar,	"XK_dollar",		"$" },
+    { KEY_percent,	"XK_percent",		"%" },
+    { KEY_ampersand,	"XK_ampersand",		"&" },
+    { KEY_apostrophe,	"XK_apostrophe",	"'" },
+    { KEY_parenleft,	"XK_parenleft",		"(" },
+    { KEY_parenright,	"XK_parenright",	")" },
+    { KEY_asterisk,	"XK_asterisk",		"*" },
+    { KEY_plus,		"XK_plus",		"+" },
+    { KEY_comma,	"XK_comma",		"," },
+    { KEY_minus,	"XK_minus",		"-" },
+    { KEY_period,	"XK_period",		"." },
+    { KEY_slash,	"XK_slash",		"/" },
+    { KEY_colon,	"XK_colon",		":" },
+    { KEY_semicolon,	"XK_semicolon",		";" },
+    { KEY_less,		"XK_less",		"<" },
+    { KEY_equal,	"XK_equal",		"=" },
+    { KEY_greater,	"XK_greater",		">" },
+    { KEY_question,	"XK_question",		"?" },
+    { KEY_at,		"XK_at",		"@" },
 
     /* more ASCII keys */
-    { XK_bracketleft,	"XK_bracketleft",	"[" },
-    { XK_backslash,	"XK_backslash",		"backslash" },
-    { XK_bracketright,	"XK_bracketright",	"]" },
-    { XK_asciicircum,	"XK_asciicircum",	"circumflex" },
-    { XK_underscore,	"XK_underscore",	"_" },
-    { XK_grave,		"XK_grave",		"grave" },
-    { XK_quoteleft,	"XK_quoteleft",		"quote left" },
-    { XK_braceleft,	"XK_braceleft",		"brace left" },
-    { XK_bar,		"XK_bar",		"bar" },
-    { XK_braceright,	"XK_braceright",	"brace right" },
-    { XK_asciitilde,	"XK_asciitilde",	"ascii tilde" },
+    { KEY_bracketleft,	"XK_bracketleft",	"[" },
+    { KEY_backslash,	"XK_backslash",		"backslash" },
+    { KEY_bracketright,	"XK_bracketright",	"]" },
+    { KEY_asciicircum,	"XK_asciicircum",	"circumflex" },
+    { KEY_underscore,	"XK_underscore",	"_" },
+    { KEY_grave,	"XK_grave",		"grave" },
+    { KEY_quoteleft,	"XK_quoteleft",		"quote left" },
+    { KEY_braceleft,	"XK_braceleft",		"brace left" },
+    { KEY_bar,		"XK_bar",		"bar" },
+    { KEY_braceright,	"XK_braceright",	"brace right" },
+    { KEY_asciitilde,	"XK_asciitilde",	"ascii tilde" },
 
     /* special (non-ASCII) keys */
-    { XK_Adiaeresis,	"XK_Adiaeresis",	"Ä" },
-    { XK_Odiaeresis,	"XK_Odiaeresis",	"Ö" },
-    { XK_Udiaeresis,	"XK_Udiaeresis",	"Ü" },
-    { XK_adiaeresis,	"XK_adiaeresis",	"ä" },
-    { XK_odiaeresis,	"XK_odiaeresis",	"ö" },
-    { XK_udiaeresis,	"XK_udiaeresis",	"ü" },
-    { XK_ssharp,	"XK_ssharp",		"sharp s" },
+    { KEY_Adiaeresis,	"XK_Adiaeresis",	"Ä" },
+    { KEY_Odiaeresis,	"XK_Odiaeresis",	"Ö" },
+    { KEY_Udiaeresis,	"XK_Udiaeresis",	"Ü" },
+    { KEY_adiaeresis,	"XK_adiaeresis",	"ä" },
+    { KEY_odiaeresis,	"XK_odiaeresis",	"ö" },
+    { KEY_udiaeresis,	"XK_udiaeresis",	"ü" },
+    { KEY_ssharp,	"XK_ssharp",		"sharp s" },
 
     /* end-of-array identifier */
     { 0,                NULL,			NULL }
@@ -790,22 +790,22 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
 
   int i;
 
-  if (mode == TRANSLATE_KEYSYM_TO_KEYNAME)
+  if (mode == TRANSLATE_KEY_TO_KEYNAME)
   {
     static char name_buffer[30];
-    KeySym key = *keysym;
-
-    if (key >= XK_A && key <= XK_Z)
-      sprintf(name_buffer, "%c", 'A' + (char)(key - XK_A));
-    else if (key >= XK_a && key <= XK_z)
-      sprintf(name_buffer, "%c", 'a' + (char)(key - XK_a));
-    else if (key >= XK_0 && key <= XK_9)
-      sprintf(name_buffer, "%c", '0' + (char)(key - XK_0));
-    else if (key >= XK_KP_0 && key <= XK_KP_9)
-      sprintf(name_buffer, "keypad %c", '0' + (char)(key - XK_KP_0));
-    else if (key >= XK_F1 && key <= XK_F24)
-      sprintf(name_buffer, "function F%d", (int)(key - XK_F1 + 1));
-    else if (key == KEY_UNDEFINDED)
+    Key key = *keysym;
+
+    if (key >= KEY_A && key <= KEY_Z)
+      sprintf(name_buffer, "%c", 'A' + (char)(key - KEY_A));
+    else if (key >= KEY_a && key <= KEY_z)
+      sprintf(name_buffer, "%c", 'a' + (char)(key - KEY_a));
+    else if (key >= KEY_0 && key <= KEY_9)
+      sprintf(name_buffer, "%c", '0' + (char)(key - KEY_0));
+    else if (key >= KEY_KP_0 && key <= KEY_KP_9)
+      sprintf(name_buffer, "keypad %c", '0' + (char)(key - KEY_KP_0));
+    else if (key >= KEY_F1 && key <= KEY_F24)
+      sprintf(name_buffer, "function F%d", (int)(key - KEY_F1 + 1));
+    else if (key == KEY_UNDEFINED)
       strcpy(name_buffer, "(undefined)");
     else
     {
@@ -813,7 +813,7 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
 
       do
       {
-	if (key == translate_key[i].keysym)
+	if (key == translate_key[i].key)
 	{
 	  strcpy(name_buffer, translate_key[i].name);
 	  break;
@@ -827,22 +827,22 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
 
     *name = name_buffer;
   }
-  else if (mode == TRANSLATE_KEYSYM_TO_X11KEYNAME)
+  else if (mode == TRANSLATE_KEY_TO_X11KEYNAME)
   {
     static char name_buffer[30];
-    KeySym key = *keysym;
-
-    if (key >= XK_A && key <= XK_Z)
-      sprintf(name_buffer, "XK_%c", 'A' + (char)(key - XK_A));
-    else if (key >= XK_a && key <= XK_z)
-      sprintf(name_buffer, "XK_%c", 'a' + (char)(key - XK_a));
-    else if (key >= XK_0 && key <= XK_9)
-      sprintf(name_buffer, "XK_%c", '0' + (char)(key - XK_0));
-    else if (key >= XK_KP_0 && key <= XK_KP_9)
-      sprintf(name_buffer, "XK_KP_%c", '0' + (char)(key - XK_KP_0));
-    else if (key >= XK_F1 && key <= XK_F24)
-      sprintf(name_buffer, "XK_F%d", (int)(key - XK_F1 + 1));
-    else if (key == KEY_UNDEFINDED)
+    Key key = *keysym;
+
+    if (key >= KEY_A && key <= KEY_Z)
+      sprintf(name_buffer, "XK_%c", 'A' + (char)(key - KEY_A));
+    else if (key >= KEY_a && key <= KEY_z)
+      sprintf(name_buffer, "XK_%c", 'a' + (char)(key - KEY_a));
+    else if (key >= KEY_0 && key <= KEY_9)
+      sprintf(name_buffer, "XK_%c", '0' + (char)(key - KEY_0));
+    else if (key >= KEY_KP_0 && key <= KEY_KP_9)
+      sprintf(name_buffer, "XK_KP_%c", '0' + (char)(key - KEY_KP_0));
+    else if (key >= KEY_F1 && key <= KEY_F24)
+      sprintf(name_buffer, "XK_F%d", (int)(key - KEY_F1 + 1));
+    else if (key == KEY_UNDEFINED)
       strcpy(name_buffer, "[undefined]");
     else
     {
@@ -850,7 +850,7 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
 
       do
       {
-	if (key == translate_key[i].keysym)
+	if (key == translate_key[i].key)
 	{
 	  strcpy(name_buffer, translate_key[i].x11name);
 	  break;
@@ -864,9 +864,9 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
 
     *x11name = name_buffer;
   }
-  else if (mode == TRANSLATE_X11KEYNAME_TO_KEYSYM)
+  else if (mode == TRANSLATE_X11KEYNAME_TO_KEY)
   {
-    KeySym key = XK_VoidSymbol;
+    Key key = KEY_UNDEFINED;
     char *name_ptr = *x11name;
 
     if (strncmp(name_ptr, "XK_", 3) == 0 && strlen(name_ptr) == 4)
@@ -874,18 +874,18 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
       char c = name_ptr[3];
 
       if (c >= 'A' && c <= 'Z')
-	key = XK_A + (KeySym)(c - 'A');
+	key = KEY_A + (Key)(c - 'A');
       else if (c >= 'a' && c <= 'z')
-	key = XK_a + (KeySym)(c - 'a');
+	key = KEY_a + (Key)(c - 'a');
       else if (c >= '0' && c <= '9')
-	key = XK_0 + (KeySym)(c - '0');
+	key = KEY_0 + (Key)(c - '0');
     }
     else if (strncmp(name_ptr, "XK_KP_", 6) == 0 && strlen(name_ptr) == 7)
     {
       char c = name_ptr[6];
 
       if (c >= '0' && c <= '9')
-	key = XK_0 + (KeySym)(c - '0');
+	key = KEY_0 + (Key)(c - '0');
     }
     else if (strncmp(name_ptr, "XK_F", 4) == 0 && strlen(name_ptr) <= 6)
     {
@@ -898,7 +898,7 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
 	d = atoi(&name_ptr[4]);
 
       if (d >=1 && d <= 24)
-	key = XK_F1 + (KeySym)(d - 1);
+	key = KEY_F1 + (Key)(d - 1);
     }
     else if (strncmp(name_ptr, "XK_", 3) == 0)
     {
@@ -908,7 +908,7 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
       {
 	if (strcmp(name_ptr, translate_key[i].x11name) == 0)
 	{
-	  key = translate_key[i].keysym;
+	  key = translate_key[i].key;
 	  break;
 	}
       }
@@ -942,40 +942,40 @@ void translate_keyname(KeySym *keysym, char **x11name, char **name, int mode)
       }
 
       if (value != -1)
-	key = (KeySym)value;
+	key = (Key)value;
     }
 
     *keysym = key;
   }
 }
 
-char *getKeyNameFromKeySym(KeySym keysym)
+char *getKeyNameFromKey(Key key)
 {
   char *name;
 
-  translate_keyname(&keysym, NULL, &name, TRANSLATE_KEYSYM_TO_KEYNAME);
+  translate_keyname(&key, NULL, &name, TRANSLATE_KEY_TO_KEYNAME);
   return name;
 }
 
-char *getX11KeyNameFromKeySym(KeySym keysym)
+char *getX11KeyNameFromKey(Key key)
 {
   char *x11name;
 
-  translate_keyname(&keysym, &x11name, NULL, TRANSLATE_KEYSYM_TO_X11KEYNAME);
+  translate_keyname(&key, &x11name, NULL, TRANSLATE_KEY_TO_X11KEYNAME);
   return x11name;
 }
 
-KeySym getKeySymFromX11KeyName(char *x11name)
+Key getKeyFromX11KeyName(char *x11name)
 {
-  KeySym keysym;
+  Key key;
 
-  translate_keyname(&keysym, &x11name, NULL, TRANSLATE_X11KEYNAME_TO_KEYSYM);
-  return keysym;
+  translate_keyname(&key, &x11name, NULL, TRANSLATE_X11KEYNAME_TO_KEY);
+  return key;
 }
 
-char getCharFromKeySym(KeySym keysym)
+char getCharFromKey(Key key)
 {
-  char *keyname = getKeyNameFromKeySym(keysym);
+  char *keyname = getKeyNameFromKey(key);
   char letter = 0;
 
   if (strlen(keyname) == 1)
diff --git a/src/misc.h b/src/misc.h
index 5aa6c15c..e376cd26 100644
--- a/src/misc.h
+++ b/src/misc.h
@@ -70,10 +70,10 @@ int getFile32BitInteger(FILE *, int);
 void putFile32BitInteger(FILE *, int, int);
 void getFileChunk(FILE *, char *, int *, int);
 void putFileChunk(FILE *, char *, int, int);
-char *getKeyNameFromKeySym(KeySym);
-char *getX11KeyNameFromKeySym(KeySym);
-KeySym getKeySymFromX11KeyName(char *);
-char getCharFromKeySym(KeySym);
+char *getKeyNameFromKey(Key);
+char *getX11KeyNameFromKey(Key);
+Key getKeyFromX11KeyName(char *);
+char getCharFromKey(Key);
 char *getJoyNameFromJoySymbol(int);
 int getJoySymbolFromJoyName(char *);
 int getJoystickNrFromDeviceName(char *);
diff --git a/src/msdos.h b/src/msdos.h
index 508bb844..a67fe229 100644
--- a/src/msdos.h
+++ b/src/msdos.h
@@ -676,7 +676,6 @@ typedef union _XEvent
   XKeyEvent xkey;
 } XEvent;
 
-unsigned char get_ascii(KeySym);
 void XMapWindow(Display *, Window);
 Display *XOpenDisplay(char *);
 Window XCreateSimpleWindow(Display *, Window, int, int,
diff --git a/src/screens.c b/src/screens.c
index 8fb300aa..ddd4def8 100644
--- a/src/screens.c
+++ b/src/screens.c
@@ -55,10 +55,6 @@ static void HandleScreenGadgets(struct GadgetInfo *);
 
 static struct GadgetInfo *screen_gadget[NUM_SCREEN_GADGETS];
 
-#ifdef MSDOS
-extern unsigned char get_ascii(KeySym);
-#endif
-
 void DrawHeadline()
 {
   int x = SX + (SXSIZE - strlen(PROGRAM_TITLE_STRING) * FONT1_XSIZE) / 2;
@@ -814,7 +810,7 @@ void HandleHelpScreen(int button)
   BackToFront();
 }
 
-void HandleTypeName(int newxpos, KeySym key)
+void HandleTypeName(int newxpos, Key key)
 {
   static int xpos = 0, ypos = 2;
 
@@ -826,15 +822,15 @@ void HandleTypeName(int newxpos, KeySym key)
     return;
   }
 
-  if (((key >= XK_A && key <= XK_Z) || (key >= XK_a && key <= XK_z)) && 
+  if (((key >= KEY_A && key <= KEY_Z) || (key >= KEY_a && key <= KEY_z)) && 
       xpos < MAX_PLAYER_NAME_LEN)
   {
     char ascii;
 
-    if (key >= XK_A && key <= XK_Z)
-      ascii = 'A' + (char)(key - XK_A);
+    if (key >= KEY_A && key <= KEY_Z)
+      ascii = 'A' + (char)(key - KEY_A);
     else
-      ascii = 'a' + (char)(key - XK_a);
+      ascii = 'a' + (char)(key - KEY_a);
 
     setup.player_name[xpos] = ascii;
     setup.player_name[xpos + 1] = 0;
@@ -845,14 +841,14 @@ void HandleTypeName(int newxpos, KeySym key)
 		setup.player_name, FS_BIG, FC_YELLOW);
     DrawGraphic(xpos + 6, ypos, GFX_KUGEL_ROT);
   }
-  else if ((key == XK_Delete || key == XK_BackSpace) && xpos > 0)
+  else if ((key == KEY_Delete || key == KEY_BackSpace) && xpos > 0)
   {
     xpos--;
     setup.player_name[xpos] = 0;
     DrawGraphic(xpos + 6, ypos, GFX_KUGEL_ROT);
     DrawGraphic(xpos + 7, ypos, GFX_LEERRAUM);
   }
-  else if (key == XK_Return && xpos > 0)
+  else if (key == KEY_Return && xpos > 0)
   {
     DrawText(SX + 6*32, SY + ypos*32, setup.player_name, FS_BIG, FC_RED);
     DrawGraphic(xpos + 6, ypos, GFX_LEERRAUM);
@@ -1040,7 +1036,7 @@ void HandleChooseLevel(int mx, int my, int dx, int dy, int button)
     else
       x = y = 0;	/* no action */
 
-    if (ABS(dy) == SCR_FIELDY)	/* handle XK_Page_Up, XK_Page_Down */
+    if (ABS(dy) == SCR_FIELDY)	/* handle KEY_Page_Up, KEY_Page_Down */
     {
       dy = SIGN(dy);
       step = num_page_entries - 1;
@@ -1228,7 +1224,7 @@ void HandleHallOfFame(int mx, int my, int dx, int dy, int button)
     return;
   }
 
-  if (ABS(dy) == SCR_FIELDY)	/* handle XK_Page_Up, XK_Page_Down */
+  if (ABS(dy) == SCR_FIELDY)	/* handle KEY_Page_Up, KEY_Page_Down */
     step = MAX_LEVEL_SERIES_ON_SCREEN - 1;
 
   if (dy < 0)
@@ -1618,7 +1614,7 @@ static void drawPlayerSetupInputInfo(int player_nr)
   static struct SetupKeyboardInfo custom_key;
   static struct
   {
-    KeySym *keysym;
+    Key *key;
     char *text;
   } custom[] =
   {
@@ -1678,7 +1674,7 @@ static void drawPlayerSetupInputInfo(int player_nr)
     DrawText(SX + 3*32, SY + ypos*32,
 	     (setup.input[player_nr].use_joystick ?
 	      custom[i].text :
-	      getKeyNameFromKeySym(*custom[i].keysym)),
+	      getKeyNameFromKey(*custom[i].key)),
 	     FS_BIG, FC_YELLOW);
   }
 }
@@ -1858,7 +1854,7 @@ void CustomizeKeyboard(int player_nr)
   static struct SetupKeyboardInfo custom_key;
   static struct
   {
-    KeySym *keysym;
+    Key *key;
     char *text;
   } customize_step[] =
   {
@@ -1885,7 +1881,7 @@ void CustomizeKeyboard(int player_nr)
   DrawText(SX, SY + (2+2*step_nr+1)*32,
 	   "Key:", FS_BIG, FC_RED);
   DrawText(SX + 4*32, SY + (2+2*step_nr+1)*32,
-	   getKeyNameFromKeySym(*customize_step[step_nr].keysym),
+	   getKeyNameFromKey(*customize_step[step_nr].key),
 	   FS_BIG, FC_BLUE);
 
   while(!finished)
@@ -1900,32 +1896,31 @@ void CustomizeKeyboard(int player_nr)
       {
         case EVENT_KEYPRESS:
 	  {
-	    KeySym key = XLookupKeysym((KeyEvent *)&event,
-				       ((KeyEvent *)&event)->state);
+	    Key key = GetEventKey((KeyEvent *)&event, TRUE);
 
-	    if (key == XK_Escape || (key == XK_Return && step_nr == 6))
+	    if (key == KEY_Escape || (key == KEY_Return && step_nr == 6))
 	    {
 	      finished = TRUE;
 	      break;
 	    }
 
 	    /* press 'Enter' to keep the existing key binding */
-	    if (key == XK_Return || step_nr == 6)
-	      key = *customize_step[step_nr].keysym;
+	    if (key == KEY_Return || step_nr == 6)
+	      key = *customize_step[step_nr].key;
 
 	    /* check if key already used */
 	    for (i=0; i<step_nr; i++)
-	      if (*customize_step[i].keysym == key)
+	      if (*customize_step[i].key == key)
 		break;
 	    if (i < step_nr)
 	      break;
 
 	    /* got new key binding */
-	    *customize_step[step_nr].keysym = key;
+	    *customize_step[step_nr].key = key;
 	    DrawText(SX + 4*32, SY + (2+2*step_nr+1)*32,
 		     "             ", FS_BIG, FC_YELLOW);
 	    DrawText(SX + 4*32, SY + (2+2*step_nr+1)*32,
-		     getKeyNameFromKeySym(key), FS_BIG, FC_YELLOW);
+		     getKeyNameFromKey(key), FS_BIG, FC_YELLOW);
 	    step_nr++;
 
 	    /* un-highlight last query */
@@ -1948,7 +1943,7 @@ void CustomizeKeyboard(int player_nr)
 	    DrawText(SX, SY+(2+2*step_nr+1)*32,
 		     "Key:", FS_BIG, FC_RED);
 	    DrawText(SX + 4*32, SY+(2+2*step_nr+1)*32,
-		     getKeyNameFromKeySym(*customize_step[step_nr].keysym),
+		     getKeyNameFromKey(*customize_step[step_nr].key),
 		     FS_BIG, FC_BLUE);
 	  }
 	  break;
@@ -2065,15 +2060,14 @@ void CalibrateJoystick(int player_nr)
       switch(event.type)
       {
 	case EVENT_KEYPRESS:
-	  switch(XLookupKeysym((KeyEvent *)&event,
-			       ((KeyEvent *)&event)->state))
+	  switch(GetEventKey((KeyEvent *)&event, TRUE))
 	  {
-	    case XK_Return:
+	    case KEY_Return:
 	      if (check_remaining == 0)
 		result = 1;
 	      break;
 
-	    case XK_Escape:
+	    case KEY_Escape:
 	      result = 0;
 	      break;
 
diff --git a/src/screens.h b/src/screens.h
index d4043273..e5053667 100644
--- a/src/screens.h
+++ b/src/screens.h
@@ -25,7 +25,7 @@ void DrawHelpScreenMusicText(int);
 void DrawHelpScreenCreditsText(void);
 void DrawHelpScreen(void);
 void HandleHelpScreen(int);
-void HandleTypeName(int, KeySym);
+void HandleTypeName(int, Key);
 void DrawChooseLevel(void);
 void HandleChooseLevel(int, int, int, int, int);
 void DrawHallOfFame(int);
diff --git a/src/system.c b/src/system.c
index 71b248e8..5fbf9efe 100644
--- a/src/system.c
+++ b/src/system.c
@@ -105,14 +105,21 @@ inline void SyncDisplay()
 
 inline void KeyboardAutoRepeatOn()
 {
-#ifndef USE_SDL_LIBRARY
+#ifdef USE_SDL_LIBRARY
+  SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY / 2,
+		      SDL_DEFAULT_REPEAT_INTERVAL / 2);
+  SDL_EnableUNICODE(1);
+#else
   XAutoRepeatOn(display);
 #endif
 }
 
 inline void KeyboardAutoRepeatOff()
 {
-#ifndef USE_SDL_LIBRARY
+#ifdef USE_SDL_LIBRARY
+  SDL_EnableKeyRepeat(0, SDL_DEFAULT_REPEAT_INTERVAL);
+  SDL_EnableUNICODE(0);
+#else
   XAutoRepeatOff(display);
 #endif
 }
@@ -152,6 +159,30 @@ inline void NextEvent(Event *event)
 #endif
 }
 
+inline Key GetEventKey(KeyEvent *event, boolean with_modifiers)
+{
+#ifdef USE_SDL_LIBRARY
+#if 0
+  printf("0x%x, 0x%x\n",
+	 event->keysym.sym, event->keysym.unicode);
+#endif
+  if (with_modifiers && event->keysym.unicode != 0)
+    return event->keysym.unicode;
+  else
+    return event->keysym.sym;
+#else
+#if 0
+  printf("0x%x, 0x%x\n",
+	 (unsigned int)XLookupKeysym(event, 0),
+	 (unsigned int)XLookupKeysym(event, event->state));
+#endif
+  if (with_modifiers)
+    return XLookupKeysym(event, event->state);
+  else
+    return XLookupKeysym(event, 0);
+#endif
+}
+
 inline void dummy()
 {
 #ifdef USE_SDL_LIBRARY
diff --git a/src/system.h b/src/system.h
index 35351e32..e2dfca6e 100644
--- a/src/system.h
+++ b/src/system.h
@@ -29,21 +29,17 @@
 #endif
 
 #ifdef USE_SDL_LIBRARY
-typedef SDL_Surface *Bitmap;
-typedef SDL_Surface *DrawWindow;
-typedef SDL_Surface *DrawBuffer;
-#else
-typedef Pixmap Bitmap;
-typedef Window DrawWindow;
-typedef Drawable DrawBuffer;
-#endif
 
-#ifdef USE_SDL_LIBRARY
+typedef SDL_Surface	       *Bitmap;
+typedef SDL_Surface	       *DrawWindow;
+typedef SDL_Surface	       *DrawBuffer;
+
+typedef SDLKey			Key;
 
 typedef SDL_Event		Event;
 typedef SDL_MouseButtonEvent	ButtonEvent;
 typedef SDL_MouseMotionEvent	MotionEvent;
-typedef XKeyEvent		KeyEvent;
+typedef SDL_KeyboardEvent	KeyEvent;
 typedef XExposeEvent		ExposeEvent;
 typedef XFocusChangeEvent	FocusChangeEvent;
 typedef XClientMessageEvent	ClientMessageEvent;
@@ -60,7 +56,233 @@ typedef XClientMessageEvent	ClientMessageEvent;
 #define EVENT_MAPNOTIFY		SDL_USEREVENT + 4
 #define EVENT_UNMAPNOTIFY	SDL_USEREVENT + 5
 
-#else
+#define KEY_UNDEFINED		SDLK_UNKNOWN
+
+#define KEY_Return		SDLK_RETURN
+#define KEY_Escape		SDLK_ESCAPE
+
+#define KEY_Left		SDLK_LEFT
+#define KEY_Right		SDLK_RIGHT
+#define KEY_Up			SDLK_UP
+#define KEY_Down		SDLK_DOWN
+
+#ifdef SDLK_KP_LEFT
+#define KEY_KP_Left		SDLK_KP_LEFT
+#define KEY_KP_Right		SDLK_KP_RIGHT
+#define KEY_KP_Up		SDLK_KP_UP
+#define KEY_KP_Down		SDLK_KP_DOWN
+#endif
+
+#define KEY_KP_Enter		SDLK_KP_ENTER
+#define KEY_KP_Add		SDLK_KP_PLUS
+#define KEY_KP_Subtract		SDLK_KP_MINUS
+#define KEY_KP_Multiply		SDLK_KP_MULTIPLY
+#define KEY_KP_Divide		SDLK_KP_DIVIDE
+#define KEY_KP_Separator	SDLK_KP_PERIOD
+
+#define KEY_Shift_L		SDLK_LSHIFT
+#define KEY_Shift_R		SDLK_RSHIFT
+#define KEY_Control_L		SDLK_LCTRL
+#define KEY_Control_R		SDLK_RCTRL
+#define KEY_Meta_L		SDLK_LMETA
+#define KEY_Meta_R		SDLK_RMETA
+#define KEY_Alt_L		SDLK_LALT
+#define KEY_Alt_R		SDLK_RALT
+#define KEY_Mode_switch		SDLK_MODE
+#define KEY_Multi_key		KEY_UNDEFINED		/* undefined */
+
+#define KEY_BackSpace		SDLK_BACKSPACE
+#define KEY_Delete		SDLK_DELETE
+#define KEY_Insert		SDLK_INSERT
+#define KEY_Tab			SDLK_TAB
+#define KEY_Home		SDLK_HOME
+#define KEY_End			SDLK_END
+#define KEY_Page_Up		SDLK_PAGEUP
+#define KEY_Page_Down		SDLK_PAGEDOWN
+
+#define KEY_space		SDLK_SPACE
+#define KEY_exclam		SDLK_EXCLAIM
+#define KEY_quotedbl		SDLK_QUOTEDBL
+#define KEY_numbersign		SDLK_HASH
+#define KEY_dollar		SDLK_DOLLAR
+#define KEY_percent		KEY_UNDEFINED		/* undefined */
+#define KEY_ampersand		SDLK_AMPERSAND
+#define KEY_apostrophe		SDLK_QUOTE
+#define KEY_parenleft		SDLK_LEFTPAREN
+#define KEY_parenright		SDLK_RIGHTPAREN
+#define KEY_asterisk		SDLK_ASTERISK
+#define KEY_plus		SDLK_PLUS
+#define KEY_comma		SDLK_COMMA
+#define KEY_minus		SDLK_MINUS
+#define KEY_period		SDLK_PERIOD
+#define KEY_slash		SDLK_SLASH
+
+#define KEY_colon		SDLK_COLON
+#define KEY_semicolon		SDLK_SEMICOLON
+#define KEY_less		SDLK_LESS
+#define KEY_equal		SDLK_EQUALS
+#define KEY_greater		SDLK_GREATER
+#define KEY_question		SDLK_QUESTION
+#define KEY_at			SDLK_AT
+
+#define KEY_bracketleft		SDLK_LEFTBRACKET
+#define KEY_backslash		SDLK_BACKSLASH
+#define KEY_bracketright	SDLK_RIGHTBRACKET
+#define KEY_asciicircum		SDLK_CARET
+#define KEY_underscore		SDLK_UNDERSCORE
+#define KEY_grave		SDLK_BACKQUOTE
+
+#define KEY_quoteleft		KEY_UNDEFINED		/* undefined */
+#define KEY_braceleft		KEY_UNDEFINED		/* undefined */
+#define KEY_bar			KEY_UNDEFINED		/* undefined */
+#define KEY_braceright		KEY_UNDEFINED		/* undefined */
+#define KEY_asciitilde		KEY_UNDEFINED		/* undefined */
+
+#define KEY_Adiaeresis		SDLK_WORLD_36
+#define KEY_Odiaeresis		SDLK_WORLD_54
+#define KEY_Udiaeresis		SDLK_WORLD_60
+#define KEY_adiaeresis		SDLK_WORLD_68
+#define KEY_odiaeresis		SDLK_WORLD_86
+#define KEY_udiaeresis		SDLK_WORLD_92
+#define KEY_ssharp		SDLK_WORLD_63
+
+#ifndef SDLK_A
+#define SDLK_A			65
+#define SDLK_B			66
+#define SDLK_C			67
+#define SDLK_D			68
+#define SDLK_E			69
+#define SDLK_F			70
+#define SDLK_G			71
+#define SDLK_H			72
+#define SDLK_I			73
+#define SDLK_J			74
+#define SDLK_K			75
+#define SDLK_L			76
+#define SDLK_M			77
+#define SDLK_N			78
+#define SDLK_O			79
+#define SDLK_P			80
+#define SDLK_Q			81
+#define SDLK_R			82
+#define SDLK_S			83
+#define SDLK_T			84
+#define SDLK_U			85
+#define SDLK_V			86
+#define SDLK_W			87
+#define SDLK_X			88
+#define SDLK_Y			89
+#define SDLK_Z			90
+#endif
+
+#define KEY_A			SDLK_A
+#define KEY_B			SDLK_B
+#define KEY_C			SDLK_C
+#define KEY_D			SDLK_D
+#define KEY_E			SDLK_E
+#define KEY_F			SDLK_F
+#define KEY_G			SDLK_G
+#define KEY_H			SDLK_H
+#define KEY_I			SDLK_I
+#define KEY_J			SDLK_J
+#define KEY_K			SDLK_K
+#define KEY_L			SDLK_L
+#define KEY_M			SDLK_M
+#define KEY_N			SDLK_N
+#define KEY_O			SDLK_O
+#define KEY_P			SDLK_P
+#define KEY_Q			SDLK_Q
+#define KEY_R			SDLK_R
+#define KEY_S			SDLK_S
+#define KEY_T			SDLK_T
+#define KEY_U			SDLK_U
+#define KEY_V			SDLK_V
+#define KEY_W			SDLK_W
+#define KEY_X			SDLK_X
+#define KEY_Y			SDLK_Y
+#define KEY_Z			SDLK_Z
+
+#define KEY_a			SDLK_a
+#define KEY_b			SDLK_b
+#define KEY_c			SDLK_c
+#define KEY_d			SDLK_d
+#define KEY_e			SDLK_e
+#define KEY_f			SDLK_f
+#define KEY_g			SDLK_g
+#define KEY_h			SDLK_h
+#define KEY_i			SDLK_i
+#define KEY_j			SDLK_j
+#define KEY_k			SDLK_k
+#define KEY_l			SDLK_l
+#define KEY_m			SDLK_m
+#define KEY_n			SDLK_n
+#define KEY_o			SDLK_o
+#define KEY_p			SDLK_p
+#define KEY_q			SDLK_q
+#define KEY_r			SDLK_r
+#define KEY_s			SDLK_s
+#define KEY_t			SDLK_t
+#define KEY_u			SDLK_u
+#define KEY_v			SDLK_v
+#define KEY_w			SDLK_w
+#define KEY_x			SDLK_x
+#define KEY_y			SDLK_y
+#define KEY_z			SDLK_z
+
+#define KEY_0			SDLK_0
+#define KEY_1			SDLK_1
+#define KEY_2			SDLK_2
+#define KEY_3			SDLK_3
+#define KEY_4			SDLK_4
+#define KEY_5			SDLK_5
+#define KEY_6			SDLK_6
+#define KEY_7			SDLK_7
+#define KEY_8			SDLK_8
+#define KEY_9			SDLK_9
+
+#define KEY_KP_0		SDLK_KP0
+#define KEY_KP_1		SDLK_KP1
+#define KEY_KP_2		SDLK_KP2
+#define KEY_KP_3		SDLK_KP3
+#define KEY_KP_4		SDLK_KP4
+#define KEY_KP_5		SDLK_KP5
+#define KEY_KP_6		SDLK_KP6
+#define KEY_KP_7		SDLK_KP7
+#define KEY_KP_8		SDLK_KP8
+#define KEY_KP_9		SDLK_KP9
+
+#define KEY_F1			SDLK_F1
+#define KEY_F2			SDLK_F2
+#define KEY_F3			SDLK_F3
+#define KEY_F4			SDLK_F4
+#define KEY_F5			SDLK_F5
+#define KEY_F6			SDLK_F6
+#define KEY_F7			SDLK_F7
+#define KEY_F8			SDLK_F8
+#define KEY_F9			SDLK_F9
+#define KEY_F10			SDLK_F10
+#define KEY_F11			SDLK_F11
+#define KEY_F12			SDLK_F12
+#define KEY_F13			SDLK_F13
+#define KEY_F14			SDLK_F14
+#define KEY_F15			SDLK_F15
+#define KEY_F16			KEY_UNDEFINED
+#define KEY_F17			KEY_UNDEFINED
+#define KEY_F18			KEY_UNDEFINED
+#define KEY_F19			KEY_UNDEFINED
+#define KEY_F20			KEY_UNDEFINED
+#define KEY_F21			KEY_UNDEFINED
+#define KEY_F22			KEY_UNDEFINED
+#define KEY_F23			KEY_UNDEFINED
+#define KEY_F24			KEY_UNDEFINED
+
+#else	/* X11 type definitions */
+
+typedef Pixmap			Bitmap;
+typedef Window			DrawWindow;
+typedef Drawable		DrawBuffer;
+
+typedef KeySym			Key;
 
 typedef XEvent			Event;
 typedef XButtonEvent		ButtonEvent;
@@ -82,6 +304,199 @@ typedef XClientMessageEvent	ClientMessageEvent;
 #define EVENT_MAPNOTIFY		MapNotify
 #define EVENT_UNMAPNOTIFY	UnmapNotify
 
+#define KEY_UNDEFINED		XK_VoidSymbol
+
+#define KEY_Return		XK_Return
+#define KEY_Escape		XK_Escape
+
+#define KEY_Left		XK_Left
+#define KEY_Right		XK_Right
+#define KEY_Up			XK_Up
+#define KEY_Down		XK_Down
+
+#ifdef XK_KP_Left
+#define KEY_KP_Left		XK_KP_Left
+#define KEY_KP_Right		XK_KP_Right
+#define KEY_KP_Up		XK_KP_Up
+#define KEY_KP_Down		XK_KP_Down
+#endif
+
+#ifdef XK_KP_Enter
+#define KEY_KP_Enter		XK_KP_Enter
+#define KEY_KP_Add		XK_KP_Add
+#define KEY_KP_Subtract		XK_KP_Subtract
+#define KEY_KP_Multiply		XK_KP_Multiply
+#define KEY_KP_Divide		XK_KP_Divide
+#define KEY_KP_Separator	XK_KP_Separator
+#endif
+
+#define KEY_Shift_L		XK_Shift_L
+#define KEY_Shift_R		XK_Shift_R
+#define KEY_Control_L		XK_Control_L
+#define KEY_Control_R		XK_Control_R
+#define KEY_Meta_L		XK_Meta_L
+#define KEY_Meta_R		XK_Meta_R
+#define KEY_Alt_L		XK_Alt_L
+#define KEY_Alt_R		XK_Alt_R
+#define KEY_Mode_switch		XK_Mode_switch
+#define KEY_Multi_key		XK_Multi_key
+
+#define KEY_BackSpace		XK_BackSpace
+#define KEY_Delete		XK_Delete
+#define KEY_Insert		XK_Insert
+#define KEY_Tab			XK_Tab
+#define KEY_Home		XK_Home
+#define KEY_End			XK_End
+#define KEY_Page_Up		XK_Page_Up
+#define KEY_Page_Down		XK_Page_Down
+
+#define KEY_space		XK_space
+#define KEY_exclam		XK_exclam
+#define KEY_quotedbl		XK_quotedbl
+#define KEY_numbersign		XK_numbersign
+#define KEY_dollar		XK_dollar
+#define KEY_percent		XK_percent
+#define KEY_ampersand		XK_ampersand
+#define KEY_apostrophe		XK_apostrophe
+#define KEY_parenleft		XK_parenleft
+#define KEY_parenright		XK_parenright
+#define KEY_asterisk		XK_asterisk
+#define KEY_plus		XK_plus
+#define KEY_comma		XK_comma
+#define KEY_minus		XK_minus
+#define KEY_period		XK_period
+#define KEY_slash		XK_slash
+
+#define KEY_colon		XK_colon
+#define KEY_semicolon		XK_semicolon
+#define KEY_less		XK_less
+#define KEY_equal		XK_equal
+#define KEY_greater		XK_greater
+#define KEY_question		XK_question
+#define KEY_at			XK_at
+
+#define KEY_bracketleft		XK_bracketleft
+#define KEY_backslash		XK_backslash
+#define KEY_bracketright	XK_bracketright
+#define KEY_asciicircum		XK_asciicircum
+#define KEY_underscore		XK_underscore
+#define KEY_grave		XK_grave
+
+#define KEY_quoteleft		XK_quoteleft
+#define KEY_braceleft		XK_braceleft
+#define KEY_bar			XK_bar
+#define KEY_braceright		XK_braceright
+#define KEY_asciitilde		XK_asciitilde
+
+#define KEY_Adiaeresis		XK_Adiaeresis
+#define KEY_Odiaeresis		XK_Odiaeresis
+#define KEY_Udiaeresis		XK_Udiaeresis
+#define KEY_adiaeresis		XK_adiaeresis
+#define KEY_odiaeresis		XK_odiaeresis
+#define KEY_udiaeresis		XK_udiaeresis
+#define KEY_ssharp		XK_ssharp
+
+#define KEY_A			XK_A
+#define KEY_B			XK_B
+#define KEY_C			XK_C
+#define KEY_D			XK_D
+#define KEY_E			XK_E
+#define KEY_F			XK_F
+#define KEY_G			XK_G
+#define KEY_H			XK_H
+#define KEY_I			XK_I
+#define KEY_J			XK_J
+#define KEY_K			XK_K
+#define KEY_L			XK_L
+#define KEY_M			XK_M
+#define KEY_N			XK_N
+#define KEY_O			XK_O
+#define KEY_P			XK_P
+#define KEY_Q			XK_Q
+#define KEY_R			XK_R
+#define KEY_S			XK_S
+#define KEY_T			XK_T
+#define KEY_U			XK_U
+#define KEY_V			XK_V
+#define KEY_W			XK_W
+#define KEY_X			XK_X
+#define KEY_Y			XK_Y
+#define KEY_Z			XK_Z
+
+#define KEY_a			XK_a
+#define KEY_b			XK_b
+#define KEY_c			XK_c
+#define KEY_d			XK_d
+#define KEY_e			XK_e
+#define KEY_f			XK_f
+#define KEY_g			XK_g
+#define KEY_h			XK_h
+#define KEY_i			XK_i
+#define KEY_j			XK_j
+#define KEY_k			XK_k
+#define KEY_l			XK_l
+#define KEY_m			XK_m
+#define KEY_n			XK_n
+#define KEY_o			XK_o
+#define KEY_p			XK_p
+#define KEY_q			XK_q
+#define KEY_r			XK_r
+#define KEY_s			XK_s
+#define KEY_t			XK_t
+#define KEY_u			XK_u
+#define KEY_v			XK_v
+#define KEY_w			XK_w
+#define KEY_x			XK_x
+#define KEY_y			XK_y
+#define KEY_z			XK_z
+
+#define KEY_0			XK_0
+#define KEY_1			XK_1
+#define KEY_2			XK_2
+#define KEY_3			XK_3
+#define KEY_4			XK_4
+#define KEY_5			XK_5
+#define KEY_6			XK_6
+#define KEY_7			XK_7
+#define KEY_8			XK_8
+#define KEY_9			XK_9
+
+#define KEY_KP_0		XK_KP_0
+#define KEY_KP_1		XK_KP_1
+#define KEY_KP_2		XK_KP_2
+#define KEY_KP_3		XK_KP_3
+#define KEY_KP_4		XK_KP_4
+#define KEY_KP_5		XK_KP_5
+#define KEY_KP_6		XK_KP_6
+#define KEY_KP_7		XK_KP_7
+#define KEY_KP_8		XK_KP_8
+#define KEY_KP_9		XK_KP_9
+
+#define KEY_F1			XK_F1
+#define KEY_F2			XK_F2
+#define KEY_F3			XK_F3
+#define KEY_F4			XK_F4
+#define KEY_F5			XK_F5
+#define KEY_F6			XK_F6
+#define KEY_F7			XK_F7
+#define KEY_F8			XK_F8
+#define KEY_F9			XK_F9
+#define KEY_F10			XK_F10
+#define KEY_F11			XK_F11
+#define KEY_F12			XK_F12
+#define KEY_F13			XK_F13
+#define KEY_F14			XK_F14
+#define KEY_F15			XK_F15
+#define KEY_F16			XK_F16
+#define KEY_F17			XK_F17
+#define KEY_F18			XK_F18
+#define KEY_F19			XK_F19
+#define KEY_F20			XK_F20
+#define KEY_F21			XK_F21
+#define KEY_F22			XK_F22
+#define KEY_F23			XK_F23
+#define KEY_F24			XK_F24
+
 #endif
 
 inline void ClearRectangle(Bitmap, int, int, int, int);
@@ -100,4 +515,6 @@ inline boolean QueryPointer(DrawWindow, int *, int *);
 inline boolean PendingEvent();
 inline void NextEvent(Event *event);
 
+inline Key GetEventKey(KeyEvent *, boolean);
+
 #endif /* SYSTEM_H */
diff --git a/src/tools.c b/src/tools.c
index 51ba2055..3bf2c5a5 100644
--- a/src/tools.c
+++ b/src/tools.c
@@ -330,23 +330,13 @@ int getFontHeight(int font_size, int font_type)
 
 void DrawInitText(char *text, int ypos, int color)
 {
-#ifdef USE_SDL_LIBRARY
   if (window && pix[PIX_SMALLFONT])
-  {
-    ClearRectangle(window, 0, ypos, WIN_XSIZE, FONT2_YSIZE);
-    DrawTextExt(window, gc, (WIN_XSIZE - strlen(text) * FONT2_XSIZE)/2,
-		ypos, text, FS_SMALL, color);
-    SDL_Flip(window);
-  }
-#else
-  if (display && window && pix[PIX_SMALLFONT])
   {
     ClearRectangle(window, 0, ypos, WIN_XSIZE, FONT2_YSIZE);
     DrawTextExt(window, gc, (WIN_XSIZE - strlen(text) * FONT2_XSIZE)/2,
 		ypos, text, FS_SMALL, color);
     FlushDisplay();
   }
-#endif
 }
 
 void DrawTextFCentered(int y, int font_type, char *format, ...)
@@ -1957,14 +1947,13 @@ boolean Request(char *text, unsigned int req_state)
 	}
 
 	case EVENT_KEYPRESS:
-	  switch(XLookupKeysym((KeyEvent *)&event,
-			       ((KeyEvent *)&event)->state))
+	  switch(GetEventKey((KeyEvent *)&event, TRUE))
 	  {
-	    case XK_Return:
+	    case KEY_Return:
 	      result = 1;
 	      break;
 
-	    case XK_Escape:
+	    case KEY_Escape:
 	      result = 0;
 	      break;