home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / Xlib_Keyboard.c < prev    next >
C/C++ Source or Header  |  2001-04-26  |  15KB  |  432 lines
  1.  
  2. #include "Xlib_private.h"
  3. #include <X11/keysym.h>
  4.  
  5. /* Responsible for mapping keysyms! */
  6.  
  7. #include "x11pmvk.h"
  8.  
  9. #ifndef XK_EuroSign
  10. #define XK_EuroSign 0x20ac
  11. #endif
  12.  
  13. struct KeyNames_st {
  14.     KeySym    keysym;
  15.     KeyCode    keycode;
  16.     char    col;
  17.     char    *keyname, *keyvalue;
  18. } KeyNames[] = {
  19.     { XK_space,        0xb9,0,            "space",    " " },
  20.     { XK_nobreakspace,    0,0,            "nobreakspace",    "á" },
  21.     { XK_exclam,        '!',0,            "exclam",    "!" },
  22.     { XK_quotedbl,        '"',0,            "quotedbl",    "\"" },
  23.     { XK_numbersign,    '#',0,            "numbersign",    "#" },
  24.     { XK_dollar,        '$',0,            "dollar",    "$" },
  25.     { XK_percent,        '%',0,            "percent",    "%" },
  26.     { XK_ampersand,        '&',0,            "ampersand",    "&" },
  27.     { XK_apostrophe,    39,0,            "apostrophe",    "'" },
  28.     { XK_quoteright,    39,0,            "quoteright",    "'" },
  29.     { XK_parenleft,        '(',0,            "parenleft",    "(" },
  30.     { XK_parenright,    ')',0,            "parenright",    ")" },
  31.     { XK_asterisk,        '*',0,            "asterisk",    "*" },
  32.     { XK_plus,        '+',0,            "plus",        "+" },
  33.     { XK_comma,        ',',0,            "comma",    "," },
  34.     { XK_minus,        '-',0,            "minus",    "-" },
  35.     { XK_period,        '.',0,            "period",    "." },
  36.     { XK_slash,        '/',0,            "slash",    "/" },
  37.     { XK_0,            '0',0,            "0",        "0" },
  38.     { XK_1,            '1',0,            "1",        "1" },
  39.     { XK_2,            '2',0,            "2",        "2" },
  40.     { XK_3,            '3',0,            "3",        "3" },
  41.     { XK_4,            '4',0,            "4",        "4" },
  42.     { XK_5,            '5',0,            "5",        "5" },
  43.     { XK_6,            '6',0,            "6",        "6" },
  44.     { XK_7,            '7',0,            "7",        "7" },
  45.     { XK_8,            '8',0,            "8",        "8" },
  46.     { XK_9,            '9',0,            "9",        "9" },    
  47.     { XK_colon,        ':',0,            "colon",    ":" },
  48.     { XK_semicolon,        ';',0,            "semicolon",    ";" },
  49.     { XK_less,        '<',0,            "less",        "<" },
  50.     { XK_equal,        '=',0,            "equal",    "=" },
  51.     { XK_greater,        '>',0,            "greater",    ">" },
  52.     { XK_question,        '?',0,            "question",    "?" },
  53.     { XK_at,        '@',0,            "at",        "@" },
  54.     { XK_A,            'A',0,            "A",        "A" },
  55.     { XK_A,            0x9e,0,            "A",        "A" },
  56.     { XK_B,            'B',0,            "B",        "B" },
  57.     { XK_B,            0xb0,0,            "B",        "B" },
  58.     { XK_C,            'C',0,            "C",        "C" },
  59.     { XK_C,            0xae,0,            "C",        "C" },
  60.     { XK_D,            'D',0,            "D",        "D" },
  61.     { XK_D,            0xa0,0,            "D",        "D" },
  62.     { XK_E,            'E',0,            "E",        "E" },
  63.     { XK_E,            0x92,0,            "E",        "E" },
  64.     { XK_F,            'F',0,            "F",        "F" },
  65.     { XK_F,            0xa1,0,            "F",        "F" },
  66.     { XK_G,            'G',0,            "G",        "G" },
  67.     { XK_G,            0xa2,0,            "G",        "G" },
  68.     { XK_H,            'H',0,            "H",        "H" },
  69.     { XK_H,            0xa3,0,            "H",        "H" },
  70.     { XK_I,            'I',0,            "I",        "I" },
  71.     { XK_I,            0x97,0,            "I",        "I" },
  72.     { XK_J,            'J',0,            "J",        "J" },
  73.     { XK_J,            0xa4,0,            "J",        "J" },
  74.     { XK_K,            'K',0,            "K",        "K" },
  75.     { XK_K,            0xa5,0,            "K",        "K" },
  76.     { XK_L,            'L',0,             "L",        "L" },
  77.     { XK_L,            0xa6,0,            "L",        "L" },
  78.     { XK_M,            'M',0,            "M",        "M" },
  79.     { XK_M,            0xb2,0,            "M",        "M" },
  80.     { XK_N,            'N',0,            "N",        "N" },
  81.     { XK_N,            0xb1,0,            "N",        "N" },
  82.     { XK_O,            'O',0,            "O",        "O" },
  83.     { XK_O,            0x98,0,            "O",        "O" },
  84.     { XK_P,            'P',0,            "P",        "P" },
  85.     { XK_P,            0x99,0,            "P",        "P" },
  86.     { XK_Q,            'Q',0,            "Q",        "Q" },
  87.     { XK_Q,            0x90,0,            "Q",        "Q" },
  88.     { XK_R,            'R',0,            "R",        "R" },
  89.     { XK_R,            0x93,0,            "R",        "R" },
  90.     { XK_S,            'S',0,            "S",        "S" },
  91.     { XK_S,            0x9f,0,            "S",        "S" },
  92.     { XK_T,            'T',0,            "T",        "T" },
  93.     { XK_T,            0x94,0,            "T",        "T" },
  94.     { XK_U,            'U',0,            "U",        "U" },
  95.     { XK_U,            0x96,0,            "U",        "U" },
  96.     { XK_V,            'V',0,            "V",        "V" },
  97.     { XK_V,            0xaf,0,            "V",        "V" },
  98.     { XK_W,            'W',0,            "W",        "W" },
  99.     { XK_W,            0x91,0,            "W",        "W" },
  100.     { XK_X,            'X',0,            "X",        "X" },
  101.     { XK_X,            0xad,0,            "X",        "X" },
  102.     { XK_Y,            'Y',0,            "Y",        "Y" },
  103.     { XK_Y,            0x95,0,            "Y",        "Y" },
  104.     { XK_Z,            'Z',0,            "Z",        "Z" },
  105.     { XK_Z,            0xac,0,            "Z",        "Z" },
  106.     { XK_bracketleft,    '[',0,            "bracketleft",    "[" },
  107.     { XK_backslash,        '\\',0,            "backslash",    "\\" },
  108.     { XK_bracketright,    ']',0,            "bracketright",    "]" },
  109.     { XK_asciicircum,    '^',0,            "asciicircum",    "^" },
  110.     { XK_underscore,    '_',0,            "underscore",    "_" },
  111.     { XK_grave,        '`',0,            "grave",    "`" },
  112.     { XK_quoteleft,        '`',0,            "quoteleft",    "`" },
  113.     { XK_a,            'a',0,            "a",        "a" },
  114.     { XK_b,            'b',0,            "b",        "b" },
  115.     { XK_c,            'c',0,            "c",        "c" },
  116.     { XK_d,            'd',0,            "d",        "d" },
  117.     { XK_e,            'e',0,            "e",        "e" },
  118.     { XK_f,            'f',0,            "f",        "f" },
  119.     { XK_g,            'g',0,            "g",        "g" },
  120.     { XK_h,            'h',0,            "h",        "h" },
  121.     { XK_i,            'i',0,            "i",        "i" },
  122.     { XK_j,            'j',0,            "j",        "j" },
  123.     { XK_k,            'k',0,            "k",        "k" },
  124.     { XK_l,            'l',0,            "l",        "l" },
  125.     { XK_m,            'm',0,            "m",        "m" },
  126.     { XK_n,            'n',0,            "n",        "n" },
  127.     { XK_o,            'o',0,            "o",        "o" },
  128.     { XK_p,            'p',0,            "p",        "p" },
  129.     { XK_q,            'q',0,            "q",        "q" },
  130.     { XK_r,            'r',0,            "r",        "r" },
  131.     { XK_s,            's',0,            "s",        "s" },
  132.     { XK_t,            't',0,            "t",        "t" },
  133.     { XK_u,            'u',0,            "u",        "u" },
  134.     { XK_v,            'v',0,            "v",        "v" },
  135.     { XK_w,            'w',0,            "w",        "w" },
  136.     { XK_x,            'x',0,            "x",        "x" },
  137.     { XK_y,            'y',0,            "y",        "y" },
  138.     { XK_z,            'z',0,            "z",        "z" },
  139.     { XK_braceleft,        '{',0,            "braceleft",    "{" },
  140.     { XK_bar,        '|',0,            "bar",        "|" },
  141.     { XK_braceright,    '}',0,            "braceright",    "}" },
  142.     { XK_asciitilde,    '~',0,            "asciitilde",    "~" },
  143.     { XK_Shift_L,        0xaa,0,            "Shift_L" },
  144.     { XK_Shift_R,        0xb6,0,            "Shift_R" },
  145.     { XK_Control_L,        0x9d,0,            "Control_L" },
  146.     { XK_Control_R,        0xdb,0,            "Control_R" },
  147.     { XK_Alt_L,        0xb8,0,            "Alt_L" },
  148.     { XK_Alt_R,        0xde,0,            "Alt_R" },
  149.     { XK_Caps_Lock,        0xba,0,            "Caps_Lock" },
  150.     { XK_BackSpace,     0x08,0,            "BackSpace" },
  151.     { XK_Tab,        0x09,0,            "Tab" },
  152.     { XK_Tab,        0x8f,0,            "Tab" },
  153.     { XK_KP_Tab,        0x09,0,            "KP_Tab" },
  154.     { XK_Linefeed,        0x0a,0,            "Linefeed" },
  155.     { XK_Clear,        0,0,            "Clear" },
  156.     { XK_Return,        0x0d,0,            "Return" },
  157.     { XK_Return,        0x9c,0,            "Return" },
  158.     { XK_Select,        0,0,            "Select" },
  159.     { XK_Pause,        0xdf,0,            "Pause" },
  160.     { XK_Scroll_Lock,    0xc6,0,            "Scroll_Lock" },
  161.     { XK_Sys_Req,        0xd4,0,            "Sys_Req" },
  162.     { XK_Escape,        0x81,0,            "Escape" },
  163.     { XK_Delete,        0xe9,0,            "Delete" },
  164.     { XK_Home,        0xe0,0,            "Home" },
  165.     { XK_Left,        0xe3,0,            "Left" },
  166.     { XK_Up,        0xe1,0,            "Up" },
  167.     { XK_Right,        0xe4,0,            "Right" },
  168.     { XK_Down,        0xe6,0,            "Down" },
  169.     { XK_Page_Up,        0xe2,0,            "Page_Up" },
  170.     { XK_Prior,        0xe2,0,            "Prior" },
  171.     { XK_Page_Down,        0xe7,0,            "Page_Down" },
  172.     { XK_Next,        0xe7,0,            "Next" },
  173.     { XK_End,        0xe5,0,            "End" },
  174.     { XK_Print,        0xdd,0,            "Print" },
  175.     { XK_Insert,        0xe8,0,            "Insert" },
  176.     { XK_Menu,        0,0,            "Menu" },
  177.     { XK_Break,        0xee,0,            "Break" },
  178.     { XK_Num_Lock,        0xc5,0,            "Num_Lock" },
  179.     { XK_KP_Decimal,    0xd3,0,            "KP_Decimal",    "." },
  180.     { XK_KP_0,        0xd2,0,            "KP_0",        "0" },
  181.     { XK_KP_1,        0xcf,0,            "KP_1",        "1" },
  182.     { XK_KP_2,        0xd0,0,            "KP_2",        "2" },
  183.     { XK_KP_3,        0xd1,0,            "KP_3",        "3" },
  184.     { XK_KP_4,        0xcb,0,            "KP_4",        "4" },
  185.     { XK_KP_5,        0xcc,0,            "KP_5",        "5" },
  186.     { XK_KP_6,        0xcd,0,            "KP_6",        "6" },
  187.     { XK_KP_7,        0xc7,0,            "KP_7",        "7" },
  188.     { XK_KP_8,        0xc8,0,            "KP_8",        "8" },
  189.     { XK_KP_9,        0xc9,0,            "KP_9",        "9" },
  190.     { XK_KP_Delete,        0x53,2,            "KP_Delete" },
  191.     { XK_KP_Insert,        0x52,2,            "KP_Insert" },
  192.     { XK_KP_End,        0x4f,2,            "KP_End" },
  193.     { XK_KP_Down,        0x50,2,            "KP_Down" },
  194.     { XK_KP_Page_Down,    0x51,2,            "KP_Page_Down" },
  195.     { XK_KP_Next,        0x51,2,            "KP_Next" },
  196.     { XK_KP_Left,        0x4b,2,            "KP_Left" },
  197.     { XK_KP_Right,        0x4d,2,            "KP_Right" },
  198.     { XK_KP_Home,        0x47,2,            "KP_Home" },
  199.     { XK_KP_Up,        0x48,2,            "KP_Up" },
  200.     { XK_KP_Page_Up,    0x49,2,            "KP_Page_Up" },
  201.     { XK_KP_Prior,        0x49,2,            "KP_Prior" },
  202.     { XK_KP_Divide,        0xdc,0,            "KP_Divide",    "/" },
  203.     { XK_KP_Multiply,    0xb7,0,            "KP_Multiply",    "*" },
  204.     { XK_KP_Subtract,    0xca,0,            "KP_Subtract",    "-" },
  205.     { XK_KP_Add,        0xce,0,            "KP_Add",    "+" },
  206.     { XK_KP_Enter,        0xda,0,            "KP_Enter" },
  207.     { XK_KP_Equal,        0xda,0,            "KP_Equal" },
  208.     { XK_F1,        0xbb,0,            "F1" },
  209.     { XK_F2,        0xbc,0,            "F2" },
  210.     { XK_F3,        0xbd,0,            "F3" },
  211.     { XK_F4,        0xbe,0,            "F4" },
  212.     { XK_F5,        0xbf,0,            "F5" },
  213.     { XK_F6,        0xc0,0,            "F6" },
  214.     { XK_F7,        0xc1,0,            "F7" },
  215.     { XK_F8,        0xc2,0,            "F8" },
  216.     { XK_F9,        0xc3,0,            "F9" },
  217.     { XK_F10,        0xc4,0,            "F10" },
  218.     { XK_F11,        0xd7,0,            "F11" },
  219.     { XK_F12,        0xd8,0,            "F12" },
  220.     /* High ASCII KeyCodes */
  221.     { XK_EuroSign,        0xd5,2,            "EuroSign",    "╒" },    
  222.     { XK_exclamdown,    '¡',2,            "exclamdown",    "í" },
  223.     { XK_cent,        '╜',2,            "cent",        "ó" },
  224.     { XK_sterling,        '£',2,            "sterling",    "ú" },
  225.     { XK_currency,        '╧',2,            "currency",    "ñ" },
  226.     { XK_yen,        '╛',2,            "yen",        "Ñ" },
  227.     { XK_brokenbar,        '▌',2,            "brokenbar",    "ª" },
  228.     { XK_section,        '⌡',2,            "section",    "º" },
  229.     { XK_diaeresis,        '∙',2,            "diaeresis",    "¿" },
  230.     { XK_copyright,        '╕',2,            "copyright",    "⌐" },
  231.     { XK_ordfeminine,    'ª',2,            "ordfemine",    "¬" },
  232.     { XK_guillemotleft,    '«',2,            "guillemotleft","½" },
  233.     { XK_notsign,        '¬',2,            "notsign",    "¼" },
  234.     { XK_hyphen,        '≡',2,            "hyphen",    "¡" },
  235.     { XK_registered,    '⌐',2,            "registered",    "«" },
  236.     { XK_macron,        0,0,            "macron",    "»" },
  237.     { XK_degree,        '°',2,            "degree",    "░" },
  238.     { XK_plusminus,        '±',2,            "plusminus",    "▒" },
  239.     { XK_twosuperior,    '²',2,            "twosuperior",    "▓" },
  240.     { XK_threesuperior,    'ⁿ',2,            "threesuperior","│" },
  241.     { XK_acute,        '∩',2,            "acute",    "┤" },
  242.     { XK_mu,        'µ',2,            "mu",        "╡" },
  243.     { XK_paragraph,        '⌠',2,            "paragraph",    "╢" },
  244.     { XK_periodcentered,    '·',2,            "periodcentered","╖" },
  245.     { XK_cedilla,        '≈',2,            "cedilla",    "╕" },
  246.     { XK_onesuperior,    '√',2,            "onesuperior",    "╣" },
  247.     { XK_masculine,        0,0,            "masculine",    "║" },
  248.     { XK_guillemotright,    '»',2,            "guillemotright","╗" },
  249.     { XK_onequarter,    '¼',2,            "onequarter",    "╝" },
  250.     { XK_onehalf,        '½',2,            "onehalf",    "╜" },
  251.     { XK_threequarters,    '≤',2,            "threequarters","╛" },
  252.     { XK_questiondown,    '¿',2,            "questiondown",    "┐" },
  253.     { XK_Agrave,        '╖',2,            "Agrave",    "└" },
  254.     { XK_Aacute,        '╡',2,            "Aacute",    "┴" },
  255.     { XK_Acircumflex,    '╢',2,            "Acircumflex",    "┬" },
  256.     { XK_Atilde,        '╟',2,            "Atilde",    "├" },
  257.     { XK_Adiaeresis,    'Ä',2,            "Adiaeresis",    "─" },
  258.     { XK_Aring,        'Å',2,            "Aring",    "┼" },
  259.     { XK_AE,        'Æ',2,            "AE",        "╞" },
  260.     { XK_Ccedilla,        'Ç',2,            "Ccedilla",    "╟" },
  261.     { XK_Egrave,        '╘',2,            "Egrave",    "╚" },
  262.     { XK_Eacute,        'É',2,            "Eacute",    "╔" },
  263.     { XK_Ecircumflex,    '╥',2,            "Ecircumflex",    "╩" },
  264.     { XK_Ediaeresis,    '╙',2,            "Ediaeresis",    "╦" },
  265.     { XK_Igrave,        '▐',2,            "Igrave",    "╠" },
  266.     { XK_Iacute,        '╓',2,            "Iacute",    "═" },
  267.     { XK_Icircumflex,    '╫',2,            "Icircumflex",    "╬" },
  268.     { XK_Idiaeresis,    '╪',2,            "Idiaeresis",    "╧" },
  269.     { XK_ETH,        0,0,            "ETH",        "╨" },
  270.     { XK_Ntilde,        'Ñ',2,            "Ntilde",    "╤" },
  271.     { XK_Ograve,        'π',2,            "Ograve",    "╥" },
  272.     { XK_Oacute,        'α',2,            "Oacute",    "╙" },
  273.     { XK_Ocircumflex,    'Γ',2,            "Ocircumflex",    "╘" },
  274.     { XK_Otilde,        'σ',2,            "Otilde",    "╒" },
  275.     { XK_Odiaeresis,    'Ö',2,            "Odiaeresis",    "╓" },
  276.     { XK_multiply,        '₧',2,            "multiply",    "╫" },
  277.     { XK_Ooblique,        '¥',2,            "Ooblique",    "╪" },
  278.     { XK_Ugrave,        'δ',2,            "Ugrave",    "┘" },
  279.     { XK_Uacute,        'Θ',2,            "Uacute",    "┌" },
  280.     { XK_Ucircumflex,    'Ω',2,            "Ucircumflex",    "█" },
  281.     { XK_Udiaeresis,    'Ü',2,            "Udiaeresis",    "▄" },
  282.     { XK_Yacute,        'φ',2,            "Yacute",    "▌" },
  283.     { XK_THORN,        0,0,            "THORN",    "▐" },
  284.     { XK_ssharp,        0,0,            "ssharp",    "▀" },
  285.     { XK_agrave,        'à',2,            "agrave",    "α" },
  286.     { XK_aacute,        'á',2,            "aacute",    "ß" },
  287.     { XK_acircumflex,    'â',2,            "acircumflex",    "Γ" },
  288.     { XK_atilde,        '╞',2,            "atilde",    "π" },
  289.     { XK_adiaeresis,    'ä',2,            "adiaeresis",    "Σ" },
  290.     { XK_aring,        'å',2,            "aring",    "σ" },
  291.     { XK_ae,        'æ',2,            "ae",        "µ" },
  292.     { XK_ccedilla,        'ç',2,            "ccedilla",    "τ" },
  293.     { XK_egrave,        'è',2,            "egrave",    "Φ" },
  294.     { XK_eacute,        'é',2,            "eacute",    "Θ" },
  295.     { XK_ecircumflex,    'ê',2,            "ecircumflex",    "Ω" },
  296.     { XK_ediaeresis,    'ë',2,            "ediaeresis",    "δ" },
  297.     { XK_igrave,        'ì',2,            "igrave",    "∞" },
  298.     { XK_iacute,        'í',2,            "iacute",    "φ" },
  299.     { XK_icircumflex,    'î',2,            "icircumflex",    "ε" },
  300.     { XK_idiaeresis,    'ï',2,            "idiaeresis",    "∩" },
  301.     { XK_eth,        0,0,            "eth",        "≡" },
  302.     { XK_ntilde,        'ñ',2,            "ntilde",    "±" },
  303.     { XK_ograve,        'ò',2,            "ograve",    "≥" },
  304.     { XK_oacute,        'ó',2,            "oacute",    "≤" },
  305.     { XK_ocircumflex,    'ô',2,            "ocircumflex",    "⌠" },
  306.     { XK_otilde,        'Σ',2,            "otilde",    "⌡" },
  307.     { XK_odiaeresis,    'ö',2,            "odiaeresis",    "÷" },
  308.     { XK_division,        '÷',2,            "division",    "≈" },
  309.     { XK_oslash,        '¢',2,            "oslash",    "°" },
  310.     { XK_ugrave,        'ù',2,            "ugrave",    "∙" },
  311.     { XK_uacute,        'ú',2,            "uacute",    "·" },
  312.     { XK_ucircumflex,    'û',2,            "ucircumflex",    "√" },
  313.     { XK_udiaeresis,    'ü',2,            "udiaeresis",    "ⁿ" },
  314.     { XK_yacute,        '∞',2,            "yacute",    "²" },
  315.     { XK_thorn,        0,0,            "thorn",    "■" },
  316.     { XK_ydiaeresis,    'ÿ',2,            "ydiaeresis",    " " },
  317.     { XK_Kanji,        0,0,            "Kanji" },
  318.     /* Special KeySyms */
  319. #if 0
  320.     { XK_blank,        ' ',0            "blank",    " " },
  321.     { XK_soliddiamond,    4,0,            "soliddiamond",    "\004" },
  322.     { XK_checkerboard,    177,2,            "checkerboard" },
  323.     { XK_ht,        9,0,            "ht",        "\011" },
  324.     { XK_ff,        12,0,            "ff",        "\014" },
  325.     { XK_cr,        13,0,            "cr",        "\015" },
  326.     { XK_lf,        10,0,            "lf",        "\012" },
  327.     { XK_vt,        11,0,            "vt",        "\013" },
  328. #endif
  329.     /* Special codes */
  330.     { XK_Mode_switch,    17,0,            "Mode_switch" },
  331.     { 0,            0,0,            NULL },
  332. };
  333.  
  334.  
  335. #define KEYSYM_PER_CODE 4
  336. KeySym *_XkeyMap = NULL, *_XkeyMap_end = NULL;
  337. char * _XkeyTable[1];
  338. unsigned int _XmaxKeyCode, _XminKeyCode;
  339.  
  340. void _XInitKeyMapping(void)
  341. {
  342.     DBUG_ENTER("_XInitKeyMapping")
  343.     int idx;
  344.     unsigned int keycode, maxcode = 0, mincode = 0xfffffff, size;
  345.  
  346.     if (_XkeyMap) DBUG_VOID_RETURN;
  347.  
  348.     for (idx = 0; KeyNames[idx].keyname; idx++) 
  349.     if ((keycode = KeyNames[idx].keycode)) {
  350.         if (maxcode < keycode) maxcode = keycode;
  351.         if (mincode > keycode) mincode = keycode;
  352.     }
  353.  
  354.     _XmaxKeyCode = maxcode;
  355.     _XminKeyCode = mincode;
  356.  
  357.     size = (maxcode-mincode + 1) * KEYSYM_PER_CODE;
  358.     if (!(_XkeyMap = calloc( size ,sizeof(KeySym)))) {
  359.         fprintf(stderr,"Xlib_Keyboard: Failed to create keymap!\n");
  360.         abort();
  361.     }
  362.  
  363.     _XkeyMap_end = _XkeyMap + size;
  364.  
  365.     for (idx = 0; KeyNames[idx].keyname; idx++)
  366.     if ((keycode = KeyNames[idx].keycode)) {
  367.         KeySym *code = &_XkeyMap[(keycode - mincode) * KEYSYM_PER_CODE];
  368.         int col = (KeyNames[idx].col == KC_VIRTUALKEY)? 2 :
  369.               (KeyNames[idx].col == KC_SCANCODE)? 3 : 0;
  370.         if (code[col]) continue;
  371.         code[col] = KeyNames[idx].keysym;
  372.     }
  373.  
  374.     DBUG_VOID_RETURN;
  375. }
  376.  
  377. KeySym *XGetKeyboardMapping(Display* display, unsigned int first_keycode, 
  378.     int keycode_count, int* keysyms_per_keycode_return)
  379. {
  380.     DBUG_ENTER("XGetKeyboardMapping")
  381.     long size, count;
  382.     KeySym *map = NULL, *src, *dst, *end;
  383.  
  384.     if (!display) DBUG_RETURN(NULL);
  385.     if (!keycode_count) goto finish;
  386.  
  387.     count = keycode_count * KEYSYM_PER_CODE;
  388.     size = count + 1;
  389.  
  390.     if (!(dst = (KeySym *)calloc( size, sizeof(KeySym) ))) {
  391.         goto finish;
  392.     }
  393.     map = dst;
  394.  
  395.     if (first_keycode < display->min_keycode) {
  396.         unsigned int diff = (display->min_keycode - first_keycode) * KEYSYM_PER_CODE;
  397.         dst += diff; count -= diff;
  398.         first_keycode = display->min_keycode;
  399.     }
  400.     src = display->keysyms + 
  401.         (first_keycode - display->min_keycode) * KEYSYM_PER_CODE;
  402.     end = display->keysyms + 
  403.         (display->max_keycode - display->min_keycode) * KEYSYM_PER_CODE;
  404.     
  405.     while (count && src < end) {
  406.         *(dst++) = *(src++);
  407.         count--;
  408.     }
  409.  
  410.     finish:
  411.     if (keysyms_per_keycode_return)
  412.         *keysyms_per_keycode_return = KEYSYM_PER_CODE;
  413.     DBUG_RETURN(map);
  414. }
  415.  
  416. char *XKeysymToString(KeySym keysym)
  417. {
  418.     DBUG_ENTER("XKeysymToString")
  419.     struct KeyNames_st *key = KeyNames;
  420.     while (key->keysym && key->keysym != keysym) key++;
  421.     DBUG_RETURN(key->keyname);
  422. }
  423.  
  424. KeySym XStringToKeysym(_Xconst char* string)
  425. {
  426.     DBUG_ENTER("XStringToKeysym")
  427.     struct KeyNames_st *key = KeyNames;
  428.     while (key->keysym && strcmp(key->keyname,string)) key++;
  429.     DBUG_RETURN(key->keysym);
  430. }
  431.  
  432.