keyboard.c 97.9 KB
Newer Older
1
/*
2
 * X11 keyboard driver
3 4
 *
 * Copyright 1993 Bob Amstadt
5
 * Copyright 1996 Albrecht Kleine
6 7 8
 * Copyright 1997 David Faure
 * Copyright 1998 Morten Welinder
 * Copyright 1998 Ulrich Weigand
9
 * Copyright 1999 Ove Kven
10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 * This library is free software; you can redistribute it and/or
 * 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
23
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 25 26 27 28 29
 */

#include "config.h"

#include <X11/Xatom.h>
#include <X11/keysym.h>
30
#include <X11/Xlib.h>
31 32
#include <X11/Xresource.h>
#include <X11/Xutil.h>
33
#ifdef HAVE_X11_XKBLIB_H
34 35
#include <X11/XKBlib.h>
#endif
36

37
#include <ctype.h>
38
#include <stdarg.h>
39 40
#include <string.h>

41 42
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
43
#include "windef.h"
44
#include "winbase.h"
45
#include "wingdi.h"
46
#include "winuser.h"
47
#include "winnls.h"
48
#include "win.h"
49
#include "x11drv.h"
50
#include "wine/server.h"
51
#include "wine/unicode.h"
52
#include "wine/debug.h"
53

54 55
WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
WINE_DECLARE_DEBUG_CHANNEL(key);
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86

typedef union
{
    struct
    {
#ifndef BITFIELDS_BIGENDIAN
        unsigned long count : 16;
#endif
        unsigned long code : 8;
        unsigned long extended : 1;
        unsigned long unused : 2;
        unsigned long win_internal : 2;
        unsigned long context : 1;
        unsigned long previous : 1;
        unsigned long transition : 1;
#ifdef BITFIELDS_BIGENDIAN
        unsigned long count : 16;
#endif
    } lp1;
    unsigned long lp2;
} KEYLP;

/* key state table bits:
  0x80 -> key is pressed
  0x40 -> key got pressed since last time
  0x01 -> key is toggled
*/
BYTE key_state_table[256];

static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
                                or a WM_KEYUP message */
87

88 89
static int min_keycode, max_keycode, keysyms_per_keycode;
static WORD keyc2vkey[256], keyc2scan[256];
90 91 92

static int NumLockMask, AltGrMask; /* mask in the XKeyEvent state */

93 94
static char KEYBOARD_MapDeadKeysym(KeySym keysym);

95
/* Keyboard translation tables */
96
#define MAIN_LEN 49
97
static const WORD main_key_scan_qwerty[MAIN_LEN] =
98 99
{
/* this is my (102-key) keyboard layout, sorry if it doesn't quite match yours */
100
 /* `    1    2    3    4    5    6    7    8    9    0    -    = */
101
   0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
102
 /* q    w    e    r    t    y    u    i    o    p    [    ] */
103
   0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
104
 /* a    s    d    f    g    h    j    k    l    ;    '    \ */
105
   0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
106
 /* z    x    c    v    b    n    m    ,    .    / */
107
   0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
108
   0x56 /* the 102nd key (actually to the right of l-shift) */
109 110
};

111 112 113 114 115 116 117 118 119 120 121 122 123
static const WORD main_key_scan_abnt_qwerty[MAIN_LEN] =
{
 /* `    1    2    3    4    5    6    7    8    9    0    -    = */
   0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
 /* q    w    e    r    t    y    u    i    o    p    [    ] */
   0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
 /* a    s    d    f    g    h    j    k    l    ;    '    \ */
   0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
 /* \      z    x    c    v    b    n    m    ,    .    / */
   0x5e,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
   0x56, /* the 102nd key (actually to the right of l-shift) */
};

124 125 126 127 128 129 130 131 132 133 134 135 136
static const WORD main_key_scan_dvorak[MAIN_LEN] =
{
 /* `    1    2    3    4    5    6    7    8    9    0    [    ] */
   0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x1A,0x1B,
 /* '    ,    .    p    y    f    g    c    r    l    /    = */
   0x28,0x33,0x34,0x19,0x15,0x21,0x22,0x2E,0x13,0x26,0x35,0x0D,
 /* a    o    e    u    i    d    h    t    n    s    -    \ */
   0x1E,0x18,0x12,0x16,0x17,0x20,0x23,0x14,0x31,0x1F,0x0C,0x2B,
 /* ;    q    j    k    x    b    m    w    v    z */
   0x27,0x10,0x24,0x25,0x2D,0x30,0x32,0x11,0x2F,0x2C,
   0x56 /* the 102nd key (actually to the right of l-shift) */
};

Aric Cyr's avatar
Aric Cyr committed
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
static const WORD main_key_scan_qwerty_jp106[MAIN_LEN] =
{
  /* this is my (106-key) keyboard layout, sorry if it doesn't quite match yours */
 /* 1    2    3    4    5    6    7    8    9    0    -    ^    \ */
   0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x29,
 /* q    w    e    r    t    y    u    i    o    p    @    [ */
   0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
 /* a    s    d    f    g    h    j    k    l    ;    :    ] */
   0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
 /* z    x    c    v    b    n    m    ,    .    / */
   0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
   0x56 /* the 102nd key (actually to the right of l-shift) */
};


152 153
static const WORD main_key_vkey_qwerty[MAIN_LEN] =
{
154
/* NOTE: this layout must concur with the scan codes layout above */
155 156 157 158
   VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
   'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_4,VK_OEM_6,
   'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
   'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
159 160 161
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

Aric Cyr's avatar
Aric Cyr committed
162 163 164 165 166 167 168 169 170 171
static const WORD main_key_vkey_qwerty_jp106[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
   '1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,VK_OEM_3,
   'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_4,VK_OEM_6,
   'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
   'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

172 173 174
static const WORD main_key_vkey_qwerty_v2[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
175 176 177 178
   VK_OEM_5,'1','2','3','4','5','6','7','8','9','0',VK_OEM_PLUS,VK_OEM_4,
   'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_6,VK_OEM_1,
   'A','S','D','F','G','H','J','K','L',VK_OEM_3,VK_OEM_7,VK_OEM_2,
   'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_MINUS,
179 180 181
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

182 183 184
static const WORD main_key_vkey_qwertz[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
185 186 187 188
   VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
   'Q','W','E','R','T','Z','U','I','O','P',VK_OEM_4,VK_OEM_6,
   'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
   'Y','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
189 190 191 192 193 194
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

static const WORD main_key_vkey_qwertz_105[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
195 196 197 198
   VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
   'Q','W','E','R','T','Z','U','I','O','P',VK_OEM_4,VK_OEM_6,
   'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
   VK_OEM_102,'Y','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2
199 200
};

201 202 203
static const WORD main_key_vkey_abnt_qwerty[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
204 205 206 207
   VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
   'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_4,VK_OEM_6,
   'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_8,VK_OEM_5,
   VK_OEM_7,'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
208 209 210
   VK_OEM_102, /* the 102nd key (actually to the right of l-shift) */
};

211 212 213
static const WORD main_key_vkey_azerty[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
214 215 216 217
   VK_OEM_7,'1','2','3','4','5','6','7','8','9','0',VK_OEM_4,VK_OEM_PLUS,
   'A','Z','E','R','T','Y','U','I','O','P',VK_OEM_6,VK_OEM_1,
   'Q','S','D','F','G','H','J','K','L','M',VK_OEM_3,VK_OEM_5,
   'W','X','C','V','B','N',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,VK_OEM_8,
218 219 220
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

221 222 223
static const WORD main_key_vkey_dvorak[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
224 225 226 227
   VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_4,VK_OEM_6,
   VK_OEM_7,VK_OEM_COMMA,VK_OEM_PERIOD,'P','Y','F','G','C','R','L',VK_OEM_2,VK_OEM_PLUS,
   'A','O','E','U','I','D','H','T','N','S',VK_OEM_MINUS,VK_OEM_5,
   VK_OEM_1,'Q','J','K','X','B','M','W','V','Z',
228 229 230
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

231 232
/*** DEFINE YOUR NEW LANGUAGE-SPECIFIC MAPPINGS BELOW, SEE EXISTING TABLES */

233 234
/* the VK mappings for the main keyboard will be auto-assigned as before,
   so what we have here is just the character tables */
235
/* order: Normal, Shift, AltGr, Shift-AltGr */
236 237 238 239 240
/* We recommend you write just what is guaranteed to be correct (i.e. what's
   written on the keycaps), not the bunch of special characters behind AltGr
   and Shift-AltGr if it can vary among different X servers */
/* Remember that your 102nd key (to the right of l-shift) should be on a
   separate line, see existing tables */
241
/* If Wine fails to match your new table, use WINEDEBUG=+key to find out why */
242 243
/* Remember to also add your new table to the layout index table far below! */

244 245 246 247 248 249 250 251 252 253
/*** German Logitech Desktop Pro keyboard layout */
static const char main_key_DE_logitech[MAIN_LEN][4] =
{
 "^\xb0","1!","2\"","3\xa7","4$","5%","6&","7/{","8([","9)]","0=}","\xdf?\\","'`",
 "qQ@","wW","eE","rR","tT","zZ","uU","iI","oO","pP","\xfc\xdc","+*~",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\xf6\xd6","\xe4\xc4","#'",
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>|"
};

254
/*** United States keyboard layout (mostly contributed by Uwe Bonnes) */
255 256
static const char main_key_US[MAIN_LEN][4] =
{
257 258 259 260 261 262
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
};

263 264 265 266 267 268 269
/*** United States keyboard layout (phantom key version) */
/* (XFree86 reports the <> key even if it's not physically there) */
static const char main_key_US_phantom[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
Mike McCormack's avatar
Mike McCormack committed
270
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
271 272 273
 "<>" /* the phantom key */
};

274 275 276 277 278 279 280 281 282
/*** United States keyboard layout (dvorak version) */
static const char main_key_US_dvorak[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","[{","]}",
 "'\"",",<",".>","pP","yY","fF","gG","cC","rR","lL","/?","=+",
 "aA","oO","eE","uU","iI","dD","hH","tT","nN","sS","-_","\\|",
 ";:","qQ","jJ","kK","xX","bB","mM","wW","vV","zZ"
};

283 284 285 286 287 288 289 290 291 292
/*** British keyboard layout */
static const char main_key_UK[MAIN_LEN][4] =
{
 "`","1!","2\"","3","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'@","#~",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "\\|"
};

293
/*** French keyboard layout (setxkbmap fr) */
294 295
static const char main_key_FR[MAIN_LEN][4] =
{
296 297 298
 "","&1","2","\"3","'4","(5","-6","7","_8","9","0",")","=+",
 "aA","zZ","eE","rR","tT","yY","uU","iI","oO","pP","^","$",
 "qQ","sS","dD","fF","gG","hH","jJ","kK","lL","mM","%","*",
299 300 301 302
 "wW","xX","cC","vV","bB","nN",",?",";.",":/","!",
 "<>"
};

303
/*** Icelandic keyboard layout (setxkbmap is) */
304 305
static const char main_key_IS[MAIN_LEN][4] =
{
306 307 308
 "","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","","-_",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","'?",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","+*",
309
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","",
310
 "<>"
311 312
};

313
/*** German keyboard layout (setxkbmap de) */
314 315
static const char main_key_DE[MAIN_LEN][4] =
{
316 317 318 319
 "^","1!","2\"","3","4$","5%","6&","7/","8(","9)","0=","?","`",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","+*",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","#'",
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
320
 "<>|"
321 322
};

323 324 325 326 327 328 329 330 331 332
/*** German keyboard layout without dead keys */
static const char main_key_DE_nodead[MAIN_LEN][4] =
{
 "^","1!","2\"","3","4$","5%","6&","7/{","8([","9)]","0=}","?\\","",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","+*~",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","#'",
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
};

333 334 335 336 337 338 339 340 341
/*** German keyboard layout without dead keys 105 Keys (contributed by Matthias Fechner)*/
static const char main_key_DE_nodead_105[MAIN_LEN][4] =
{
 "^","1!","2\"","3","4$","5%","6&","7/{","8([","9)]","0=}","?\\","'`",
 "qQ@","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","+*~",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","#'",
 "<>|","yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
};

342
/*** Swiss German keyboard layout (setxkbmap ch -variant de) */
343 344
static const char main_key_SG[MAIN_LEN][4] =
{
345 346 347
 "","1+","2\"","3*","4","5%","6&","7/","8(","9)","0=","'?","^`",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","!",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","$",
348
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
349
 "<>"
350 351
};

352
/*** Swiss French keyboard layout (setxkbmap ch -variant fr) */
353 354
static const char main_key_SF[MAIN_LEN][4] =
{
355 356 357
 "","1+","2\"","3*","4","5%","6&","7/","8(","9)","0=","'?","^`",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","!",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","$",
358
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
359
 "<>"
360 361
};

362
/*** Norwegian keyboard layout (contributed by Ove Kven) */
363 364 365 366 367 368 369 370 371
static const char main_key_NO[MAIN_LEN][4] =
{
 "|","1!","2\"@","3#","4$","5%","6&","7/{","8([","9)]","0=}","+?","\\`",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","^~",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","'*",
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
};

372
/*** Danish keyboard layout (setxkbmap dk) */
373 374
static const char main_key_DA[MAIN_LEN][4] =
{
375 376
 "","1!","2\"","3#","4","5%","6&","7/","8(","9)","0=","+?","`",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","^",
377 378
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","'*",
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
379
 "<>"
380 381
};

382
/*** Swedish keyboard layout (setxkbmap se) */
383 384
static const char main_key_SE[MAIN_LEN][4] =
{
385 386
 "","1!","2\"","3#","4","5%","6&","7/","8(","9)","0=","+?","`",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","^",
387 388
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","'*",
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
389
 "<>"
390 391
};

392
/*** Estonian keyboard layout (setxkbmap ee) */
393 394
static const char main_key_ET[MAIN_LEN][4] =
{
395 396 397
 "~","1!","2\"","3#","4","5%","6&","7/","8(","9)","0=","+?","`",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","'*",
398
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
399
 "<>"
400 401
};

402
/*** Canadian French keyboard layout (setxkbmap ca_enhanced) */
403 404
static const char main_key_CF[MAIN_LEN][4] =
{
405 406
 "#|\\","1!","2\"@","3/","4$","5%","6?","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","^^[","]",
407
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:~","``{","<>}",
408
 "zZ","xX","cC","vV","bB","nN","mM",",'-",".","",
409
 ""
410 411
};

412 413 414 415 416 417 418 419 420 421
/*** Canadian French keyboard layout (setxkbmap ca -variant fr) */
static const char main_key_CA_fr[MAIN_LEN][4] =
{
 "#|","1!","2\"","3/","4$","5%","6?","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","^^","",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","``","<>",
 "zZ","xX","cC","vV","bB","nN","mM",",'",".","",
 ""
};

422
/*** Canadian keyboard layout (setxkbmap ca) */
423 424 425
static const char main_key_CA[MAIN_LEN][4] =
{
 "/\\","1!","2@","3#","4$","5%","6?","7&","8*","9(","0)","-_","=+",
426
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","^","~",
427 428 429 430 431
 "aA","sSߧ","dD","fF","gG","hH","jJ","kK","lL",";:","","",
 "zZ","xX","cC","vV","bB","nN","mM",",'",".\"","",
 ""
};

432
/*** Portuguese keyboard layout (setxkbmap pt) */
433 434
static const char main_key_PT[MAIN_LEN][4] =
{
435 436 437 438
 "\\|","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","+*","`",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","~^",
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
439 440 441
 "<>"
};

442
/*** Italian keyboard layout (setxkbmap it) */
's avatar
committed
443 444
static const char main_key_IT[MAIN_LEN][4] =
{
445 446 447 448 449
 "\\|","1!","2\"","3","4$","5%","6&","7/","8(","9)","0=","'?","^",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","+*",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","",
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
's avatar
committed
450 451
};

452
/*** Finnish keyboard layout (setxkbmap fi) */
453 454
static const char main_key_FI[MAIN_LEN][4] =
{
455 456
 "","1!","2\"","3#","4","5%","6&","7/","8(","9)","0=","+?","`",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","","^",
457
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","'*",
458
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
459
 "<>"
460 461
};

462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
/*** Bulgarian bds keyboard layout */
static const char main_key_BG_bds[MAIN_LEN][4] =
{
 "`~()","1!","2@2?","3#3+","4$4\"","5%","6^6=","7&7:","8*8/","9(","0)","-_-I","=+.V",
 "qQ,","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]};",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|'",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>" /* the phantom key */
};

/*** Bulgarian phonetic keyboard layout */
static const char main_key_BG_phonetic[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>" /* the phantom key */
};

482 483 484 485 486 487 488 489 490 491 492
/*** Belarusian standard keyboard layout (contributed by Hleb Valoska) */
/*** It matches belarusian layout for XKB from Alexander Mikhailian    */
static const char main_key_BY[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}''",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|/|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?.,", "<>|",
};


493 494 495 496 497 498 499 500 501
/*** Russian keyboard layout (contributed by Pavel Roskin) */
static const char main_key_RU[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
};

502 503 504 505 506 507 508 509 510 511
/*** Russian keyboard layout (phantom key version) */
static const char main_key_RU_phantom[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>" /* the phantom key */
};

512 513 514 515 516 517 518 519 520 521
/*** Russian keyboard layout KOI8-R */
static const char main_key_RU_koi8r[MAIN_LEN][4] =
{
 "()","1!","2\"","3/","4$","5:","6,","7.","8;","9?","0%","-_","=+",
 "","","","","","","","","","","","",
 "","","","","","","","","","","","\\|",
 "","","","","","","","","","/?",
 "<>" /* the phantom key */
};

522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
/*** Russian keyboard layout cp1251 */
static const char main_key_RU_cp1251[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>" /* the phantom key */
};

/*** Russian phonetic keyboard layout */
static const char main_key_RU_phonetic[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>" /* the phantom key */
};

542 543 544 545 546 547 548 549 550 551
/*** Ukrainian keyboard layout KOI8-U */
static const char main_key_UA[MAIN_LEN][4] =
{
 "`~","1!1!","2@2\"","3#3'","4$4*","5%5:","6^6,","7&7.","8*8;","9(9(","0)0)","-_-_","=+=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?/?",
 "<>" /* the phantom key */
};

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
/*** Ukrainian keyboard layout KOI8-U by O. Nykyforchyn */
/***  (as it appears on most of keyboards sold today)   */
static const char main_key_UA_std[MAIN_LEN][4] =
{
 "","1!","2\"","3'","4;","5%","6:","7?","8*","9(","0)","-_","=+",
 "","","","","","","","","","","","",
 "","","","","","","","","","","","\\/",
 "","","","","","","","","",".,",
 "<>" /* the phantom key */
};

/*** Russian keyboard layout KOI8-R (pair to the previous) */
static const char main_key_RU_std[MAIN_LEN][4] =
{
 "","1!","2\"","3'","4;","5%","6:","7?","8*","9(","0)","-_","=+",
 "","","","","","","","","","","","",
 "","","","","","","","","","","","\\/",
 "","","","","","","","","",".,",
 "<>" /* the phantom key */
};

573
/*** Spanish keyboard layout (setxkbmap es) */
574 575
static const char main_key_ES[MAIN_LEN][4] =
{
576 577 578
 "","1!","2\"","3","4$","5%","6&","7/","8(","9)","0=","'?","",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","`^","+*",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","",
579 580 581 582
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
};

583 584 585 586 587 588 589 590 591 592
/*** Belgian keyboard layout ***/
static const char main_key_BE[MAIN_LEN][4] =
{
 "","&1|","2@","\"3#","'4","(5","6^","7","!8","9{","0}",")","-_",
 "aA","zZ","eE","rR","tT","yY","uU","iI","oO","pP","^[","$*]",
 "qQ","sS","dD","fF","gG","hH","jJ","kK","lL","mM","%","`",
 "wW","xX","cC","vV","bB","nN",",?",";.",":/","=+~",
 "<>\\"
};

593
/*** Hungarian keyboard layout (setxkbmap hu) */
594 595
static const char main_key_HU[MAIN_LEN][4] =
{
596 597 598 599 600
 "0","1'","2\"","3+","4!","5%","6/","7=","8(","9)","","","",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","",
 "yY","xX","cC","vV","bB","nN","mM",",?",".:","-_",
 ""
601 602
};

603 604 605 606 607 608 609 610 611 612
/*** Polish (programmer's) keyboard layout ***/
static const char main_key_PL[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>|"
};

613
/*** Slovenian keyboard layout (setxkbmap si) ***/
Rok Mandeljc's avatar
Rok Mandeljc committed
614 615
static const char main_key_SI[MAIN_LEN][4] =
{
616 617 618 619
 "","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","+*",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","",
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
Rok Mandeljc's avatar
Rok Mandeljc committed
620 621 622
 "<>"
};

623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
/*** Serbian keyboard layout (setxkbmap sr) ***/
static const char main_key_SR[MAIN_LEN][4] =
{
 "`~","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","+*",
 "","","","","","","","","","","","[]",
 "","","","","","","","","","","","-_",
 "","","","","","","",",;",".:","",
 "<>" /* the phantom key */
};

/*** Serbian keyboard layout (setxkbmap us,sr) ***/
static const char main_key_US_SR[MAIN_LEN][4] =
{
 "`~","1!","2@2\"","3#","4$","5%","6^6&","7&7/","8*8(","9(9)","0)0=","-_'?","=++*",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}[]",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|-_",
 "zZ","xX","cC","vV","bB","nN","mM",",<,;",".>.:","/?",
 "<>" /* the phantom key */
};

643 644 645 646 647 648 649 650 651 652
/*** Croatian keyboard layout specific for me <jelly@srk.fer.hr> ***/
static const char main_key_HR_jelly[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>|"
};

653
/*** Croatian keyboard layout (setxkbmap hr) ***/
654 655
static const char main_key_HR[MAIN_LEN][4] =
{
656 657 658 659
 "","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","+*",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","","",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","","",
 "yY","xX","cC","vV","bB","nN","mM",",;",".:","/?",
660 661 662
 "<>"
};

663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
/*** Japanese 106 keyboard layout ***/
static const char main_key_JA_jp106[MAIN_LEN][4] =
{
 "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0~","-=","^~","\\|",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@`","[{",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "\\_",
};

/*** Japanese pc98x1 keyboard layout ***/
static const char main_key_JA_pc98x1[MAIN_LEN][4] =
{
 "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0","-=","^`","\\|",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@~","[{",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "\\_",
};

683 684 685
/*** Brazilian ABNT-2 keyboard layout (contributed by Raul Gomes Fernandes) */
static const char main_key_PT_br[MAIN_LEN][4] =
{
686 687
 "'\"","1!","2@","3#","4$","5%","6","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","`","[{",
688
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","~^","]}",
689
 "\\|","zZ","xX","cC","vV","bB","nN","mM",",<",".>",";:","/?",
690 691 692 693 694 695 696 697
};

/*** Brazilian ABNT-2 keyboard layout with <ALT GR> (contributed by Mauro Carvalho Chehab) */
static const char main_key_PT_br_alt_gr[MAIN_LEN][4] =
{
 "'\"","1!9","2@2","3#3","4$#","5%\"","6(,","7&","8*","9(","0)","-_","=+'",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","4`","[{*",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","gG","~^","]}:",
698
 "\\|","zZ","xX","cC","vV","bB","nN","mM",",<",".>",";:","/?0"
699
};
700

701 702 703 704 705 706 707 708 709
/*** US international keyboard layout (contributed by Gustavo Noronha (kov@debian.org)) */
static const char main_key_US_intl[MAIN_LEN][4] =
{
  "`~", "1!", "2@", "3#", "4$", "5%", "6^", "7&", "8*", "9(", "0)", "-_", "=+", "\\|",
  "qQ", "wW", "eE", "rR", "tT", "yY", "uU", "iI", "oO", "pP", "[{", "]}",
  "aA", "sS", "dD", "fF", "gG", "hH", "jJ", "kK", "lL", ";:", "'\"",
  "zZ", "xX", "cC", "vV", "bB", "nN", "mM", ",<", ".>", "/?"
};

710 711 712 713 714
/*** Slovak keyboard layout (see cssk_ibm(sk_qwerty) in xkbsel)
  - dead_abovering replaced with degree - no symbol in iso8859-2
  - brokenbar replaced with bar					*/
static const char main_key_SK[MAIN_LEN][4] =
{
715 716 717 718 719
 ";0","+1","2","3","4","5","6","7","8","9","0","=%","'v",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","/","(",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\"","!",")",
 "zZ","xX","cC","vV","bB","nN","mM",",?",".:","-_",
 "<>"
720 721
};

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741
/*** Czech keyboard layout (setxkbmap cz) */
static const char main_key_CZ[MAIN_LEN][4] =
{
 ";","+1","2","3","4","5","6","7","8","9","0","=%","",
 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","/",")(",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\"","!","'",
 "yY","xX","cC","vV","bB","nN","mM",",?",".:","-_",
 "\\"
};

/*** Czech keyboard layout (setxkbmap cz_qwerty) */
static const char main_key_CZ_qwerty[MAIN_LEN][4] =
{
 ";","+1","2","3","4","5","6","7","8","9","0","=%","",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","/",")(",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\"","!","'",
 "zZ","xX","cC","vV","bB","nN","mM",",?",".:","-_",
 "\\"
};

742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
/*** Slovak and Czech (programmer's) keyboard layout (see cssk_dual(cs_sk_ucw)) */
static const char main_key_SK_prog[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>"
};

/*** Czech keyboard layout (see cssk_ibm(cs_qwerty) in xkbsel) */
static const char main_key_CS[MAIN_LEN][4] =
{
 ";","+1","2","3","4","5","6","7","8","9","0)","=%","",
 "qQ\\","wW|","eE","rR","tT","yY","uU","iI","oO","pP","/[{",")(]}",
 "aA","sS","dD","fF[","gG]","hH","jJ","kK","lL","\"$","!","'",
 "zZ>","xX#","cC&","vV@","bB{","nN}","mM",",?<",".:>","-_*",
 "<>\\|"
};

762 763 764
/*** Latin American keyboard layout (contributed by Gabriel Orlando Garcia) */
static const char main_key_LA[MAIN_LEN][4] =
{
765 766 767
 "|","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","",
 "qQ@","wW","eE","rR","tT","yY","uU","iI","oO","pP","","+*",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","","{[^","}]",
768 769 770
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
};
771

772
/*** Lithuanian keyboard layout (setxkbmap lt) */
773 774
static const char main_key_LT_B[MAIN_LEN][4] =
{
Nerijus Baliunas's avatar
Nerijus Baliunas committed
775
 "`~","","","","","","","","","(",")","-_","","\\|",
776
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
777
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"",
778 779
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 ""
780 781
};

782 783 784 785 786 787 788 789 790
/*** Turkish keyboard Layout */
static const char main_key_TK[MAIN_LEN][4] =
{
"\"","1!","2'","3^#","4+$","5%","6&","7/{","8([","9)]","0=}","*?\\","-_",
"qQ@","wW","eE","rR","tT","yY","uU","I","oO","pP","","~",
"aA","sS","dD","fF","gG","hH","jJ","kK","lL","","i",",;`",
"zZ","xX","cC","vV","bB","nN","mM","","",".:"
};

791 792 793 794
/*** Turkish keyboard layout (setxkbmap tr) */
static const char main_key_TR[MAIN_LEN][4] =
{
"\"\\","1!","2'","3^","4+","5%","6&","7/","8(","9)","0=","*?","-_",
795 796
"qQ","wW","eE","rR","tT","yY","uU","\xb9I","oO","pP","\xbb\xab","",
"aA","sS","dD","fF","gG","hH","jJ","kK","lL","\xba\xaa","i\0",",;",
797 798 799 800
"zZ","xX","cC","vV","bB","nN","mM","","",".:",
"<>"
};

801 802 803 804
/*** Turkish F keyboard layout (setxkbmap trf) */
static const char main_key_TR_F[MAIN_LEN][4] =
{
"+*","1!","2\"","3^#","4$","5%","6&","7'","8(","9)","0=","/?","-_",
805 806
"fF","gG","\xbb\xab","\xb9I","oO","dD","rR","nN","hH","pP","qQ","wW",
"uU","i\0","eE","aA","","tT","kK","mM","lL","yY","\xba\xaa","xX",
807 808 809 810
"jJ","","vV","cC","","zZ","sS","bB",".:",",;",
"<>"
};

811
/*** Israelian keyboard layout (setxkbmap us,il) */
812 813
static const char main_key_IL[MAIN_LEN][4] =
{
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838
 "`~;","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ/","wW'","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","\'\",","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?.",
 "<>"
};

/*** Israelian phonetic keyboard layout (setxkbmap us,il_phonetic) */
static const char main_key_IL_phonetic[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>"
};

/*** Israelian Saharon keyboard layout (setxkbmap -symbols "us(pc105)+il_saharon") */
static const char main_key_IL_saharon[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>"
839 840
};

841 842 843 844 845 846 847 848 849 850 851 852
/*** Greek keyboard layout (contributed by Kriton Kyrimis <kyrimis@cti.gr>)
  Greek characters for "wW" and "sS" are omitted to not produce a mismatch
  message since they have different characters in gr and el XFree86 layouts. */
static const char main_key_EL[MAIN_LEN][4] =
{
 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ;:","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
 "<>"
};

853 854 855 856 857 858 859 860 861
/*** Thai (Kedmanee) keyboard layout by Supphachoke Suntiwichaya <mrchoke@opentle.org> */
static const char main_key_th[MAIN_LEN][4] =
{
 "`~_%","1!+","2@/","3#-","4$","5%","6^","7&","8*","9(","0)","-_","=+",
 "qQ","wW\"","eEӮ","rR","tTи","yY","uU","iIó","oO","pP­","[{","]},",
 "aA","sS˦","dD","fF","gG","hH","jJ","kK","lL",";:ǫ","\'\".","\\|",
 "zZ(","xX)","cC","vV","bB","nN","mM?",",<",".>","/?"
}; 

862 863 864 865 866 867 868 869 870 871
/*** VNC keyboard layout */
static const WORD main_key_scan_vnc[MAIN_LEN] =
{
   0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x1A,0x1B,0x27,0x28,0x29,0x33,0x34,0x35,0x2B,
   0x1E,0x30,0x2E,0x20,0x12,0x21,0x22,0x23,0x17,0x24,0x25,0x26,0x32,0x31,0x18,0x19,0x10,0x13,0x1F,0x14,0x16,0x2F,0x11,0x2D,0x15,0x2C,
   0x56
};

static const WORD main_key_vkey_vnc[MAIN_LEN] =
{
872 873
   '1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,VK_OEM_4,VK_OEM_6,VK_OEM_1,VK_OEM_7,VK_OEM_3,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,VK_OEM_5,
   'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
874 875 876 877 878 879 880 881 882
   VK_OEM_102
};

static const char main_key_vnc[MAIN_LEN][4] =
{
 "1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+","[{","]}",";:","'\"","`~",",<",".>","/?","\\|",
 "aA","bB","cC","dD","eE","fF","gG","hH","iI","jJ","kK","lL","mM","nN","oO","pP","qQ","rR","sS","tT","uU","vV","wW","xX","yY","zZ"
};

883 884 885 886 887 888 889 890 891 892 893 894
/*** Dutch keyboard layout (setxkbmap nl) ***/
static const char main_key_NL[MAIN_LEN][4] =
{
 "@","1!","2\"","3#","4$","5%","6&","7_","8(","9)","0'","/?","~",
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","~","*|",
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","+","'`","<>",
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-=",
 "[]"
};



895
/*** Layout table. Add your keyboard mappings to this list */
896
static const struct {
897 898
    LCID lcid; /* input locale identifier, look for LOCALE_ILANGUAGE
                 in the appropriate dlls/kernel/nls/.nls file */
899 900 901 902
    const char *comment;
    const char (*key)[MAIN_LEN][4];
    const WORD (*scan)[MAIN_LEN]; /* scan codes mapping */
    const WORD (*vkey)[MAIN_LEN]; /* virtual key codes mapping */
903
} main_key_tab[]={
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
 {0x0409, "United States keyboard layout", &main_key_US, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0409, "United States keyboard layout (phantom key version)", &main_key_US_phantom, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0409, "United States keyboard layout (dvorak)", &main_key_US_dvorak, &main_key_scan_dvorak, &main_key_vkey_dvorak},
 {0x0409, "United States International keyboard layout", &main_key_US_intl, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0809, "British keyboard layout", &main_key_UK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0407, "German keyboard layout", &main_key_DE, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x0407, "German keyboard layout without dead keys", &main_key_DE_nodead, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x0407, "German keyboard layout for logitech desktop pro", &main_key_DE_logitech,  &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x0407, "German keyboard layout without dead keys 105", &main_key_DE_nodead_105, &main_key_scan_qwerty, &main_key_vkey_qwertz_105},
 {0x0807, "Swiss German keyboard layout", &main_key_SG, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x100c, "Swiss French keyboard layout", &main_key_SF, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x041d, "Swedish keyboard layout", &main_key_SE, &main_key_scan_qwerty, &main_key_vkey_qwerty_v2},
 {0x0425, "Estonian keyboard layout", &main_key_ET, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0414, "Norwegian keyboard layout", &main_key_NO, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0406, "Danish keyboard layout", &main_key_DA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x040c, "French keyboard layout", &main_key_FR, &main_key_scan_qwerty, &main_key_vkey_azerty},
 {0x0c0c, "Canadian French keyboard layout", &main_key_CF, &main_key_scan_qwerty, &main_key_vkey_qwerty},
921
 {0x0c0c, "Canadian French keyboard layout (CA_fr)", &main_key_CA_fr, &main_key_scan_qwerty, &main_key_vkey_qwerty},
922
 {0x0c0c, "Canadian keyboard layout", &main_key_CA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
923 924 925 926 927 928 929 930 931 932 933 934 935 936
 {0x080c, "Belgian keyboard layout", &main_key_BE, &main_key_scan_qwerty, &main_key_vkey_azerty},
 {0x0816, "Portuguese keyboard layout", &main_key_PT, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0416, "Brazilian ABNT-2 keyboard layout", &main_key_PT_br, &main_key_scan_abnt_qwerty, &main_key_vkey_abnt_qwerty},
 {0x0416, "Brazilian ABNT-2 keyboard layout ALT GR", &main_key_PT_br_alt_gr,&main_key_scan_abnt_qwerty, &main_key_vkey_abnt_qwerty},
 {0x040b, "Finnish keyboard layout", &main_key_FI, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0402, "Bulgarian bds keyboard layout", &main_key_BG_bds, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0402, "Bulgarian phonetic keyboard layout", &main_key_BG_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0423, "Belarusian keyboard layout", &main_key_BY, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0419, "Russian keyboard layout", &main_key_RU, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0419, "Russian keyboard layout (phantom key version)", &main_key_RU_phantom, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0419, "Russian keyboard layout KOI8-R", &main_key_RU_koi8r, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0419, "Russian keyboard layout cp1251", &main_key_RU_cp1251, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0419, "Russian phonetic keyboard layout", &main_key_RU_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0422, "Ukrainian keyboard layout KOI8-U", &main_key_UA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
937 938
 {0x0422, "Ukrainian keyboard layout (standard)", &main_key_UA_std, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0419, "Russian keyboard layout (standard)", &main_key_RU_std, &main_key_scan_qwerty, &main_key_vkey_qwerty},
939 940 941 942 943 944
 {0x040a, "Spanish keyboard layout", &main_key_ES, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0410, "Italian keyboard layout", &main_key_IT, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x040f, "Icelandic keyboard layout", &main_key_IS, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x040e, "Hungarian keyboard layout", &main_key_HU, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x0415, "Polish (programmer's) keyboard layout", &main_key_PL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0424, "Slovenian keyboard layout", &main_key_SI, &main_key_scan_qwerty, &main_key_vkey_qwertz},
945 946
 {0x0c1a, "Serbian keyboard layout sr", &main_key_SR, &main_key_scan_qwerty, &main_key_vkey_qwerty}, /* LANG_SERBIAN,SUBLANG_SERBIAN_CYRILLIC */
 {0x0c1a, "Serbian keyboard layout us,sr", &main_key_US_SR, &main_key_scan_qwerty, &main_key_vkey_qwerty}, /* LANG_SERBIAN,SUBLANG_SERBIAN_CYRILLIC */
947 948
 {0x041a, "Croatian keyboard layout", &main_key_HR, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x041a, "Croatian keyboard layout (specific)", &main_key_HR_jelly, &main_key_scan_qwerty, &main_key_vkey_qwerty},
Aric Cyr's avatar
Aric Cyr committed
949
 {0x0411, "Japanese 106 keyboard layout", &main_key_JA_jp106, &main_key_scan_qwerty_jp106, &main_key_vkey_qwerty_jp106},
950
 {0x0411, "Japanese pc98x1 keyboard layout", &main_key_JA_pc98x1, &main_key_scan_qwerty, &main_key_vkey_qwerty},
951 952 953 954 955 956 957 958
 {0x041b, "Slovak keyboard layout", &main_key_SK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x041b, "Slovak and Czech keyboard layout without dead keys", &main_key_SK_prog, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0405, "Czech keyboard layout", &main_key_CS, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0405, "Czech keyboard layout cz", &main_key_CZ, &main_key_scan_qwerty, &main_key_vkey_qwertz},
 {0x0405, "Czech keyboard layout cz_qwerty", &main_key_CZ_qwerty, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x040a, "Latin American keyboard layout", &main_key_LA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0427, "Lithuanian (Baltic) keyboard layout", &main_key_LT_B, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x041f, "Turkish keyboard layout", &main_key_TK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
959
 {0x041f, "Turkish keyboard layout tr", &main_key_TR, &main_key_scan_qwerty, &main_key_vkey_qwerty},
960
 {0x041f, "Turkish keyboard layout trf", &main_key_TR_F, &main_key_scan_qwerty, &main_key_vkey_qwerty},
961 962 963 964 965 966
 {0x040d, "Israelian keyboard layout", &main_key_IL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x040d, "Israelian phonetic keyboard layout", &main_key_IL_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x040d, "Israelian Saharon keyboard layout", &main_key_IL_saharon, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x0409, "VNC keyboard layout", &main_key_vnc, &main_key_scan_vnc, &main_key_vkey_vnc},
 {0x0408, "Greek keyboard layout", &main_key_EL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
 {0x041e, "Thai (Kedmanee)  keyboard layout", &main_key_th, &main_key_scan_qwerty, &main_key_vkey_qwerty},
967
 {0x0413, "Dutch keyboard layout", &main_key_NL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
968 969

 {0, NULL, NULL, NULL, NULL} /* sentinel */
970 971 972 973 974 975 976 977 978
};
static unsigned kbd_layout=0; /* index into above table of layouts */

/* maybe more of these scancodes should be extended? */
                /* extended must be set for ALT_R, CTRL_R,
                   INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
                   keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
                /* FIXME should we set extended bit for NumLock ? My
                 * Windows does ... DF */
979 980 981
                /* Yes, to distinguish based on scan codes, also
                   for PrtScn key ... GA */

982
static const WORD nonchar_key_vkey[256] =
983
{
984 985 986
    /* unused */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF00 */
    /* special keys */
987 988
    VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,           /* FF08 */
    0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0,                      /* FF10 */
989 990 991 992 993 994 995 996 997 998 999 1000 1001
    0, 0, 0, VK_ESCAPE, 0, 0, 0, 0,                             /* FF18 */
    /* unused */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF20 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF28 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF30 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF38 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF40 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF48 */
    /* cursor keys */
    VK_HOME, VK_LEFT, VK_UP, VK_RIGHT,                          /* FF50 */
    VK_DOWN, VK_PRIOR, VK_NEXT, VK_END,
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF58 */
    /* misc keys */
1002
    VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0,0,0, VK_APPS, /* FF60 */
1003
    0, VK_CANCEL, VK_HELP, VK_CANCEL, 0, 0, 0, 0,               /* FF68 */
1004 1005 1006
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF70 */
    /* keypad keys */
    0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK,                            /* FF78 */
1007 1008 1009
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF80 */
    0, 0, 0, 0, 0, VK_RETURN, 0, 0,                             /* FF88 */
    0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP,                     /* FF90 */
1010
    VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT,                       /* FF98 */
1011
    VK_END, VK_CLEAR, VK_INSERT, VK_DELETE,
1012
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFA0 */
1013 1014 1015 1016
    0, 0, VK_MULTIPLY, VK_ADD,                                  /* FFA8 */
    VK_SEPARATOR, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE,
    VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3,             /* FFB0 */
    VK_NUMPAD4, VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7,
1017
    VK_NUMPAD8, VK_NUMPAD9, 0, 0, 0, VK_OEM_NEC_EQUAL,          /* FFB8 */
1018 1019
    /* function keys */
    VK_F1, VK_F2,
1020
    VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,    /* FFC0 */
1021 1022 1023 1024 1025 1026 1027 1028 1029
    VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16, 0, 0,       /* FFC8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFD0 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFD8 */
    /* modifier keys */
    0, VK_SHIFT, VK_SHIFT, VK_CONTROL,                          /* FFE0 */
    VK_CONTROL, VK_CAPITAL, 0, VK_MENU,
    VK_MENU, VK_MENU, VK_MENU, 0, 0, 0, 0, 0,                   /* FFE8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFF0 */
    0, 0, 0, 0, 0, 0, 0, VK_DELETE                              /* FFF8 */
1030
};
1031

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
static const WORD nonchar_key_scan[256] =
{
    /* unused */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF00 */
    /* special keys */
    0x0E, 0x0F, 0x00, /*?*/ 0, 0x00, 0x1C, 0x00, 0x00,           /* FF08 */
    0x00, 0x00, 0x00, 0x45, 0x46, 0x00, 0x00, 0x00,              /* FF10 */
    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,              /* FF18 */
    /* unused */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF20 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF28 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF30 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF38 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF40 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF48 */
    /* cursor keys */
    0x147, 0x14B, 0x148, 0x14D, 0x150, 0x149, 0x151, 0x14F,      /* FF50 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF58 */
    /* misc keys */
    /*?*/ 0, 0x137, /*?*/ 0, 0x152, 0x00, 0x00, 0x00, 0x00,      /* FF60 */
    /*?*/ 0, /*?*/ 0, 0x38, 0x146, 0x00, 0x00, 0x00, 0x00,       /* FF68 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF70 */
    /* keypad keys */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x138, 0x145,            /* FF78 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF80 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x11C, 0x00, 0x00,             /* FF88 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x4B, 0x48,              /* FF90 */
    0x4D, 0x50, 0x49, 0x51, 0x4F, 0x4C, 0x52, 0x53,              /* FF98 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFA0 */
1061
    0x00, 0x00, 0x37, 0x4E, 0x53, 0x4A, 0x53, 0x135,             /* FFA8 */
1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
    0x52, 0x4F, 0x50, 0x51, 0x4B, 0x4C, 0x4D, 0x47,              /* FFB0 */
    0x48, 0x49, 0x00, 0x00, 0x00, 0x00,                          /* FFB8 */
    /* function keys */
    0x3B, 0x3C,
    0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44,              /* FFC0 */
    0x57, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFC8 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFD0 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFD8 */
    /* modifier keys */
    0x00, 0x2A, 0x36, 0x1D, 0x11D, 0x3A, 0x00, 0x38,             /* FFE0 */
    0x138, 0x38, 0x138, 0x00, 0x00, 0x00, 0x00, 0x00,            /* FFE8 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFF0 */
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x153              /* FFF8 */
1075
};
1076

1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
static const WORD xfree86_vendor_key_vkey[256] =
{
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF00 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF08 */
    0, VK_VOLUME_DOWN, VK_VOLUME_MUTE, VK_VOLUME_UP,            /* 1008FF10 */
    VK_MEDIA_PLAY_PAUSE, VK_MEDIA_STOP,
    VK_MEDIA_PREV_TRACK, VK_MEDIA_NEXT_TRACK,
    0, VK_LAUNCH_MAIL, 0, VK_BROWSER_SEARCH,                    /* 1008FF18 */
    0, 0, 0, VK_BROWSER_HOME,
    0, 0, 0, 0, 0, 0, VK_BROWSER_BACK, VK_BROWSER_FORWARD,      /* 1008FF20 */
    VK_BROWSER_STOP, VK_BROWSER_REFRESH, 0, 0, 0, 0, 0, 0,      /* 1008FF28 */
    VK_BROWSER_FAVORITES, 0, VK_LAUNCH_MEDIA_SELECT, 0,         /* 1008FF30 */
    0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF38 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF40 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF48 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF50 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF58 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF60 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF68 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF70 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF78 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF80 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF88 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF90 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF98 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFA0 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFA8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFB0 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFB8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFC0 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFC8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFD0 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFD8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFE0 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFE8 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFF0 */
    0, 0, 0, 0, 0, 0, 0, 0                                      /* 1008FFF8 */
};
1116

1117
/* Returns the Windows virtual key code associated with the X event <e> */
1118
/* x11 lock must be held */
1119
static WORD EVENT_event_to_vkey( XIC xic, XKeyEvent *e)
1120
{
1121
    KeySym keysym = 0;
1122 1123
    Status status;
    char buf[24];
1124

1125 1126
    /* Clients should pass only KeyPress events to XmbLookupString */
    if (xic && e->type == KeyPress)
1127
        XmbLookupString(xic, e, buf, sizeof(buf), &keysym, &status);
1128
    else
1129
        XLookupString(e, buf, sizeof(buf), &keysym, NULL);
1130

1131 1132 1133
    if ((e->state & NumLockMask) &&
        (keysym == XK_KP_Separator || keysym == XK_KP_Decimal ||
         (keysym >= XK_KP_0 && keysym <= XK_KP_9)))
1134 1135
        /* Only the Keypad keys 0-9 and . send different keysyms
         * depending on the NumLock state */
1136
        return nonchar_key_vkey[keysym & 0xFF];
1137

1138 1139
    TRACE_(key)("e->keycode = %x\n", e->keycode);

1140 1141 1142
    return keyc2vkey[e->keycode];
}

1143
static BOOL NumState=FALSE, CapsState=FALSE;
1144

1145 1146

/***********************************************************************
1147
 *           X11DRV_send_keyboard_input
1148
 */
1149 1150 1151 1152 1153 1154
void X11DRV_send_keyboard_input( WORD wVk, WORD wScan, DWORD dwFlags, DWORD time,
                                 DWORD dwExtraInfo, UINT injected_flags )
{
    UINT message;
    KEYLP keylp;
    KBDLLHOOKSTRUCT hook;
1155 1156
    WORD wVkStripped;

1157 1158
    wVk = LOBYTE(wVk);

1159 1160 1161 1162 1163 1164 1165 1166 1167
    /* strip left/right for menu, control, shift */
    if (wVk == VK_LMENU || wVk == VK_RMENU)
        wVkStripped = VK_MENU;
    else if (wVk == VK_LCONTROL || wVk == VK_RCONTROL)
        wVkStripped = VK_CONTROL;
    else if (wVk == VK_LSHIFT || wVk == VK_RSHIFT)
        wVkStripped = VK_SHIFT;
    else
        wVkStripped = wVk;
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182

    keylp.lp2 = 0;
    keylp.lp1.count = 1;
    keylp.lp1.code = wScan;
    keylp.lp1.extended = (dwFlags & KEYEVENTF_EXTENDEDKEY) != 0;
    keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
                                * don't remember where I read it - AK */
                                /* it's '1' under windows, when a dialog box appears
                                 * and you press one of the underlined keys - DF*/

    /* note that there is a test for all this */
    if (dwFlags & KEYEVENTF_KEYUP )
    {
        message = WM_KEYUP;
        if ((key_state_table[VK_MENU] & 0x80) &&
1183 1184
            ((wVkStripped == VK_MENU) || (wVkStripped == VK_CONTROL)
             || !(key_state_table[VK_CONTROL] & 0x80)))
1185 1186
        {
            if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
1187
                (wVkStripped != VK_MENU)) /* <ALT>-down...<something else>-up */
1188 1189 1190 1191
                message = WM_SYSKEYUP;
            TrackSysKey = 0;
        }
        key_state_table[wVk] &= ~0x80;
1192
        key_state_table[wVkStripped] &= ~0x80;
1193 1194 1195 1196 1197 1198 1199 1200 1201
        keylp.lp1.previous = 1;
        keylp.lp1.transition = 1;
    }
    else
    {
        keylp.lp1.previous = (key_state_table[wVk] & 0x80) != 0;
        keylp.lp1.transition = 0;
        if (!(key_state_table[wVk] & 0x80)) key_state_table[wVk] ^= 0x01;
        key_state_table[wVk] |= 0xc0;
1202
        key_state_table[wVkStripped] |= 0xc0;
1203 1204 1205 1206 1207

        message = WM_KEYDOWN;
        if ((key_state_table[VK_MENU] & 0x80) && !(key_state_table[VK_CONTROL] & 0x80))
        {
            message = WM_SYSKEYDOWN;
1208
            TrackSysKey = wVkStripped;
1209 1210 1211 1212
        }
    }

    keylp.lp1.context = (key_state_table[VK_MENU] & 0x80) != 0; /* 1 if alt */
1213

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
    TRACE_(key)(" wParam=%04x, lParam=%08lx, InputKeyState=%x\n",
                wVk, keylp.lp2, key_state_table[wVk] );

    hook.vkCode      = wVk;
    hook.scanCode    = wScan;
    hook.flags       = (keylp.lp2 >> 24) | injected_flags;
    hook.time        = time;
    hook.dwExtraInfo = dwExtraInfo;
    if (HOOK_CallHooks( WH_KEYBOARD_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;

1224
    SERVER_START_REQ( send_hardware_message )
1225
    {
1226
        req->id       = (injected_flags & LLKHF_INJECTED) ? 0 : GetCurrentThreadId();
1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
        req->win      = 0;
        req->msg      = message;
        req->wparam   = wVk;
        req->lparam   = keylp.lp2;
        req->x        = cursor_pos.x;
        req->y        = cursor_pos.y;
        req->time     = time;
        req->info     = dwExtraInfo;
        wine_server_call( req );
    }
    SERVER_END_REQ;
1238 1239 1240
}


1241 1242 1243 1244 1245 1246 1247 1248
/**********************************************************************
 *		KEYBOARD_GenerateMsg
 *
 * Generate Down+Up messages when NumLock or CapsLock is pressed.
 *
 * Convention : called with vkey only VK_NUMLOCK or VK_CAPITAL
 *
 */
1249
static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, DWORD event_time )
1250
{
1251
  BOOL * State = (vkey==VK_NUMLOCK? &NumState : &CapsState);
1252
  DWORD up, down;
1253 1254 1255 1256 1257 1258

  if (*State) {
    /* The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes,
       don't treat it. It's from the same key press. Then the state goes to ON.
       And from there, a 'release' event will switch off the toggle key. */
    *State=FALSE;
1259 1260
    TRACE("INTERM : don't treat release of toggle key. key_state_table[%#x] = %#x\n",
          vkey,key_state_table[vkey]);
1261 1262
  } else
    {
1263 1264
        down = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0);
        up = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0) | KEYEVENTF_KEYUP;
1265
	if ( key_state_table[vkey] & 0x1 ) /* it was ON */
1266 1267 1268
	  {
	    if (Evtype!=KeyPress)
	      {
1269
		TRACE("ON + KeyRelease => generating DOWN and UP messages.\n");
1270 1271
	        X11DRV_send_keyboard_input( vkey, scan, down, event_time, 0, 0 );
	        X11DRV_send_keyboard_input( vkey, scan, up, event_time, 0, 0 );
1272
		*State=FALSE;
1273
		key_state_table[vkey] &= ~0x01; /* Toggle state to off. */
1274
	      }
1275 1276 1277 1278
	  }
	else /* it was OFF */
	  if (Evtype==KeyPress)
	    {
1279
	      TRACE("OFF + Keypress => generating DOWN and UP messages.\n");
1280 1281
	      X11DRV_send_keyboard_input( vkey, scan, down, event_time, 0, 0 );
	      X11DRV_send_keyboard_input( vkey, scan, up, event_time, 0, 0 );
1282
	      *State=TRUE; /* Goes to intermediary state before going to ON */
1283
	      key_state_table[vkey] |= 0x01; /* Toggle state to on. */
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
	    }
    }
}

/***********************************************************************
 *           KEYBOARD_UpdateOneState
 *
 * Updates internal state for <vkey>, depending on key <state> under X
 *
 */
1294
static inline void KEYBOARD_UpdateOneState ( int vkey, int state, DWORD time )
1295 1296
{
    /* Do something if internal table state != X state for keycode */
1297
    if (((key_state_table[vkey] & 0x80)!=0) != state)
1298
    {
Andreas Mohr's avatar
Andreas Mohr committed
1299
        TRACE("Adjusting state for vkey %#.2x. State before %#.2x\n",
1300
              vkey, key_state_table[vkey]);
1301 1302

        /* Fake key being pressed inside wine */
1303
        X11DRV_send_keyboard_input( vkey, 0, state? 0 : KEYEVENTF_KEYUP, time, 0, 0 );
1304

1305
        TRACE("State after %#.2x\n",key_state_table[vkey]);
1306 1307 1308 1309
    }
}

/***********************************************************************
1310
 *           X11DRV_KeymapNotify
1311
 *
1312
 * Update modifiers state (Ctrl, Alt, Shift) when window is activated.
1313 1314 1315
 *
 * This handles the case where one uses Ctrl+... Alt+... or Shift+.. to switch
 * from wine to another application and back.
1316
 * Toggle keys are handled in HandleEvent.
1317
 */
1318
void X11DRV_KeymapNotify( HWND hwnd, XEvent *event )
1319
{
1320 1321
    int i, j, alt, control, shift;
    DWORD time = GetCurrentTime();
1322

1323
    alt = control = shift = 0;
1324 1325 1326 1327
    /* the minimum keycode is always greater or equal to 8, so we can
     * skip the first 8 values, hence start at 1
     */
    for (i = 1; i < 32; i++)
1328
    {
1329
        if (!event->xkeymap.key_vector[i]) continue;
1330 1331
        for (j = 0; j < 8; j++)
        {
1332
            if (!(event->xkeymap.key_vector[i] & (1<<j))) continue;
1333 1334 1335 1336 1337 1338 1339
            switch(keyc2vkey[(i * 8) + j] & 0xff)
            {
            case VK_MENU:    alt = 1; break;
            case VK_CONTROL: control = 1; break;
            case VK_SHIFT:   shift = 1; break;
            }
        }
1340
    }
1341 1342 1343
    KEYBOARD_UpdateOneState( VK_MENU, alt, time );
    KEYBOARD_UpdateOneState( VK_CONTROL, control, time );
    KEYBOARD_UpdateOneState( VK_SHIFT, shift, time );
1344 1345 1346
}

/***********************************************************************
1347
 *           X11DRV_KeyEvent
1348 1349 1350
 *
 * Handle a X key event
 */
1351
void X11DRV_KeyEvent( HWND hwnd, XEvent *xev )
1352
{
1353
    XKeyEvent *event = &xev->xkey;
1354
    char Str[24];
1355
    KeySym keysym = 0;
1356 1357 1358
    WORD vkey = 0, bScan;
    DWORD dwFlags;
    int ascii_chars;
1359
    XIC xic = X11DRV_get_ic( hwnd );
1360
    DWORD event_time = EVENT_x11_time_to_win32_time(event->time);
1361 1362 1363 1364
    Status status = 0;

    TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
		event->type, event->window, event->state, event->keycode);
1365

1366
    wine_tsx11_lock();
1367 1368
    /* Clients should pass only KeyPress events to XmbLookupString */
    if (xic && event->type == KeyPress)
1369
        ascii_chars = XmbLookupString(xic, event, Str, sizeof(Str), &keysym, &status);
1370 1371
    else
        ascii_chars = XLookupString(event, Str, sizeof(Str), &keysym, NULL);
1372
    wine_tsx11_unlock();
1373

1374
    TRACE_(key)("nbyte = %d, status 0x%x\n", ascii_chars, status);
1375 1376 1377 1378 1379 1380 1381 1382 1383

    if (status == XBufferOverflow)
        ERR("Buffer Overflow need %i!\n",ascii_chars);

    if (status == XLookupChars)
    {
        X11DRV_XIMLookupChars( Str, ascii_chars );
        return;
    }
1384

Andreas Mohr's avatar
Andreas Mohr committed
1385
    /* If XKB extensions are used, the state mask for AltGr will use the group
1386 1387
       index instead of the modifier mask. The group index is set in bits
       13-14 of the state field in the XKeyEvent structure. So if AltGr is
Andreas Mohr's avatar
Andreas Mohr committed
1388 1389 1390
       pressed, look if the group index is different than 0. From XKB
       extension documentation, the group index for AltGr should be 2
       (event->state = 0x2000). It's probably better to not assume a
1391
       predefined group index and find it dynamically
1392 1393

       Ref: X Keyboard Extension: Library specification (section 14.1.1 and 17.1.1) */
1394 1395
    /* Save also all possible modifier states. */
    AltGrMask = event->state & (0x6000 | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
1396 1397

    if (TRACE_ON(key)){
1398
	const char *ksname;
1399

1400 1401 1402
        wine_tsx11_lock();
        ksname = XKeysymToString(keysym);
        wine_tsx11_unlock();
1403 1404
	if (!ksname)
	  ksname = "No Name";
1405
	TRACE_(key)("%s : keysym=%lX (%s), # of chars=%d / %s\n",
1406
                    (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
1407
                    keysym, ksname, ascii_chars, debugstr_an(Str, ascii_chars));
1408 1409
    }

1410
    wine_tsx11_lock();
1411 1412 1413
    vkey = EVENT_event_to_vkey(xic,event);
    /* X returns keycode 0 for composed characters */
    if (!vkey && ascii_chars) vkey = VK_NONAME;
1414
    wine_tsx11_unlock();
1415

1416
    TRACE_(key)("keycode 0x%x converted to vkey 0x%x\n",
1417
                event->keycode, vkey);
1418 1419 1420 1421 1422

   if (vkey)
   {
    switch (vkey & 0xff)
    {
1423
    case VK_NUMLOCK:
1424
      KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, event->type, event_time );
1425 1426
      break;
    case VK_CAPITAL:
1427
      TRACE("Caps Lock event. (type %d). State before : %#.2x\n",event->type,key_state_table[vkey]);
1428
      KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, event->type, event_time );
1429
      TRACE("State after : %#.2x\n",key_state_table[vkey]);
1430 1431 1432
      break;
    default:
        /* Adjust the NUMLOCK state if it has been changed outside wine */
1433
	if (!(key_state_table[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
1434
	  {
Andreas Mohr's avatar
Andreas Mohr committed
1435
	    TRACE("Adjusting NumLock state.\n");
1436 1437
	    KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyPress, event_time );
	    KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyRelease, event_time );
1438 1439
	  }
        /* Adjust the CAPSLOCK state if it has been changed outside wine */
1440
	if (!(key_state_table[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
1441
	  {
1442
              TRACE("Adjusting Caps Lock state.\n");
1443 1444
	    KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyPress, event_time );
	    KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyRelease, event_time );
1445 1446 1447 1448 1449
	  }
	/* Not Num nor Caps : end of intermediary states for both. */
	NumState = FALSE;
	CapsState = FALSE;

1450
	bScan = keyc2scan[event->keycode] & 0xFF;
1451
	TRACE_(key)("bScan = 0x%02x.\n", bScan);
1452

1453 1454 1455 1456
	dwFlags = 0;
	if ( event->type == KeyRelease ) dwFlags |= KEYEVENTF_KEYUP;
	if ( vkey & 0x100 )              dwFlags |= KEYEVENTF_EXTENDEDKEY;

1457
        X11DRV_send_keyboard_input( vkey & 0xff, bScan, dwFlags, event_time, 0, 0 );
1458 1459 1460 1461
    }
   }
}

1462 1463 1464
/**********************************************************************
 *		X11DRV_KEYBOARD_DetectLayout
 *
1465
 * Called from X11DRV_InitKeyboard
1466 1467
 *  This routine walks through the defined keyboard layouts and selects
 *  whichever matches most closely.
1468
 * X11 lock must be held.
1469
 */
Patrik Stridvall's avatar
Patrik Stridvall committed
1470
static void
1471
X11DRV_KEYBOARD_DetectLayout (void)
1472
{
1473
  Display *display = thread_display();
1474 1475
  unsigned current, match, mismatch, seq, i, syms;
  int score, keyc, key, pkey, ok;
1476
  KeySym keysym = 0;
1477
  const char (*lkey)[MAIN_LEN][4];
1478
  unsigned max_seq = 0;
1479
  int max_score = 0, ismatch = 0;
1480
  char ckey[256][4];
1481 1482 1483

  syms = keysyms_per_keycode;
  if (syms > 4) {
1484
    WARN("%d keysyms per keycode not supported, set to 4\n", syms);
1485 1486
    syms = 4;
  }
1487 1488 1489

  memset( ckey, 0, sizeof(ckey) );
  for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
1490 1491
      /* get data for keycode from X server */
      for (i = 0; i < syms; i++) {
1492
        if (!(keysym = XKeycodeToKeysym (display, keyc, i))) continue;
1493
	/* Allow both one-byte and two-byte national keysyms */
1494
	if ((keysym < 0x8000) && (keysym != ' '))
1495 1496
        {
#ifdef HAVE_XKB
1497
            if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[keyc][i], 1, NULL))
1498 1499 1500 1501 1502 1503 1504
#endif
            {
                TRACE("XKB could not translate keysym %ld\n", keysym);
                /* FIXME: query what keysym is used as Mode_switch, fill XKeyEvent
                 * with appropriate ShiftMask and Mode_switch, use XLookupString
                 * to get character in the local encoding.
                 */
1505
                ckey[keyc][i] = keysym & 0xFF;
1506 1507
            }
        }
1508
	else {
1509
	  ckey[keyc][i] = KEYBOARD_MapDeadKeysym(keysym);
1510
	}
1511
      }
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
  }

  for (current = 0; main_key_tab[current].comment; current++) {
    TRACE("Attempting to match against \"%s\"\n", main_key_tab[current].comment);
    match = 0;
    mismatch = 0;
    score = 0;
    seq = 0;
    lkey = main_key_tab[current].key;
    pkey = -1;
    for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
      if (ckey[keyc][0]) {
1524 1525 1526 1527 1528 1529 1530
	/* search for a match in layout table */
	/* right now, we just find an absolute match for defined positions */
	/* (undefined positions are ignored, so if it's defined as "3#" in */
	/* the table, it's okay that the X server has "3#", for example) */
	/* however, the score will be higher for longer matches */
	for (key = 0; key < MAIN_LEN; key++) {
	  for (ok = 0, i = 0; (ok >= 0) && (i < syms); i++) {
1531
	    if ((*lkey)[key][i] && ((*lkey)[key][i] == ckey[keyc][i]))
1532
	      ok++;
1533
	    if ((*lkey)[key][i] && ((*lkey)[key][i] != ckey[keyc][i]))
1534
	      ok = -1;
1535
	  }
1536 1537 1538
	  if (ok > 0) {
	    score += ok;
	    break;
1539 1540
	  }
	}
1541
	/* count the matches and mismatches */
1542
	if (ok > 0) {
1543
	  match++;
1544 1545 1546 1547
	  /* and how much the keycode order matches */
	  if (key > pkey) seq++;
	  pkey = key;
	} else {
1548
          /* print spaces instead of \0's */
1549 1550 1551 1552 1553 1554
          char str[5];
          for (i = 0; i < 4; i++) str[i] = ckey[keyc][i] ? ckey[keyc][i] : ' ';
          str[4] = 0;
          TRACE_(key)("mismatch for keysym 0x%04lX, keycode %d, got %s\n", keysym, keyc, str );
          mismatch++;
          score -= syms;
1555
	}
1556 1557
      }
    }
1558 1559
    TRACE("matches=%d, mismatches=%d, seq=%d, score=%d\n",
	   match, mismatch, seq, score);
1560 1561
    if ((score > max_score) ||
	((score == max_score) && (seq > max_seq))) {
1562 1563 1564
      /* best match so far */
      kbd_layout = current;
      max_score = score;
1565
      max_seq = seq;
1566
      ismatch = !mismatch;
1567
    }
1568 1569
  }
  /* we're done, report results if necessary */
1570 1571 1572
  if (!ismatch)
    WARN("Using closest match (%s) for scan/virtual codes mapping.\n",
        main_key_tab[kbd_layout].comment);
1573 1574

  TRACE("detected layout is \"%s\"\n", main_key_tab[kbd_layout].comment);
1575 1576
}

1577
/**********************************************************************
1578
 *		X11DRV_InitKeyboard
1579
 */
1580
void X11DRV_InitKeyboard(void)
1581
{
1582
    Display *display = thread_display();
1583 1584 1585 1586 1587
    KeySym *ksp;
    XModifierKeymap *mmp;
    KeySym keysym;
    KeyCode *kcp;
    XKeyEvent e2;
1588 1589 1590 1591
    WORD scan, vkey, OEMvkey;
    int keyc, i, keyn, syms;
    char ckey[4]={0,0,0,0};
    const char (*lkey)[MAIN_LEN][4];
1592
    char vkey_used[256] = { 0 };
1593

1594
    wine_tsx11_lock();
1595 1596
    XDisplayKeycodes(display, &min_keycode, &max_keycode);
    ksp = XGetKeyboardMapping(display, min_keycode,
1597 1598 1599
                              max_keycode + 1 - min_keycode, &keysyms_per_keycode);
    /* We are only interested in keysyms_per_keycode.
       There is no need to hold a local copy of the keysyms table */
1600 1601 1602
    XFree(ksp);

    mmp = XGetModifierMapping(display);
1603 1604 1605 1606
    kcp = mmp->modifiermap;
    for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
    {
        int j;
1607

1608 1609 1610 1611
        for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
	    if (*kcp)
            {
		int k;
1612

1613
		for (k = 0; k < keysyms_per_keycode; k += 1)
1614
                    if (XKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
1615 1616
		    {
                        NumLockMask = 1 << i;
1617
                        TRACE_(key)("NumLockMask is %x\n", NumLockMask);
1618 1619 1620
		    }
            }
    }
1621
    XFreeModifiermap(mmp);
1622

1623 1624 1625 1626 1627
    /* Detect the keyboard layout */
    X11DRV_KEYBOARD_DetectLayout();
    lkey = main_key_tab[kbd_layout].key;
    syms = (keysyms_per_keycode > 4) ? 4 : keysyms_per_keycode;

1628
    /* Now build two conversion arrays :
1629
     * keycode -> vkey + scancode + extended
1630 1631 1632 1633 1634
     * vkey + extended -> keycode */

    e2.display = display;
    e2.state = 0;

1635
    OEMvkey = VK_OEM_8; /* next is available.  */
1636
    memset(keyc2vkey, 0, sizeof(keyc2vkey));
1637 1638
    for (keyc = min_keycode; keyc <= max_keycode; keyc++)
    {
1639 1640 1641
        char buf[30];
        int have_chars;

1642
        keysym = 0;
1643
        e2.keycode = (KeyCode)keyc;
1644
        have_chars = XLookupString(&e2, buf, sizeof(buf), &keysym, NULL);
1645
        vkey = 0; scan = 0;
1646 1647 1648 1649
        if (keysym)  /* otherwise, keycode not used */
        {
            if ((keysym >> 8) == 0xFF)         /* non-character key */
            {
1650 1651
                vkey = nonchar_key_vkey[keysym & 0xff];
                scan = nonchar_key_scan[keysym & 0xff];
1652 1653
		/* set extended bit when necessary */
		if (scan & 0x100) vkey |= 0x100;
1654 1655 1656 1657 1658
            } else if ((keysym >> 8) == 0x1008FF) { /* XFree86 vendor keys */
                vkey = xfree86_vendor_key_vkey[keysym & 0xff];
                /* All vendor keys are extended with a scan code of 0 per testing on WinXP */
                scan = 0x100;
		vkey |= 0x100;
1659 1660 1661
            } else if (keysym == 0x20) {                 /* Spacebar */
	        vkey = VK_SPACE;
		scan = 0x39;
1662
	    } else if (have_chars) {
1663 1664 1665
	      /* we seem to need to search the layout-dependent scancodes */
	      int maxlen=0,maxval=-1,ok;
	      for (i=0; i<syms; i++) {
1666
		keysym = XKeycodeToKeysym(display, keyc, i);
1667
		if ((keysym<0x8000) && (keysym!=' '))
1668 1669
                {
#ifdef HAVE_XKB
1670
                    if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[i], 1, NULL))
1671 1672 1673 1674 1675 1676 1677 1678
#endif
                    {
                        /* FIXME: query what keysym is used as Mode_switch, fill XKeyEvent
                         * with appropriate ShiftMask and Mode_switch, use XLookupString
                         * to get character in the local encoding.
                         */
                        ckey[i] = keysym & 0xFF;
                    }
1679 1680 1681
		} else {
		  ckey[i] = KEYBOARD_MapDeadKeysym(keysym);
		}
1682 1683 1684 1685 1686
	      }
	      /* find key with longest match streak */
	      for (keyn=0; keyn<MAIN_LEN; keyn++) {
		for (ok=(*lkey)[keyn][i=0]; ok&&(i<4); i++)
		  if ((*lkey)[keyn][i] && (*lkey)[keyn][i]!=ckey[i]) ok=0;
1687
		if (!ok) i--; /* we overshot */
1688 1689 1690 1691 1692 1693 1694
		if (ok||(i>maxlen)) {
		  maxlen=i; maxval=keyn;
		}
		if (ok) break;
	      }
	      if (maxval>=0) {
		/* got it */
1695 1696 1697 1698
		const WORD (*lscan)[MAIN_LEN] = main_key_tab[kbd_layout].scan;
		const WORD (*lvkey)[MAIN_LEN] = main_key_tab[kbd_layout].vkey;
		scan = (*lscan)[maxval];
		vkey = (*lvkey)[maxval];
1699 1700
	      }
	    }
1701 1702 1703 1704 1705 1706 1707 1708 1709
        }
        TRACE("keycode %04x => vkey %04x\n", e2.keycode, vkey);
        keyc2vkey[e2.keycode] = vkey;
        keyc2scan[e2.keycode] = scan;
        if ((vkey & 0xff) && vkey_used[(vkey & 0xff)])
            WARN("vkey %04x is being used by more than one keycode\n", vkey);
        vkey_used[(vkey & 0xff)] = 1;
    } /* for */

1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721
#define VKEY_IF_NOT_USED(vkey) (vkey_used[(vkey)] ? 0 : (vkey_used[(vkey)] = 1, (vkey)))
    for (keyc = min_keycode; keyc <= max_keycode; keyc++)
    {
        vkey = keyc2vkey[keyc] & 0xff;
        if (vkey)
            continue;

        e2.keycode = (KeyCode)keyc;
        keysym = XLookupKeysym(&e2, 0);
        if (!keysym)
           continue;

1722 1723 1724 1725 1726 1727 1728
        /* find a suitable layout-dependent VK code */
        /* (most Winelib apps ought to be able to work without layout tables!) */
        for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
        {
            keysym = XLookupKeysym(&e2, i);
            if ((keysym >= XK_0 && keysym <= XK_9)
                || (keysym >= XK_A && keysym <= XK_Z)) {
1729
                vkey = VKEY_IF_NOT_USED(keysym);
1730
            }
1731
        }
1732

1733 1734 1735 1736
        for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
        {
            keysym = XLookupKeysym(&e2, i);
            switch (keysym)
1737
            {
1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748
            case ';':             vkey = VKEY_IF_NOT_USED(VK_OEM_1); break;
            case '/':             vkey = VKEY_IF_NOT_USED(VK_OEM_2); break;
            case '`':             vkey = VKEY_IF_NOT_USED(VK_OEM_3); break;
            case '[':             vkey = VKEY_IF_NOT_USED(VK_OEM_4); break;
            case '\\':            vkey = VKEY_IF_NOT_USED(VK_OEM_5); break;
            case ']':             vkey = VKEY_IF_NOT_USED(VK_OEM_6); break;
            case '\'':            vkey = VKEY_IF_NOT_USED(VK_OEM_7); break;
            case ',':             vkey = VKEY_IF_NOT_USED(VK_OEM_COMMA); break;
            case '.':             vkey = VKEY_IF_NOT_USED(VK_OEM_PERIOD); break;
            case '-':             vkey = VKEY_IF_NOT_USED(VK_OEM_MINUS); break;
            case '+':             vkey = VKEY_IF_NOT_USED(VK_OEM_PLUS); break;
1749 1750
            }
        }
1751

1752 1753 1754 1755
        if (!vkey)
        {
            /* Others keys: let's assign OEM virtual key codes in the allowed range,
             * that is ([0xba,0xc0], [0xdb,0xe4], 0xe6 (given up) et [0xe9,0xf5]) */
1756
            do
1757
            {
1758 1759 1760 1761 1762 1763 1764
                switch (++OEMvkey)
                {
                case 0xc1 : OEMvkey=0xdb; break;
                case 0xe5 : OEMvkey=0xe9; break;
                case 0xf6 : OEMvkey=0xf5; WARN("No more OEM vkey available!\n");
                }
            } while (OEMvkey < 0xf5 && vkey_used[OEMvkey]);
1765

1766
            vkey = VKEY_IF_NOT_USED(OEMvkey);
1767

1768 1769 1770 1771 1772 1773
            if (TRACE_ON(keyboard))
            {
                TRACE("OEM specific virtual key %X assigned to keycode %X:\n",
                                 OEMvkey, e2.keycode);
                TRACE("(");
                for (i = 0; i < keysyms_per_keycode; i += 1)
1774
                {
1775
                    const char *ksname;
1776

1777 1778 1779 1780 1781
                    keysym = XLookupKeysym(&e2, i);
                    ksname = XKeysymToString(keysym);
                    if (!ksname)
                        ksname = "NoSymbol";
                    TRACE( "%lX (%s) ", keysym, ksname);
1782
                }
1783
                TRACE(")\n");
1784
            }
1785
        }
1786 1787 1788 1789 1790 1791 1792 1793

        if (vkey)
        {
            TRACE("keycode %04x => vkey %04x\n", e2.keycode, vkey);
            keyc2vkey[e2.keycode] = vkey;
        }
    } /* for */
#undef VKEY_IF_NOT_USED
1794 1795 1796 1797

    /* If some keys still lack scancodes, assign some arbitrary ones to them now */
    for (scan = 0x60, keyc = min_keycode; keyc <= max_keycode; keyc++)
      if (keyc2vkey[keyc]&&!keyc2scan[keyc]) {
1798
	const char *ksname;
1799 1800
	keysym = XKeycodeToKeysym(display, keyc, 0);
	ksname = XKeysymToString(keysym);
1801 1802 1803 1804
	if (!ksname) ksname = "NoSymbol";

	/* should make sure the scancode is unassigned here, but >=0x60 currently always is */

1805
	TRACE_(key)("assigning scancode %02x to unidentified keycode %02x (%s)\n",scan,keyc,ksname);
1806 1807 1808
	keyc2scan[keyc]=scan++;
      }

1809
    wine_tsx11_unlock();
1810 1811
}

1812

1813 1814 1815 1816 1817
/**********************************************************************
 *		GetAsyncKeyState (X11DRV.@)
 */
SHORT X11DRV_GetAsyncKeyState(INT key)
{
1818 1819
    SHORT retval;

1820 1821
    /* Photoshop livelocks unless mouse events are included here */
    X11DRV_MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_KEY | QS_MOUSE, 0 );
1822 1823 1824

    retval = ((key_state_table[key] & 0x40) ? 0x0001 : 0) |
             ((key_state_table[key] & 0x80) ? 0x8000 : 0);
1825 1826 1827 1828 1829 1830
    key_state_table[key] &= ~0x40;
    TRACE_(key)("(%x) -> %x\n", key, retval);
    return retval;
}


1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
/***********************************************************************
 *		GetKeyboardLayoutList (X11DRV.@)
 */
UINT X11DRV_GetKeyboardLayoutList(INT size, HKL *hkl)
{
    INT i;

    TRACE("%d, %p\n", size, hkl);

    if (!size)
    {
        size = 4096; /* hope we will never have that many */
        hkl = NULL;
    }

    for (i = 0; main_key_tab[i].comment && (i < size); i++)
    {
        if (hkl)
1849
        {
1850
            ULONG_PTR layout = main_key_tab[i].lcid;
1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861
            LANGID langid;

            /* see comment for GetKeyboardLayout */
            langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
            if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
                layout |= 0xe001 << 16; /* FIXME */
            else
                layout |= layout << 16;

            hkl[i] = (HKL)layout;
        }
1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
    }
    return i;
}


/***********************************************************************
 *		GetKeyboardLayout (X11DRV.@)
 */
HKL X11DRV_GetKeyboardLayout(DWORD dwThreadid)
{
1872
    ULONG_PTR layout;
1873 1874
    LANGID langid;

1875
    if (dwThreadid && dwThreadid != GetCurrentThreadId())
1876
        FIXME("couldn't return keyboard layout for thread %04x\n", dwThreadid);
1877

1878
#if 0
1879
    layout = main_key_tab[kbd_layout].lcid;
1880 1881 1882 1883 1884 1885 1886 1887 1888 1889
#else
    /* FIXME:
     * Winword uses return value of GetKeyboardLayout as a codepage
     * to translate ANSI keyboard messages to unicode. But we have
     * a problem with it: for instance Polish keyboard layout is
     * identical to the US one, and therefore instead of the Polish
     * locale id we return the US one.
     */
    layout = GetUserDefaultLCID();
#endif
1890 1891 1892
    /* 
     * Microsoft Office expects this value to be something specific
     * for Japanese and Korean Windows with an IME the value is 0xe001
1893
     * We should probably check to see if an IME exists and if so then
1894 1895 1896 1897
     * set this word properly.
     */
    langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
    if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
1898
        layout |= 0xe001 << 16; /* FIXME */
1899 1900
    else
        layout |= layout << 16;
1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915

    return (HKL)layout;
}


/***********************************************************************
 *		GetKeyboardLayoutName (X11DRV.@)
 */
BOOL X11DRV_GetKeyboardLayoutName(LPWSTR name)
{
    static const WCHAR formatW[] = {'%','0','8','l','x',0};
    DWORD layout;
    LANGID langid;

    layout = main_key_tab[kbd_layout].lcid;
1916
    /* see comment for GetKeyboardLayout */
1917 1918 1919
    langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
    if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
        layout |= 0xe001 << 16; /* FIXME */
1920 1921
    else
        layout |= layout << 16;
1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961

    sprintfW(name, formatW, layout);
    TRACE("returning %s\n", debugstr_w(name));
    return TRUE;
}


/***********************************************************************
 *		LoadKeyboardLayout (X11DRV.@)
 */
HKL X11DRV_LoadKeyboardLayout(LPCWSTR name, UINT flags)
{
    FIXME("%s, %04x: stub!\n", debugstr_w(name), flags);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}


/***********************************************************************
 *		UnloadKeyboardLayout (X11DRV.@)
 */
BOOL X11DRV_UnloadKeyboardLayout(HKL hkl)
{
    FIXME("%p: stub!\n", hkl);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return FALSE;
}


/***********************************************************************
 *		ActivateKeyboardLayout (X11DRV.@)
 */
HKL X11DRV_ActivateKeyboardLayout(HKL hkl, UINT flags)
{
    FIXME("%p, %04x: stub!\n", hkl, flags);
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}


1962 1963 1964
/***********************************************************************
 *           X11DRV_MappingNotify
 */
1965
void X11DRV_MappingNotify( HWND dummy, XEvent *event )
1966
{
1967 1968
    HWND hwnd;

1969
    wine_tsx11_lock();
1970
    XRefreshKeyboardMapping(&event->xmapping);
1971
    wine_tsx11_unlock();
1972
    X11DRV_InitKeyboard();
1973 1974 1975 1976 1977

    hwnd = GetFocus();
    if (!hwnd) hwnd = GetActiveWindow();
    PostMessageW(hwnd, WM_INPUTLANGCHANGEREQUEST,
                 0 /*FIXME*/, (LPARAM)X11DRV_GetKeyboardLayout(0));
1978 1979 1980
}


1981
/***********************************************************************
1982 1983 1984
 *		VkKeyScanEx (X11DRV.@)
 *
 * Note: Windows ignores HKL parameter and uses current active layout instead
1985
 */
1986
SHORT X11DRV_VkKeyScanEx(WCHAR wChar, HKL hkl)
1987
{
1988 1989 1990 1991
    Display *display = thread_display();
    KeyCode keycode;
    KeySym keysym;
    int i, index;
1992
    CHAR cChar;
1993 1994
    SHORT ret;

1995 1996 1997
    /* FIXME: what happens if wChar is not a Latin1 character and CP_UNIXCP
     * is UTF-8 (multibyte encoding)?
     */
1998 1999 2000 2001 2002 2003 2004 2005
    if (!WideCharToMultiByte(CP_UNIXCP, 0, &wChar, 1, &cChar, 1, NULL, NULL))
    {
        WARN("no translation from unicode to CP_UNIXCP for 0x%02x\n", wChar);
        return -1;
    }

    TRACE("wChar 0x%02x -> cChar '%c'\n", wChar, cChar);

2006 2007 2008 2009
    /* char->keysym (same for ANSI chars) */
    keysym = (unsigned char)cChar; /* (!) cChar is signed */
    if (keysym <= 27) keysym += 0xFF00; /* special chars : return, backspace... */

2010 2011
    wine_tsx11_lock();
    keycode = XKeysymToKeycode(display, keysym);  /* keysym -> keycode */
2012
    if (!keycode)
2013 2014 2015 2016 2017 2018 2019 2020 2021
    {
        if (keysym >= 0xFF00) /* Windows returns 0x0240 + cChar in this case */
        {
            ret = 0x0240 + cChar; /* 0x0200 indicates a control character */
            TRACE(" ... returning ctrl char %#.2x\n", ret);
            wine_tsx11_unlock();
            return ret;
        }
        /* It didn't work ... let's try with deadchar code. */
2022
        TRACE("retrying with | 0xFE00\n");
2023
        keycode = XKeysymToKeycode(display, keysym | 0xFE00);
2024
    }
2025
    wine_tsx11_unlock();
2026

2027 2028
    TRACE("'%c'(%#lx, %lu): got keycode %#.2x (%d)\n",
            cChar, keysym, keysym, keycode, keycode);
2029

2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
    /* keycode -> (keyc2vkey) vkey */
    ret = keyc2vkey[keycode];

    if (!keycode || !ret)
    {
        TRACE("keycode for '%c' not found, returning -1\n", cChar);
        return -1;
    }

    index = -1;
2040
    wine_tsx11_lock();
2041 2042
    for (i = 0; i < 4; i++) /* find shift state */
    {
2043
        if (XKeycodeToKeysym(display, keycode, i) == keysym)
2044 2045 2046 2047 2048
        {
            index = i;
            break;
        }
    }
2049
    wine_tsx11_unlock();
2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072

    switch (index)
    {
        default:
        case -1:
            WARN("Keysym %lx not found while parsing the keycode table\n", keysym);
            return -1;

        case 0: break;
        case 1: ret += 0x0100; break;
        case 2: ret += 0x0600; break;
        case 3: ret += 0x0700; break;
    }
    /*
      index : 0     adds 0x0000
      index : 1     adds 0x0100 (shift)
      index : ?     adds 0x0200 (ctrl)
      index : 2     adds 0x0600 (ctrl+alt)
      index : 3     adds 0x0700 (ctrl+alt+shift)
     */

    TRACE(" ... returning %#.2x\n", ret);
    return ret;
2073 2074 2075
}

/***********************************************************************
2076
 *		MapVirtualKeyEx (X11DRV.@)
2077
 */
2078
UINT X11DRV_MapVirtualKeyEx(UINT wCode, UINT wMapType, HKL hkl)
2079
{
2080 2081
    Display *display = thread_display();

2082
#define returnMVK(value) { TRACE("returning 0x%x.\n",value); return value; }
2083

2084 2085 2086 2087
    TRACE("wCode=0x%x, wMapType=%d, hkl %p\n", wCode, wMapType, hkl);
    if (hkl != X11DRV_GetKeyboardLayout(0))
        FIXME("keyboard layout %p is not supported\n", hkl);

2088
	switch(wMapType) {
2089 2090 2091 2092
		case MAPVK_VK_TO_VSC: /* vkey-code to scan-code */
		case MAPVK_VK_TO_VSC_EX: /* FIXME: should differentiate between
                                            left and right keys */
		{
2093 2094 2095 2096
			/* let's do vkey -> keycode -> scan */
			int keyc;
			for (keyc=min_keycode; keyc<=max_keycode; keyc++)
				if ((keyc2vkey[keyc] & 0xFF) == wCode)
2097
					returnMVK (keyc2scan[keyc] & 0xFF);
2098
			TRACE("returning no scan-code.\n");
2099 2100 2101 2102 2103 2104
		        return 0;
		}
		case MAPVK_VSC_TO_VK: /* scan-code to vkey-code */
		case MAPVK_VSC_TO_VK_EX: /* FIXME: should differentiate between
                                            left and right keys */
		{
2105
			/* let's do scan -> keycode -> vkey */
2106 2107
			int keyc;
			for (keyc=min_keycode; keyc<=max_keycode; keyc++)
2108
				if ((keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
2109
					returnMVK (keyc2vkey[keyc] & 0xFF);
2110
			TRACE("returning no vkey-code.\n");
2111 2112 2113 2114
		        return 0;
		}
		case MAPVK_VK_TO_CHAR: /* vkey-code to unshifted ANSI code */
		{
2115 2116 2117 2118 2119 2120
                        /* we still don't know what "unshifted" means. in windows VK_W (0x57)
                         * returns 0x57, which is upercase 'W'. So we have to return the uppercase
                         * key.. Looks like something is wrong with the MS docs?
                         * This is only true for letters, for example VK_0 returns '0' not ')'.
                         * - hence we use the lock mask to ensure this happens.
                         */
2121 2122 2123
			/* let's do vkey -> keycode -> (XLookupString) ansi char */
			XKeyEvent e;
			KeySym keysym;
2124
			int keyc;
2125 2126
			char s[2];
			e.display = display;
2127 2128 2129

			e.state = LockMask;
			/* LockMask should behave exactly like caps lock - upercase
2130
			 * the letter keys and that's about it. */
2131

2132 2133
                        wine_tsx11_lock();

2134 2135 2136 2137 2138 2139 2140
			e.keycode = 0;
			/* We exit on the first keycode found, to speed up the thing. */
			for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
			{ /* Find a keycode that could have generated this virtual key */
			    if  ((keyc2vkey[keyc] & 0xFF) == wCode)
			    { /* We filter the extended bit, we don't know it */
			        e.keycode = keyc; /* Store it temporarily */
2141
				if ((EVENT_event_to_vkey(0,&e) & 0xFF) != wCode) {
2142 2143 2144 2145 2146 2147 2148
				    e.keycode = 0; /* Wrong one (ex: because of the NumLock
					 state), so set it to 0, we'll find another one */
				}
			    }
			}

			if ((wCode>=VK_NUMPAD0) && (wCode<=VK_NUMPAD9))
2149
			  e.keycode = XKeysymToKeycode(e.display, wCode-VK_NUMPAD0+XK_KP_0);
2150

2151
			if (wCode==VK_DECIMAL)
2152
			  e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2153 2154 2155

			if (!e.keycode)
			{
2156
			  WARN("Unknown virtual key %X !!!\n", wCode);
2157
                          wine_tsx11_unlock();
2158 2159
			  return 0; /* whatever */
			}
2160
			TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2161

2162 2163 2164 2165 2166
			if (XLookupString(&e, s, 2, &keysym, NULL))
                        {
                            wine_tsx11_unlock();
                            returnMVK (*s);
                        }
2167

2168
			TRACE("returning no ANSI.\n");
2169
                        wine_tsx11_unlock();
2170
			return 0;
2171
		}
2172
		default: /* reserved */
2173
			FIXME("Unknown wMapType %d !\n", wMapType);
2174
			return 0;
2175 2176 2177 2178 2179
	}
	return 0;
}

/***********************************************************************
2180
 *		GetKeyNameText (X11DRV.@)
2181
 */
2182
INT X11DRV_GetKeyNameText(LONG lParam, LPWSTR lpBuffer, INT nSize)
2183
{
2184
  int vkey, ansi, scanCode;
2185
  KeyCode keyc;
2186
  int keyi;
2187 2188
  KeySym keys;
  char *name;
2189

2190
  scanCode = lParam >> 16;
2191 2192 2193
  scanCode &= 0x1ff;  /* keep "extended-key" flag with code */

  /* FIXME: should use MVK type 3 (NT version that distinguishes right and left */
2194
  vkey = X11DRV_MapVirtualKeyEx(scanCode, 1, X11DRV_GetKeyboardLayout(0));
2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214

  /*  handle "don't care" bit (0x02000000) */
  if (!(lParam & 0x02000000)) {
    switch (vkey) {
         case VK_LSHIFT:
         case VK_RSHIFT:
                          vkey = VK_SHIFT;
                          break;
       case VK_LCONTROL:
       case VK_RCONTROL:
                          vkey = VK_CONTROL;
                          break;
          case VK_LMENU:
          case VK_RMENU:
                          vkey = VK_MENU;
                          break;
               default:
                          break;
    }
  }
2215

2216
  ansi = X11DRV_MapVirtualKeyEx(vkey, 2, X11DRV_GetKeyboardLayout(0));
2217
  TRACE("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n", scanCode, vkey, ansi);
2218

2219 2220 2221 2222 2223 2224 2225 2226
  /* first get the name of the "regular" keys which is the Upper case
     value of the keycap imprint.                                     */
  if ( ((ansi >= 0x21) && (ansi <= 0x7e)) &&
       (scanCode != 0x137) &&   /* PrtScn   */
       (scanCode != 0x135) &&   /* numpad / */
       (scanCode != 0x37 ) &&   /* numpad * */
       (scanCode != 0x4a ) &&   /* numpad - */
       (scanCode != 0x4e ) )    /* numpad + */
2227 2228 2229
      {
        if ((nSize >= 2) && lpBuffer)
	{
2230
          *lpBuffer = toupperW((WCHAR)ansi);
2231 2232
          *(lpBuffer+1) = 0;
          return 1;
2233
        }
2234 2235
     else
        return 0;
2236 2237
  }

2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
  /* FIXME: horrible hack to fix function keys. Windows reports scancode
            without "extended-key" flag. However Wine generates scancode
            *with* "extended-key" flag. Seems to occur *only* for the
            function keys. Soooo.. We will leave the table alone and
            fudge the lookup here till the other part is found and fixed!!! */

  if ( ((scanCode >= 0x13b) && (scanCode <= 0x144)) ||
       (scanCode == 0x157) || (scanCode == 0x158))
    scanCode &= 0xff;   /* remove "extended-key" flag for Fx keys */

  /* let's do scancode -> keycode -> keysym -> String */

2250 2251
  for (keyi=min_keycode; keyi<=max_keycode; keyi++)
      if ((keyc2scan[keyi]) == scanCode)
2252
         break;
2253
  if (keyi <= max_keycode)
2254
  {
2255
      wine_tsx11_lock();
2256
      keyc = (KeyCode) keyi;
2257 2258 2259
      keys = XKeycodeToKeysym(thread_display(), keyc, 0);
      name = XKeysymToString(keys);
      wine_tsx11_unlock();
2260 2261
      TRACE("found scan=%04x keyc=%04x keysym=%04x string=%s\n",
            scanCode, keyc, (int)keys, name);
2262 2263
      if (lpBuffer && nSize && name)
      {
2264 2265
          MultiByteToWideChar(CP_UNIXCP, 0, name, -1, lpBuffer, nSize);
          lpBuffer[nSize - 1] = 0;
2266 2267 2268
          return 1;
      }
  }
2269

2270
  /* Finally issue WARN for unknown keys   */
2271

2272
  WARN("(%08x,%p,%d): unsupported key, vkey=%04x, ansi=%04x\n",lParam,lpBuffer,nSize,vkey,ansi);
2273 2274
  if (lpBuffer && nSize)
    *lpBuffer = 0;
2275 2276 2277
  return 0;
}

2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
/***********************************************************************
 *		X11DRV_KEYBOARD_MapDeadKeysym
 */
static char KEYBOARD_MapDeadKeysym(KeySym keysym)
{
	switch (keysym)
	    {
	/* symbolic ASCII is the same as defined in rfc1345 */
#ifdef XK_dead_tilde
	    case XK_dead_tilde :
#endif
	    case 0x1000FE7E : /* Xfree's XK_Dtilde */
		return '~';	/* '? */
#ifdef XK_dead_acute
	    case XK_dead_acute :
#endif
	    case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
		return 0xb4;	/* '' */
#ifdef XK_dead_circumflex
	    case XK_dead_circumflex:
#endif
	    case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
		return '^';	/* '> */
#ifdef XK_dead_grave
	    case XK_dead_grave :
#endif
	    case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
		return '`';	/* '! */
#ifdef XK_dead_diaeresis
	    case XK_dead_diaeresis :
#endif
	    case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
		return 0xa8;	/* ': */
#ifdef XK_dead_cedilla
	    case XK_dead_cedilla :
	        return 0xb8;	/* ', */
#endif
#ifdef XK_dead_macron
	    case XK_dead_macron :
	        return '-';	/* 'm isn't defined on iso-8859-x */
#endif
#ifdef XK_dead_breve
	    case XK_dead_breve :
	        return 0xa2;	/* '( */
#endif
#ifdef XK_dead_abovedot
	    case XK_dead_abovedot :
	        return 0xff;	/* '. */
#endif
#ifdef XK_dead_abovering
	    case XK_dead_abovering :
	        return '0';	/* '0 isn't defined on iso-8859-x */
#endif
#ifdef XK_dead_doubleacute
	    case XK_dead_doubleacute :
	        return 0xbd;	/* '" */
#endif
#ifdef XK_dead_caron
	    case XK_dead_caron :
	        return 0xb7;	/* '< */
#endif
#ifdef XK_dead_ogonek
	    case XK_dead_ogonek :
	        return 0xb2;	/* '; */
#endif
/* FIXME: I don't know this three.
	    case XK_dead_iota :
2345
	        return 'i';
2346 2347 2348 2349 2350 2351
	    case XK_dead_voiced_sound :
	        return 'v';
	    case XK_dead_semivoiced_sound :
	        return 's';
*/
	    }
2352
	TRACE("no character for dead keysym 0x%08lx\n",keysym);
2353 2354 2355
	return 0;
}

2356
/***********************************************************************
2357
 *		ToUnicodeEx (X11DRV.@)
2358
 *
2359
 * The ToUnicode function translates the specified virtual-key code and keyboard
2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373
 * state to the corresponding Windows character or characters.
 *
 * If the specified key is a dead key, the return value is negative. Otherwise,
 * it is one of the following values:
 * Value	Meaning
 * 0	The specified virtual key has no translation for the current state of the keyboard.
 * 1	One Windows character was copied to the buffer.
 * 2	Two characters were copied to the buffer. This usually happens when a
 *      dead-key character (accent or diacritic) stored in the keyboard layout cannot
 *      be composed with the specified virtual key to form a single character.
 *
 * FIXME : should do the above (return 2 for non matching deadchar+char combinations)
 *
 */
2374 2375
INT X11DRV_ToUnicodeEx(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
		     LPWSTR bufW, int bufW_size, UINT flags, HKL hkl)
2376
{
2377
    Display *display = thread_display();
2378
    XKeyEvent e;
2379
    KeySym keysym = 0;
2380
    INT ret;
2381
    int keyc;
2382
    char lpChar[10];
2383 2384
    HWND focus;
    XIC xic;
2385
    Status status = 0;
2386

2387 2388
    if (scanCode & 0x8000)
    {
2389
        TRACE("Key UP, doing nothing\n" );
2390 2391
        return 0;
    }
2392

2393 2394 2395
    if (hkl != X11DRV_GetKeyboardLayout(0))
        FIXME("keyboard layout %p is not supported\n", hkl);

2396 2397 2398 2399 2400 2401
    if ((lpKeyState[VK_MENU] & 0x80) && (lpKeyState[VK_CONTROL] & 0x80))
    {
        TRACE("Ctrl+Alt+[key] won't generate a character\n");
        return 0;
    }

2402 2403 2404
    e.display = display;
    e.keycode = 0;
    e.state = 0;
2405 2406 2407 2408 2409 2410 2411 2412
    e.type = KeyPress;

    focus = GetFocus();
    if (focus) focus = GetAncestor( focus, GA_ROOT );
    if (!focus) focus = GetActiveWindow();
    e.window = X11DRV_get_whole_window( focus );
    xic = X11DRV_get_ic( focus );

2413
    if (lpKeyState[VK_SHIFT] & 0x80)
2414 2415
    {
	TRACE("ShiftMask = %04x\n", ShiftMask);
2416
	e.state |= ShiftMask;
2417
    }
2418
    if (lpKeyState[VK_CAPITAL] & 0x01)
2419 2420
    {
	TRACE("LockMask = %04x\n", LockMask);
2421
	e.state |= LockMask;
2422
    }
2423
    if (lpKeyState[VK_CONTROL] & 0x80)
2424 2425
    {
	TRACE("ControlMask = %04x\n", ControlMask);
2426
	e.state |= ControlMask;
2427
    }
2428
    if (lpKeyState[VK_NUMLOCK] & 0x01)
2429 2430
    {
	TRACE("NumLockMask = %04x\n", NumLockMask);
2431
	e.state |= NumLockMask;
2432
    }
2433 2434

    /* Restore saved AltGr state */
2435
    TRACE("AltGrMask = %04x\n", AltGrMask);
2436 2437
    e.state |= AltGrMask;

2438
    TRACE_(key)("(%04X, %04X) : faked state = 0x%04x\n",
2439
		virtKey, scanCode, e.state);
2440
    wine_tsx11_lock();
2441 2442 2443 2444 2445 2446
    /* We exit on the first keycode found, to speed up the thing. */
    for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
      { /* Find a keycode that could have generated this virtual key */
          if  ((keyc2vkey[keyc] & 0xFF) == virtKey)
          { /* We filter the extended bit, we don't know it */
              e.keycode = keyc; /* Store it temporarily */
2447
              if ((EVENT_event_to_vkey(xic,&e) & 0xFF) != virtKey) {
2448 2449 2450 2451 2452 2453
                  e.keycode = 0; /* Wrong one (ex: because of the NumLock
                         state), so set it to 0, we'll find another one */
              }
	  }
      }

2454 2455 2456
    if (virtKey >= VK_LEFT && virtKey <= VK_DOWN)
        e.keycode = XKeysymToKeycode(e.display, virtKey - VK_LEFT + XK_Left);

2457
    if ((virtKey>=VK_NUMPAD0) && (virtKey<=VK_NUMPAD9))
2458
        e.keycode = XKeysymToKeycode(e.display, virtKey-VK_NUMPAD0+XK_KP_0);
2459

2460
    if (virtKey==VK_DECIMAL)
2461
        e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2462

2463 2464 2465
    if (virtKey==VK_SEPARATOR)
        e.keycode = XKeysymToKeycode(e.display, XK_KP_Separator);

2466
    if (!e.keycode && virtKey != VK_NONAME)
2467
      {
2468
	WARN("Unknown virtual key %X !!!\n", virtKey);
2469
        wine_tsx11_unlock();
2470
	return 0;
2471
      }
2472
    else TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2473

2474 2475 2476
    TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
		e.type, e.window, e.state, e.keycode);

2477 2478 2479
    /* Clients should pass only KeyPress events to XmbLookupString,
     * e.type was set to KeyPress above.
     */
2480
    if (xic)
2481
        ret = XmbLookupString(xic, &e, lpChar, sizeof(lpChar), &keysym, &status);
2482
    else
2483
        ret = XLookupString(&e, lpChar, sizeof(lpChar), &keysym, NULL);
2484 2485
    wine_tsx11_unlock();

2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
    TRACE_(key)("nbyte = %d, status 0x%x\n", ret, status);

    if (status == XBufferOverflow)
        ERR("Buffer Overflow need %d!\n", ret);

    if (TRACE_ON(key))
    {
        const char *ksname;

        wine_tsx11_lock();
        ksname = XKeysymToString(keysym);
        wine_tsx11_unlock();
        if (!ksname) ksname = "No Name";
        TRACE_(key)("%s : keysym=%lX (%s), # of chars=%d / %s\n",
                    (e.type == KeyPress) ? "KeyPress" : "KeyRelease",
                    keysym, ksname, ret, debugstr_an(lpChar, ret));
    }

2504
    if (ret == 0)
2505
    {
Mike McCormack's avatar
Mike McCormack committed
2506
	char dead_char;
2507

2508
#ifdef XK_EuroSign
2509 2510 2511 2512 2513 2514 2515 2516
        /* An ugly hack for EuroSign: X can't translate it to a character
           for some locales. */
        if (keysym == XK_EuroSign)
        {
            bufW[0] = 0x20AC;
            ret = 1;
            goto found;
        }
2517
#endif
2518 2519 2520 2521 2522 2523 2524 2525 2526
        /* Special case: X turns shift-tab into ISO_Left_Tab. */
        /* Here we change it back. */
        if (keysym == XK_ISO_Left_Tab)
        {
            bufW[0] = 0x09;
            ret = 1;
            goto found;
        }

2527
	dead_char = KEYBOARD_MapDeadKeysym(keysym);
2528
	if (dead_char)
2529
        {
2530
	    MultiByteToWideChar(CP_UNIXCP, 0, &dead_char, 1, bufW, bufW_size);
2531
	    ret = -1;
2532 2533 2534 2535 2536 2537 2538 2539 2540 2541
            goto found;
        }

        if (keysym >= 0x01000100 && keysym <= 0x0100ffff)
        {
            /* Unicode direct mapping */
            bufW[0] = keysym & 0xffff;
            ret = 1;
            goto found;
        }
2542 2543 2544 2545 2546
        else if ((keysym >> 8) == 0x1008FF) {
            bufW[0] = 0;
            ret = 0;
            goto found;
        }
2547 2548
	else
	    {
2549
	    const char *ksname;
2550

2551 2552 2553
            wine_tsx11_lock();
	    ksname = XKeysymToString(keysym);
            wine_tsx11_unlock();
2554 2555 2556 2557
	    if (!ksname)
		ksname = "No Name";
	    if ((keysym >> 8) != 0xff)
		{
2558
		WARN("no char for keysym %04lX (%s) :\n",
2559
                    keysym, ksname);
2560
		WARN("virtKey=%X, scanCode=%X, keycode=%X, state=%X\n",
2561
                    virtKey, scanCode, e.keycode, e.state);
2562 2563 2564
		}
	    }
	}
2565
    else {  /* ret != 0 */
2566 2567
        /* We have a special case to handle : Shift + arrow, shift + home, ...
           X returns a char for it, but Windows doesn't. Let's eat it. */
2568 2569
        if (!(e.state & NumLockMask)  /* NumLock is off */
            && (e.state & ShiftMask) /* Shift is pressed */
2570 2571
            && (keysym>=XK_KP_0) && (keysym<=XK_KP_9))
        {
2572
            lpChar[0] = 0;
2573 2574
            ret = 0;
        }
2575

2576
        /* more areas where X returns characters but Windows does not
Andreas Mohr's avatar
Andreas Mohr committed
2577
           CTRL + number or CTRL + symbol */
2578
        if (e.state & ControlMask)
2579
        {
2580 2581 2582
            if (((keysym>=33) && (keysym < 'A')) ||
                ((keysym > 'Z') && (keysym < 'a')))
            {
2583
                lpChar[0] = 0;
2584 2585
                ret = 0;
            }
2586
        }
2587

2588 2589 2590 2591
        /* We have another special case for delete key (XK_Delete) on an
         extended keyboard. X returns a char for it, but Windows doesn't */
        if (keysym == XK_Delete)
        {
2592
            lpChar[0] = 0;
2593 2594
            ret = 0;
        }
2595 2596 2597
	else if((lpKeyState[VK_SHIFT] & 0x80) /* Shift is pressed */
		&& (keysym == XK_KP_Decimal))
        {
2598
            lpChar[0] = 0;
2599 2600
            ret = 0;
        }
2601

2602 2603 2604 2605 2606 2607 2608
        /* Hack to detect an XLookupString hard-coded to Latin1 */
        if (ret == 1 && keysym >= 0x00a0 && keysym <= 0x00ff && (BYTE)lpChar[0] == keysym)
        {
            bufW[0] = (BYTE)lpChar[0];
            goto found;
        }

2609 2610
	/* perform translation to unicode */
	if(ret)
2611
	{
2612 2613
	    TRACE_(key)("Translating char 0x%02x to unicode\n", *(BYTE *)lpChar);
	    ret = MultiByteToWideChar(CP_UNIXCP, 0, lpChar, ret, bufW, bufW_size);
2614
	}
2615 2616
    }

2617
found:
2618
    TRACE_(key)("ToUnicode about to return %d with char %x %s\n",
2619
		ret, (ret && bufW) ? bufW[0] : 0, bufW ? "" : "(no buffer)");
2620 2621 2622
    return ret;
}

2623
/***********************************************************************
2624
 *		Beep (X11DRV.@)
2625
 */
2626
void X11DRV_Beep(void)
2627
{
2628 2629 2630
    wine_tsx11_lock();
    XBell(thread_display(), 0);
    wine_tsx11_unlock();
2631
}