keyboard.c revision efa6b167f02f459ba8f35825d999afefff261f78
/* $Id$ */
/** @file
*/
/* This code is originally from the Wine project. */
/*
* X11 keyboard driver
*
* Copyright 1993 Bob Amstadt
* Copyright 1996 Albrecht Kleine
* Copyright 1997 David Faure
* Copyright 1998 Morten Welinder
* Copyright 1998 Ulrich Weigand
* Copyright 1999 Ove K�ven
*
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
/*
* Sun LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
* other than GPL or LGPL is available it will apply instead, Sun elects to use only
* the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
* a choice of LGPL license versions is made available with the language indicating
* that LGPLv2 or any later version may be used, or where a choice of which version
* of the LGPL is applied is otherwise unspecified.
*/
#include <X11/Xresource.h>
#include <ctype.h>
#include <stdarg.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <VBox/VBoxKeyboard.h>
#define KEYC2SCAN_SIZE 256
/**
* Array containing the current mapping of keycodes to scan codes, detected
* using the keyboard layout algorithm in X11DRV_InitKeyboardByLayout.
*/
static unsigned keyc2scan[KEYC2SCAN_SIZE];
/** 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 { \
if (log_kb_1) { \
printf a; \
} \
} while (0)
/** Output verbose debugging information if wished */
#define LOG_KB_2(a) \
do { \
if (log_kb_2) { \
printf a; \
} \
} while (0)
/** 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. If the keycode maps
* to a key symbol which is in the same place on all PC keyboards, look it
* up by symbol in one of our hard-coded translation tables. It it maps to
* a symbol which can be in a different place on different PC keyboards, look
* it up by keycode using either the lookup table which we constructed
* earlier, or using a hard-coded table if we know what type of keyboard is
* in use.
*
* @returns the scan code number, with 0x100 added for extended scan codes
* @param code the X11 key code to be looked up
*/
{
unsigned scan;
scan = 0;
if (keysym != 0) /* otherwise, keycode not used */
{
scan = 0x39;
scan = 0x138;
}
/* Disabled "keysym != 0" as we can now match keycodes with no keysym */
if (/* keysym != 0 && */ scan == 0)
return scan;
}
/**
* 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
* nothing fits
* @param display pointer to the X11 display handle
* @param min_keycode the lowest value in use as a keycode on this server
* @param max_keycode the highest value in use as a keycode on this server
*/
static int
unsigned max_keycode)
{
/** Counter variable for iterating through the keyboard layout tables. */
unsigned current;
/** The best candidate so far for the layout. */
unsigned kbd_layout = 0;
/** The number of matching keys in the current best candidate layout. */
unsigned max_score = 0;
/** The number of changes of scan-code direction in the current
best candidate. */
unsigned max_seq = 0;
/** Table for the current keycode to keysym mapping. */
/** Counter variable representing a keycode */
unsigned keyc;
/* Fill in our keycode to keysym mapping table. */
/* get data for keycodes from X server */
/* We leave keycodes which will definitely not be in the lookup tables
marked with 0 so that we know that we know not to look them up when
we scan the tables. */
) {
}
}
/* Now scan the lookup tables, looking for one that is as close as
possible to our current keycode to keysym mapping. */
/** How many keys have matched so far in this layout? */
unsigned match = 0;
/** How many keys have not changed the direction? */
unsigned seq = 0;
/** Pointer to the layout we are currently comparing against. */
/** For detecting dvorak layouts - in which direction do the server's
keycodes seem to be running? We count the number of times that
this direction changes as an additional hint as to how likely this
layout is to be the right one. */
int direction = 1;
/** The keycode of the last key that we matched. This is used to
determine the direction that the keycodes are running in. */
int pkey = -1;
/** The candidate key in the current layout for this keycode. */
int key;
/** Does this key match? */
int ok = 0;
/* search for a match in layout table */
) {
ok = 1;
}
}
/* count the matches and mismatches */
if (0 != ok) {
match++;
/* How well in sequence are the keys? For dvorak layouts. */
if (1 == direction) {
++seq;
} else {
direction = -1;
}
}
if (1 != direction) {
++seq;
} else {
direction = 1;
}
}
} else {
#ifdef DEBUG
/* print spaces instead of \0's */
}
}
LOG_KB_2(("Mismatch for keycode %d, keysym \"%s\" (0x%.2hx 0x%.2hx)\n",
#endif /* DEBUG defined */
}
}
}
) {
/* best match so far */
}
}
/* we're done, report results if necessary */
LOG_KB_1(("Detected layout is \"%s\", matches=%d, seq=%d\n",
return kbd_layout;
}
/**
* 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
* @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
*/
static unsigned
{
unsigned scan;
int min_keycode, max_keycode;
int kbd_layout;
/* Should we log to standard output? */
log_kb_1 = 1;
}
log_kb_1 = 1;
log_kb_2 = 1;
}
/* according to the space this function is guaranteed to never return
* values for min_keycode < 8 and values for max_keycode > 255 */
if (min_keycode < 0)
min_keycode = 0;
if (max_keycode > 255)
max_keycode = 255;
/* Detect the keyboard layout */
/* Now build a conversion array :
* keycode -> scancode + extended */
{
scan = 0;
if (keysym) /* otherwise, keycode not used */
{
/* Skip over keysyms which we look up on the fly */
) {
unsigned found = 0;
/* we seem to need to search the layout-dependent scancodes */
/* find a key which matches */
) {
found = 1;
}
}
if (0 != found) {
/* got it */
/* We keep track of the number of keys that we found a
* match for to see if the layout is optimal or not.
* We ignore the 102nd key though (key number 48), since
* not all keyboards have it. */
if (keyn != 48)
++matches;
}
if (0 == scan) {
/* print spaces instead of \0's */
}
}
LOG_KB_1(("No match found for keycode %d, keysym \"%s\" (0x%x 0x%x)\n",
/* print spaces instead of \0's */
}
}
LOG_KB_1(("Warning - keycode %d, keysym \"%s\" (0x%x 0x%x) was matched to scancode %d\n",
}
}
}
} /* for */
/* Did we find a match for all keys in the layout? Count them first.
* Note that we skip the 102nd key, so that owners of 101 key keyboards
* don't get bogus messages about bad matches. */
) {
++entries;
}
}
LOG_KB_1(("Finished mapping keyboard, matches=%d, entries=%d (excluding 102nd key)\n", matches, entries));
{
return 0;
}
return 1;
}
{
if (!targetCode)
return 0;
return 0;
return 1;
}
{
return 0;
/* This test is for the people who like to swap control and caps lock */
return 0;
return 0;
return 1;
}
{
int i = 0;
for (; i < cList; ++i)
return i;
return -1;
}
#ifdef DEBUG
static void testFindHostKB(void)
{
12, 13, 14, 15, 16, 17, 18 };
12, 13, 14, 15, 16, 17, 18 };
0, 0, 0, 0, 0, 0, 0 };
0, 0, 0, 0, 0, 0, 18 };
12, 13, 14, 15, 16, 17, 18 };
keyboard_type targetList[] = {
8 /* F1 */, 7, 6, 5, 4, 3, 2, 1 },
11 /* F1 */, 12, 13, 14, 15, 16, 17, 18 }
};
/* As we don't have assertions here, just printf. This should *really*
* never happen. */
printf("ERROR: testFindHostKB: bad structures\n");
printf("ERROR: findHostKBInList failed to find a target in a list\n");
printf("ERROR: findHostKBInList failed on a ctrl-caps swapped map\n");
printf("ERROR: findHostKBInList accepted an empty host map\n");
printf("ERROR: findHostKBInList failed on a partly empty host map\n");
printf("ERROR: findHostKBInList failed to fail a wrong host map\n");
}
#endif
static unsigned
{
int cMap;
#ifdef DEBUG
#endif
sizeof(main_keyboard_type_list)
/ sizeof(main_keyboard_type_list[0]));
#ifdef DEBUG
/* Assertion */
{
printf("ERROR: keyc2scan array size doesn't match main_keyboard_type_scans[]!\n");
return 0;
}
#endif
if (cMap >= 0)
{
return 1;
}
return 0;
}
/**
* Checks for the XKB extension, and if it is found initialises the X11 keycode
* to XT scan code mapping by looking at the XKB names for each keycode.
*/
static unsigned
{
return 0;
return 0;
if (!pKBDesc)
return 0;
return 0;
{
unsigned i, j;
{
break;
}
}
return 1;
}
/**
* 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
* @param byXkbOK diagnostic - set to one if detection using XKB
* succeeded, and to 0 otherwise
* @param remapScancode array of tuples that remap the keycode (first
* part) to a scancode (second part)
*/
int (*remapScancodes)[2])
{
if (byLayoutOK)
*byLayoutOK = byLayout;
if (byTypeOK)
if (byXkbOK)
/* Remap keycodes after initialization. Remapping stops after an
identity mapping is seen */
if (remapScancodes != NULL)
}
/**
* Returns the keycode to scancode array
*/
unsigned *X11DRV_getKeyc2scan(void)
{
return keyc2scan;
}