Discover X keycodes at runtime, as they are server dependent.

os.c

@@ -4,7 +4,8 @@
 #include "os_sound_linux.c"
 #include "os_thread_linux.c"
 #include "os_window_x11.c"
-#include "os_x11_keys_linux.c"
+/* #include "os_x11_keys_linux.c" */
+#include "os_x11_keys_generic.c"
 
 #else
 #error Not yet ported to Windows, Mac, etc.

os_window_x11.c

@@ -292,7 +292,7 @@ os_window_create(uint32_t width, uint32_t height) {
     errx(1, "XFlush failed");
   }
 
-  p_window->p_key_map = os_x11_keys_get_mapping();
+  p_window->p_key_map = os_x11_keys_get_mapping(p_window->d);
 
   return p_window;
 }

os_x11_keys.h

@@ -2,6 +2,6 @@
 #define OS_X11_KEYS_H
 
 /* Must return a 256 array mapping to keyboard.h values. */
-uint8_t* os_x11_keys_get_mapping();
+uint8_t* os_x11_keys_get_mapping(void* p_display);
 
 #endif /* OS_X11_KEYS_H */

os_x11_keys_generic.c

@@ -0,0 +1,181 @@
+#include "os_x11_keys.h"
+
+#include <X11/Xlib.h>
+
+struct mapping_struct {
+  const char *p_x_key_name;
+  uint8_t key;
+};
+
+static const struct mapping_struct s_x_keys_mapping[] = {
+  {"Escape", k_keyboard_key_escape},
+  {"0", '0'},
+  {"1", '1'},
+  {"2", '2'},
+  {"3", '3'},
+  {"4", '4'},
+  {"5", '5'},
+  {"6", '6'},
+  {"7", '7'},
+  {"8", '8'},
+  {"9", '9'},
+  {"minus", '-'},
+  {"equal", '='},
+  {"BackSpace", k_keyboard_key_backspace},
+
+  {"Tab", k_keyboard_key_tab},
+  {"Q", 'Q'},
+  {"W", 'W'},
+  {"E", 'E'},
+  {"R", 'R'},
+  {"T", 'T'},
+  {"Y", 'Y'},
+  {"U", 'U'},
+  {"I", 'I'},
+  {"O", 'O'},
+  {"P", 'P'},
+  {"bracketleft", '['},
+  {"bracketright", ']'},
+  {"backslash", '\\'},
+
+  {"Caps_Lock", k_keyboard_key_caps_lock},
+  {"A", 'A'},
+  {"S", 'S'},
+  {"D", 'D'},
+  {"F", 'F'},
+  {"G", 'G'},
+  {"H", 'H'},
+  {"J", 'J'},
+  {"K", 'K'},
+  {"L", 'L'},
+  {"semicolon", ';'},
+  {"apostrophe", '\''},
+  {"Return", k_keyboard_key_enter},
+
+  {"Shift_L", k_keyboard_key_shift_left},
+  {"Z", 'Z'},
+  {"X", 'X'},
+  {"C", 'C'},
+  {"V", 'V'},
+  {"B", 'B'},
+  {"N", 'N'},
+  {"M", 'M'},
+  {"comma", ','},
+  {"period", '.'},
+  {"slash", '/'},
+  {"Shift_R", k_keyboard_key_shift_right},
+
+  {"Control_L", k_keyboard_key_ctrl_left},
+  {"Meta_L", k_keyboard_key_alt_left},
+  {"space", ' '},
+
+  {"F1", k_keyboard_key_f1},
+  {"F2", k_keyboard_key_f2},
+  {"F3", k_keyboard_key_f3},
+  {"F4", k_keyboard_key_f4},
+  {"F5", k_keyboard_key_f5},
+  {"F6", k_keyboard_key_f6},
+  {"F7", k_keyboard_key_f7},
+  {"F8", k_keyboard_key_f8},
+  {"F9", k_keyboard_key_f9},
+  {"F10", k_keyboard_key_f0},
+  {"F11", k_keyboard_key_f11},
+  {"F12", k_keyboard_key_f12},
+
+  {"Up",  k_keyboard_key_arrow_up},
+  {"Down", k_keyboard_key_arrow_down},
+  {"Left", k_keyboard_key_arrow_left},
+  {"Right", k_keyboard_key_arrow_right},
+
+  {"End", k_keyboard_key_end},
+
+  {NULL},
+};
+
+static int s_keys_mapping_built;
+static uint8_t s_keys_mapping[256];
+
+/* XKeysymToKeycode only returns one keycode - but a keysym can map to multiple
+ * keycodes. So this code does an exhaustive search to find everything.
+ *
+ * There's probably a better way of doing this.
+ */
+static void
+init_mapping(Display* p_display) {
+  const struct mapping_struct* p_mapping;
+  int keycode;
+  int min_keycode;
+  int max_keycode;
+  /* X keycodes are byte values, so 256 entries is sufficient. */
+  KeySym* keysyms_by_keycode[256];
+  int num_keysyms_by_keycode[256];
+
+  (void) XDisplayKeycodes(p_display, &min_keycode, &max_keycode);
+  if ((min_keycode > max_keycode) || (min_keycode < 8) || (max_keycode > 255)) {
+    errx(1, "inexplicable XDisplayKeycodes result");
+  }
+
+  /* XGetKeyboardMapping took long enough on my Mac that it seems to be worth
+   * calling it for each keycode outside the loop. (The endless calls to
+   * XKeysymToString in the inner loop below, on the other hand, aren't
+   * obviously causing a problem.)
+   */
+  for (keycode = min_keycode; keycode <= max_keycode; ++keycode) {
+    keysyms_by_keycode[keycode] = XGetKeyboardMapping(p_display,
+                                                      keycode,
+                                                      1,
+                                                      &num_keysyms_by_keycode[keycode]);
+  }
+
+  for (p_mapping = s_x_keys_mapping;
+       p_mapping->p_x_key_name != NULL;
+       ++p_mapping) {
+    int found_x_key = 0;
+
+    for (keycode = min_keycode; keycode <= max_keycode; ++keycode) {
+      int i;
+      const KeySym *keysyms = keysyms_by_keycode[keycode];
+
+      for (i = 0; i < num_keysyms_by_keycode[keycode]; ++i) {
+        const char *keysym_name = XKeysymToString(keysyms[i]);
+        if (keysym_name != NULL) {
+          if (strcmp(keysym_name, p_mapping->p_x_key_name) == 0) {
+            /* Can multiple keysyms map to the same keycode? Should probably
+             * print a warning if that happens. */
+            s_keys_mapping[keycode] = p_mapping->key;
+
+            found_x_key = 1;
+
+            /* Continue checking key codes. The same X key name might map to
+             * multiple physical keys.
+             */
+            break;
+          }
+        }
+      }
+    }
+
+    if (!found_x_key) {
+      /* Not an error... right? This key presumably just isn't on the
+       * keyboard.
+       */
+      log_do_log(k_log_misc, k_log_info, "X key not available: %s", p_mapping->p_x_key_name);
+    }
+  }
+
+  for (keycode = min_keycode; keycode <= max_keycode; ++keycode) {
+    (void) XFree(keysyms_by_keycode[keycode]);
+    keysyms_by_keycode[keycode] = NULL;
+  }
+}
+
+uint8_t*
+os_x11_keys_get_mapping(void* display) {
+  if (!s_keys_mapping_built) {
+    init_mapping(display);
+
+    s_keys_mapping_built = 1;
+  }
+
+  return s_keys_mapping;
+}

os_x11_keys_linux.c

@@ -223,7 +223,9 @@ os_x11_keys_build_mapping() {
 }
 
 uint8_t*
-os_x11_keys_get_mapping() {
+os_x11_keys_get_mapping(void* p_display) {
+  (void) p_display;
+
   if (!g_keys_mapping_built) {
     os_x11_keys_build_mapping();
     g_keys_mapping_built = 1;