Changeset 9991 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Jun 27, 2008 11:58:47 AM (16 years ago)

Author:

vboxsync

Message:

FE/Qt3 and 4: added a second algorithm for detecting host keyboard layout

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (1 diff)
• src/linux/XKeyboard-new.cpp (modified) (4 diffs)
• src/linux/keyboard-new.c (modified) (7 diffs)
• src/linux/keyboard-types.h (added)
• src/linux/keyboard.h (modified) (1 diff)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -129 +129 @@
         src/linux/keyboard-list.h \
         src/linux/keyboard-tables.h \
+        src/linux/keyboard-types.h \
         src/linux/Makefile
 VBoxKeyboard_LIBS     = X11

trunk/src/VBox/Frontends/VirtualBox/src/linux/XKeyboard-new.cpp

@@ -24 +24 @@
 
 #include <X11/Xlib.h>
+#include <X11/keysym.h>
 #include <XKeyboard.h>
 #include <VBox/log.h>
 #include "keyboard.h"
 
-static bool gInitStatus = false;
+static unsigned gfByLayoutOK = 1;
+static unsigned gfByTypeOK = 1;
 
 /**
@@ -77 +79 @@
 /**
  * DEBUG function
- * Dump the keyboard layout to the release log.  The result will only make
- * sense if the user is using an X.org or XFree86 server locally.
+ * Dump the keyboard layout to the release log.
  */
 static void dumpLayout(Display *display)
 {
-    LogRel(("Your keyboard layout does not appear to fully supported by VirtualBox.  "
-            "If you would like to help us improve the product, please submit a "
-            "bug report and attach this logfile.  Please note that the following "
-            "table will only be valid if you are using an X.org or XFree86 server "
-            "locally.\n\nThe correct table for your layout is:\n"));
-    LogRel(("\""));
-    printKey(display, 49);
-    for (int i = 10; i <= 21; ++i)
-    {
-        LogRel(("\",\""));
-        printKey(display, i);
+    LogRel(("Your keyboard layout does not appear to fully supported by\n"
+            "VirtualBox. If you would like to help us improve the product,\n"
+            "please submit a bug report and attach this logfile.\n\n"
+            "The correct table for your layout is:\n"));
+    /* First, build up a table of scan-to-key code mappings */
+    unsigned scanToKeycode[512] = { 0 };
+    int minKey, maxKey;
+    XDisplayKeycodes(display, &minKey, &maxKey);
+    for (int i = minKey; i < maxKey; ++i)
+        scanToKeycode[X11DRV_KeyEvent(i)] = i;
+    LogRel(("\""));
+    printKey(display, scanToKeycode[0x29]); /* `~ */
+    for (int i = 2; i <= 0xd; ++i) /* 1! - =+ */
+    {
+        LogRel(("\",\""));
+        printKey(display, scanToKeycode[i]);
     }
     LogRel(("\",\n"));
     LogRel(("\""));
-    printKey(display, 24);
-    for (int i = 25; i <= 35; ++i)
-    {
-        LogRel(("\",\""));
-        printKey(display, i);
+    printKey(display, scanToKeycode[0x10]); /* qQ */
+    for (int i = 0x11; i <= 0x1b; ++i) /* wW - ]} */
+    {
+        LogRel(("\",\""));
+        printKey(display, scanToKeycode[i]);
     }
     LogRel(("\",\n"));
     LogRel(("\""));
-    printKey(display, 38);
-    for (int i = 39; i <= 48; ++i)
-    {
-        LogRel(("\",\""));
-        printKey(display, i);
-    }
-    LogRel(("\",\""));
-    printKey(display, 51);
+    printKey(display, scanToKeycode[0x1e]); /* aA */
+    for (int i = 0x1f; i <= 0x28; ++i) /* sS - '" */
+    {
+        LogRel(("\",\""));
+        printKey(display, scanToKeycode[i]);
+    }
+    LogRel(("\",\""));
+    printKey(display, scanToKeycode[0x2b]); /* \| */
     LogRel(("\",\n"));
     LogRel(("\""));
-    printKey(display, 52);
-    for (int i = 53; i <= 61; ++i)
-    {
-        LogRel(("\",\""));
-        printKey(display, i);
-    }
-    LogRel(("\",\""));
-    printKey(display, 94); /* The 102nd key */
-    LogRel(("\",\""));
-    printKey(display, 211); /* The Brazilian key */
-    LogRel(("\",\""));
-    printKey(display, 133); /* The Yen key */
+    printKey(display, scanToKeycode[0x2c]); /* zZ */
+    for (int i = 0x2d; i <= 0x35; ++i) /* xX - /? */
+    {
+        LogRel(("\",\""));
+        printKey(display, scanToKeycode[i]);
+    }
+    LogRel(("\",\""));
+    printKey(display, scanToKeycode[0x56]); /* The 102nd key */
+    LogRel(("\",\""));
+    printKey(display, scanToKeycode[0x73]); /* The Brazilian key */
+    LogRel(("\",\""));
+    printKey(display, scanToKeycode[0x7d]); /* The Yen key */
     LogRel(("\"\n\n"));
+}
+
+/**
+ * DEBUG function
+ * Dump the keyboard type tables to the release log.
+ */
+static void dumpType(Display *display)
+{
+    LogRel(("Your keyboard type does not appear to be known to VirtualBox. If\n"
+            "you would like to help us improve the product, please submit a bug\n"
+            "report, attach this logfile and provide information about what type\n"
+            "of keyboard you have and whether you are using a remote X server or\n"
+            "something similar.\n\n"
+            "The tables for your keyboard are:\n"));
+    for (unsigned i = 0; i < 256; ++i)
+    {
+        LogRel(("0x%x", X11DRV_KeyEvent(i)));
+        if (i < 255)
+            LogRel((", "));
+        if (15 == (i % 16))
+            LogRel(("\n"));
+    }
+    LogRel(("and\n"));
+    LogRel(("NULL, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x,\n0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x\n",
+            XKeysymToKeycode(display, XK_Control_L),
+            XKeysymToKeycode(display, XK_Shift_L),
+            XKeysymToKeycode(display, XK_Caps_Lock),
+            XKeysymToKeycode(display, XK_Tab),
+            XKeysymToKeycode(display, XK_Escape),
+            XKeysymToKeycode(display, XK_Return),
+            XKeysymToKeycode(display, XK_Up),
+            XKeysymToKeycode(display, XK_Down),
+            XKeysymToKeycode(display, XK_Left),
+            XKeysymToKeycode(display, XK_Right),
+            XKeysymToKeycode(display, XK_F1),
+            XKeysymToKeycode(display, XK_F2),
+            XKeysymToKeycode(display, XK_F3),
+            XKeysymToKeycode(display, XK_F4),
+            XKeysymToKeycode(display, XK_F5),
+            XKeysymToKeycode(display, XK_F6),
+            XKeysymToKeycode(display, XK_F7),
+            XKeysymToKeycode(display, XK_F8)));
 }
 
@@ -140 +188 @@
 bool initXKeyboard(Display *dpy)
 {
-    if (0 != X11DRV_InitKeyboard(dpy))
-    {
-        /* The layout found was optimal. */
-        gInitStatus = true;
-    }
+    X11DRV_InitKeyboard(dpy, &gfByLayoutOK, &gfByTypeOK);
+    /* It will almost always work to some extent */
     return true;
 }
@@ -153 +198 @@
 void doXKeyboardLogging(Display *dpy)
 {
-    if (!gInitStatus)
-    {
+    if ((gfByLayoutOK != 1) && (1 == gfByTypeOK))
         dumpLayout(dpy);
-    }
+    if ((1 == gfByLayoutOK) && (gfByTypeOK != 1))
+        dumpType(dpy);
+    if ((gfByLayoutOK != 1) && (gfByTypeOK != 1))
+        LogRel(("Failed to recognize the keyboard mapping or to guess it based on\n"
+                "the keyboard layout.  It is very likely that some keys will not\n"
+                "work correctly in the guest.  If you would like to help us improve\n"
+                "the product, please submit a bug report, giving us information\n"
+                "about your keyboard type, its layout and other relevant\n"
+                "information such as whether you are using a remote X server or\n"
+                "something similar.\n"));
 }
 

trunk/src/VBox/Frontends/VirtualBox/src/linux/keyboard-new.c

@@ -46 +46 @@
 #include <stdio.h>
 
+/** 
+ * Array containing the current mapping of keycodes to scan codes, detected
+ * using the keyboard layout algorithm in X11DRV_InitKeyboardByLayout.
+ */
 static unsigned keyc2scan[256];
+/** 
+ * Whether a keyboard was detected with a well-known keycode to scan code
+ * mapping.
+ */
+static unsigned use_builtin_table = 0;
+/** The index of the well-known keycode to scan code mapping in our table. */
+static unsigned builtin_table_number;
+/** Whether to output basic debugging information to standard output */
 static int log_kb_1 = 0;
+/** Whether to output verbose debugging information to standard output */
 static int log_kb_2 = 0;
 
+/** Output basic debugging information if wished */
 #define LOG_KB_1(a) \
 do { \
@@ -57 +71 @@
 } while (0)
 
+/** Output verbose debugging information if wished */
 #define LOG_KB_2(a) \
 do { \
@@ -64 +79 @@
 } while (0)
 
-/* Keyboard layout tables for guessing the current keyboard layout. */
+/** Keyboard layout tables for guessing the current keyboard layout. */
 #include "keyboard-tables.h"
 
+/** Tables of keycode to scan code mappings for well-known keyboard types. */
+#include "keyboard-types.h"
+
 /**
-  * Translate a keycode in a key event to a scan code, using the lookup
-  * table which we constructed earlier.
+  * Translate a keycode in a key event to a scan code, using the lookup table
+  * which we constructed earlier or a well-known mapping from our mapping
+  * table.
   *
-  * @returns the scan code number
+  * @returns the scan code number, with 0x100 added for extended scan codes
   * @param code the X11 key code to be looked up
   */
@@ -77 +96 @@
 unsigned X11DRV_KeyEvent(KeyCode code)
 {
-    return keyc2scan[code];
+    unsigned key;
+    if (use_builtin_table != 0)
+        key = main_keyboard_type_scans[builtin_table_number][code];
+    else
+        key = keyc2scan[code];
+    return key;
 }
 
-/**********************************************************************
- *              X11DRV_KEYBOARD_DetectLayout
- *
- * Called from X11DRV_InitKeyboard
- *  This routine walks through the defined keyboard layouts and selects
- *  whichever matches most closely.
+/**
+ * Called from X11DRV_InitKeyboardByLayout
+ *  See the comments for that function for a description what this function
+ *  does.
  *
  * @returns an index into the table of keyboard layouts, or 0 if absolutely
@@ -214 +236 @@
 
 /**
- * Initialise the X11 keyboard driver.  In practice, this means building
- * up an internal table to map X11 keycodes to their equivalent PC scan
- * codes.
+ * Initialise the X11 keyboard driver by building up a table to convert X11
+ * keycodes to scan codes using a heuristic based on comparing the current
+ * keyboard map to known international keyboard layouts.
+ * The basic idea is to examine each key in the current layout to see which
+ * characters it produces in its normal and its "shifted" state, and to look
+ * for known keyboard layouts which it could belong to.  We then guess the
+ * current layout based on the number of matches we find.
+ * One difficulty with this approach is so-called Dvorak layouts, which are
+ * identical to non-Dvorak layouts, but with the keys in a different order.
+ * To deal with this, we compare the different candidate layouts to see in
+ * which one the X11 keycodes would be most sequential and hope that they
+ * really are layed out more or less sequentially.
+ * 
+ * The actual detection of the current layout is done in the sub-function
+ * X11DRV_KEYBOARD_DetectLayout.  Once we have determined the layout, since we 
+ * know which PC scan code corresponds to each key in the layout, we can use
+ * this information to associate the scan code with an X11 keycode, which is
+ * what the rest of this function does.
  *
  * @warning not re-entrant
@@ -223 +260 @@
  * @param   display a pointer to the X11 display
  */
-int X11DRV_InitKeyboard(Display *display)
+static unsigned
+X11DRV_InitKeyboardByLayout(Display *display)
 {
     KeySym keysym;
@@ -332 +370 @@
     return 1;
 }
+
+static unsigned
+X11DRV_InitKeyboardByType(Display *display)
+{
+    unsigned i = 0, found = 0;
+    
+    for (; (main_keyboard_type_list[i].comment != NULL) && (0 == found); ++i)
+        if (   (XKeysymToKeycode(display, XK_Control_L) == main_keyboard_type_list[i].lctrl)
+            && (XKeysymToKeycode(display, XK_Shift_L)   == main_keyboard_type_list[i].lshift)
+            && (XKeysymToKeycode(display, XK_Caps_Lock) == main_keyboard_type_list[i].capslock)
+            && (XKeysymToKeycode(display, XK_Tab)       == main_keyboard_type_list[i].tab)
+            && (XKeysymToKeycode(display, XK_Escape)    == main_keyboard_type_list[i].esc)
+            && (XKeysymToKeycode(display, XK_Return)    == main_keyboard_type_list[i].enter)
+            && (XKeysymToKeycode(display, XK_Up)        == main_keyboard_type_list[i].up)
+            && (XKeysymToKeycode(display, XK_Down)      == main_keyboard_type_list[i].down)
+            && (XKeysymToKeycode(display, XK_Left)      == main_keyboard_type_list[i].left)
+            && (XKeysymToKeycode(display, XK_Right)     == main_keyboard_type_list[i].right)
+            && (XKeysymToKeycode(display, XK_F1)        == main_keyboard_type_list[i].f1)
+            && (XKeysymToKeycode(display, XK_F2)        == main_keyboard_type_list[i].f2)
+            && (XKeysymToKeycode(display, XK_F3)        == main_keyboard_type_list[i].f3)
+            && (XKeysymToKeycode(display, XK_F4)        == main_keyboard_type_list[i].f4)
+            && (XKeysymToKeycode(display, XK_F5)        == main_keyboard_type_list[i].f5)
+            && (XKeysymToKeycode(display, XK_F6)        == main_keyboard_type_list[i].f6)
+            && (XKeysymToKeycode(display, XK_F7)        == main_keyboard_type_list[i].f7)
+            && (XKeysymToKeycode(display, XK_F8)        == main_keyboard_type_list[i].f8)
+           )
+            found = 1;
+    use_builtin_table = found;
+    if (found != 0)
+        builtin_table_number = i - 1;
+    return found;
+}
+
+/**
+ * Initialise the X11 keyboard driver by finding which X11 keycodes correspond
+ * to which PC scan codes.  If the keyboard being used is not a PC keyboard,
+ * the X11 keycodes will be mapped to the scan codes which the equivalent keys
+ * on a PC keyboard would use.
+ * 
+ * We use two algorithms to try to determine the mapping.  See the comments
+ * attached to the two algorithm functions (X11DRV_InitKeyboardByLayout and
+ * X11DRV_InitKeyboardByType) for descriptions of the algorithms used.  Both
+ * functions tell us on return whether they think that they have correctly
+ * determined the mapping.  If both functions claim to have determined the
+ * mapping correctly, we prefer the second (ByType).  However, if neither does
+ * then we prefer the first (ByLayout), as it produces a fuzzy result which is
+ * still likely to be partially correct.
+ *
+ * @warning not re-entrant
+ * @returns 1 if the layout found was optimal, 0 if it was not.  This is
+ *          for diagnostic purposes
+ * @param   display     a pointer to the X11 display
+ * @param   byLayoutOK  diagnostic - set to one if detection by layout
+ *                      succeeded, and to 0 otherwise
+ * @param   byTypeOK    diagnostic - set to one if detection by type
+ *                      succeeded, and to 0 otherwise
+ */
+unsigned X11DRV_InitKeyboard(Display *display, unsigned *byLayoutOK, unsigned *byTypeOK)
+{
+    unsigned byLayout = X11DRV_InitKeyboardByLayout(display);
+    unsigned byType   = X11DRV_InitKeyboardByType(display);
+    *byLayoutOK = byLayout;
+    *byTypeOK   = byType;
+    return (byLayout || byType) ? 1 : 0;
+}

trunk/src/VBox/Frontends/VirtualBox/src/linux/keyboard.h

@@ -35 +35 @@
 #endif
 #ifdef VBOX_HAVE_VISIBILITY_HIDDEN
-extern CCALL __attribute__((visibility("default"))) int X11DRV_InitKeyboard(Display *dpy);
+extern CCALL __attribute__((visibility("default"))) unsigned X11DRV_InitKeyboard(Display *dpy, unsigned *byLayoutOK, unsigned *byTypeOK);
 extern CCALL __attribute__((visibility("default"))) unsigned X11DRV_KeyEvent(KeyCode code);
 #else
-extern CCALL int X11DRV_InitKeyboard(Display *dpy);
+extern CCALL unsigned X11DRV_InitKeyboard(Display *dpy, unsigned *byLayoutOK, unsigned *byTypeOK);
 extern CCALL unsigned X11DRV_KeyEvent(KeyCode code);
 #endif