keyboard.c 91.5 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 23
 *
 * 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
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 34 35
#ifdef HAVE_XKB
#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 "wine/winuser16.h"
48
#include "winnls.h"
49
#include "win.h"
50
#include "x11drv.h"
51
#include "wine/server.h"
52
#include "wine/unicode.h"
53
#include "wine/debug.h"
54

55 56
WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
WINE_DECLARE_DEBUG_CHANNEL(key);
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 87

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 */
88

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

static int NumLockMask, AltGrMask; /* mask in the XKeyEvent state */
static int kcControl, kcAlt, kcShift, kcNumLock, kcCapsLock; /* keycodes */

95 96
static char KEYBOARD_MapDeadKeysym(KeySym keysym);

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

113 114 115 116 117 118 119 120 121 122 123 124 125
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) */
};

126 127 128 129 130 131 132 133 134 135 136 137 138
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
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153
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) */
};


154 155
static const WORD main_key_vkey_qwerty[MAIN_LEN] =
{
156
/* NOTE: this layout must concur with the scan codes layout above */
157 158 159 160
   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,
161 162 163
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

Aric Cyr's avatar
Aric Cyr committed
164 165 166 167 168 169 170 171 172 173
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) */
};

174 175 176
static const WORD main_key_vkey_qwerty_v2[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
177 178 179 180
   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,
181 182 183
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

184 185 186
static const WORD main_key_vkey_qwertz[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
187 188 189 190
   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,
191 192 193 194 195 196
   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 */
197 198 199 200
   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
201 202
};

203 204 205
static const WORD main_key_vkey_abnt_qwerty[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
206 207 208 209
   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,
210 211 212
   VK_OEM_102, /* the 102nd key (actually to the right of l-shift) */
};

213 214 215
static const WORD main_key_vkey_azerty[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
216 217 218 219
   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,
220 221 222
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

223 224 225
static const WORD main_key_vkey_dvorak[MAIN_LEN] =
{
/* NOTE: this layout must concur with the scan codes layout above */
226 227 228 229
   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',
230 231 232
   VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
};

233 234
/*** DEFINE YOUR NEW LANGUAGE-SPECIFIC MAPPINGS BELOW, SEE EXISTING TABLES */

235 236
/* the VK mappings for the main keyboard will be auto-assigned as before,
   so what we have here is just the character tables */
237
/* order: Normal, Shift, AltGr, Shift-AltGr */
238 239 240 241 242
/* 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 */
243
/* If Wine fails to match your new table, use WINEDEBUG=+key to find out why */
244 245
/* Remember to also add your new table to the layout index table far below! */

246 247 248 249 250 251 252 253 254 255
/*** 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",",;",".:","-_",
 "<>|"
};

256
/*** United States keyboard layout (mostly contributed by Uwe Bonnes) */
257 258
static const char main_key_US[MAIN_LEN][4] =
{
259 260 261 262 263 264
 "`~","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",",<",".>","/?"
};

265 266 267 268 269 270 271
/*** 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
272
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
273 274 275
 "<>" /* the phantom key */
};

276 277 278 279 280 281 282 283 284
/*** 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"
};

285 286 287 288 289 290 291 292 293 294
/*** 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",",<",".>","/?",
 "\\|"
};

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

305
/*** Icelandic keyboard layout (setxkbmap is) */
306 307
static const char main_key_IS[MAIN_LEN][4] =
{
308 309 310
 "","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","","","+*",
311
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","",
312
 "<>"
313 314
};

315
/*** German keyboard layout (setxkbmap de) */
316 317
static const char main_key_DE[MAIN_LEN][4] =
{
318 319 320 321
 "^","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",",;",".:","-_",
322
 "<>|"
323 324
};

325 326 327 328 329 330 331 332 333 334
/*** 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",",;",".:","-_",
 "<>"
};

335 336 337 338 339 340 341 342 343
/*** 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",",;",".:","-_",
};

344 345 346 347 348 349 350 351 352 353
/*** Swiss German keyboard layout (contributed by Jonathan Naylor) */
static const char main_key_SG[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",",;",".:","-_",
 "<>\\"
};

354 355 356 357 358 359 360 361 362 363
/*** Swiss French keyboard layout (contributed by Philippe Froidevaux) */
static const char main_key_SF[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",",;",".:","-_",
 "<>\\"
};

364
/*** Norwegian keyboard layout (contributed by Ove Kven) */
365 366 367 368 369 370 371 372 373
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",",;",".:","-_",
 "<>"
};

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

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

394
/*** Estonian keyboard layout (setxkbmap ee) */
395 396
static const char main_key_ET[MAIN_LEN][4] =
{
397 398 399
 "~","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","","","'*",
400
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
401
 "<>"
402 403
};

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

414 415 416 417 418 419 420 421 422 423 424 425
/*** Canadian CAN/CSA Z243.200-92 keyboard layout 
 *** Contributed by Jean-Michel Dault <jmdault@revolutionlinux.com> */
static const char main_key_CA[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",",'",".\"","",
 ""
};

426
/*** Portuguese keyboard layout (setxkbmap pt) */
427 428
static const char main_key_PT[MAIN_LEN][4] =
{
429 430 431 432
 "\\|","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",",;",".:","-_",
433 434 435
 "<>"
};

436
/*** Italian keyboard layout (setxkbmap it) */
's avatar
committed
437 438
static const char main_key_IT[MAIN_LEN][4] =
{
439 440 441 442 443
 "\\|","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
444 445
};

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

456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
/*** 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 */
};

476 477 478 479 480 481 482 483 484 485 486
/*** 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",",<",".>","/?.,", "<>|",
};


487 488 489 490 491 492 493 494 495
/*** 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",",<",".>","/?"
};

496 497 498 499 500 501 502 503 504 505
/*** 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 */
};

506 507 508 509 510 511 512 513 514 515
/*** 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 */
};

516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535
/*** 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 */
};

536 537 538 539 540 541 542 543 544 545
/*** 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 */
};

546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566
/*** 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 */
};

567
/*** Spanish keyboard layout (setxkbmap es) */
568 569
static const char main_key_ES[MAIN_LEN][4] =
{
570 571 572
 "","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","","","",
573 574 575 576
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
};

577 578 579 580 581 582 583 584 585 586
/*** 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",",?",";.",":/","=+~",
 "<>\\"
};

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

597 598 599 600 601 602 603 604 605 606
/*** 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",",<",".>","/?",
 "<>|"
};

607
/*** Slovenian keyboard layout (setxkbmap si) ***/
Rok Mandeljc's avatar
Rok Mandeljc committed
608 609
static const char main_key_SI[MAIN_LEN][4] =
{
610 611 612 613
 "","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
614 615 616
 "<>"
};

617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636
/*** 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 */
};

637 638 639 640 641 642 643 644 645 646
/*** 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",",<",".>","/?",
 "<>|"
};

647
/*** Croatian keyboard layout (setxkbmap hr) ***/
648 649
static const char main_key_HR[MAIN_LEN][4] =
{
650 651 652 653
 "","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",",;",".:","/?",
654 655 656
 "<>"
};

657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
/*** 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",",<",".>","/?",
 "\\_",
};

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

/*** 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","~^","]}:",
692
 "\\|","zZ","xX","cC","vV","bB","nN","mM",",<",".>",";:","/?0"
693
};
694

695 696 697 698 699 700 701 702 703
/*** 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", ",<", ".>", "/?"
};

704 705 706 707 708
/*** 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] =
{
709 710 711 712 713
 ";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",",?",".:","-_",
 "<>"
714 715
};

716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
/*** 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",",?",".:","-_",
 "\\"
};

736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
/*** 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",",?<",".:>","-_*",
 "<>\\|"
};

756 757 758
/*** Latin American keyboard layout (contributed by Gabriel Orlando Garcia) */
static const char main_key_LA[MAIN_LEN][4] =
{
759 760 761
 "|","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","","{[^","}]",
762 763 764
 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
 "<>"
};
765

Nerijus Baliunas's avatar
Nerijus Baliunas committed
766
/*** Lithuanian (Baltic) keyboard layout (pc/lt in XFree86 4.3.0, contributed by Nerijus Balinas) */
767 768
static const char main_key_LT_B[MAIN_LEN][4] =
{
Nerijus Baliunas's avatar
Nerijus Baliunas committed
769
 "`~","","","","","","","","","(",")","-_","","\\|",
770
 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
771
 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"",
772 773 774
 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
};

775 776 777 778 779 780 781 782 783
/*** 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","","",".:"
};

784 785 786 787 788 789 790 791 792 793
/*** Turkish keyboard layout (setxkbmap tr) */
static const char main_key_TR[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","","",".:",
"<>"
};

794
/*** Israelian keyboard layout (setxkbmap us,il) */
795 796
static const char main_key_IL[MAIN_LEN][4] =
{
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
 "`~;","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",",<",".>","/?",
 "<>"
822 823
};

824 825 826 827 828 829 830 831 832 833 834 835
/*** 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",",<",".>","/?",
 "<>"
};

836 837 838 839 840 841 842 843 844
/*** 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?",",<",".>","/?"
}; 

845 846 847 848 849 850 851 852 853 854
/*** 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] =
{
855 856
   '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',
857 858 859 860 861 862 863 864 865
   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"
};

866 867 868 869 870 871 872 873 874 875 876 877
/*** 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",",;",".:","-=",
 "[]"
};



878
/*** Layout table. Add your keyboard mappings to this list */
879
static const struct {
880 881
    LCID lcid; /* input locale identifier, look for LOCALE_ILANGUAGE
                 in the appropriate dlls/kernel/nls/.nls file */
882 883 884 885
    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 */
886
} main_key_tab[]={
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
 {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},
904
 {0x0c0c, "Canadian CAN/CSA-Z243.200-92 keyboard layout", &main_key_CA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
905 906 907 908 909 910 911 912 913 914 915 916 917 918
 {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},
919 920
 {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},
921 922 923 924 925 926
 {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},
927 928
 {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 */
929 930
 {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
931
 {0x0411, "Japanese 106 keyboard layout", &main_key_JA_jp106, &main_key_scan_qwerty_jp106, &main_key_vkey_qwerty_jp106},
932
 {0x0411, "Japanese pc98x1 keyboard layout", &main_key_JA_pc98x1, &main_key_scan_qwerty, &main_key_vkey_qwerty},
933 934 935 936 937 938 939 940
 {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},
941
 {0x041f, "Turkish keyboard layout tr", &main_key_TR, &main_key_scan_qwerty, &main_key_vkey_qwerty},
942 943 944 945 946 947
 {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},
948
 {0x0413, "Dutch keyboard layout", &main_key_NL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
949 950

 {0, NULL, NULL, NULL, NULL} /* sentinel */
951 952 953 954 955 956 957 958 959
};
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 */
960 961 962
                /* Yes, to distinguish based on scan codes, also
                   for PrtScn key ... GA */

963
static const WORD nonchar_key_vkey[256] =
964
{
965 966 967
    /* unused */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF00 */
    /* special keys */
968 969
    VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,           /* FF08 */
    0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0,                      /* FF10 */
970 971 972 973 974 975 976 977 978 979 980 981 982
    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 */
983
    VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0, 0, 0, 0,  /* FF60 */
984 985 986 987
    VK_CANCEL, VK_HELP, VK_CANCEL, VK_CANCEL, 0, 0, 0, 0,       /* FF68 */
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF70 */
    /* keypad keys */
    0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK,                            /* FF78 */
988 989 990
    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 */
991
    VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT,                       /* FF98 */
992
    VK_END, VK_CLEAR, VK_INSERT, VK_DELETE,
993
    0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFA0 */
994 995 996 997 998 999 1000
    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,
    VK_NUMPAD8, VK_NUMPAD9, 0, 0, 0, 0,                         /* FFB8 */
    /* function keys */
    VK_F1, VK_F2,
1001
    VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,    /* FFC0 */
1002 1003 1004 1005 1006 1007 1008 1009 1010
    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 */
1011
};
1012

1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 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
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 */
    0x00, 0x00, 0x37, 0x4E, /*?*/ 0, 0x4A, 0x53, 0x135,          /* FFA8 */
    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 */
1056
};
1057

1058

1059
/* Returns the Windows virtual key code associated with the X event <e> */
1060
/* x11 lock must be held */
1061
static WORD EVENT_event_to_vkey( XIC xic, XKeyEvent *e)
1062
{
1063
    KeySym keysym = 0;
1064 1065
    Status status;
    char buf[24];
1066

1067
    if (xic)
1068
        XmbLookupString(xic, e, buf, sizeof(buf), &keysym, &status);
1069
    else
1070
        XLookupString(e, buf, sizeof(buf), &keysym, NULL);
1071

1072 1073
    if ((keysym >= 0xFFAE) && (keysym <= 0xFFB9) && (keysym != 0xFFAF)
	&& (e->state & NumLockMask))
1074 1075
        /* Only the Keypad keys 0-9 and . send different keysyms
         * depending on the NumLock state */
1076
        return nonchar_key_vkey[keysym & 0xFF];
1077

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

1080 1081 1082
    return keyc2vkey[e->keycode];
}

1083
static BOOL NumState=FALSE, CapsState=FALSE;
1084

1085 1086

/***********************************************************************
1087
 *           X11DRV_send_keyboard_input
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 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136
void X11DRV_send_keyboard_input( WORD wVk, WORD wScan, DWORD dwFlags, DWORD time,
                                 DWORD dwExtraInfo, UINT injected_flags )
{
    UINT message;
    KEYLP keylp;
    KBDLLHOOKSTRUCT hook;

    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) &&
            ((wVk == VK_MENU) || (wVk == VK_CONTROL) || !(key_state_table[VK_CONTROL] & 0x80)))
        {
            if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
                (wVk != VK_MENU)) /* <ALT>-down...<something else>-up */
                message = WM_SYSKEYUP;
            TrackSysKey = 0;
        }
        key_state_table[wVk] &= ~0x80;
        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;

        message = WM_KEYDOWN;
        if ((key_state_table[VK_MENU] & 0x80) && !(key_state_table[VK_CONTROL] & 0x80))
        {
            message = WM_SYSKEYDOWN;
            TrackSysKey = wVk;
        }
    }

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

1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149
    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;

    SERVER_START_REQ( send_message )
    {
1150
        req->id       = (injected_flags & LLKHF_INJECTED) ? 0 : GetCurrentThreadId();
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
        req->type     = MSG_HARDWARE;
        req->flags    = 0;
        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;
        req->timeout  = -1;
        req->callback = NULL;
        wine_server_call( req );
    }
    SERVER_END_REQ;
1166 1167 1168
}


1169 1170 1171 1172 1173 1174 1175 1176
/**********************************************************************
 *		KEYBOARD_GenerateMsg
 *
 * Generate Down+Up messages when NumLock or CapsLock is pressed.
 *
 * Convention : called with vkey only VK_NUMLOCK or VK_CAPITAL
 *
 */
1177
static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, DWORD event_time )
1178
{
1179
  BOOL * State = (vkey==VK_NUMLOCK? &NumState : &CapsState);
1180
  DWORD up, down;
1181 1182 1183 1184 1185 1186

  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;
1187 1188
    TRACE("INTERM : don't treat release of toggle key. key_state_table[%#x] = %#x\n",
          vkey,key_state_table[vkey]);
1189 1190
  } else
    {
1191 1192
        down = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0);
        up = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0) | KEYEVENTF_KEYUP;
1193
	if ( key_state_table[vkey] & 0x1 ) /* it was ON */
1194 1195 1196
	  {
	    if (Evtype!=KeyPress)
	      {
1197
		TRACE("ON + KeyRelease => generating DOWN and UP messages.\n");
1198 1199
	        X11DRV_send_keyboard_input( vkey, scan, down, event_time, 0, 0 );
	        X11DRV_send_keyboard_input( vkey, scan, up, event_time, 0, 0 );
1200
		*State=FALSE;
1201
		key_state_table[vkey] &= ~0x01; /* Toggle state to off. */
1202
	      }
1203 1204 1205 1206
	  }
	else /* it was OFF */
	  if (Evtype==KeyPress)
	    {
1207
	      TRACE("OFF + Keypress => generating DOWN and UP messages.\n");
1208 1209
	      X11DRV_send_keyboard_input( vkey, scan, down, event_time, 0, 0 );
	      X11DRV_send_keyboard_input( vkey, scan, up, event_time, 0, 0 );
1210
	      *State=TRUE; /* Goes to intermediary state before going to ON */
1211
	      key_state_table[vkey] |= 0x01; /* Toggle state to on. */
1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
	    }
    }
}

/***********************************************************************
 *           KEYBOARD_UpdateOneState
 *
 * Updates internal state for <vkey>, depending on key <state> under X
 *
 */
1222
inline static void KEYBOARD_UpdateOneState ( int vkey, int state, DWORD time )
1223 1224
{
    /* Do something if internal table state != X state for keycode */
1225
    if (((key_state_table[vkey] & 0x80)!=0) != state)
1226
    {
Andreas Mohr's avatar
Andreas Mohr committed
1227
        TRACE("Adjusting state for vkey %#.2x. State before %#.2x\n",
1228
              vkey, key_state_table[vkey]);
1229 1230

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

1233
        TRACE("State after %#.2x\n",key_state_table[vkey]);
1234 1235 1236 1237
    }
}

/***********************************************************************
1238
 *           X11DRV_KeymapNotify
1239
 *
1240
 * Update modifiers state (Ctrl, Alt, Shift) when window is activated.
1241 1242 1243
 *
 * This handles the case where one uses Ctrl+... Alt+... or Shift+.. to switch
 * from wine to another application and back.
1244
 * Toggle keys are handled in HandleEvent.
1245
 */
1246
void X11DRV_KeymapNotify( HWND hwnd, XEvent *event )
1247
{
1248 1249
    int i, j, alt, control, shift;
    DWORD time = GetCurrentTime();
1250

1251 1252 1253
    alt = control = shift = 0;
    for (i = 0; i < 32; i++)
    {
1254
        if (!event->xkeymap.key_vector[i]) continue;
1255 1256
        for (j = 0; j < 8; j++)
        {
1257
            if (!(event->xkeymap.key_vector[i] & (1<<j))) continue;
1258 1259 1260 1261 1262 1263 1264
            switch(keyc2vkey[(i * 8) + j] & 0xff)
            {
            case VK_MENU:    alt = 1; break;
            case VK_CONTROL: control = 1; break;
            case VK_SHIFT:   shift = 1; break;
            }
        }
1265
    }
1266 1267 1268
    KEYBOARD_UpdateOneState( VK_MENU, alt, time );
    KEYBOARD_UpdateOneState( VK_CONTROL, control, time );
    KEYBOARD_UpdateOneState( VK_SHIFT, shift, time );
1269 1270 1271
}

/***********************************************************************
1272
 *           X11DRV_KeyEvent
1273 1274 1275
 *
 * Handle a X key event
 */
1276
void X11DRV_KeyEvent( HWND hwnd, XEvent *xev )
1277
{
1278
    XKeyEvent *event = &xev->xkey;
1279
    char Str[24];
1280
    KeySym keysym = 0;
1281 1282 1283
    WORD vkey = 0, bScan;
    DWORD dwFlags;
    int ascii_chars;
1284
    XIC xic = X11DRV_get_ic( hwnd );
1285
    DWORD event_time = EVENT_x11_time_to_win32_time(event->time);
1286 1287 1288 1289
    Status status = 0;

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

1291
    wine_tsx11_lock();
1292
    if (xic)
1293
        ascii_chars = XmbLookupString(xic, event, Str, sizeof(Str), &keysym, &status);
1294 1295
    else
        ascii_chars = XLookupString(event, Str, sizeof(Str), &keysym, NULL);
1296
    wine_tsx11_unlock();
1297

1298
    /* Ignore some unwanted events */
1299 1300
    if ((keysym >= XK_ISO_Lock && keysym <= XK_ISO_Last_Group_Lock) ||
         keysym == XK_Mode_switch)
1301
    {
1302 1303 1304
        wine_tsx11_lock();
        TRACE("Ignoring %s keyboard event\n", XKeysymToString(keysym));
        wine_tsx11_unlock();
1305 1306 1307
        return;
    }

1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
    TRACE_(key)("state = %X nbyte = %d, status 0x%x\n", event->state, ascii_chars, status);

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

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

Andreas Mohr's avatar
Andreas Mohr committed
1319
    /* If XKB extensions are used, the state mask for AltGr will use the group
1320 1321
       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
1322 1323 1324
       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
1325
       predefined group index and find it dynamically
1326 1327

       Ref: X Keyboard Extension: Library specification (section 14.1.1 and 17.1.1) */
1328 1329
    /* Save also all possible modifier states. */
    AltGrMask = event->state & (0x6000 | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
1330 1331 1332 1333 1334

    Str[ascii_chars] = '\0';
    if (TRACE_ON(key)){
	char	*ksname;

1335 1336 1337
        wine_tsx11_lock();
        ksname = XKeysymToString(keysym);
        wine_tsx11_unlock();
1338 1339
	if (!ksname)
	  ksname = "No Name";
1340
	TRACE_(key)("%s : keysym=%lX (%s), # of chars=%d / 0x%02x / '%s'\n",
1341 1342
                    (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
                    keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
1343 1344
    }

1345
    wine_tsx11_lock();
1346 1347 1348
    vkey = EVENT_event_to_vkey(xic,event);
    /* X returns keycode 0 for composed characters */
    if (!vkey && ascii_chars) vkey = VK_NONAME;
1349
    wine_tsx11_unlock();
1350

1351
    TRACE_(key)("keycode 0x%x converted to vkey 0x%x\n",
1352
                event->keycode, vkey);
1353 1354 1355 1356 1357

   if (vkey)
   {
    switch (vkey & 0xff)
    {
1358
    case VK_NUMLOCK:
1359
      KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, event->type, event_time );
1360 1361
      break;
    case VK_CAPITAL:
1362
      TRACE("Caps Lock event. (type %d). State before : %#.2x\n",event->type,key_state_table[vkey]);
1363
      KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, event->type, event_time );
1364
      TRACE("State after : %#.2x\n",key_state_table[vkey]);
1365 1366 1367
      break;
    default:
        /* Adjust the NUMLOCK state if it has been changed outside wine */
1368
	if (!(key_state_table[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
1369
	  {
Andreas Mohr's avatar
Andreas Mohr committed
1370
	    TRACE("Adjusting NumLock state.\n");
1371 1372
	    KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyPress, event_time );
	    KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyRelease, event_time );
1373 1374
	  }
        /* Adjust the CAPSLOCK state if it has been changed outside wine */
1375
	if (!(key_state_table[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
1376
	  {
1377
              TRACE("Adjusting Caps Lock state.\n");
1378 1379
	    KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyPress, event_time );
	    KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyRelease, event_time );
1380 1381 1382 1383 1384
	  }
	/* Not Num nor Caps : end of intermediary states for both. */
	NumState = FALSE;
	CapsState = FALSE;

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

1388 1389 1390 1391
	dwFlags = 0;
	if ( event->type == KeyRelease ) dwFlags |= KEYEVENTF_KEYUP;
	if ( vkey & 0x100 )              dwFlags |= KEYEVENTF_EXTENDEDKEY;

1392
        X11DRV_send_keyboard_input( vkey & 0xff, bScan, dwFlags, event_time, 0, 0 );
1393 1394 1395 1396
    }
   }
}

1397 1398 1399
/**********************************************************************
 *		X11DRV_KEYBOARD_DetectLayout
 *
1400
 * Called from X11DRV_InitKeyboard
1401 1402
 *  This routine walks through the defined keyboard layouts and selects
 *  whichever matches most closely.
1403
 * X11 lock must be held.
1404
 */
Patrik Stridvall's avatar
Patrik Stridvall committed
1405
static void
1406
X11DRV_KEYBOARD_DetectLayout (void)
1407
{
1408
  Display *display = thread_display();
1409 1410
  unsigned current, match, mismatch, seq, i, syms;
  int score, keyc, key, pkey, ok;
1411 1412
  KeySym keysym;
  const char (*lkey)[MAIN_LEN][4];
1413
  unsigned max_seq = 0;
1414 1415 1416 1417 1418 1419
  int max_score = 0, ismatch = 0;
  char ckey[4] =
  {0, 0, 0, 0};

  syms = keysyms_per_keycode;
  if (syms > 4) {
1420
    WARN("%d keysyms per keycode not supported, set to 4\n", syms);
1421 1422
    syms = 4;
  }
1423 1424
  for (current = 0; main_key_tab[current].comment; current++) {
    TRACE("Attempting to match against \"%s\"\n", main_key_tab[current].comment);
1425 1426 1427
    match = 0;
    mismatch = 0;
    score = 0;
1428
    seq = 0;
1429
    lkey = main_key_tab[current].key;
1430
    pkey = -1;
1431 1432 1433
    for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
      /* get data for keycode from X server */
      for (i = 0; i < syms; i++) {
1434
	keysym = XKeycodeToKeysym (display, keyc, i);
1435
	/* Allow both one-byte and two-byte national keysyms */
1436
	if ((keysym < 0x8000) && (keysym != ' '))
1437 1438
        {
#ifdef HAVE_XKB
1439
            if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[i], 1, NULL))
1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
#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.
                 */
                ckey[i] = keysym & 0xFF;
            }
        }
1450 1451 1452
	else {
	  ckey[i] = KEYBOARD_MapDeadKeysym(keysym);
	}
1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
      }
      if (ckey[0]) {
	/* 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++) {
	    if ((*lkey)[key][i] && ((*lkey)[key][i] == ckey[i]))
	      ok++;
	    if ((*lkey)[key][i] && ((*lkey)[key][i] != ckey[i]))
	      ok = -1;
1466
	  }
1467 1468 1469
	  if (ok > 0) {
	    score += ok;
	    break;
1470 1471
	  }
	}
1472
	/* count the matches and mismatches */
1473
	if (ok > 0) {
1474
	  match++;
1475 1476 1477 1478
	  /* and how much the keycode order matches */
	  if (key > pkey) seq++;
	  pkey = key;
	} else {
1479 1480 1481 1482
          /* print spaces instead of \0's */
          for (i = 0; i < sizeof(ckey); i++) if (!ckey[i]) ckey[i] = ' ';
          TRACE_(key)("mismatch for keysym 0x%04lX, keycode %d, got %c%c%c%c\n",
                      keysym, keyc, ckey[0], ckey[1], ckey[2], ckey[3]);
1483 1484 1485
	  mismatch++;
	  score -= syms;
	}
1486 1487
      }
    }
1488 1489
    TRACE("matches=%d, mismatches=%d, seq=%d, score=%d\n",
	   match, mismatch, seq, score);
1490 1491
    if ((score > max_score) ||
	((score == max_score) && (seq > max_seq))) {
1492 1493 1494
      /* best match so far */
      kbd_layout = current;
      max_score = score;
1495
      max_seq = seq;
1496
      ismatch = !mismatch;
1497
    }
1498 1499
  }
  /* we're done, report results if necessary */
1500 1501 1502
  if (!ismatch)
    WARN("Using closest match (%s) for scan/virtual codes mapping.\n",
        main_key_tab[kbd_layout].comment);
1503 1504

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

1507
/**********************************************************************
1508
 *		X11DRV_InitKeyboard
1509
 */
1510
void X11DRV_InitKeyboard(void)
1511
{
1512
    Display *display = thread_display();
1513 1514 1515 1516 1517
    KeySym *ksp;
    XModifierKeymap *mmp;
    KeySym keysym;
    KeyCode *kcp;
    XKeyEvent e2;
1518 1519 1520 1521
    WORD scan, vkey, OEMvkey;
    int keyc, i, keyn, syms;
    char ckey[4]={0,0,0,0};
    const char (*lkey)[MAIN_LEN][4];
1522

1523
    wine_tsx11_lock();
1524 1525
    XDisplayKeycodes(display, &min_keycode, &max_keycode);
    ksp = XGetKeyboardMapping(display, min_keycode,
1526 1527 1528
                              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 */
1529 1530 1531
    XFree(ksp);

    mmp = XGetModifierMapping(display);
1532 1533 1534 1535
    kcp = mmp->modifiermap;
    for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
    {
        int j;
1536

1537 1538 1539 1540
        for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
	    if (*kcp)
            {
		int k;
1541

1542
		for (k = 0; k < keysyms_per_keycode; k += 1)
1543
                    if (XKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
1544 1545
		    {
                        NumLockMask = 1 << i;
1546
                        TRACE_(key)("NumLockMask is %x\n", NumLockMask);
1547 1548 1549
		    }
            }
    }
1550
    XFreeModifiermap(mmp);
1551

1552 1553 1554 1555 1556
    /* Detect the keyboard layout */
    X11DRV_KEYBOARD_DetectLayout();
    lkey = main_key_tab[kbd_layout].key;
    syms = (keysyms_per_keycode > 4) ? 4 : keysyms_per_keycode;

1557
    /* Now build two conversion arrays :
1558
     * keycode -> vkey + scancode + extended
1559 1560 1561 1562 1563
     * vkey + extended -> keycode */

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

1564
    OEMvkey = VK_OEM_8; /* next is available.  */
1565 1566
    for (keyc = min_keycode; keyc <= max_keycode; keyc++)
    {
1567 1568 1569
        char buf[30];
        int have_chars;

1570
        keysym = 0;
1571
        e2.keycode = (KeyCode)keyc;
1572
        have_chars = XLookupString(&e2, buf, sizeof(buf), &keysym, NULL);
1573
        vkey = 0; scan = 0;
1574 1575 1576 1577
        if (keysym)  /* otherwise, keycode not used */
        {
            if ((keysym >> 8) == 0xFF)         /* non-character key */
            {
1578 1579
                vkey = nonchar_key_vkey[keysym & 0xff];
                scan = nonchar_key_scan[keysym & 0xff];
1580 1581 1582 1583 1584
		/* set extended bit when necessary */
		if (scan & 0x100) vkey |= 0x100;
            } else if (keysym == 0x20) {                 /* Spacebar */
	        vkey = VK_SPACE;
		scan = 0x39;
1585
	    } else if (have_chars) {
1586 1587 1588
	      /* we seem to need to search the layout-dependent scancodes */
	      int maxlen=0,maxval=-1,ok;
	      for (i=0; i<syms; i++) {
1589
		keysym = XKeycodeToKeysym(display, keyc, i);
1590
		if ((keysym<0x8000) && (keysym!=' '))
1591 1592
                {
#ifdef HAVE_XKB
1593
                    if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[i], 1, NULL))
1594 1595 1596 1597 1598 1599 1600 1601
#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;
                    }
1602 1603 1604
		} else {
		  ckey[i] = KEYBOARD_MapDeadKeysym(keysym);
		}
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
	      }
	      /* 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;
		if (ok||(i>maxlen)) {
		  maxlen=i; maxval=keyn;
		}
		if (ok) break;
	      }
	      if (maxval>=0) {
		/* got it */
1617 1618 1619 1620
		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];
1621 1622
	      }
	    }
1623 1624 1625
#if 0 /* this breaks VK_OEM_x VKeys in some layout tables by inserting
       * a VK code into a not appropriate place.
       */
1626 1627
            /* find a suitable layout-dependent VK code */
	    /* (most Winelib apps ought to be able to work without layout tables!) */
1628 1629
            for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
            {
1630
                keysym = XLookupKeysym(&e2, i);
1631
                if ((keysym >= VK_0 && keysym <= VK_9)
1632
                    || (keysym >= VK_A && keysym <= VK_Z)) {
1633
		    vkey = keysym;
1634
		}
1635 1636 1637 1638
            }

            for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
            {
1639
                keysym = XLookupKeysym(&e2, i);
1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654
		switch (keysym)
		{
		case ';':             vkey = VK_OEM_1; break;
		case '/':             vkey = VK_OEM_2; break;
		case '`':             vkey = VK_OEM_3; break;
		case '[':             vkey = VK_OEM_4; break;
		case '\\':            vkey = VK_OEM_5; break;
		case ']':             vkey = VK_OEM_6; break;
		case '\'':            vkey = VK_OEM_7; break;
		case ',':             vkey = VK_OEM_COMMA; break;
		case '.':             vkey = VK_OEM_PERIOD; break;
		case '-':             vkey = VK_OEM_MINUS; break;
		case '+':             vkey = VK_OEM_PLUS; break;
		}
	    }
1655

1656 1657 1658 1659 1660 1661 1662 1663
            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]) */
                switch (++OEMvkey)
                {
                case 0xc1 : OEMvkey=0xdb; break;
                case 0xe5 : OEMvkey=0xe9; break;
1664
                case 0xf6 : OEMvkey=0xf5; WARN("No more OEM vkey available!\n");
1665 1666 1667
                }

                vkey = OEMvkey;
1668

1669 1670
                if (TRACE_ON(keyboard))
                {
1671
                    TRACE("OEM specific virtual key %X assigned to keycode %X:\n",
1672
                                     OEMvkey, e2.keycode);
1673
                    TRACE("(");
1674 1675 1676
                    for (i = 0; i < keysyms_per_keycode; i += 1)
                    {
                        char	*ksname;
1677

1678 1679
                        keysym = XLookupKeysym(&e2, i);
                        ksname = XKeysymToString(keysym);
1680 1681
                        if (!ksname)
			    ksname = "NoSymbol";
1682
                        TRACE( "%lX (%s) ", keysym, ksname);
1683
                    }
1684
                    TRACE(")\n");
1685 1686
                }
            }
1687
#endif
1688
        }
1689
        TRACE("keycode %04x => vkey %04x\n", e2.keycode, vkey);
1690
        keyc2vkey[e2.keycode] = vkey;
1691
        keyc2scan[e2.keycode] = scan;
1692
    } /* for */
1693 1694 1695 1696 1697

    /* 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]) {
	char *ksname;
1698 1699
	keysym = XKeycodeToKeysym(display, keyc, 0);
	ksname = XKeysymToString(keysym);
1700 1701 1702 1703
	if (!ksname) ksname = "NoSymbol";

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

1704
	TRACE_(key)("assigning scancode %02x to unidentified keycode %02x (%s)\n",scan,keyc,ksname);
1705 1706 1707
	keyc2scan[keyc]=scan++;
      }

1708
    /* Now store one keycode for each modifier. Used to simulate keypresses. */
1709 1710 1711 1712 1713 1714 1715
    kcControl = XKeysymToKeycode(display, XK_Control_L);
    kcAlt = XKeysymToKeycode(display, XK_Alt_L);
    if (!kcAlt) kcAlt = XKeysymToKeycode(display, XK_Meta_L);
    kcShift = XKeysymToKeycode(display, XK_Shift_L);
    kcNumLock = XKeysymToKeycode(display, XK_Num_Lock);
    kcCapsLock = XKeysymToKeycode(display, XK_Caps_Lock);
    wine_tsx11_unlock();
1716 1717
}

1718

1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731
/**********************************************************************
 *		GetAsyncKeyState (X11DRV.@)
 */
SHORT X11DRV_GetAsyncKeyState(INT key)
{
    SHORT retval = ((key_state_table[key] & 0x40) ? 0x0001 : 0) |
                   ((key_state_table[key] & 0x80) ? 0x8000 : 0);
    key_state_table[key] &= ~0x40;
    TRACE_(key)("(%x) -> %x\n", key, retval);
    return retval;
}


1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
/***********************************************************************
 *		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)
1750
        {
1751
            ULONG_PTR layout = main_key_tab[i].lcid;
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
            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;
        }
1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
    }
    return i;
}


/***********************************************************************
 *		GetKeyboardLayout (X11DRV.@)
 */
HKL X11DRV_GetKeyboardLayout(DWORD dwThreadid)
{
1773
    ULONG_PTR layout;
1774 1775
    LANGID langid;

1776
    if (dwThreadid && dwThreadid != GetCurrentThreadId())
1777 1778
        FIXME("couldn't return keyboard layout for thread %04lx\n", dwThreadid);

1779
#if 0
1780
    layout = main_key_tab[kbd_layout].lcid;
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790
#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
1791 1792 1793
    /* 
     * Microsoft Office expects this value to be something specific
     * for Japanese and Korean Windows with an IME the value is 0xe001
1794
     * We should probably check to see if an IME exists and if so then
1795 1796 1797 1798
     * set this word properly.
     */
    langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
    if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
1799
        layout |= 0xe001 << 16; /* FIXME */
1800 1801
    else
        layout |= layout << 16;
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816

    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;
1817
    /* see comment for GetKeyboardLayout */
1818 1819 1820
    langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
    if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
        layout |= 0xe001 << 16; /* FIXME */
1821 1822
    else
        layout |= layout << 16;
1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862

    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;
}


1863 1864 1865
/***********************************************************************
 *           X11DRV_MappingNotify
 */
1866
void X11DRV_MappingNotify( HWND dummy, XEvent *event )
1867
{
1868 1869
    HWND hwnd;

1870
    wine_tsx11_lock();
1871
    XRefreshKeyboardMapping(&event->xmapping);
1872
    wine_tsx11_unlock();
1873
    X11DRV_InitKeyboard();
1874 1875 1876 1877 1878

    hwnd = GetFocus();
    if (!hwnd) hwnd = GetActiveWindow();
    PostMessageW(hwnd, WM_INPUTLANGCHANGEREQUEST,
                 0 /*FIXME*/, (LPARAM)X11DRV_GetKeyboardLayout(0));
1879 1880 1881
}


1882
/***********************************************************************
1883 1884 1885
 *		VkKeyScanEx (X11DRV.@)
 *
 * Note: Windows ignores HKL parameter and uses current active layout instead
1886
 */
1887
SHORT X11DRV_VkKeyScanEx(WCHAR wChar, HKL hkl)
1888
{
1889 1890 1891 1892
    Display *display = thread_display();
    KeyCode keycode;
    KeySym keysym;
    int i, index;
1893
    CHAR cChar;
1894 1895
    SHORT ret;

1896 1897 1898
    /* FIXME: what happens if wChar is not a Latin1 character and CP_UNIXCP
     * is UTF-8 (multibyte encoding)?
     */
1899 1900 1901 1902 1903 1904 1905 1906
    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);

1907 1908 1909 1910
    /* char->keysym (same for ANSI chars) */
    keysym = (unsigned char)cChar; /* (!) cChar is signed */
    if (keysym <= 27) keysym += 0xFF00; /* special chars : return, backspace... */

1911 1912
    wine_tsx11_lock();
    keycode = XKeysymToKeycode(display, keysym);  /* keysym -> keycode */
1913
    if (!keycode)
1914 1915 1916 1917 1918 1919 1920 1921 1922
    {
        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. */
1923
        TRACE("retrying with | 0xFE00\n");
1924
        keycode = XKeysymToKeycode(display, keysym | 0xFE00);
1925
    }
1926
    wine_tsx11_unlock();
1927

1928 1929
    TRACE("'%c'(%#lx, %lu): got keycode %#.2x (%d)\n",
            cChar, keysym, keysym, keycode, keycode);
1930

1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
    /* keycode -> (keyc2vkey) vkey */
    ret = keyc2vkey[keycode];

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

    index = -1;
1941
    wine_tsx11_lock();
1942 1943
    for (i = 0; i < 4; i++) /* find shift state */
    {
1944
        if (XKeycodeToKeysym(display, keycode, i) == keysym)
1945 1946 1947 1948 1949
        {
            index = i;
            break;
        }
    }
1950
    wine_tsx11_unlock();
1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973

    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;
1974 1975 1976
}

/***********************************************************************
1977
 *		MapVirtualKeyEx (X11DRV.@)
1978
 */
1979
UINT X11DRV_MapVirtualKeyEx(UINT wCode, UINT wMapType, HKL hkl)
1980
{
1981 1982
    Display *display = thread_display();

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

1985 1986 1987 1988
    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);

1989 1990 1991 1992 1993 1994
	switch(wMapType) {
		case 0:	{ /* vkey-code to scan-code */
			/* let's do vkey -> keycode -> scan */
			int keyc;
			for (keyc=min_keycode; keyc<=max_keycode; keyc++)
				if ((keyc2vkey[keyc] & 0xFF) == wCode)
1995
					returnMVK (keyc2scan[keyc] & 0xFF);
1996
			TRACE("returning no scan-code.\n");
1997 1998
		        return 0; }

1999
		case 1: { /* scan-code to vkey-code */
2000
			/* let's do scan -> keycode -> vkey */
2001 2002
			int keyc;
			for (keyc=min_keycode; keyc<=max_keycode; keyc++)
2003
				if ((keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
2004
					returnMVK (keyc2vkey[keyc] & 0xFF);
2005
			TRACE("returning no vkey-code.\n");
2006
		        return 0; }
2007 2008

		case 2: { /* vkey-code to unshifted ANSI code */
2009 2010 2011 2012 2013 2014
                        /* 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.
                         */
2015 2016 2017
			/* let's do vkey -> keycode -> (XLookupString) ansi char */
			XKeyEvent e;
			KeySym keysym;
2018
			int keyc;
2019 2020
			char s[2];
			e.display = display;
2021 2022 2023 2024

			e.state = LockMask;
			/* LockMask should behave exactly like caps lock - upercase
			 * the letter keys and thats about it. */
2025

2026 2027
                        wine_tsx11_lock();

2028 2029 2030 2031 2032 2033 2034
			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 */
2035
				if ((EVENT_event_to_vkey(0,&e) & 0xFF) != wCode) {
2036 2037 2038 2039 2040 2041 2042
				    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))
2043
			  e.keycode = XKeysymToKeycode(e.display, wCode-VK_NUMPAD0+XK_KP_0);
2044

2045
			if (wCode==VK_DECIMAL)
2046
			  e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2047 2048 2049

			if (!e.keycode)
			{
2050
			  WARN("Unknown virtual key %X !!!\n", wCode);
2051
                          wine_tsx11_unlock();
2052 2053
			  return 0; /* whatever */
			}
2054
			TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2055

2056 2057 2058 2059 2060
			if (XLookupString(&e, s, 2, &keysym, NULL))
                        {
                            wine_tsx11_unlock();
                            returnMVK (*s);
                        }
2061

2062
			TRACE("returning no ANSI.\n");
2063
                        wine_tsx11_unlock();
2064 2065
			return 0;
			}
2066 2067 2068

		case 3:   /* **NT only** scan-code to vkey-code but distinguish between  */
              		  /*             left and right  */
2069
		          FIXME(" stub for NT\n");
2070 2071
                          return 0;

2072
		default: /* reserved */
2073
			WARN("Unknown wMapType %d !\n", wMapType);
2074
			return 0;
2075 2076 2077 2078 2079
	}
	return 0;
}

/***********************************************************************
2080
 *		GetKeyNameText (X11DRV.@)
2081
 */
2082
INT X11DRV_GetKeyNameText(LONG lParam, LPWSTR lpBuffer, INT nSize)
2083
{
2084
  int vkey, ansi, scanCode;
2085
  KeyCode keyc;
2086
  int keyi;
2087 2088
  KeySym keys;
  char *name;
2089

2090
  scanCode = lParam >> 16;
2091 2092 2093
  scanCode &= 0x1ff;  /* keep "extended-key" flag with code */

  /* FIXME: should use MVK type 3 (NT version that distinguishes right and left */
2094
  vkey = X11DRV_MapVirtualKeyEx(scanCode, 1, X11DRV_GetKeyboardLayout(0));
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114

  /*  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;
    }
  }
2115

2116
  ansi = X11DRV_MapVirtualKeyEx(vkey, 2, X11DRV_GetKeyboardLayout(0));
2117
  TRACE("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n", scanCode, vkey, ansi);
2118

2119 2120 2121 2122 2123 2124 2125 2126
  /* 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 + */
2127 2128 2129
      {
        if ((nSize >= 2) && lpBuffer)
	{
2130
          *lpBuffer = toupperW((WCHAR)ansi);
2131 2132
          *(lpBuffer+1) = 0;
          return 1;
2133
        }
2134 2135
     else
        return 0;
2136 2137
  }

2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149
  /* 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 */

2150 2151
  for (keyi=min_keycode; keyi<=max_keycode; keyi++)
      if ((keyc2scan[keyi]) == scanCode)
2152
         break;
2153
  if (keyi <= max_keycode)
2154
  {
2155
      wine_tsx11_lock();
2156
      keyc = (KeyCode) keyi;
2157 2158 2159
      keys = XKeycodeToKeysym(thread_display(), keyc, 0);
      name = XKeysymToString(keys);
      wine_tsx11_unlock();
2160 2161
      TRACE("found scan=%04x keyc=%04x keysym=%04x string=%s\n",
            scanCode, keyc, (int)keys, name);
2162 2163
      if (lpBuffer && nSize && name)
      {
2164 2165
          MultiByteToWideChar(CP_UNIXCP, 0, name, -1, lpBuffer, nSize);
          lpBuffer[nSize - 1] = 0;
2166 2167 2168
          return 1;
      }
  }
2169

2170
  /* Finally issue FIXME for unknown keys   */
2171

2172
  FIXME("(%08lx,%p,%d): unsupported key, vkey=%04x, ansi=%04x\n",lParam,lpBuffer,nSize,vkey,ansi);
2173 2174
  if (lpBuffer && nSize)
    *lpBuffer = 0;
2175 2176 2177
  return 0;
}

2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
/***********************************************************************
 *		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 :
2245
	        return 'i';
2246 2247 2248 2249 2250 2251
	    case XK_dead_voiced_sound :
	        return 'v';
	    case XK_dead_semivoiced_sound :
	        return 's';
*/
	    }
2252
	TRACE("no character for dead keysym 0x%08lx\n",keysym);
2253 2254 2255
	return 0;
}

2256
/***********************************************************************
2257
 *		ToUnicodeEx (X11DRV.@)
2258
 *
2259
 * The ToUnicode function translates the specified virtual-key code and keyboard
2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273
 * 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)
 *
 */
2274 2275
INT X11DRV_ToUnicodeEx(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
		     LPWSTR bufW, int bufW_size, UINT flags, HKL hkl)
2276
{
2277
    Display *display = thread_display();
2278
    XKeyEvent e;
2279
    KeySym keysym = 0;
2280
    INT ret;
2281
    int keyc;
2282
    char lpChar[10];
2283 2284
    HWND focus;
    XIC xic;
2285
    Status status;
2286

2287 2288
    if (scanCode & 0x8000)
    {
2289
        TRACE("Key UP, doing nothing\n" );
2290 2291
        return 0;
    }
2292

2293 2294 2295
    if (hkl != X11DRV_GetKeyboardLayout(0))
        FIXME("keyboard layout %p is not supported\n", hkl);

2296 2297 2298 2299 2300 2301
    if ((lpKeyState[VK_MENU] & 0x80) && (lpKeyState[VK_CONTROL] & 0x80))
    {
        TRACE("Ctrl+Alt+[key] won't generate a character\n");
        return 0;
    }

2302 2303 2304
    e.display = display;
    e.keycode = 0;
    e.state = 0;
2305 2306 2307 2308 2309 2310 2311 2312
    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 );

2313
    if (lpKeyState[VK_SHIFT] & 0x80)
2314 2315
    {
	TRACE("ShiftMask = %04x\n", ShiftMask);
2316
	e.state |= ShiftMask;
2317
    }
2318
    if (lpKeyState[VK_CAPITAL] & 0x01)
2319 2320
    {
	TRACE("LockMask = %04x\n", LockMask);
2321
	e.state |= LockMask;
2322
    }
2323
    if (lpKeyState[VK_CONTROL] & 0x80)
2324 2325
    {
	TRACE("ControlMask = %04x\n", ControlMask);
2326
	e.state |= ControlMask;
2327
    }
2328
    if (lpKeyState[VK_NUMLOCK] & 0x01)
2329 2330
    {
	TRACE("NumLockMask = %04x\n", NumLockMask);
2331
	e.state |= NumLockMask;
2332
    }
2333 2334

    /* Restore saved AltGr state */
2335
    TRACE("AltGrMask = %04x\n", AltGrMask);
2336 2337
    e.state |= AltGrMask;

2338
    TRACE_(key)("(%04X, %04X) : faked state = 0x%04x\n",
2339
		virtKey, scanCode, e.state);
2340
    wine_tsx11_lock();
2341 2342 2343 2344 2345 2346
    /* 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 */
2347
              if ((EVENT_event_to_vkey(xic,&e) & 0xFF) != virtKey) {
2348 2349 2350 2351 2352 2353 2354
                  e.keycode = 0; /* Wrong one (ex: because of the NumLock
                         state), so set it to 0, we'll find another one */
              }
	  }
      }

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

2357
    if (virtKey==VK_DECIMAL)
2358
        e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2359

2360
    if (!e.keycode && virtKey != VK_NONAME)
2361
      {
2362
	WARN("Unknown virtual key %X !!!\n", virtKey);
2363
        wine_tsx11_unlock();
2364 2365
	return virtKey; /* whatever */
      }
2366
    else TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2367

2368 2369 2370
    TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
		e.type, e.window, e.state, e.keycode);

2371
    if (xic)
2372
        ret = XmbLookupString(xic, &e, lpChar, sizeof(lpChar), &keysym, &status);
2373
    else
2374
        ret = XLookupString(&e, lpChar, sizeof(lpChar), &keysym, NULL);
2375 2376
    wine_tsx11_unlock();

2377
    if (ret == 0)
2378
    {
Mike McCormack's avatar
Mike McCormack committed
2379
	char dead_char;
2380

2381
#ifdef XK_EuroSign
2382 2383 2384 2385 2386 2387 2388 2389
        /* 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;
        }
2390
#endif
2391 2392 2393 2394 2395 2396 2397 2398 2399
        /* 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;
        }

2400
	dead_char = KEYBOARD_MapDeadKeysym(keysym);
2401 2402
	if (dead_char)
	    {
2403
	    MultiByteToWideChar(CP_UNIXCP, 0, &dead_char, 1, bufW, bufW_size);
2404 2405 2406 2407 2408 2409
	    ret = -1;
	    }
	else
	    {
	    char	*ksname;

2410 2411 2412
            wine_tsx11_lock();
	    ksname = XKeysymToString(keysym);
            wine_tsx11_unlock();
2413 2414 2415 2416
	    if (!ksname)
		ksname = "No Name";
	    if ((keysym >> 8) != 0xff)
		{
2417 2418 2419 2420
		ERR("Please report: no char for keysym %04lX (%s) :\n",
                    keysym, ksname);
		ERR("(virtKey=%X,scanCode=%X,keycode=%X,state=%X)\n",
                    virtKey, scanCode, e.keycode, e.state);
2421 2422 2423
		}
	    }
	}
2424
    else {  /* ret != 0 */
2425 2426
        /* 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. */
2427 2428
        if (!(e.state & NumLockMask)  /* NumLock is off */
            && (e.state & ShiftMask) /* Shift is pressed */
2429 2430
            && (keysym>=XK_KP_0) && (keysym<=XK_KP_9))
        {
2431
            lpChar[0] = 0;
2432 2433
            ret = 0;
        }
2434

2435
        /* more areas where X returns characters but Windows does not
Andreas Mohr's avatar
Andreas Mohr committed
2436
           CTRL + number or CTRL + symbol */
2437
        if (e.state & ControlMask)
2438
        {
2439 2440 2441
            if (((keysym>=33) && (keysym < 'A')) ||
                ((keysym > 'Z') && (keysym < 'a')))
            {
2442
                lpChar[0] = 0;
2443 2444
                ret = 0;
            }
2445
        }
2446

2447 2448 2449 2450
        /* 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)
        {
2451
            lpChar[0] = 0;
2452 2453
            ret = 0;
        }
2454 2455 2456
	else if((lpKeyState[VK_SHIFT] & 0x80) /* Shift is pressed */
		&& (keysym == XK_KP_Decimal))
        {
2457
            lpChar[0] = 0;
2458 2459
            ret = 0;
        }
2460

2461 2462
	/* perform translation to unicode */
	if(ret)
2463
	{
2464 2465
	    TRACE_(key)("Translating char 0x%02x to unicode\n", *(BYTE *)lpChar);
	    ret = MultiByteToWideChar(CP_UNIXCP, 0, lpChar, ret, bufW, bufW_size);
2466
	}
2467 2468
    }

2469
found:
2470
    TRACE_(key)("ToUnicode about to return %d with char %x %s\n",
2471
		ret, (ret && bufW) ? bufW[0] : 0, bufW ? "" : "(no buffer)");
2472 2473 2474
    return ret;
}

2475
/***********************************************************************
2476
 *		Beep (X11DRV.@)
2477
 */
2478
void X11DRV_Beep(void)
2479
{
2480 2481 2482
    wine_tsx11_lock();
    XBell(thread_display(), 0);
    wine_tsx11_unlock();
2483
}