msvcrt/tests: Avoid size_t in a trace.
[wine] / dlls / winex11.drv / keyboard.c
1 /*
2  * X11 keyboard driver
3  *
4  * Copyright 1993 Bob Amstadt
5  * Copyright 1996 Albrecht Kleine
6  * Copyright 1997 David Faure
7  * Copyright 1998 Morten Welinder
8  * Copyright 1998 Ulrich Weigand
9  * Copyright 1999 Ove Kåven
10  *
11  * This library is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * This library is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with this library; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24  */
25
26 #include "config.h"
27
28 #include <X11/Xatom.h>
29 #include <X11/keysym.h>
30 #include <X11/Xlib.h>
31 #include <X11/Xresource.h>
32 #include <X11/Xutil.h>
33 #ifdef HAVE_X11_XKBLIB_H
34 #include <X11/XKBlib.h>
35 #endif
36
37 #include <ctype.h>
38 #include <stdarg.h>
39 #include <string.h>
40
41 #define NONAMELESSUNION
42 #define NONAMELESSSTRUCT
43 #include "windef.h"
44 #include "winbase.h"
45 #include "wingdi.h"
46 #include "winuser.h"
47 #include "winreg.h"
48 #include "winnls.h"
49 #include "x11drv.h"
50 #include "wine/server.h"
51 #include "wine/unicode.h"
52 #include "wine/debug.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(keyboard);
55 WINE_DECLARE_DEBUG_CHANNEL(key);
56
57 /* key state table bits:
58   0x80 -> key is pressed
59   0x40 -> key got pressed since last time
60   0x01 -> key is toggled
61 */
62 BYTE key_state_table[256];
63
64 static BYTE TrackSysKey = 0; /* determine whether ALT key up will cause a WM_SYSKEYUP
65                                 or a WM_KEYUP message */
66
67 static int min_keycode, max_keycode, keysyms_per_keycode;
68 static WORD keyc2vkey[256], keyc2scan[256];
69
70 static int NumLockMask, ScrollLockMask, AltGrMask; /* mask in the XKeyEvent state */
71
72 static char KEYBOARD_MapDeadKeysym(KeySym keysym);
73
74 /* Keyboard translation tables */
75 #define MAIN_LEN 49
76 static const WORD main_key_scan_qwerty[MAIN_LEN] =
77 {
78 /* this is my (102-key) keyboard layout, sorry if it doesn't quite match yours */
79  /* `    1    2    3    4    5    6    7    8    9    0    -    = */
80    0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
81  /* q    w    e    r    t    y    u    i    o    p    [    ] */
82    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
83  /* a    s    d    f    g    h    j    k    l    ;    '    \ */
84    0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
85  /* z    x    c    v    b    n    m    ,    .    / */
86    0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
87    0x56 /* the 102nd key (actually to the right of l-shift) */
88 };
89
90 static const WORD main_key_scan_abnt_qwerty[MAIN_LEN] =
91 {
92  /* `    1    2    3    4    5    6    7    8    9    0    -    = */
93    0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
94  /* q    w    e    r    t    y    u    i    o    p    [    ] */
95    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
96  /* a    s    d    f    g    h    j    k    l    ;    '    \ */
97    0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
98  /* \      z    x    c    v    b    n    m    ,    .    / */
99    0x5e,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
100    0x56, /* the 102nd key (actually to the right of l-shift) */
101 };
102
103 static const WORD main_key_scan_dvorak[MAIN_LEN] =
104 {
105  /* `    1    2    3    4    5    6    7    8    9    0    [    ] */
106    0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x1A,0x1B,
107  /* '    ,    .    p    y    f    g    c    r    l    /    = */
108    0x28,0x33,0x34,0x19,0x15,0x21,0x22,0x2E,0x13,0x26,0x35,0x0D,
109  /* a    o    e    u    i    d    h    t    n    s    -    \ */
110    0x1E,0x18,0x12,0x16,0x17,0x20,0x23,0x14,0x31,0x1F,0x0C,0x2B,
111  /* ;    q    j    k    x    b    m    w    v    z */
112    0x27,0x10,0x24,0x25,0x2D,0x30,0x32,0x11,0x2F,0x2C,
113    0x56 /* the 102nd key (actually to the right of l-shift) */
114 };
115
116 static const WORD main_key_scan_qwerty_jp106[MAIN_LEN] =
117 {
118   /* this is my (106-key) keyboard layout, sorry if it doesn't quite match yours */
119  /* 1    2    3    4    5    6    7    8    9    0    -    ^    \ */
120    0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x29,
121  /* q    w    e    r    t    y    u    i    o    p    @    [ */
122    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
123  /* a    s    d    f    g    h    j    k    l    ;    :    ] */
124    0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
125  /* z    x    c    v    b    n    m    ,    .    / */
126    0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
127    0x56 /* the 102nd key (actually to the right of l-shift) */
128 };
129
130 static const WORD main_key_scan_qwerty_macjp[MAIN_LEN] =
131 {
132  /* 1    2    3    4    5    6    7    8    9    0    -    ^    \ */
133    0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x7d,
134  /* q    w    e    r    t    y    u    i    o    p    @    [ */
135    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
136  /* a    s    d    f    g    h    j    k    l    ;    :    ] */
137    0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
138  /* z    x    c    v    b    n    m    ,    .    / */
139    0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
140    0x73 /* the 102nd key (actually to the right of l-shift) */
141 };
142
143
144 static const WORD main_key_vkey_qwerty[MAIN_LEN] =
145 {
146 /* NOTE: this layout must concur with the scan codes layout above */
147    VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
148    'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_4,VK_OEM_6,
149    'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
150    'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
151    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
152 };
153
154 static const WORD main_key_vkey_qwerty_jp106[MAIN_LEN] =
155 {
156 /* NOTE: this layout must concur with the scan codes layout above */
157    '1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,VK_OEM_3,
158    'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_4,VK_OEM_6,
159    'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
160    'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
161    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
162 };
163
164 static const WORD main_key_vkey_qwerty_macjp[MAIN_LEN] =
165 {
166 /* NOTE: this layout must concur with the scan codes layout above */
167    '1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_7,VK_OEM_5,
168    'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_3,VK_OEM_4,
169    'A','S','D','F','G','H','J','K','L',VK_OEM_PLUS,VK_OEM_1,VK_OEM_6,
170    'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
171    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
172 };
173
174 static const WORD main_key_vkey_qwerty_v2[MAIN_LEN] =
175 {
176 /* NOTE: this layout must concur with the scan codes layout above */
177    VK_OEM_5,'1','2','3','4','5','6','7','8','9','0',VK_OEM_PLUS,VK_OEM_4,
178    'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_6,VK_OEM_1,
179    'A','S','D','F','G','H','J','K','L',VK_OEM_3,VK_OEM_7,VK_OEM_2,
180    'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_MINUS,
181    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
182 };
183
184 static const WORD main_key_vkey_qwertz[MAIN_LEN] =
185 {
186 /* NOTE: this layout must concur with the scan codes layout above */
187    VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
188    'Q','W','E','R','T','Z','U','I','O','P',VK_OEM_4,VK_OEM_6,
189    'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_7,VK_OEM_5,
190    'Y','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
191    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
192 };
193
194 static const WORD main_key_vkey_abnt_qwerty[MAIN_LEN] =
195 {
196 /* NOTE: this layout must concur with the scan codes layout above */
197    VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_MINUS,VK_OEM_PLUS,
198    'Q','W','E','R','T','Y','U','I','O','P',VK_OEM_4,VK_OEM_6,
199    'A','S','D','F','G','H','J','K','L',VK_OEM_1,VK_OEM_8,VK_OEM_5,
200    VK_OEM_7,'Z','X','C','V','B','N','M',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
201    VK_OEM_102, /* the 102nd key (actually to the right of l-shift) */
202 };
203
204 static const WORD main_key_vkey_azerty[MAIN_LEN] =
205 {
206 /* NOTE: this layout must concur with the scan codes layout above */
207    VK_OEM_7,'1','2','3','4','5','6','7','8','9','0',VK_OEM_4,VK_OEM_PLUS,
208    'A','Z','E','R','T','Y','U','I','O','P',VK_OEM_6,VK_OEM_1,
209    'Q','S','D','F','G','H','J','K','L','M',VK_OEM_3,VK_OEM_5,
210    'W','X','C','V','B','N',VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,VK_OEM_8,
211    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
212 };
213
214 static const WORD main_key_vkey_dvorak[MAIN_LEN] =
215 {
216 /* NOTE: this layout must concur with the scan codes layout above */
217    VK_OEM_3,'1','2','3','4','5','6','7','8','9','0',VK_OEM_4,VK_OEM_6,
218    VK_OEM_7,VK_OEM_COMMA,VK_OEM_PERIOD,'P','Y','F','G','C','R','L',VK_OEM_2,VK_OEM_PLUS,
219    'A','O','E','U','I','D','H','T','N','S',VK_OEM_MINUS,VK_OEM_5,
220    VK_OEM_1,'Q','J','K','X','B','M','W','V','Z',
221    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
222 };
223
224 /*** DEFINE YOUR NEW LANGUAGE-SPECIFIC MAPPINGS BELOW, SEE EXISTING TABLES */
225
226 /* the VK mappings for the main keyboard will be auto-assigned as before,
227    so what we have here is just the character tables */
228 /* order: Normal, Shift, AltGr, Shift-AltGr */
229 /* We recommend you write just what is guaranteed to be correct (i.e. what's
230    written on the keycaps), not the bunch of special characters behind AltGr
231    and Shift-AltGr if it can vary among different X servers */
232 /* Remember that your 102nd key (to the right of l-shift) should be on a
233    separate line, see existing tables */
234 /* If Wine fails to match your new table, use WINEDEBUG=+key to find out why */
235 /* Remember to also add your new table to the layout index table far below! */
236
237 /*** United States keyboard layout (mostly contributed by Uwe Bonnes) */
238 static const char main_key_US[MAIN_LEN][4] =
239 {
240  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
241  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
242  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
243  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
244 };
245
246 /*** United States keyboard layout (phantom key version) */
247 /* (XFree86 reports the <> key even if it's not physically there) */
248 static const char main_key_US_phantom[MAIN_LEN][4] =
249 {
250  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
251  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
252  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
253  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
254  "<>" /* the phantom key */
255 };
256
257 /*** United States keyboard layout (dvorak version) */
258 static const char main_key_US_dvorak[MAIN_LEN][4] =
259 {
260  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","[{","]}",
261  "'\"",",<",".>","pP","yY","fF","gG","cC","rR","lL","/?","=+",
262  "aA","oO","eE","uU","iI","dD","hH","tT","nN","sS","-_","\\|",
263  ";:","qQ","jJ","kK","xX","bB","mM","wW","vV","zZ"
264 };
265
266 /*** British keyboard layout */
267 static const char main_key_UK[MAIN_LEN][4] =
268 {
269  "`","1!","2\"","3£","4$","5%","6^","7&","8*","9(","0)","-_","=+",
270  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
271  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'@","#~",
272  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
273  "\\|"
274 };
275
276 /*** French keyboard layout (setxkbmap fr) */
277 static const char main_key_FR[MAIN_LEN][4] =
278 {
279  "²","&1","é2","\"3","'4","(5","-6","è7","_8","ç9","à0",")°","=+",
280  "aA","zZ","eE","rR","tT","yY","uU","iI","oO","pP","^¨","$£",
281  "qQ","sS","dD","fF","gG","hH","jJ","kK","lL","mM","ù%","*µ",
282  "wW","xX","cC","vV","bB","nN",",?",";.",":/","!§",
283  "<>"
284 };
285
286 /*** Icelandic keyboard layout (setxkbmap is) */
287 static const char main_key_IS[MAIN_LEN][4] =
288 {
289  "°","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","öÖ","-_",
290  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","ðÐ","'?",
291  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","æÆ","´Ä","+*",
292  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","þÞ",
293  "<>"
294 };
295
296 /* All german keyb layout tables have the acute/apostrophe symbol next to
297  * the BACKSPACE key removed (replaced with NULL which is ignored by the
298  * detection code).
299  * This was done because the mapping of the acute (and apostrophe) is done
300  * differently in various xkb-data/xkeyboard-config versions. Some replace
301  * the acute with a normal apostrophe, so that the apostrophe is found twice
302  * on the keyboard (one next to BACKSPACE and one next to ENTER).
303  * Others put the acute and grave accents on the key left of BACKSPACE.
304  * More information on the fd.o bugtracker:
305  * https://bugs.freedesktop.org/show_bug.cgi?id=11514
306  */
307
308 /*** German Logitech Desktop Pro keyboard layout */
309 static const char main_key_DE_logitech[MAIN_LEN][4] =
310 {
311  "^\xb0","1!","2\"","3\xa7","4$","5%","6&","7/{","8([","9)]","0=}","\xdf?\\","\0`",
312  "qQ@","wW","eE","rR","tT","zZ","uU","iI","oO","pP","\xfc\xdc","+*~",
313  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\xf6\xd6","\xe4\xc4","#'",
314  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
315  "<>|"
316 };
317
318 /*** German keyboard layout (setxkbmap de) */
319 static const char main_key_DE[MAIN_LEN][4] =
320 {
321  "^°","1!","2\"","3§","4$","5%","6&","7/","8(","9)","0=","ß?","\0`",
322  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üÜ","+*",
323  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","#'",
324  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
325  "<>|"
326 };
327
328 /*** German keyboard layout without dead keys */
329 static const char main_key_DE_nodead[MAIN_LEN][4] =
330 {
331  "^°","1!","2\"","3§","4$","5%","6&","7/{","8([","9)]","0=}","ß?\\","",
332  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üÜ","+*~",
333  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","#'",
334  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
335  "<>"
336 };
337
338 /*** Swiss German keyboard layout (setxkbmap ch -variant de) */
339 static const char main_key_SG[MAIN_LEN][4] =
340 {
341  "§°","1+","2\"","3*","4ç","5%","6&","7/","8(","9)","0=","'?","^`",
342  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üè","¨!",
343  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öé","äà","$£",
344  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
345  "<>"
346 };
347
348 /*** Swiss French keyboard layout (setxkbmap ch -variant fr) */
349 static const char main_key_SF[MAIN_LEN][4] =
350 {
351  "§°","1+","2\"","3*","4ç","5%","6&","7/","8(","9)","0=","'?","^`",
352  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","èü","¨!",
353  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","éö","àä","$£",
354  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
355  "<>"
356 };
357
358 /*** Norwegian keyboard layout (contributed by Ove Kåven) */
359 static const char main_key_NO[MAIN_LEN][4] =
360 {
361  "|§","1!","2\"@","3#£","4¤$","5%","6&","7/{","8([","9)]","0=}","+?","\\`´",
362  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^~",
363  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","øØ","æÆ","'*",
364  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
365  "<>"
366 };
367
368 /*** Danish keyboard layout (setxkbmap dk) */
369 static const char main_key_DA[MAIN_LEN][4] =
370 {
371  "½§","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
372  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^",
373  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","æÆ","øØ","'*",
374  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
375  "<>"
376 };
377
378 /*** Swedish keyboard layout (setxkbmap se) */
379 static const char main_key_SE[MAIN_LEN][4] =
380 {
381  "§½","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
382  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^",
383  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","'*",
384  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
385  "<>"
386 };
387
388 /*** Estonian keyboard layout (setxkbmap ee) */
389 static const char main_key_ET[MAIN_LEN][4] =
390 {
391  "·~","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
392  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","üÜ","õÕ",
393  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","'*",
394  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
395  "<>"
396 };
397
398 /*** Canadian French keyboard layout (setxkbmap ca_enhanced) */
399 static const char main_key_CF[MAIN_LEN][4] =
400 {
401  "#|\\","1!±","2\"@","3/£","4$¢","5%¤","6?¬","7&¦","8*²","9(³","0)¼","-_½","=+¾",
402  "qQ","wW","eE","rR","tT","yY","uU","iI","oO§","pP¶","^^[","¸¨]",
403  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:~","``{","<>}",
404  "zZ","xX","cC","vV","bB","nN","mM",",'-",".","éÉ",
405  "«»°"
406 };
407
408 /*** Canadian French keyboard layout (setxkbmap ca -variant fr) */
409 static const char main_key_CA_fr[MAIN_LEN][4] =
410 {
411  "#|","1!","2\"","3/","4$","5%","6?","7&","8*","9(","0)","-_","=+",
412  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","^^","¸¨",
413  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","``","<>",
414  "zZ","xX","cC","vV","bB","nN","mM",",'",".","éÉ",
415  "«»"
416 };
417
418 /*** Canadian keyboard layout (setxkbmap ca) */
419 static const char main_key_CA[MAIN_LEN][4] =
420 {
421  "/\\","1!¹¡","2@²","3#³£","4$¼¤","5%½","6?¾","7&","8*","9(","0)","-_","=+",
422  "qQ","wW","eE","rR","tT","yY","uU","iI","oOøØ","pPþÞ","^¨¨","çÇ~",
423  "aAæÆ","sSߧ","dDðÐ","fF","gG","hH","jJ","kK","lL",";:´","èÈ","àÀ",
424  "zZ","xX","cC¢©","vV","bB","nN","mMµº",",'",".\"·÷","éÉ",
425  "ùÙ"
426 };
427
428 /*** Portuguese keyboard layout (setxkbmap pt) */
429 static const char main_key_PT[MAIN_LEN][4] =
430 {
431  "\\|","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","«»",
432  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","+*","´`",
433  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","çÇ","ºª","~^",
434  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
435  "<>"
436 };
437
438 /*** Italian keyboard layout (setxkbmap it) */
439 static const char main_key_IT[MAIN_LEN][4] =
440 {
441  "\\|","1!","2\"","3£","4$","5%","6&","7/","8(","9)","0=","'?","ì^",
442  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","èé","+*",
443  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","òç","à°","ù§",
444  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
445  "<>"
446 };
447
448 /*** Finnish keyboard layout (setxkbmap fi) */
449 static const char main_key_FI[MAIN_LEN][4] =
450 {
451  "§½","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
452  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^",
453  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","'*",
454  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
455  "<>"
456 };
457
458 /*** Bulgarian bds keyboard layout */
459 static const char main_key_BG_bds[MAIN_LEN][4] =
460 {
461  "`~()","1!","2@2?","3#3+","4$4\"","5%","6^6=","7&7:","8*8/","9(","0)","-_-I","=+.V",
462  "qQ,û","wWóÓ","eEåÅ","rRèÈ","tTøØ","yYùÙ","uUêÊ","iIñÑ","oOäÄ","pPçÇ","[{öÖ","]};",
463  "aAüÜ","sSÿß","dDàÀ","fFîÎ","gGæÆ","hHãÃ","jJòÒ","kKíÍ","lLâÂ",";:ìÌ","'\"÷×","\\|'Û",
464  "zZþÞ","xXéÉ","cCúÚ","vVýÝ","bBôÔ","nNõÕ","mMïÏ",",<ðÐ",".>ëË","/?áÁ",
465  "<>" /* the phantom key */
466 };
467
468 /*** Bulgarian phonetic keyboard layout */
469 static const char main_key_BG_phonetic[MAIN_LEN][4] =
470 {
471  "`~÷×","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
472  "qQÿß","wWâÂ","eEåÅ","rRðÐ","tTòÒ","yYúÚ","uUóÓ","iIèÈ","oOîÎ","pPïÏ","[{øØ","]}ùÙ",
473  "aAàÀ","sSñÑ","dDäÄ","fFôÔ","gGãÃ","hHõÕ","jJéÉ","kKêÊ","lLëË",";:","'\"","\\|þÞ",
474  "zZçÇ","xXüÜ","cCöÖ","vVæÆ","bBáÁ","nNíÍ","mMìÌ",",<",".>","/?",
475  "<>" /* the phantom key */
476 };
477
478 /*** Belarusian standard keyboard layout (contributed by Hleb Valoska) */
479 /*** It matches belarusian layout for XKB from Alexander Mikhailian    */
480 static const char main_key_BY[MAIN_LEN][4] =
481 {
482  "`~£³","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
483  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oO®¾","pPÚú","[{Èè","]}''",
484  "aAÆæ","sSÙù","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"Üü","\\|/|",
485  "zZÑñ","xXÞþ","cCÓó","vVÍí","bB¦¶","nNÔô","mMØø",",<Ââ",".>Àà","/?.,", "<>|¦",
486 };
487
488
489 /*** Russian keyboard layout (contributed by Pavel Roskin) */
490 static const char main_key_RU[MAIN_LEN][4] =
491 {
492  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
493  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oOÝý","pPÚú","[{Èè","]}ßÿ",
494  "aAÆæ","sSÙù","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"Üü","\\|",
495  "zZÑñ","xXÞþ","cCÓó","vVÍí","bBÉé","nNÔô","mMØø",",<Ââ",".>Àà","/?"
496 };
497
498 /*** Russian keyboard layout (phantom key version) */
499 static const char main_key_RU_phantom[MAIN_LEN][4] =
500 {
501  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
502  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oOÝý","pPÚú","[{Èè","]}ßÿ",
503  "aAÆæ","sSÙù","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"Üü","\\|",
504  "zZÑñ","xXÞþ","cCÓó","vVÍí","bBÉé","nNÔô","mMØø",",<Ââ",".>Àà","/?",
505  "<>" /* the phantom key */
506 };
507
508 /*** Russian keyboard layout KOI8-R */
509 static const char main_key_RU_koi8r[MAIN_LEN][4] =
510 {
511  "()","1!","2\"","3/","4$","5:","6,","7.","8;","9?","0%","-_","=+",
512  "Êê","Ãã","Õõ","Ëë","Åå","Îî","Çç","Ûû","Ýý","Úú","Èè","ßÿ",
513  "Ææ","Ùù","×÷","Áá","Ðð","Òò","Ïï","Ìì","Ää","Öö","Üü","\\|",
514  "Ññ","Þþ","Óó","Íí","Éé","Ôô","Øø","Ââ","Àà","/?",
515  "<>" /* the phantom key */
516 };
517
518 /*** Russian keyboard layout cp1251 */
519 static const char main_key_RU_cp1251[MAIN_LEN][4] =
520 {
521  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
522  "qQéÉ","wWöÖ","eEóÓ","rRêÊ","tTåÅ","yYíÍ","uUãÃ","iIøØ","oOùÙ","pPçÇ","[{õÕ","]}úÚ",
523  "aAôÔ","sSûÛ","dDâÂ","fFàÀ","gGïÏ","hHðÐ","jJîÎ","kKëË","lLäÄ",";:æÆ","'\"ýÝ","\\|",
524  "zZÿß","xX÷×","cCñÑ","vVìÌ","bBèÈ","nNòÒ","mMüÜ",",<áÁ",".>þÞ","/?",
525  "<>" /* the phantom key */
526 };
527
528 /*** Russian phonetic keyboard layout */
529 static const char main_key_RU_phonetic[MAIN_LEN][4] =
530 {
531  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
532  "qQÑñ","wW×÷","eEÅå","rRÒò","tTÔô","yYÙù","uUÕõ","iIÉé","oOÏï","pPÐð","[{Ûû","]}Ýý",
533  "aAÁá","sSÓó","dDÄä","fFÆæ","gGÇç","hHÈè","jJÊê","kKËë","lLÌì",";:","'\"","\\|",
534  "zZÚú","xXØø","cCÃã","vVÖö","bBÂâ","nNÎî","mMÍí",",<",".>","/?",
535  "<>" /* the phantom key */
536 };
537
538 /*** Ukrainian keyboard layout KOI8-U */
539 static const char main_key_UA[MAIN_LEN][4] =
540 {
541  "`~­½","1!1!","2@2\"","3#3'","4$4*","5%5:","6^6,","7&7.","8*8;","9(9(","0)0)","-_-_","=+=+",
542  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oOÝý","pPÚú","[{Èè","]}§·",
543  "aAÆæ","sS¦¶","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"¤´","\\|\\|",
544  "zZÑñ","xXÞþ","cCÓó","vVÍí","bBÉé","nNÔô","mMØø",",<Ââ",".>Àà","/?/?",
545  "<>" /* the phantom key */
546 };
547
548 /*** Ukrainian keyboard layout KOI8-U by O. Nykyforchyn */
549 /***  (as it appears on most of keyboards sold today)   */
550 static const char main_key_UA_std[MAIN_LEN][4] =
551 {
552  "­½","1!","2\"","3'","4;","5%","6:","7?","8*","9(","0)","-_","=+",
553  "Êê","Ãã","Õõ","Ëë","Åå","Îî","Çç","Ûû","Ýý","Úú","Èè","§·",
554  "Ææ","¦¶","×÷","Áá","Ðð","Òò","Ïï","Ìì","Ää","Öö","¤´","\\/",
555  "Ññ","Þþ","Óó","Íí","Éé","Ôô","Øø","Ââ","Àà",".,",
556  "<>" /* the phantom key */
557 };
558
559 /*** Russian keyboard layout KOI8-R (pair to the previous) */
560 static const char main_key_RU_std[MAIN_LEN][4] =
561 {
562  "£³","1!","2\"","3'","4;","5%","6:","7?","8*","9(","0)","-_","=+",
563  "Êê","Ãã","Õõ","Ëë","Åå","Îî","Çç","Ûû","Ýý","Úú","Èè","ßÿ",
564  "Ææ","Ùù","×÷","Áá","Ðð","Òò","Ïï","Ìì","Ää","Öö","Üü","\\/",
565  "Ññ","Þþ","Óó","Íí","Éé","Ôô","Øø","Ââ","Àà",".,",
566  "<>" /* the phantom key */
567 };
568
569 /*** Spanish keyboard layout (setxkbmap es) */
570 static const char main_key_ES[MAIN_LEN][4] =
571 {
572  "ºª","1!","2\"","3·","4$","5%","6&","7/","8(","9)","0=","'?","¡¿",
573  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","`^","+*",
574  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ñÑ","´¨","çÇ",
575  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
576  "<>"
577 };
578
579 /*** Belgian keyboard layout ***/
580 static const char main_key_BE[MAIN_LEN][4] =
581 {
582  "","&1|","é2@","\"3#","'4","(5","§6^","è7","!8","ç9{","à0}",")°","-_",
583  "aA","zZ","eE¤","rR","tT","yY","uU","iI","oO","pP","^¨[","$*]",
584  "qQ","sSß","dD","fF","gG","hH","jJ","kK","lL","mM","ù%´","µ£`",
585  "wW","xX","cC","vV","bB","nN",",?",";.",":/","=+~",
586  "<>\\"
587 };
588
589 /*** Hungarian keyboard layout (setxkbmap hu) */
590 static const char main_key_HU[MAIN_LEN][4] =
591 {
592  "0§","1'","2\"","3+","4!","5%","6/","7=","8(","9)","öÖ","üÜ","óÓ",
593  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","õÕ","úÚ",
594  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","éÉ","áÁ","ûÛ",
595  "yY","xX","cC","vV","bB","nN","mM",",?",".:","-_",
596  "íÍ"
597 };
598
599 /*** Polish (programmer's) keyboard layout ***/
600 static const char main_key_PL[MAIN_LEN][4] =
601 {
602  "`~","1!","2@","3#","4$","5%","6^","7&§","8*","9(","0)","-_","=+",
603  "qQ","wW","eEêÊ","rR","tT","yY","uU","iI","oOóÓ","pP","[{","]}",
604  "aA±¡","sS¶¦","dD","fF","gG","hH","jJ","kK","lL³£",";:","'\"","\\|",
605  "zZ¿¯","xX¼¬","cCæÆ","vV","bB","nNñÑ","mM",",<",".>","/?",
606  "<>|"
607 };
608
609 /*** Slovenian keyboard layout (setxkbmap si) ***/
610 static const char main_key_SI[MAIN_LEN][4] =
611 {
612  "¸¨","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","+*",
613  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","¹©","ðÐ",
614  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","èÈ","æÆ","¾®",
615  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
616  "<>"
617 };
618
619 /*** Serbian keyboard layout (setxkbmap sr) ***/
620 static const char main_key_SR[MAIN_LEN][4] =
621 {
622  "`~","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","+*",
623  "©¹","ªº","Åå","Òò","Ôô","Úú","Õõ","Éé","Ïï","Ðð","Ûû","[]",
624  "Áá","Óó","Ää","Ææ","Çç","Èè","¨¸","Ëë","Ìì","Þþ","«»","-_",
625  "¡±","¯¿","Ãã","×÷","Ââ","Îî","Íí",",;",".:","Öö",
626  "<>" /* the phantom key */
627 };
628
629 /*** Serbian keyboard layout (setxkbmap us,sr) ***/
630 static const char main_key_US_SR[MAIN_LEN][4] =
631 {
632  "`~","1!","2@2\"","3#","4$","5%","6^6&","7&7/","8*8(","9(9)","0)0=","-_'?","=++*",
633  "qQ©¹","wWªº","eEÅå","rRÒò","tTÔô","yYÚú","uUÕõ","iIÉé","oOÏï","pPÐð","[{Ûû","]}[]",
634  "aAÁá","sSÓó","dDÄä","fFÆæ","gGÇç","hHÈè","jJ¨¸","kKËë","lLÌì",";:Þþ","'\"«»","\\|-_",
635  "zZ¡±","xX¯¿","cCÃã","vV×÷","bBÂâ","nNÎî","mMÍí",",<,;",".>.:","/?Öö",
636  "<>" /* the phantom key */
637 };
638
639 /*** Croatian keyboard layout specific for me <jelly@srk.fer.hr> ***/
640 static const char main_key_HR_jelly[MAIN_LEN][4] =
641 {
642  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
643  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{¹©","]}ðÐ",
644  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:èÈ","'\"æÆ","\\|¾®",
645  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
646  "<>|"
647 };
648
649 /*** Croatian keyboard layout (setxkbmap hr) ***/
650 static const char main_key_HR[MAIN_LEN][4] =
651 {
652  "¸¨","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","+*",
653  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","¹©","ðÐ",
654  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","èÈ","æÆ","¾®",
655  "yY","xX","cC","vV","bB","nN","mM",",;",".:","/?",
656  "<>"
657 };
658
659 /*** Japanese 106 keyboard layout ***/
660 static const char main_key_JA_jp106[MAIN_LEN][4] =
661 {
662  "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0~","-=","^~","\\|",
663  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@`","[{",
664  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
665  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
666  "\\_",
667 };
668
669 static const char main_key_JA_macjp[MAIN_LEN][4] =
670 {
671  "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0","-=","^~","\\|",
672  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@`","[{",
673  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
674  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
675  "__",
676 };
677
678 /*** Japanese pc98x1 keyboard layout ***/
679 static const char main_key_JA_pc98x1[MAIN_LEN][4] =
680 {
681  "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0","-=","^`","\\|",
682  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@~","[{",
683  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
684  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
685  "\\_",
686 };
687
688 /*** Brazilian ABNT-2 keyboard layout (contributed by Raul Gomes Fernandes) */
689 static const char main_key_PT_br[MAIN_LEN][4] =
690 {
691  "'\"","1!","2@","3#","4$","5%","6¨","7&","8*","9(","0)","-_","=+",
692  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","´`","[{",
693  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","çÇ","~^","]}",
694  "\\|","zZ","xX","cC","vV","bB","nN","mM",",<",".>",";:","/?",
695 };
696
697 /*** Brazilian ABNT-2 keyboard layout with <ALT GR> (contributed by Mauro Carvalho Chehab) */
698 static const char main_key_PT_br_alt_gr[MAIN_LEN][4] =
699 {
700  "'\"","1!9","2@2","3#3","4$#","5%\"","6(,","7&","8*","9(","0)","-_","=+'",
701  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","4`","[{*",
702  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","gG","~^","]}:",
703  "\\|","zZ","xX","cC","vV","bB","nN","mM",",<",".>",";:","/?0"
704 };
705
706 /*** US international keyboard layout (contributed by Gustavo Noronha (kov@debian.org)) */
707 static const char main_key_US_intl[MAIN_LEN][4] =
708 {
709   "`~", "1!", "2@", "3#", "4$", "5%", "6^", "7&", "8*", "9(", "0)", "-_", "=+", "\\|",
710   "qQ", "wW", "eE", "rR", "tT", "yY", "uU", "iI", "oO", "pP", "[{", "]}",
711   "aA", "sS", "dD", "fF", "gG", "hH", "jJ", "kK", "lL", ";:", "'\"",
712   "zZ", "xX", "cC", "vV", "bB", "nN", "mM", ",<", ".>", "/?"
713 };
714
715 /*** Slovak keyboard layout (see cssk_ibm(sk_qwerty) in xkbsel)
716   - dead_abovering replaced with degree - no symbol in iso8859-2
717   - brokenbar replaced with bar                                 */
718 static const char main_key_SK[MAIN_LEN][4] =
719 {
720  ";0","+1","µ2","¹3","è4","»5","¾6","ý7","á8","í9","é0","=%","'v",
721  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","ú/","ä(",
722  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ô\"","§!","ò)",
723  "zZ","xX","cC","vV","bB","nN","mM",",?",".:","-_",
724  "<>"
725 };
726
727 /*** Czech keyboard layout (setxkbmap cz) */
728 static const char main_key_CZ[MAIN_LEN][4] =
729 {
730  ";","+1","ì2","¹3","è4","ø5","¾6","ý7","á8","í9","é0","=%","´·",
731  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","ú/",")(",
732  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ù\"","§!","¨'",
733  "yY","xX","cC","vV","bB","nN","mM",",?",".:","-_",
734  "\\"
735 };
736
737 /*** Czech keyboard layout (setxkbmap cz_qwerty) */
738 static const char main_key_CZ_qwerty[MAIN_LEN][4] =
739 {
740  ";","+1","ì2","¹3","è4","ø5","¾6","ý7","á8","í9","é0","=%","´·",
741  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","ú/",")(",
742  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ù\"","§!","¨'",
743  "zZ","xX","cC","vV","bB","nN","mM",",?",".:","-_",
744  "\\"
745 };
746
747 /*** Slovak and Czech (programmer's) keyboard layout (see cssk_dual(cs_sk_ucw)) */
748 static const char main_key_SK_prog[MAIN_LEN][4] =
749 {
750  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
751  "qQäÄ","wWìÌ","eEéÉ","rRøØ","tT»«","yYýÝ","uUùÙ","iIíÍ","oOóÓ","pPöÖ","[{","]}",
752  "aAáÁ","sS¹©","dDïÏ","fFëË","gGàÀ","hHúÚ","jJüÜ","kKôÔ","lLµ¥",";:","'\"","\\|",
753  "zZ¾®","xX¤","cCèÈ","vVçÇ","bB","nNòÒ","mMåÅ",",<",".>","/?",
754  "<>"
755 };
756
757 /*** Czech keyboard layout (see cssk_ibm(cs_qwerty) in xkbsel) */
758 static const char main_key_CS[MAIN_LEN][4] =
759 {
760  ";","+1","ì2","¹3","è4","ø5","¾6","ý7","á8","í9","é0½)","=%","",
761  "qQ\\","wW|","eE","rR","tT","yY","uU","iI","oO","pP","ú/[{",")(]}",
762  "aA","sSð","dDÐ","fF[","gG]","hH","jJ","kK³","lL£","ù\"$","§!ß","¨'",
763  "zZ>","xX#","cC&","vV@","bB{","nN}","mM",",?<",".:>","-_*",
764  "<>\\|"
765 };
766
767 /*** Latin American keyboard layout (contributed by Gabriel Orlando Garcia) */
768 static const char main_key_LA[MAIN_LEN][4] =
769 {
770  "|°","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","¿¡",
771  "qQ@","wW","eE","rR","tT","yY","uU","iI","oO","pP","´¨","+*",
772  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ñÑ","{[^","}]",
773  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
774  "<>"
775 };
776
777 /*** Lithuanian keyboard layout (setxkbmap lt) */
778 static const char main_key_LT_B[MAIN_LEN][4] =
779 {
780  "`~","àÀ","èÈ","æÆ","ëË","áÁ","ðÐ","øØ","ûÛ","¥(","´)","-_","þÞ","\\|",
781  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
782  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"",
783  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
784  "ª¬"
785 };
786
787 /*** Turkish keyboard Layout */
788 static const char main_key_TK[MAIN_LEN][4] =
789 {
790 "\"é","1!","2'","3^#","4+$","5%","6&","7/{","8([","9)]","0=}","*?\\","-_",
791 "qQ@","wW","eE","rR","tT","yY","uU","ýIî","oO","pP","ðÐ","üÜ~",
792 "aAæ","sSß","dD","fF","gG","hH","jJ","kK","lL","þÞ","iÝ",",;`",
793 "zZ","xX","cC","vV","bB","nN","mM","öÖ","çÇ",".:"
794 };
795
796 /*** Turkish keyboard layout (setxkbmap tr) */
797 static const char main_key_TR[MAIN_LEN][4] =
798 {
799 "\"\\","1!","2'","3^","4+","5%","6&","7/","8(","9)","0=","*?","-_",
800 "qQ","wW","eE","rR","tT","yY","uU","\xb9I","oO","pP","\xbb\xab","üÜ",
801 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\xba\xaa","i\0",",;",
802 "zZ","xX","cC","vV","bB","nN","mM","öÖ","çÇ",".:",
803 "<>"
804 };
805
806 /*** Turkish F keyboard layout (setxkbmap trf) */
807 static const char main_key_TR_F[MAIN_LEN][4] =
808 {
809 "+*","1!","2\"","3^#","4$","5%","6&","7'","8(","9)","0=","/?","-_",
810 "fF","gG","\xbb\xab","\xb9I","oO","dD","rR","nN","hH","pP","qQ","wW",
811 "uU","i\0","eE","aA","üÜ","tT","kK","mM","lL","yY","\xba\xaa","xX",
812 "jJ","öÖ","vV","cC","çÇ","zZ","sS","bB",".:",",;",
813 "<>"
814 };
815
816 /*** Israelian keyboard layout (setxkbmap us,il) */
817 static const char main_key_IL[MAIN_LEN][4] =
818 {
819  "`~;","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
820  "qQ/","wW'","eE÷","rRø","tTà","yYè","uUå","iIï","oOí","pPô","[{","]}",
821  "aAù","sSã","dDâ","fFë","gGò","hHé","jJç","kKì","lLê",";:ó","\'\",","\\|",
822  "zZæ","xXñ","cCá","vVä","bBð","nNî","mMö",",<ú",".>õ","/?.",
823  "<>"
824 };
825
826 /*** Israelian phonetic keyboard layout (setxkbmap us,il_phonetic) */
827 static const char main_key_IL_phonetic[MAIN_LEN][4] =
828 {
829  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
830  "qQ÷","wWå","eEà","rRø","tTú","yYò","uUå","iIé","oOñ","pPô","[{","]}",
831  "aAà","sSù","dDã","fFô","gGâ","hHä","jJé","kKë","lLì",";:","'\"","\\|",
832  "zZæ","xXç","cCö","vVå","bBá","nNð","mMî",",<",".>","/?",
833  "<>"
834 };
835
836 /*** Israelian Saharon keyboard layout (setxkbmap -symbols "us(pc105)+il_saharon") */
837 static const char main_key_IL_saharon[MAIN_LEN][4] =
838 {
839  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
840  "qQ÷","wWñ","eE","rRø","tTè","yYã","uU","iI","oO","pPô","[{","]}",
841  "aAà","sSå","dDì","fFú","gGâ","hHä","jJù","kKë","lLé",";:","'\"","\\|",
842  "zZæ","xXç","cCö","vVò","bBá","nNð","mMî",",<",".>","/?",
843  "<>"
844 };
845
846 /*** Greek keyboard layout (contributed by Kriton Kyrimis <kyrimis@cti.gr>)
847   Greek characters for "wW" and "sS" are omitted to not produce a mismatch
848   message since they have different characters in gr and el XFree86 layouts. */
849 static const char main_key_EL[MAIN_LEN][4] =
850 {
851  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
852  "qQ;:","wW","eEåÅ","rRñÑ","tTôÔ","yYõÕ","uUèÈ","iIéÉ","oOïÏ","pPðÐ","[{","]}",
853  "aAáÁ","sS","dDäÄ","fFöÖ","gGãÃ","hHçÇ","jJîÎ","kKêÊ","lLëË",";:´¨","'\"","\\|",
854  "zZæÆ","xX÷×","cCøØ","vVùÙ","bBâÂ","nNíÍ","mMìÌ",",<",".>","/?",
855  "<>"
856 };
857
858 /*** Thai (Kedmanee) keyboard layout by Supphachoke Suntiwichaya <mrchoke@opentle.org> */
859 static const char main_key_th[MAIN_LEN][4] =
860 {
861  "`~_%","1!å+","2@/ñ","3#-ò","4$Àó","5%¶ô","6^ØÙ","7&Öß","8*¤õ","9(µö","0)¨÷","-_¢ø","=+ªù",
862  "qQæð","wWä\"","eEÓ®","rR¾±","tTи","yYÑí","uUÕê","iIó","oO¹Ï","pP­","[{º°","]}Å,",
863  "aA¿Ä","sS˦","dD¡¯","fF´â","gGà¬","hHéç","jJèë","kKÒÉ","lLÊÈ",";:Ç«","\'\"§.","\\|£¥",
864  "zZ¼(","xX»)","cCá©","vVÍÎ","bBÚ","nN×ì","mM·?",",<Á²",".>ãÌ","/?½Æ"
865 }; 
866
867 /*** VNC keyboard layout */
868 static const WORD main_key_scan_vnc[MAIN_LEN] =
869 {
870    0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x1A,0x1B,0x27,0x28,0x29,0x33,0x34,0x35,0x2B,
871    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,
872    0x56
873 };
874
875 static const WORD main_key_vkey_vnc[MAIN_LEN] =
876 {
877    '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,
878    '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',
879    VK_OEM_102
880 };
881
882 static const char main_key_vnc[MAIN_LEN][4] =
883 {
884  "1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+","[{","]}",";:","'\"","`~",",<",".>","/?","\\|",
885  "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"
886 };
887
888 /*** Dutch keyboard layout (setxkbmap nl) ***/
889 static const char main_key_NL[MAIN_LEN][4] =
890 {
891  "@§","1!","2\"","3#","4$","5%","6&","7_","8(","9)","0'","/?","°~",
892  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","¨~","*|",
893  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","+±","'`","<>",
894  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-=",
895  "[]"
896 };
897
898
899
900 /*** Layout table. Add your keyboard mappings to this list */
901 static const struct {
902     LCID lcid; /* input locale identifier, look for LOCALE_ILANGUAGE
903                  in the appropriate dlls/kernel/nls/.nls file */
904     const char *comment;
905     const char (*key)[MAIN_LEN][4];
906     const WORD (*scan)[MAIN_LEN]; /* scan codes mapping */
907     const WORD (*vkey)[MAIN_LEN]; /* virtual key codes mapping */
908 } main_key_tab[]={
909  {0x0409, "United States keyboard layout", &main_key_US, &main_key_scan_qwerty, &main_key_vkey_qwerty},
910  {0x0409, "United States keyboard layout (phantom key version)", &main_key_US_phantom, &main_key_scan_qwerty, &main_key_vkey_qwerty},
911  {0x0409, "United States keyboard layout (dvorak)", &main_key_US_dvorak, &main_key_scan_dvorak, &main_key_vkey_dvorak},
912  {0x0409, "United States International keyboard layout", &main_key_US_intl, &main_key_scan_qwerty, &main_key_vkey_qwerty},
913  {0x0809, "British keyboard layout", &main_key_UK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
914  {0x0407, "German keyboard layout", &main_key_DE, &main_key_scan_qwerty, &main_key_vkey_qwertz},
915  {0x0407, "German keyboard layout without dead keys", &main_key_DE_nodead, &main_key_scan_qwerty, &main_key_vkey_qwertz},
916  {0x0407, "German keyboard layout for logitech desktop pro", &main_key_DE_logitech,  &main_key_scan_qwerty, &main_key_vkey_qwertz},
917  {0x0807, "Swiss German keyboard layout", &main_key_SG, &main_key_scan_qwerty, &main_key_vkey_qwertz},
918  {0x100c, "Swiss French keyboard layout", &main_key_SF, &main_key_scan_qwerty, &main_key_vkey_qwertz},
919  {0x041d, "Swedish keyboard layout", &main_key_SE, &main_key_scan_qwerty, &main_key_vkey_qwerty_v2},
920  {0x0425, "Estonian keyboard layout", &main_key_ET, &main_key_scan_qwerty, &main_key_vkey_qwerty},
921  {0x0414, "Norwegian keyboard layout", &main_key_NO, &main_key_scan_qwerty, &main_key_vkey_qwerty},
922  {0x0406, "Danish keyboard layout", &main_key_DA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
923  {0x040c, "French keyboard layout", &main_key_FR, &main_key_scan_qwerty, &main_key_vkey_azerty},
924  {0x0c0c, "Canadian French keyboard layout", &main_key_CF, &main_key_scan_qwerty, &main_key_vkey_qwerty},
925  {0x0c0c, "Canadian French keyboard layout (CA_fr)", &main_key_CA_fr, &main_key_scan_qwerty, &main_key_vkey_qwerty},
926  {0x0c0c, "Canadian keyboard layout", &main_key_CA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
927  {0x080c, "Belgian keyboard layout", &main_key_BE, &main_key_scan_qwerty, &main_key_vkey_azerty},
928  {0x0816, "Portuguese keyboard layout", &main_key_PT, &main_key_scan_qwerty, &main_key_vkey_qwerty},
929  {0x0416, "Brazilian ABNT-2 keyboard layout", &main_key_PT_br, &main_key_scan_abnt_qwerty, &main_key_vkey_abnt_qwerty},
930  {0x0416, "Brazilian ABNT-2 keyboard layout ALT GR", &main_key_PT_br_alt_gr,&main_key_scan_abnt_qwerty, &main_key_vkey_abnt_qwerty},
931  {0x040b, "Finnish keyboard layout", &main_key_FI, &main_key_scan_qwerty, &main_key_vkey_qwerty},
932  {0x0402, "Bulgarian bds keyboard layout", &main_key_BG_bds, &main_key_scan_qwerty, &main_key_vkey_qwerty},
933  {0x0402, "Bulgarian phonetic keyboard layout", &main_key_BG_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
934  {0x0423, "Belarusian keyboard layout", &main_key_BY, &main_key_scan_qwerty, &main_key_vkey_qwerty},
935  {0x0419, "Russian keyboard layout", &main_key_RU, &main_key_scan_qwerty, &main_key_vkey_qwerty},
936  {0x0419, "Russian keyboard layout (phantom key version)", &main_key_RU_phantom, &main_key_scan_qwerty, &main_key_vkey_qwerty},
937  {0x0419, "Russian keyboard layout KOI8-R", &main_key_RU_koi8r, &main_key_scan_qwerty, &main_key_vkey_qwerty},
938  {0x0419, "Russian keyboard layout cp1251", &main_key_RU_cp1251, &main_key_scan_qwerty, &main_key_vkey_qwerty},
939  {0x0419, "Russian phonetic keyboard layout", &main_key_RU_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
940  {0x0422, "Ukrainian keyboard layout KOI8-U", &main_key_UA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
941  {0x0422, "Ukrainian keyboard layout (standard)", &main_key_UA_std, &main_key_scan_qwerty, &main_key_vkey_qwerty},
942  {0x0419, "Russian keyboard layout (standard)", &main_key_RU_std, &main_key_scan_qwerty, &main_key_vkey_qwerty},
943  {0x040a, "Spanish keyboard layout", &main_key_ES, &main_key_scan_qwerty, &main_key_vkey_qwerty},
944  {0x0410, "Italian keyboard layout", &main_key_IT, &main_key_scan_qwerty, &main_key_vkey_qwerty},
945  {0x040f, "Icelandic keyboard layout", &main_key_IS, &main_key_scan_qwerty, &main_key_vkey_qwerty},
946  {0x040e, "Hungarian keyboard layout", &main_key_HU, &main_key_scan_qwerty, &main_key_vkey_qwertz},
947  {0x0415, "Polish (programmer's) keyboard layout", &main_key_PL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
948  {0x0424, "Slovenian keyboard layout", &main_key_SI, &main_key_scan_qwerty, &main_key_vkey_qwertz},
949  {0x0c1a, "Serbian keyboard layout sr", &main_key_SR, &main_key_scan_qwerty, &main_key_vkey_qwerty}, /* LANG_SERBIAN,SUBLANG_SERBIAN_CYRILLIC */
950  {0x0c1a, "Serbian keyboard layout us,sr", &main_key_US_SR, &main_key_scan_qwerty, &main_key_vkey_qwerty}, /* LANG_SERBIAN,SUBLANG_SERBIAN_CYRILLIC */
951  {0x041a, "Croatian keyboard layout", &main_key_HR, &main_key_scan_qwerty, &main_key_vkey_qwertz},
952  {0x041a, "Croatian keyboard layout (specific)", &main_key_HR_jelly, &main_key_scan_qwerty, &main_key_vkey_qwerty},
953  {0x0411, "Japanese 106 keyboard layout", &main_key_JA_jp106, &main_key_scan_qwerty_jp106, &main_key_vkey_qwerty_jp106},
954  {0x0411, "Japanese Mac keyboard layout", &main_key_JA_macjp, &main_key_scan_qwerty_macjp, &main_key_vkey_qwerty_macjp},
955  {0x0411, "Japanese pc98x1 keyboard layout", &main_key_JA_pc98x1, &main_key_scan_qwerty, &main_key_vkey_qwerty},
956  {0x041b, "Slovak keyboard layout", &main_key_SK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
957  {0x041b, "Slovak and Czech keyboard layout without dead keys", &main_key_SK_prog, &main_key_scan_qwerty, &main_key_vkey_qwerty},
958  {0x0405, "Czech keyboard layout", &main_key_CS, &main_key_scan_qwerty, &main_key_vkey_qwerty},
959  {0x0405, "Czech keyboard layout cz", &main_key_CZ, &main_key_scan_qwerty, &main_key_vkey_qwertz},
960  {0x0405, "Czech keyboard layout cz_qwerty", &main_key_CZ_qwerty, &main_key_scan_qwerty, &main_key_vkey_qwerty},
961  {0x040a, "Latin American keyboard layout", &main_key_LA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
962  {0x0427, "Lithuanian (Baltic) keyboard layout", &main_key_LT_B, &main_key_scan_qwerty, &main_key_vkey_qwerty},
963  {0x041f, "Turkish keyboard layout", &main_key_TK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
964  {0x041f, "Turkish keyboard layout tr", &main_key_TR, &main_key_scan_qwerty, &main_key_vkey_qwerty},
965  {0x041f, "Turkish keyboard layout trf", &main_key_TR_F, &main_key_scan_qwerty, &main_key_vkey_qwerty},
966  {0x040d, "Israelian keyboard layout", &main_key_IL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
967  {0x040d, "Israelian phonetic keyboard layout", &main_key_IL_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
968  {0x040d, "Israelian Saharon keyboard layout", &main_key_IL_saharon, &main_key_scan_qwerty, &main_key_vkey_qwerty},
969  {0x0409, "VNC keyboard layout", &main_key_vnc, &main_key_scan_vnc, &main_key_vkey_vnc},
970  {0x0408, "Greek keyboard layout", &main_key_EL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
971  {0x041e, "Thai (Kedmanee)  keyboard layout", &main_key_th, &main_key_scan_qwerty, &main_key_vkey_qwerty},
972  {0x0413, "Dutch keyboard layout", &main_key_NL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
973
974  {0, NULL, NULL, NULL, NULL} /* sentinel */
975 };
976 static unsigned kbd_layout=0; /* index into above table of layouts */
977
978 /* maybe more of these scancodes should be extended? */
979                 /* extended must be set for ALT_R, CTRL_R,
980                    INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
981                    keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
982                 /* FIXME should we set extended bit for NumLock ? My
983                  * Windows does ... DF */
984                 /* Yes, to distinguish based on scan codes, also
985                    for PrtScn key ... GA */
986
987 static const WORD nonchar_key_vkey[256] =
988 {
989     /* unused */
990     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF00 */
991     /* special keys */
992     VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,           /* FF08 */
993     0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0,                      /* FF10 */
994     0, 0, 0, VK_ESCAPE, 0, 0, 0, 0,                             /* FF18 */
995     /* unused */
996     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF20 */
997     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF28 */
998     0, VK_HANGUL, 0, 0, VK_HANJA, 0, 0, 0,                      /* FF30 */
999     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF38 */
1000     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF40 */
1001     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF48 */
1002     /* cursor keys */
1003     VK_HOME, VK_LEFT, VK_UP, VK_RIGHT,                          /* FF50 */
1004     VK_DOWN, VK_PRIOR, VK_NEXT, VK_END,
1005     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF58 */
1006     /* misc keys */
1007     VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0,0,0, VK_APPS, /* FF60 */
1008     0, VK_CANCEL, VK_HELP, VK_CANCEL, 0, 0, 0, 0,               /* FF68 */
1009     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF70 */
1010     /* keypad keys */
1011     0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK,                            /* FF78 */
1012     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF80 */
1013     0, 0, 0, 0, 0, VK_RETURN, 0, 0,                             /* FF88 */
1014     0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP,                     /* FF90 */
1015     VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT,                       /* FF98 */
1016     VK_END, VK_CLEAR, VK_INSERT, VK_DELETE,
1017     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFA0 */
1018     0, 0, VK_MULTIPLY, VK_ADD,                                  /* FFA8 */
1019     VK_SEPARATOR, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE,
1020     VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3,             /* FFB0 */
1021     VK_NUMPAD4, VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7,
1022     VK_NUMPAD8, VK_NUMPAD9, 0, 0, 0, VK_OEM_NEC_EQUAL,          /* FFB8 */
1023     /* function keys */
1024     VK_F1, VK_F2,
1025     VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,    /* FFC0 */
1026     VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16, VK_F17, VK_F18, /* FFC8 */
1027     VK_F19, VK_F20, VK_F21, VK_F22, VK_F23, VK_F24, 0, 0,       /* FFD0 */
1028     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFD8 */
1029     /* modifier keys */
1030     0, VK_LSHIFT, VK_RSHIFT, VK_LCONTROL,                       /* FFE0 */
1031     VK_RCONTROL, VK_CAPITAL, 0, VK_MENU,
1032     VK_MENU, VK_LMENU, VK_RMENU, VK_LWIN, VK_RWIN, 0, 0, 0,     /* FFE8 */
1033     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFF0 */
1034     0, 0, 0, 0, 0, 0, 0, VK_DELETE                              /* FFF8 */
1035 };
1036
1037 static const WORD nonchar_key_scan[256] =
1038 {
1039     /* unused */
1040     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF00 */
1041     /* special keys */
1042     0x0E, 0x0F, 0x00, /*?*/ 0, 0x00, 0x1C, 0x00, 0x00,           /* FF08 */
1043     0x00, 0x00, 0x00, 0x45, 0x46, 0x00, 0x00, 0x00,              /* FF10 */
1044     0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,              /* FF18 */
1045     /* unused */
1046     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF20 */
1047     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF28 */
1048     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF30 */
1049     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF38 */
1050     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF40 */
1051     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF48 */
1052     /* cursor keys */
1053     0x147, 0x14B, 0x148, 0x14D, 0x150, 0x149, 0x151, 0x14F,      /* FF50 */
1054     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF58 */
1055     /* misc keys */
1056     /*?*/ 0, 0x137, /*?*/ 0, 0x152, 0x00, 0x00, 0x00, 0x15D,     /* FF60 */
1057     /*?*/ 0, /*?*/ 0, 0x38, 0x146, 0x00, 0x00, 0x00, 0x00,       /* FF68 */
1058     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF70 */
1059     /* keypad keys */
1060     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x145,             /* FF78 */
1061     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF80 */
1062     0x00, 0x00, 0x00, 0x00, 0x00, 0x11C, 0x00, 0x00,             /* FF88 */
1063     0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x4B, 0x48,              /* FF90 */
1064     0x4D, 0x50, 0x49, 0x51, 0x4F, 0x4C, 0x52, 0x53,              /* FF98 */
1065     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFA0 */
1066     0x00, 0x00, 0x37, 0x4E, 0x53, 0x4A, 0x53, 0x135,             /* FFA8 */
1067     0x52, 0x4F, 0x50, 0x51, 0x4B, 0x4C, 0x4D, 0x47,              /* FFB0 */
1068     0x48, 0x49, 0x00, 0x00, 0x00, 0x00,                          /* FFB8 */
1069     /* function keys */
1070     0x3B, 0x3C,
1071     0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44,              /* FFC0 */
1072     0x57, 0x58, 0x5B, 0x5C, 0x5D, 0x00, 0x00, 0x00,              /* FFC8 */
1073     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFD0 */
1074     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFD8 */
1075     /* modifier keys */
1076     0x00, 0x2A, 0x136, 0x1D, 0x11D, 0x3A, 0x00, 0x38,            /* FFE0 */
1077     0x138, 0x38, 0x138, 0x15b, 0x15c, 0x00, 0x00, 0x00,          /* FFE8 */
1078     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFF0 */
1079     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x153              /* FFF8 */
1080 };
1081
1082 static const WORD xfree86_vendor_key_vkey[256] =
1083 {
1084     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF00 */
1085     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF08 */
1086     0, VK_VOLUME_DOWN, VK_VOLUME_MUTE, VK_VOLUME_UP,            /* 1008FF10 */
1087     VK_MEDIA_PLAY_PAUSE, VK_MEDIA_STOP,
1088     VK_MEDIA_PREV_TRACK, VK_MEDIA_NEXT_TRACK,
1089     0, VK_LAUNCH_MAIL, 0, VK_BROWSER_SEARCH,                    /* 1008FF18 */
1090     0, 0, 0, VK_BROWSER_HOME,
1091     0, 0, 0, 0, 0, 0, VK_BROWSER_BACK, VK_BROWSER_FORWARD,      /* 1008FF20 */
1092     VK_BROWSER_STOP, VK_BROWSER_REFRESH, 0, 0, 0, 0, 0, 0,      /* 1008FF28 */
1093     VK_BROWSER_FAVORITES, 0, VK_LAUNCH_MEDIA_SELECT, 0,         /* 1008FF30 */
1094     0, 0, 0, 0,
1095     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF38 */
1096     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF40 */
1097     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF48 */
1098     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF50 */
1099     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF58 */
1100     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF60 */
1101     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF68 */
1102     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF70 */
1103     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF78 */
1104     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF80 */
1105     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF88 */
1106     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF90 */
1107     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FF98 */
1108     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFA0 */
1109     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFA8 */
1110     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFB0 */
1111     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFB8 */
1112     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFC0 */
1113     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFC8 */
1114     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFD0 */
1115     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFD8 */
1116     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFE0 */
1117     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFE8 */
1118     0, 0, 0, 0, 0, 0, 0, 0,                                     /* 1008FFF0 */
1119     0, 0, 0, 0, 0, 0, 0, 0                                      /* 1008FFF8 */
1120 };
1121
1122 /* Returns the Windows virtual key code associated with the X event <e> */
1123 /* x11 lock must be held */
1124 static WORD EVENT_event_to_vkey( XIC xic, XKeyEvent *e)
1125 {
1126     KeySym keysym = 0;
1127     Status status;
1128     char buf[24];
1129
1130     /* Clients should pass only KeyPress events to XmbLookupString */
1131     if (xic && e->type == KeyPress)
1132         XmbLookupString(xic, e, buf, sizeof(buf), &keysym, &status);
1133     else
1134         XLookupString(e, buf, sizeof(buf), &keysym, NULL);
1135
1136     if ((e->state & NumLockMask) &&
1137         (keysym == XK_KP_Separator || keysym == XK_KP_Decimal ||
1138          (keysym >= XK_KP_0 && keysym <= XK_KP_9)))
1139         /* Only the Keypad keys 0-9 and . send different keysyms
1140          * depending on the NumLock state */
1141         return nonchar_key_vkey[keysym & 0xFF];
1142
1143     /* Pressing the Pause/Break key alone produces VK_PAUSE vkey, while
1144      * pressing Ctrl+Pause/Break produces VK_CANCEL. */
1145     if ((e->state & ControlMask) && (keysym == XK_Break))
1146         return VK_CANCEL;
1147
1148     TRACE_(key)("e->keycode = %x\n", e->keycode);
1149
1150     return keyc2vkey[e->keycode];
1151 }
1152
1153
1154 /***********************************************************************
1155  *           X11DRV_send_keyboard_input
1156  */
1157 void X11DRV_send_keyboard_input( WORD wVk, WORD wScan, DWORD event_flags, DWORD time,
1158                                  DWORD dwExtraInfo, UINT injected_flags )
1159 {
1160     UINT message;
1161     KBDLLHOOKSTRUCT hook;
1162     WORD flags, wVkStripped, wVkL, wVkR, vk_hook = wVk;
1163     LPARAM lParam = 0;
1164
1165     wVk = LOBYTE(wVk);
1166     flags = LOBYTE(wScan);
1167
1168     if (event_flags & KEYEVENTF_EXTENDEDKEY) flags |= KF_EXTENDED;
1169     /* FIXME: set KF_DLGMODE and KF_MENUMODE when needed */
1170
1171     /* strip left/right for menu, control, shift */
1172     switch (wVk)
1173     {
1174     case VK_MENU:
1175     case VK_LMENU:
1176     case VK_RMENU:
1177         wVk = (event_flags & KEYEVENTF_EXTENDEDKEY) ? VK_RMENU : VK_LMENU;
1178         wVkStripped = VK_MENU;
1179         wVkL = VK_LMENU;
1180         wVkR = VK_RMENU;
1181         break;
1182     case VK_CONTROL:
1183     case VK_LCONTROL:
1184     case VK_RCONTROL:
1185         wVk = (event_flags & KEYEVENTF_EXTENDEDKEY) ? VK_RCONTROL : VK_LCONTROL;
1186         wVkStripped = VK_CONTROL;
1187         wVkL = VK_LCONTROL;
1188         wVkR = VK_RCONTROL;
1189         break;
1190     case VK_SHIFT:
1191     case VK_LSHIFT:
1192     case VK_RSHIFT:
1193         wVk = (event_flags & KEYEVENTF_EXTENDEDKEY) ? VK_RSHIFT : VK_LSHIFT;
1194         wVkStripped = VK_SHIFT;
1195         wVkL = VK_LSHIFT;
1196         wVkR = VK_RSHIFT;
1197         break;
1198     default:
1199         wVkStripped = wVkL = wVkR = wVk;
1200     }
1201
1202     if (event_flags & KEYEVENTF_KEYUP)
1203     {
1204         message = WM_KEYUP;
1205         if (((key_state_table[VK_MENU] & 0x80) &&
1206              ((wVkStripped == VK_MENU) || (wVkStripped == VK_CONTROL)
1207               || !(key_state_table[VK_CONTROL] & 0x80)))
1208             || (wVkStripped == VK_F10))
1209         {
1210             if( TrackSysKey == VK_MENU || /* <ALT>-down/<ALT>-up sequence */
1211                 (wVkStripped != VK_MENU)) /* <ALT>-down...<something else>-up */
1212                 message = WM_SYSKEYUP;
1213             TrackSysKey = 0;
1214         }
1215         flags |= KF_REPEAT | KF_UP;
1216     }
1217     else
1218     {
1219         message = WM_KEYDOWN;
1220         if (((key_state_table[VK_MENU] & 0x80 || wVkStripped == VK_MENU) &&
1221              !(key_state_table[VK_CONTROL] & 0x80 || wVkStripped == VK_CONTROL)) ||
1222             (wVkStripped == VK_F10))
1223         {
1224             message = WM_SYSKEYDOWN;
1225             TrackSysKey = wVkStripped;
1226         }
1227         if (!(event_flags & KEYEVENTF_UNICODE) && key_state_table[wVk] & 0x80) flags |= KF_REPEAT;
1228     }
1229
1230     if (event_flags & KEYEVENTF_UNICODE)
1231     {
1232         vk_hook = wVk = VK_PACKET;
1233         lParam = MAKELPARAM(1 /* repeat count */, wScan);
1234         TRACE_(key)(" message=0x%04x wParam=0x%04x lParam=0x%08lx\n",
1235                     message, wVk, lParam);
1236     }
1237
1238     /* Hook gets whatever key was sent. */
1239     hook.vkCode      = vk_hook;
1240     hook.scanCode    = wScan;
1241     hook.flags       = (flags >> 8) | injected_flags;
1242     hook.time        = time;
1243     hook.dwExtraInfo = dwExtraInfo;
1244     if (HOOK_CallHooks( WH_KEYBOARD_LL, HC_ACTION, message, (LPARAM)&hook, TRUE )) return;
1245
1246     if (!(event_flags & KEYEVENTF_UNICODE))
1247     {
1248         if (event_flags & KEYEVENTF_KEYUP)
1249         {
1250             key_state_table[wVk] &= ~0x80;
1251             key_state_table[wVkStripped] = key_state_table[wVkL] | key_state_table[wVkR];
1252         }
1253         else
1254         {
1255             if (!(key_state_table[wVk] & 0x80)) key_state_table[wVk] ^= 0x01;
1256             key_state_table[wVk] |= 0xc0;
1257             key_state_table[wVkStripped] = key_state_table[wVkL] | key_state_table[wVkR];
1258         }
1259
1260         if (key_state_table[VK_MENU] & 0x80) flags |= KF_ALTDOWN;
1261
1262         if (wVkStripped == VK_SHIFT) flags &= ~KF_EXTENDED;
1263
1264         lParam = MAKELPARAM(1 /* repeat count */, flags);
1265
1266         TRACE_(key)(" message=0x%04x wParam=0x%04x, lParam=0x%08lx, InputKeyState=0x%x\n",
1267                     message, wVk, lParam, key_state_table[wVk]);
1268     }
1269
1270     SERVER_START_REQ( send_hardware_message )
1271     {
1272         req->id       = (injected_flags & LLKHF_INJECTED) ? 0 : GetCurrentThreadId();
1273         req->win      = 0;
1274         req->msg      = message;
1275         req->wparam   = wVk;
1276         req->lparam   = lParam;
1277         req->x        = cursor_pos.x;
1278         req->y        = cursor_pos.y;
1279         req->time     = time;
1280         req->info     = dwExtraInfo;
1281         wine_server_call( req );
1282     }
1283     SERVER_END_REQ;
1284 }
1285
1286
1287 /***********************************************************************
1288  *           KEYBOARD_UpdateOneState
1289  *
1290  * Updates internal state for <vkey>, depending on key <state> under X
1291  *
1292  */
1293 static inline void KEYBOARD_UpdateOneState ( WORD vkey, WORD scan, int state, DWORD time )
1294 {
1295     /* Do something if internal table state != X state for keycode */
1296     if (((key_state_table[vkey & 0xff] & 0x80)!=0) != state)
1297     {
1298         DWORD flags = vkey & 0x100 ? KEYEVENTF_EXTENDEDKEY : 0;
1299
1300         if (!state) flags |= KEYEVENTF_KEYUP;
1301
1302         TRACE("Adjusting state for vkey %#.2x. State before %#.2x\n",
1303               vkey, key_state_table[vkey & 0xff]);
1304
1305         /* Fake key being pressed inside wine */
1306         X11DRV_send_keyboard_input( vkey & 0xff, scan & 0xff, flags, time, 0, 0 );
1307
1308         TRACE("State after %#.2x\n", key_state_table[vkey & 0xff]);
1309     }
1310 }
1311
1312 /***********************************************************************
1313  *           X11DRV_KeymapNotify
1314  *
1315  * Update modifiers state (Ctrl, Alt, Shift) when window is activated.
1316  *
1317  * This handles the case where one uses Ctrl+... Alt+... or Shift+.. to switch
1318  * from wine to another application and back.
1319  * Toggle keys are handled in HandleEvent.
1320  */
1321 void X11DRV_KeymapNotify( HWND hwnd, XEvent *event )
1322 {
1323     int i, j;
1324     DWORD time = GetCurrentTime();
1325
1326     /* the minimum keycode is always greater or equal to 8, so we can
1327      * skip the first 8 values, hence start at 1
1328      */
1329     for (i = 1; i < 32; i++)
1330     {
1331         for (j = 0; j < 8; j++)
1332         {
1333             WORD vkey = keyc2vkey[(i * 8) + j];
1334             WORD scan = keyc2scan[(i * 8) + j];
1335             int state = (event->xkeymap.key_vector[i] & (1<<j)) != 0;
1336
1337             switch(vkey & 0xff)
1338             {
1339             case VK_LMENU:
1340             case VK_RMENU:
1341             case VK_LCONTROL:
1342             case VK_RCONTROL:
1343             case VK_LSHIFT:
1344             case VK_RSHIFT:
1345                 KEYBOARD_UpdateOneState( vkey, scan, state, time );
1346                 break;
1347             }
1348         }
1349     }
1350 }
1351
1352 static void update_lock_state(BYTE vkey, WORD scan, DWORD time)
1353 {
1354     DWORD flags = vkey == VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0;
1355
1356     if (key_state_table[vkey] & 0x80) flags ^= KEYEVENTF_KEYUP;
1357
1358     X11DRV_send_keyboard_input( vkey, scan, flags, time, 0, 0 );
1359     X11DRV_send_keyboard_input( vkey, scan, flags ^ KEYEVENTF_KEYUP, time, 0, 0 );
1360 }
1361
1362 /***********************************************************************
1363  *           X11DRV_KeyEvent
1364  *
1365  * Handle a X key event
1366  */
1367 void X11DRV_KeyEvent( HWND hwnd, XEvent *xev )
1368 {
1369     XKeyEvent *event = &xev->xkey;
1370     char buf[24];
1371     char *Str = buf;
1372     KeySym keysym = 0;
1373     WORD vkey = 0, bScan;
1374     DWORD dwFlags;
1375     int ascii_chars;
1376     XIC xic = X11DRV_get_ic( hwnd );
1377     DWORD event_time = EVENT_x11_time_to_win32_time(event->time);
1378     Status status = 0;
1379
1380     TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
1381                 event->type, event->window, event->state, event->keycode);
1382
1383     wine_tsx11_lock();
1384     /* Clients should pass only KeyPress events to XmbLookupString */
1385     if (xic && event->type == KeyPress)
1386     {
1387         ascii_chars = XmbLookupString(xic, event, buf, sizeof(buf), &keysym, &status);
1388         TRACE("XmbLookupString needs %i byte(s)\n", ascii_chars);
1389         if (status == XBufferOverflow)
1390         {
1391             Str = HeapAlloc(GetProcessHeap(), 0, ascii_chars);
1392             if (Str == NULL)
1393             {
1394                 ERR("Failed to allocate memory!\n");
1395                 wine_tsx11_unlock();
1396                 return;
1397             }
1398             ascii_chars = XmbLookupString(xic, event, Str, ascii_chars, &keysym, &status);
1399         }
1400     }
1401     else
1402         ascii_chars = XLookupString(event, buf, sizeof(buf), &keysym, NULL);
1403     wine_tsx11_unlock();
1404
1405     TRACE_(key)("nbyte = %d, status 0x%x\n", ascii_chars, status);
1406
1407     if (status == XLookupChars)
1408     {
1409         X11DRV_XIMLookupChars( Str, ascii_chars );
1410         if (buf != Str)
1411             HeapFree(GetProcessHeap(), 0, Str);
1412         return;
1413     }
1414
1415     /* If XKB extensions are used, the state mask for AltGr will use the group
1416        index instead of the modifier mask. The group index is set in bits
1417        13-14 of the state field in the XKeyEvent structure. So if AltGr is
1418        pressed, look if the group index is different than 0. From XKB
1419        extension documentation, the group index for AltGr should be 2
1420        (event->state = 0x2000). It's probably better to not assume a
1421        predefined group index and find it dynamically
1422
1423        Ref: X Keyboard Extension: Library specification (section 14.1.1 and 17.1.1) */
1424     /* Save also all possible modifier states. */
1425     AltGrMask = event->state & (0x6000 | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
1426
1427     if (TRACE_ON(key)){
1428         const char *ksname;
1429
1430         wine_tsx11_lock();
1431         ksname = XKeysymToString(keysym);
1432         wine_tsx11_unlock();
1433         if (!ksname)
1434           ksname = "No Name";
1435         TRACE_(key)("%s : keysym=%lX (%s), # of chars=%d / %s\n",
1436                     (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
1437                     keysym, ksname, ascii_chars, debugstr_an(Str, ascii_chars));
1438     }
1439     if (buf != Str)
1440         HeapFree(GetProcessHeap(), 0, Str);
1441
1442     wine_tsx11_lock();
1443     vkey = EVENT_event_to_vkey(xic,event);
1444     /* X returns keycode 0 for composed characters */
1445     if (!vkey && ascii_chars) vkey = VK_NONAME;
1446     wine_tsx11_unlock();
1447
1448     TRACE_(key)("keycode 0x%x converted to vkey 0x%x\n",
1449                 event->keycode, vkey);
1450
1451     if (!vkey) return;
1452
1453     dwFlags = 0;
1454     if ( event->type == KeyRelease ) dwFlags |= KEYEVENTF_KEYUP;
1455     if ( vkey & 0x100 )              dwFlags |= KEYEVENTF_EXTENDEDKEY;
1456
1457
1458     /* Note: X sets the below states on key down and clears them on key up.
1459        Windows triggers them on key down. */
1460
1461     /* Adjust the CAPSLOCK state if it has been changed outside wine */
1462     if (!(key_state_table[VK_CAPITAL] & 0x01) != !(event->state & LockMask) &&
1463         vkey != VK_CAPITAL)
1464     {
1465         TRACE("Adjusting CapsLock state (%#.2x)\n", key_state_table[VK_CAPITAL]);
1466         update_lock_state(VK_CAPITAL, 0x3A, event_time);
1467     }
1468
1469     /* Adjust the NUMLOCK state if it has been changed outside wine */
1470     if (!(key_state_table[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask) &&
1471         (vkey & 0xff) != VK_NUMLOCK)
1472     {
1473         TRACE("Adjusting NumLock state (%#.2x)\n", key_state_table[VK_NUMLOCK]);
1474         update_lock_state(VK_NUMLOCK, 0x45, event_time);
1475     }
1476
1477     /* Adjust the SCROLLLOCK state if it has been changed outside wine */
1478     if (!(key_state_table[VK_SCROLL] & 0x01) != !(event->state & ScrollLockMask) &&
1479         vkey != VK_SCROLL)
1480     {
1481         TRACE("Adjusting ScrLock state (%#.2x)\n", key_state_table[VK_SCROLL]);
1482         update_lock_state(VK_SCROLL, 0x46, event_time);
1483     }
1484
1485     bScan = keyc2scan[event->keycode] & 0xFF;
1486     TRACE_(key)("bScan = 0x%02x.\n", bScan);
1487
1488     X11DRV_send_keyboard_input( vkey & 0xff, bScan, dwFlags, event_time, 0, 0 );
1489 }
1490
1491 /**********************************************************************
1492  *              X11DRV_KEYBOARD_DetectLayout
1493  *
1494  * Called from X11DRV_InitKeyboard
1495  *  This routine walks through the defined keyboard layouts and selects
1496  *  whichever matches most closely.
1497  * X11 lock must be held.
1498  */
1499 static void
1500 X11DRV_KEYBOARD_DetectLayout( Display *display )
1501 {
1502   unsigned current, match, mismatch, seq, i, syms;
1503   int score, keyc, key, pkey, ok;
1504   KeySym keysym = 0;
1505   const char (*lkey)[MAIN_LEN][4];
1506   unsigned max_seq = 0;
1507   int max_score = 0, ismatch = 0;
1508   char ckey[256][4];
1509
1510   syms = keysyms_per_keycode;
1511   if (syms > 4) {
1512     WARN("%d keysyms per keycode not supported, set to 4\n", syms);
1513     syms = 4;
1514   }
1515
1516   memset( ckey, 0, sizeof(ckey) );
1517   for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
1518       /* get data for keycode from X server */
1519       for (i = 0; i < syms; i++) {
1520         if (!(keysym = XKeycodeToKeysym (display, keyc, i))) continue;
1521         /* Allow both one-byte and two-byte national keysyms */
1522         if ((keysym < 0x8000) && (keysym != ' '))
1523         {
1524 #ifdef HAVE_XKB
1525             if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[keyc][i], 1, NULL))
1526 #endif
1527             {
1528                 TRACE("XKB could not translate keysym %ld\n", keysym);
1529                 /* FIXME: query what keysym is used as Mode_switch, fill XKeyEvent
1530                  * with appropriate ShiftMask and Mode_switch, use XLookupString
1531                  * to get character in the local encoding.
1532                  */
1533                 ckey[keyc][i] = keysym & 0xFF;
1534             }
1535         }
1536         else {
1537           ckey[keyc][i] = KEYBOARD_MapDeadKeysym(keysym);
1538         }
1539       }
1540   }
1541
1542   for (current = 0; main_key_tab[current].comment; current++) {
1543     TRACE("Attempting to match against \"%s\"\n", main_key_tab[current].comment);
1544     match = 0;
1545     mismatch = 0;
1546     score = 0;
1547     seq = 0;
1548     lkey = main_key_tab[current].key;
1549     pkey = -1;
1550     for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
1551       if (ckey[keyc][0]) {
1552         /* search for a match in layout table */
1553         /* right now, we just find an absolute match for defined positions */
1554         /* (undefined positions are ignored, so if it's defined as "3#" in */
1555         /* the table, it's okay that the X server has "3#£", for example) */
1556         /* however, the score will be higher for longer matches */
1557         for (key = 0; key < MAIN_LEN; key++) {
1558           for (ok = 0, i = 0; (ok >= 0) && (i < syms); i++) {
1559             if ((*lkey)[key][i] && ((*lkey)[key][i] == ckey[keyc][i]))
1560               ok++;
1561             if ((*lkey)[key][i] && ((*lkey)[key][i] != ckey[keyc][i]))
1562               ok = -1;
1563           }
1564           if (ok > 0) {
1565             score += ok;
1566             break;
1567           }
1568         }
1569         /* count the matches and mismatches */
1570         if (ok > 0) {
1571           match++;
1572           /* and how much the keycode order matches */
1573           if (key > pkey) seq++;
1574           pkey = key;
1575         } else {
1576           /* print spaces instead of \0's */
1577           char str[5];
1578           for (i = 0; i < 4; i++) str[i] = ckey[keyc][i] ? ckey[keyc][i] : ' ';
1579           str[4] = 0;
1580           TRACE_(key)("mismatch for keysym 0x%04lX, keycode %d, got %s\n", keysym, keyc, str );
1581           mismatch++;
1582           score -= syms;
1583         }
1584       }
1585     }
1586     TRACE("matches=%d, mismatches=%d, seq=%d, score=%d\n",
1587            match, mismatch, seq, score);
1588     if ((score > max_score) ||
1589         ((score == max_score) && (seq > max_seq))) {
1590       /* best match so far */
1591       kbd_layout = current;
1592       max_score = score;
1593       max_seq = seq;
1594       ismatch = !mismatch;
1595     }
1596   }
1597   /* we're done, report results if necessary */
1598   if (!ismatch)
1599     WARN("Using closest match (%s) for scan/virtual codes mapping.\n",
1600         main_key_tab[kbd_layout].comment);
1601
1602   TRACE("detected layout is \"%s\"\n", main_key_tab[kbd_layout].comment);
1603 }
1604
1605 static HKL get_locale_kbd_layout(void)
1606 {
1607     ULONG_PTR layout;
1608     LANGID langid;
1609
1610     /* FIXME:
1611      *
1612      * layout = main_key_tab[kbd_layout].lcid;
1613      *
1614      * Winword uses return value of GetKeyboardLayout as a codepage
1615      * to translate ANSI keyboard messages to unicode. But we have
1616      * a problem with it: for instance Polish keyboard layout is
1617      * identical to the US one, and therefore instead of the Polish
1618      * locale id we return the US one.
1619      */
1620
1621     layout = GetUserDefaultLCID();
1622
1623     /*
1624      * Microsoft Office expects this value to be something specific
1625      * for Japanese and Korean Windows with an IME the value is 0xe001
1626      * We should probably check to see if an IME exists and if so then
1627      * set this word properly.
1628      */
1629     langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
1630     if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
1631         layout |= 0xe001 << 16; /* IME */
1632     else
1633         layout |= layout << 16;
1634
1635     return (HKL)layout;
1636 }
1637
1638 /***********************************************************************
1639  *     GetKeyboardLayoutName (X11DRV.@)
1640  */
1641 BOOL CDECL X11DRV_GetKeyboardLayoutName(LPWSTR name)
1642 {
1643     static const WCHAR formatW[] = {'%','0','8','x',0};
1644     DWORD layout;
1645
1646     layout = HandleToUlong( get_locale_kbd_layout() );
1647     if (HIWORD(layout) == LOWORD(layout)) layout = LOWORD(layout);
1648     sprintfW(name, formatW, layout);
1649     TRACE("returning %s\n", debugstr_w(name));
1650     return TRUE;
1651 }
1652
1653 static void set_kbd_layout_preload_key(void)
1654 {
1655     static const WCHAR preload[] =
1656         {'K','e','y','b','o','a','r','d',' ','L','a','y','o','u','t','\\','P','r','e','l','o','a','d',0};
1657     static const WCHAR one[] = {'1',0};
1658
1659     HKEY hkey;
1660     WCHAR layout[KL_NAMELENGTH];
1661
1662     if (RegCreateKeyExW(HKEY_CURRENT_USER, preload, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL))
1663         return;
1664
1665     if (!RegQueryValueExW(hkey, one, NULL, NULL, NULL, NULL))
1666     {
1667         RegCloseKey(hkey);
1668         return;
1669     }
1670     if (X11DRV_GetKeyboardLayoutName(layout))
1671         RegSetValueExW(hkey, one, 0, REG_SZ, (const BYTE *)layout, sizeof(layout));
1672
1673     RegCloseKey(hkey);
1674 }
1675
1676 /**********************************************************************
1677  *              X11DRV_InitKeyboard
1678  */
1679 void X11DRV_InitKeyboard( Display *display )
1680 {
1681     KeySym *ksp;
1682     XModifierKeymap *mmp;
1683     KeySym keysym;
1684     KeyCode *kcp;
1685     XKeyEvent e2;
1686     WORD scan, vkey;
1687     int keyc, i, keyn, syms;
1688     char ckey[4]={0,0,0,0};
1689     const char (*lkey)[MAIN_LEN][4];
1690     char vkey_used[256] = { 0 };
1691
1692     /* Ranges of OEM, function key, and character virtual key codes.
1693      * Don't include those handled specially in X11DRV_ToUnicodeEx and
1694      * X11DRV_MapVirtualKeyEx, like VK_NUMPAD0 - VK_DIVIDE. */
1695     static const struct {
1696         WORD first, last;
1697     } vkey_ranges[] = {
1698         { VK_OEM_1, VK_OEM_3 },
1699         { VK_OEM_4, VK_ICO_00 },
1700         { 0xe6, 0xe6 },
1701         { 0xe9, 0xf5 },
1702         { VK_OEM_NEC_EQUAL, VK_OEM_NEC_EQUAL },
1703         { VK_F1, VK_F24 },
1704         { 0x30, 0x39 }, /* VK_0 - VK_9 */
1705         { 0x41, 0x5a }, /* VK_A - VK_Z */
1706         { 0, 0 }
1707     };
1708     int vkey_range;
1709
1710     set_kbd_layout_preload_key();
1711
1712     wine_tsx11_lock();
1713     XDisplayKeycodes(display, &min_keycode, &max_keycode);
1714     ksp = XGetKeyboardMapping(display, min_keycode,
1715                               max_keycode + 1 - min_keycode, &keysyms_per_keycode);
1716     /* We are only interested in keysyms_per_keycode.
1717        There is no need to hold a local copy of the keysyms table */
1718     XFree(ksp);
1719
1720     mmp = XGetModifierMapping(display);
1721     kcp = mmp->modifiermap;
1722     for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
1723     {
1724         int j;
1725
1726         for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
1727             if (*kcp)
1728             {
1729                 int k;
1730
1731                 for (k = 0; k < keysyms_per_keycode; k += 1)
1732                     if (XKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
1733                     {
1734                         NumLockMask = 1 << i;
1735                         TRACE_(key)("NumLockMask is %x\n", NumLockMask);
1736                     }
1737                     else if (XKeycodeToKeysym(display, *kcp, k) == XK_Scroll_Lock)
1738                     {
1739                         ScrollLockMask = 1 << i;
1740                         TRACE_(key)("ScrollLockMask is %x\n", ScrollLockMask);
1741                     }
1742             }
1743     }
1744     XFreeModifiermap(mmp);
1745
1746     /* Detect the keyboard layout */
1747     X11DRV_KEYBOARD_DetectLayout( display );
1748     lkey = main_key_tab[kbd_layout].key;
1749     syms = (keysyms_per_keycode > 4) ? 4 : keysyms_per_keycode;
1750
1751     /* Now build two conversion arrays :
1752      * keycode -> vkey + scancode + extended
1753      * vkey + extended -> keycode */
1754
1755     e2.display = display;
1756     e2.state = 0;
1757     e2.type = KeyPress;
1758
1759     memset(keyc2vkey, 0, sizeof(keyc2vkey));
1760     for (keyc = min_keycode; keyc <= max_keycode; keyc++)
1761     {
1762         char buf[30];
1763         int have_chars;
1764
1765         keysym = 0;
1766         e2.keycode = (KeyCode)keyc;
1767         have_chars = XLookupString(&e2, buf, sizeof(buf), &keysym, NULL);
1768         vkey = 0; scan = 0;
1769         if (keysym)  /* otherwise, keycode not used */
1770         {
1771             if ((keysym >> 8) == 0xFF)         /* non-character key */
1772             {
1773                 vkey = nonchar_key_vkey[keysym & 0xff];
1774                 scan = nonchar_key_scan[keysym & 0xff];
1775                 /* set extended bit when necessary */
1776                 if (scan & 0x100) vkey |= 0x100;
1777             } else if ((keysym >> 8) == 0x1008FF) { /* XFree86 vendor keys */
1778                 vkey = xfree86_vendor_key_vkey[keysym & 0xff];
1779                 /* All vendor keys are extended with a scan code of 0 per testing on WinXP */
1780                 scan = 0x100;
1781                 vkey |= 0x100;
1782             } else if (keysym == 0x20) {                 /* Spacebar */
1783                 vkey = VK_SPACE;
1784                 scan = 0x39;
1785             } else if (have_chars) {
1786               /* we seem to need to search the layout-dependent scancodes */
1787               int maxlen=0,maxval=-1,ok;
1788               for (i=0; i<syms; i++) {
1789                 keysym = XKeycodeToKeysym(display, keyc, i);
1790                 if ((keysym<0x8000) && (keysym!=' '))
1791                 {
1792 #ifdef HAVE_XKB
1793                     if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[i], 1, NULL))
1794 #endif
1795                     {
1796                         /* FIXME: query what keysym is used as Mode_switch, fill XKeyEvent
1797                          * with appropriate ShiftMask and Mode_switch, use XLookupString
1798                          * to get character in the local encoding.
1799                          */
1800                         ckey[i] = keysym & 0xFF;
1801                     }
1802                 } else {
1803                   ckey[i] = KEYBOARD_MapDeadKeysym(keysym);
1804                 }
1805               }
1806               /* find key with longest match streak */
1807               for (keyn=0; keyn<MAIN_LEN; keyn++) {
1808                 for (ok=(*lkey)[keyn][i=0]; ok&&(i<4); i++)
1809                   if ((*lkey)[keyn][i] && (*lkey)[keyn][i]!=ckey[i]) ok=0;
1810                 if (!ok) i--; /* we overshot */
1811                 if (ok||(i>maxlen)) {
1812                   maxlen=i; maxval=keyn;
1813                 }
1814                 if (ok) break;
1815               }
1816               if (maxval>=0) {
1817                 /* got it */
1818                 const WORD (*lscan)[MAIN_LEN] = main_key_tab[kbd_layout].scan;
1819                 const WORD (*lvkey)[MAIN_LEN] = main_key_tab[kbd_layout].vkey;
1820                 scan = (*lscan)[maxval];
1821                 vkey = (*lvkey)[maxval];
1822               }
1823             }
1824         }
1825         TRACE("keycode %04x => vkey %04x\n", e2.keycode, vkey);
1826         keyc2vkey[e2.keycode] = vkey;
1827         keyc2scan[e2.keycode] = scan;
1828         if ((vkey & 0xff) && vkey_used[(vkey & 0xff)])
1829             WARN("vkey %04x is being used by more than one keycode\n", vkey);
1830         vkey_used[(vkey & 0xff)] = 1;
1831     } /* for */
1832
1833 #define VKEY_IF_NOT_USED(vkey) (vkey_used[(vkey)] ? 0 : (vkey_used[(vkey)] = 1, (vkey)))
1834     for (keyc = min_keycode; keyc <= max_keycode; keyc++)
1835     {
1836         vkey = keyc2vkey[keyc] & 0xff;
1837         if (vkey)
1838             continue;
1839
1840         e2.keycode = (KeyCode)keyc;
1841         keysym = XLookupKeysym(&e2, 0);
1842         if (!keysym)
1843            continue;
1844
1845         /* find a suitable layout-dependent VK code */
1846         /* (most Winelib apps ought to be able to work without layout tables!) */
1847         for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
1848         {
1849             keysym = XLookupKeysym(&e2, i);
1850             if ((keysym >= XK_0 && keysym <= XK_9)
1851                 || (keysym >= XK_A && keysym <= XK_Z)) {
1852                 vkey = VKEY_IF_NOT_USED(keysym);
1853             }
1854         }
1855
1856         for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
1857         {
1858             keysym = XLookupKeysym(&e2, i);
1859             switch (keysym)
1860             {
1861             case ';':             vkey = VKEY_IF_NOT_USED(VK_OEM_1); break;
1862             case '/':             vkey = VKEY_IF_NOT_USED(VK_OEM_2); break;
1863             case '`':             vkey = VKEY_IF_NOT_USED(VK_OEM_3); break;
1864             case '[':             vkey = VKEY_IF_NOT_USED(VK_OEM_4); break;
1865             case '\\':            vkey = VKEY_IF_NOT_USED(VK_OEM_5); break;
1866             case ']':             vkey = VKEY_IF_NOT_USED(VK_OEM_6); break;
1867             case '\'':            vkey = VKEY_IF_NOT_USED(VK_OEM_7); break;
1868             case ',':             vkey = VKEY_IF_NOT_USED(VK_OEM_COMMA); break;
1869             case '.':             vkey = VKEY_IF_NOT_USED(VK_OEM_PERIOD); break;
1870             case '-':             vkey = VKEY_IF_NOT_USED(VK_OEM_MINUS); break;
1871             case '+':             vkey = VKEY_IF_NOT_USED(VK_OEM_PLUS); break;
1872             }
1873         }
1874
1875         if (vkey)
1876         {
1877             TRACE("keycode %04x => vkey %04x\n", e2.keycode, vkey);
1878             keyc2vkey[e2.keycode] = vkey;
1879         }
1880     } /* for */
1881
1882     /* For any keycodes which still don't have a vkey, assign any spare
1883      * character, function key, or OEM virtual key code. */
1884     vkey_range = 0;
1885     vkey = vkey_ranges[vkey_range].first;
1886     for (keyc = min_keycode; keyc <= max_keycode; keyc++)
1887     {
1888         if (keyc2vkey[keyc] & 0xff)
1889             continue;
1890
1891         e2.keycode = (KeyCode)keyc;
1892         keysym = XLookupKeysym(&e2, 0);
1893         if (!keysym)
1894            continue;
1895
1896         while (vkey && vkey_used[vkey])
1897         {
1898             if (vkey == vkey_ranges[vkey_range].last)
1899             {
1900                 vkey_range++;
1901                 vkey = vkey_ranges[vkey_range].first;
1902             }
1903             else
1904                 vkey++;
1905         }
1906
1907         if (!vkey)
1908         {
1909             WARN("No more vkeys available!\n");
1910             break;
1911         }
1912
1913         if (TRACE_ON(keyboard))
1914         {
1915             TRACE("spare virtual key %X assigned to keycode %X:\n",
1916                              vkey, e2.keycode);
1917             TRACE("(");
1918             for (i = 0; i < keysyms_per_keycode; i += 1)
1919             {
1920                 const char *ksname;
1921
1922                 keysym = XLookupKeysym(&e2, i);
1923                 ksname = XKeysymToString(keysym);
1924                 if (!ksname)
1925                     ksname = "NoSymbol";
1926                 TRACE( "%lX (%s) ", keysym, ksname);
1927             }
1928             TRACE(")\n");
1929         }
1930
1931         TRACE("keycode %04x => vkey %04x\n", e2.keycode, vkey);
1932         keyc2vkey[e2.keycode] = vkey;
1933         vkey_used[vkey] = 1;
1934     } /* for */
1935 #undef VKEY_IF_NOT_USED
1936
1937     /* If some keys still lack scancodes, assign some arbitrary ones to them now */
1938     for (scan = 0x60, keyc = min_keycode; keyc <= max_keycode; keyc++)
1939       if (keyc2vkey[keyc]&&!keyc2scan[keyc]) {
1940         const char *ksname;
1941         keysym = XKeycodeToKeysym(display, keyc, 0);
1942         ksname = XKeysymToString(keysym);
1943         if (!ksname) ksname = "NoSymbol";
1944
1945         /* should make sure the scancode is unassigned here, but >=0x60 currently always is */
1946
1947         TRACE_(key)("assigning scancode %02x to unidentified keycode %02x (%s)\n",scan,keyc,ksname);
1948         keyc2scan[keyc]=scan++;
1949       }
1950
1951     wine_tsx11_unlock();
1952 }
1953
1954 static BOOL match_x11_keyboard_layout(HKL hkl)
1955 {
1956     const DWORD isIME = 0xE0000000;
1957     HKL xHkl = get_locale_kbd_layout();
1958
1959     /* if the layout is an IME, only match the low word (LCID) */
1960     if (((ULONG_PTR)hkl & isIME) == isIME)
1961         return (LOWORD(hkl) == LOWORD(xHkl));
1962     else
1963         return (hkl == xHkl);
1964 }
1965
1966 /**********************************************************************
1967  *              GetAsyncKeyState (X11DRV.@)
1968  */
1969 SHORT CDECL X11DRV_GetAsyncKeyState(INT key)
1970 {
1971     SHORT retval;
1972
1973     /* Photoshop livelocks unless mouse events are included here */
1974     X11DRV_MsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_KEY | QS_MOUSE, 0 );
1975
1976     retval = ((key_state_table[key] & 0x40) ? 0x0001 : 0) |
1977              ((key_state_table[key] & 0x80) ? 0x8000 : 0);
1978     key_state_table[key] &= ~0x40;
1979     TRACE_(key)("(%x) -> %x\n", key, retval);
1980     return retval;
1981 }
1982
1983
1984 /***********************************************************************
1985  *              GetKeyboardLayout (X11DRV.@)
1986  */
1987 HKL CDECL X11DRV_GetKeyboardLayout(DWORD dwThreadid)
1988 {
1989     if (!dwThreadid || dwThreadid == GetCurrentThreadId())
1990     {
1991         struct x11drv_thread_data *thread_data = x11drv_thread_data();
1992         if (thread_data && thread_data->kbd_layout) return thread_data->kbd_layout;
1993     }
1994     else
1995         FIXME("couldn't return keyboard layout for thread %04x\n", dwThreadid);
1996
1997     return get_locale_kbd_layout();
1998 }
1999
2000
2001 /***********************************************************************
2002  *              LoadKeyboardLayout (X11DRV.@)
2003  */
2004 HKL CDECL X11DRV_LoadKeyboardLayout(LPCWSTR name, UINT flags)
2005 {
2006     FIXME("%s, %04x: stub!\n", debugstr_w(name), flags);
2007     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2008     return 0;
2009 }
2010
2011
2012 /***********************************************************************
2013  *              UnloadKeyboardLayout (X11DRV.@)
2014  */
2015 BOOL CDECL X11DRV_UnloadKeyboardLayout(HKL hkl)
2016 {
2017     FIXME("%p: stub!\n", hkl);
2018     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2019     return FALSE;
2020 }
2021
2022
2023 /***********************************************************************
2024  *              ActivateKeyboardLayout (X11DRV.@)
2025  */
2026 HKL CDECL X11DRV_ActivateKeyboardLayout(HKL hkl, UINT flags)
2027 {
2028     HKL oldHkl = 0;
2029     struct x11drv_thread_data *thread_data = x11drv_init_thread_data();
2030
2031     FIXME("%p, %04x: semi-stub!\n", hkl, flags);
2032     if (flags & KLF_SETFORPROCESS)
2033     {
2034         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2035         FIXME("KLF_SETFORPROCESS not supported\n");
2036         return 0;
2037     }
2038
2039     if (flags)
2040         FIXME("flags %x not supported\n",flags);
2041
2042     if (hkl == (HKL)HKL_NEXT || hkl == (HKL)HKL_PREV)
2043     {
2044         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2045         FIXME("HKL_NEXT and HKL_PREV not supported\n");
2046         return 0;
2047     }
2048
2049     if (!match_x11_keyboard_layout(hkl))
2050     {
2051         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2052         FIXME("setting keyboard of different locales not supported\n");
2053         return 0;
2054     }
2055
2056     oldHkl = thread_data->kbd_layout;
2057     if (!oldHkl) oldHkl = get_locale_kbd_layout();
2058
2059     thread_data->kbd_layout = hkl;
2060
2061     return oldHkl;
2062 }
2063
2064
2065 /***********************************************************************
2066  *           X11DRV_MappingNotify
2067  */
2068 void X11DRV_MappingNotify( HWND dummy, XEvent *event )
2069 {
2070     HWND hwnd;
2071
2072     wine_tsx11_lock();
2073     XRefreshKeyboardMapping(&event->xmapping);
2074     wine_tsx11_unlock();
2075     X11DRV_InitKeyboard( event->xmapping.display );
2076
2077     hwnd = GetFocus();
2078     if (!hwnd) hwnd = GetActiveWindow();
2079     PostMessageW(hwnd, WM_INPUTLANGCHANGEREQUEST,
2080                  0 /*FIXME*/, (LPARAM)X11DRV_GetKeyboardLayout(0));
2081 }
2082
2083
2084 /***********************************************************************
2085  *              VkKeyScanEx (X11DRV.@)
2086  *
2087  * Note: Windows ignores HKL parameter and uses current active layout instead
2088  */
2089 SHORT CDECL X11DRV_VkKeyScanEx(WCHAR wChar, HKL hkl)
2090 {
2091     Display *display = thread_init_display();
2092     KeyCode keycode;
2093     KeySym keysym;
2094     int i, index;
2095     CHAR cChar;
2096     SHORT ret;
2097
2098     /* FIXME: what happens if wChar is not a Latin1 character and CP_UNIXCP
2099      * is UTF-8 (multibyte encoding)?
2100      */
2101     if (!WideCharToMultiByte(CP_UNIXCP, 0, &wChar, 1, &cChar, 1, NULL, NULL))
2102     {
2103         WARN("no translation from unicode to CP_UNIXCP for 0x%02x\n", wChar);
2104         return -1;
2105     }
2106
2107     TRACE("wChar 0x%02x -> cChar '%c'\n", wChar, cChar);
2108
2109     /* char->keysym (same for ANSI chars) */
2110     keysym = (unsigned char)cChar; /* (!) cChar is signed */
2111     if (keysym <= 27) keysym += 0xFF00; /* special chars : return, backspace... */
2112
2113     wine_tsx11_lock();
2114     keycode = XKeysymToKeycode(display, keysym);  /* keysym -> keycode */
2115     if (!keycode)
2116     {
2117         if (keysym >= 0xFF00) /* Windows returns 0x0240 + cChar in this case */
2118         {
2119             ret = 0x0240 + cChar; /* 0x0200 indicates a control character */
2120             TRACE(" ... returning ctrl char %#.2x\n", ret);
2121             wine_tsx11_unlock();
2122             return ret;
2123         }
2124         /* It didn't work ... let's try with deadchar code. */
2125         TRACE("retrying with | 0xFE00\n");
2126         keycode = XKeysymToKeycode(display, keysym | 0xFE00);
2127     }
2128     wine_tsx11_unlock();
2129
2130     TRACE("'%c'(%#lx, %lu): got keycode %#.2x (%d)\n",
2131             cChar, keysym, keysym, keycode, keycode);
2132
2133     /* keycode -> (keyc2vkey) vkey */
2134     ret = keyc2vkey[keycode];
2135
2136     if (!keycode || !ret)
2137     {
2138         TRACE("keycode for '%c' not found, returning -1\n", cChar);
2139         return -1;
2140     }
2141
2142     index = -1;
2143     wine_tsx11_lock();
2144     for (i = 0; i < 4; i++) /* find shift state */
2145     {
2146         if (XKeycodeToKeysym(display, keycode, i) == keysym)
2147         {
2148             index = i;
2149             break;
2150         }
2151     }
2152     wine_tsx11_unlock();
2153
2154     switch (index)
2155     {
2156         default:
2157         case -1:
2158             WARN("Keysym %lx not found while parsing the keycode table\n", keysym);
2159             return -1;
2160
2161         case 0: break;
2162         case 1: ret += 0x0100; break;
2163         case 2: ret += 0x0600; break;
2164         case 3: ret += 0x0700; break;
2165     }
2166     /*
2167       index : 0     adds 0x0000
2168       index : 1     adds 0x0100 (shift)
2169       index : ?     adds 0x0200 (ctrl)
2170       index : 2     adds 0x0600 (ctrl+alt)
2171       index : 3     adds 0x0700 (ctrl+alt+shift)
2172      */
2173
2174     TRACE(" ... returning %#.2x\n", ret);
2175     return ret;
2176 }
2177
2178 /***********************************************************************
2179  *              MapVirtualKeyEx (X11DRV.@)
2180  */
2181 UINT CDECL X11DRV_MapVirtualKeyEx(UINT wCode, UINT wMapType, HKL hkl)
2182 {
2183     Display *display = thread_init_display();
2184
2185 #define returnMVK(value) do { TRACE("returning 0x%x.\n",value); return value; } while(0)
2186
2187     TRACE("wCode=0x%x, wMapType=%d, hkl %p\n", wCode, wMapType, hkl);
2188     if (!match_x11_keyboard_layout(hkl))
2189         FIXME("keyboard layout %p is not supported\n", hkl);
2190
2191     switch(wMapType)
2192     {
2193         case MAPVK_VK_TO_VSC: /* vkey-code to scan-code */
2194         case MAPVK_VK_TO_VSC_EX:
2195         {
2196             int keyc;
2197
2198             switch (wCode)
2199             {
2200                 case VK_SHIFT: wCode = VK_LSHIFT; break;
2201                 case VK_CONTROL: wCode = VK_LCONTROL; break;
2202                 case VK_MENU: wCode = VK_LMENU; break;
2203             }
2204
2205             /* let's do vkey -> keycode -> scan */
2206             for (keyc = min_keycode; keyc <= max_keycode; keyc++)
2207                 if ((keyc2vkey[keyc] & 0xFF) == wCode) break;
2208
2209             if (keyc > max_keycode)
2210             {
2211                 TRACE("returning no scan-code.\n");
2212                 return 0;
2213             }
2214             returnMVK (keyc2scan[keyc] & 0xFF);
2215         }
2216         case MAPVK_VSC_TO_VK: /* scan-code to vkey-code */
2217         case MAPVK_VSC_TO_VK_EX:
2218         {
2219             int keyc;
2220             UINT vkey = 0;
2221
2222             /* let's do scan -> keycode -> vkey */
2223             for (keyc = min_keycode; keyc <= max_keycode; keyc++)
2224                 if ((keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
2225                 {
2226                     vkey = keyc2vkey[keyc] & 0xFF;
2227                     /* Only stop if it's not a numpad vkey; otherwise keep
2228                        looking for a potential better vkey. */
2229                     if (vkey && (vkey < VK_NUMPAD0 || VK_DIVIDE < vkey))
2230                         break;
2231                 }
2232
2233             if (vkey == 0)
2234             {
2235                 TRACE("returning no vkey-code.\n");
2236                 return 0;
2237             }
2238
2239             if (wMapType == MAPVK_VSC_TO_VK)
2240                 switch (vkey)
2241                 {
2242                     case VK_LSHIFT:
2243                     case VK_RSHIFT:
2244                         vkey = VK_SHIFT; break;
2245                     case VK_LCONTROL:
2246                     case VK_RCONTROL:
2247                         vkey = VK_CONTROL; break;
2248                     case VK_LMENU:
2249                     case VK_RMENU:
2250                         vkey = VK_MENU; break;
2251                 }
2252
2253             returnMVK (vkey);
2254         }
2255                 case MAPVK_VK_TO_CHAR: /* vkey-code to unshifted ANSI code */
2256                 {
2257                         /* we still don't know what "unshifted" means. in windows VK_W (0x57)
2258                          * returns 0x57, which is upercase 'W'. So we have to return the uppercase
2259                          * key.. Looks like something is wrong with the MS docs?
2260                          * This is only true for letters, for example VK_0 returns '0' not ')'.
2261                          * - hence we use the lock mask to ensure this happens.
2262                          */
2263                         /* let's do vkey -> keycode -> (XLookupString) ansi char */
2264                         XKeyEvent e;
2265                         KeySym keysym;
2266                         int keyc, len;
2267                         char s[10];
2268
2269                         e.display = display;
2270                         e.state = 0;
2271                         e.keycode = 0;
2272                         e.type = KeyPress;
2273
2274                         wine_tsx11_lock();
2275
2276                         /* We exit on the first keycode found, to speed up the thing. */
2277                         for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
2278                         { /* Find a keycode that could have generated this virtual key */
2279                             if  ((keyc2vkey[keyc] & 0xFF) == wCode)
2280                             { /* We filter the extended bit, we don't know it */
2281                                 e.keycode = keyc; /* Store it temporarily */
2282                                 if ((EVENT_event_to_vkey(0,&e) & 0xFF) != wCode) {
2283                                     e.keycode = 0; /* Wrong one (ex: because of the NumLock
2284                                          state), so set it to 0, we'll find another one */
2285                                 }
2286                             }
2287                         }
2288
2289                         if ((wCode>=VK_NUMPAD0) && (wCode<=VK_NUMPAD9))
2290                           e.keycode = XKeysymToKeycode(e.display, wCode-VK_NUMPAD0+XK_KP_0);
2291
2292                         if (wCode==VK_DECIMAL)
2293                           e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2294
2295                         if (!e.keycode)
2296                         {
2297                           WARN("Unknown virtual key %X !!!\n", wCode);
2298                           wine_tsx11_unlock();
2299                           return 0; /* whatever */
2300                         }
2301                         TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2302
2303                         len = XLookupString(&e, s, sizeof(s), &keysym, NULL);
2304                         wine_tsx11_unlock();
2305
2306                         if (len)
2307                         {
2308                             WCHAR wch;
2309                             if (MultiByteToWideChar(CP_UNIXCP, 0, s, len, &wch, 1))
2310                                 returnMVK(toupperW(wch));
2311                         }
2312                         TRACE("returning no ANSI.\n");
2313                         return 0;
2314                 }
2315                 default: /* reserved */
2316                         FIXME("Unknown wMapType %d !\n", wMapType);
2317                         return 0;
2318         }
2319         return 0;
2320 }
2321
2322 /***********************************************************************
2323  *              GetKeyNameText (X11DRV.@)
2324  */
2325 INT CDECL X11DRV_GetKeyNameText(LONG lParam, LPWSTR lpBuffer, INT nSize)
2326 {
2327   Display *display = thread_init_display();
2328   int vkey, ansi, scanCode;
2329   KeyCode keyc;
2330   int keyi;
2331   KeySym keys;
2332   char *name;
2333
2334   scanCode = lParam >> 16;
2335   scanCode &= 0x1ff;  /* keep "extended-key" flag with code */
2336
2337   vkey = X11DRV_MapVirtualKeyEx(scanCode, MAPVK_VSC_TO_VK_EX, X11DRV_GetKeyboardLayout(0));
2338
2339   /*  handle "don't care" bit (0x02000000) */
2340   if (!(lParam & 0x02000000)) {
2341     switch (vkey) {
2342          case VK_RSHIFT:
2343                           /* R-Shift is "special" - it is an extended key with separate scan code */
2344                           scanCode |= 0x100;
2345          case VK_LSHIFT:
2346                           vkey = VK_SHIFT;
2347                           break;
2348        case VK_LCONTROL:
2349        case VK_RCONTROL:
2350                           vkey = VK_CONTROL;
2351                           break;
2352           case VK_LMENU:
2353           case VK_RMENU:
2354                           vkey = VK_MENU;
2355                           break;
2356     }
2357   }
2358
2359   ansi = X11DRV_MapVirtualKeyEx(vkey, MAPVK_VK_TO_CHAR, X11DRV_GetKeyboardLayout(0));
2360   TRACE("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n", scanCode, vkey, ansi);
2361
2362   /* first get the name of the "regular" keys which is the Upper case
2363      value of the keycap imprint.                                     */
2364   if ( ((ansi >= 0x21) && (ansi <= 0x7e)) &&
2365        (scanCode != 0x137) &&   /* PrtScn   */
2366        (scanCode != 0x135) &&   /* numpad / */
2367        (scanCode != 0x37 ) &&   /* numpad * */
2368        (scanCode != 0x4a ) &&   /* numpad - */
2369        (scanCode != 0x4e ) )    /* numpad + */
2370       {
2371         if ((nSize >= 2) && lpBuffer)
2372         {
2373           *lpBuffer = toupperW((WCHAR)ansi);
2374           *(lpBuffer+1) = 0;
2375           return 1;
2376         }
2377      else
2378         return 0;
2379   }
2380
2381   /* FIXME: horrible hack to fix function keys. Windows reports scancode
2382             without "extended-key" flag. However Wine generates scancode
2383             *with* "extended-key" flag. Seems to occur *only* for the
2384             function keys. Soooo.. We will leave the table alone and
2385             fudge the lookup here till the other part is found and fixed!!! */
2386
2387   if ( ((scanCode >= 0x13b) && (scanCode <= 0x144)) ||
2388        (scanCode == 0x157) || (scanCode == 0x158))
2389     scanCode &= 0xff;   /* remove "extended-key" flag for Fx keys */
2390
2391   /* let's do scancode -> keycode -> keysym -> String */
2392
2393   for (keyi=min_keycode; keyi<=max_keycode; keyi++)
2394       if ((keyc2scan[keyi]) == scanCode)
2395          break;
2396   if (keyi <= max_keycode)
2397   {
2398       wine_tsx11_lock();
2399       keyc = (KeyCode) keyi;
2400       keys = XKeycodeToKeysym(display, keyc, 0);
2401       name = XKeysymToString(keys);
2402       wine_tsx11_unlock();
2403       TRACE("found scan=%04x keyc=%04x keysym=%04x string=%s\n",
2404             scanCode, keyc, (int)keys, name);
2405       if (lpBuffer && nSize && name)
2406           return MultiByteToWideChar(CP_UNIXCP, 0, name, -1, lpBuffer, nSize);
2407   }
2408
2409   /* Finally issue WARN for unknown keys   */
2410
2411   WARN("(%08x,%p,%d): unsupported key, vkey=%04x, ansi=%04x\n",lParam,lpBuffer,nSize,vkey,ansi);
2412   if (lpBuffer && nSize)
2413     *lpBuffer = 0;
2414   return 0;
2415 }
2416
2417 /***********************************************************************
2418  *              X11DRV_KEYBOARD_MapDeadKeysym
2419  */
2420 static char KEYBOARD_MapDeadKeysym(KeySym keysym)
2421 {
2422         switch (keysym)
2423             {
2424         /* symbolic ASCII is the same as defined in rfc1345 */
2425 #ifdef XK_dead_tilde
2426             case XK_dead_tilde :
2427 #endif
2428             case 0x1000FE7E : /* Xfree's XK_Dtilde */
2429                 return '~';     /* '? */
2430 #ifdef XK_dead_acute
2431             case XK_dead_acute :
2432 #endif
2433             case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
2434                 return 0xb4;    /* '' */
2435 #ifdef XK_dead_circumflex
2436             case XK_dead_circumflex:
2437 #endif
2438             case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
2439                 return '^';     /* '> */
2440 #ifdef XK_dead_grave
2441             case XK_dead_grave :
2442 #endif
2443             case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
2444                 return '`';     /* '! */
2445 #ifdef XK_dead_diaeresis
2446             case XK_dead_diaeresis :
2447 #endif
2448             case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
2449                 return 0xa8;    /* ': */
2450 #ifdef XK_dead_cedilla
2451             case XK_dead_cedilla :
2452                 return 0xb8;    /* ', */
2453 #endif
2454 #ifdef XK_dead_macron
2455             case XK_dead_macron :
2456                 return '-';     /* 'm isn't defined on iso-8859-x */
2457 #endif
2458 #ifdef XK_dead_breve
2459             case XK_dead_breve :
2460                 return 0xa2;    /* '( */
2461 #endif
2462 #ifdef XK_dead_abovedot
2463             case XK_dead_abovedot :
2464                 return 0xff;    /* '. */
2465 #endif
2466 #ifdef XK_dead_abovering
2467             case XK_dead_abovering :
2468                 return '0';     /* '0 isn't defined on iso-8859-x */
2469 #endif
2470 #ifdef XK_dead_doubleacute
2471             case XK_dead_doubleacute :
2472                 return 0xbd;    /* '" */
2473 #endif
2474 #ifdef XK_dead_caron
2475             case XK_dead_caron :
2476                 return 0xb7;    /* '< */
2477 #endif
2478 #ifdef XK_dead_ogonek
2479             case XK_dead_ogonek :
2480                 return 0xb2;    /* '; */
2481 #endif
2482 /* FIXME: I don't know this three.
2483             case XK_dead_iota :
2484                 return 'i';
2485             case XK_dead_voiced_sound :
2486                 return 'v';
2487             case XK_dead_semivoiced_sound :
2488                 return 's';
2489 */
2490             }
2491         TRACE("no character for dead keysym 0x%08lx\n",keysym);
2492         return 0;
2493 }
2494
2495 /***********************************************************************
2496  *              ToUnicodeEx (X11DRV.@)
2497  *
2498  * The ToUnicode function translates the specified virtual-key code and keyboard
2499  * state to the corresponding Windows character or characters.
2500  *
2501  * If the specified key is a dead key, the return value is negative. Otherwise,
2502  * it is one of the following values:
2503  * Value        Meaning
2504  * 0    The specified virtual key has no translation for the current state of the keyboard.
2505  * 1    One Windows character was copied to the buffer.
2506  * 2    Two characters were copied to the buffer. This usually happens when a
2507  *      dead-key character (accent or diacritic) stored in the keyboard layout cannot
2508  *      be composed with the specified virtual key to form a single character.
2509  *
2510  * FIXME : should do the above (return 2 for non matching deadchar+char combinations)
2511  *
2512  */
2513 INT CDECL X11DRV_ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState,
2514                              LPWSTR bufW, int bufW_size, UINT flags, HKL hkl)
2515 {
2516     Display *display = thread_init_display();
2517     XKeyEvent e;
2518     KeySym keysym = 0;
2519     INT ret;
2520     int keyc;
2521     char buf[10];
2522     char *lpChar = buf;
2523     HWND focus;
2524     XIC xic;
2525     Status status = 0;
2526
2527     if (scanCode & 0x8000)
2528     {
2529         TRACE("Key UP, doing nothing\n" );
2530         return 0;
2531     }
2532
2533     if (!match_x11_keyboard_layout(hkl))
2534         FIXME("keyboard layout %p is not supported\n", hkl);
2535
2536     if ((lpKeyState[VK_MENU] & 0x80) && (lpKeyState[VK_CONTROL] & 0x80))
2537     {
2538         TRACE("Ctrl+Alt+[key] won't generate a character\n");
2539         return 0;
2540     }
2541
2542     e.display = display;
2543     e.keycode = 0;
2544     e.state = 0;
2545     e.type = KeyPress;
2546
2547     focus = GetFocus();
2548     if (focus) focus = GetAncestor( focus, GA_ROOT );
2549     if (!focus) focus = GetActiveWindow();
2550     e.window = X11DRV_get_whole_window( focus );
2551     xic = X11DRV_get_ic( focus );
2552
2553     if (lpKeyState[VK_SHIFT] & 0x80)
2554     {
2555         TRACE("ShiftMask = %04x\n", ShiftMask);
2556         e.state |= ShiftMask;
2557     }
2558     if (lpKeyState[VK_CAPITAL] & 0x01)
2559     {
2560         TRACE("LockMask = %04x\n", LockMask);
2561         e.state |= LockMask;
2562     }
2563     if (lpKeyState[VK_CONTROL] & 0x80)
2564     {
2565         TRACE("ControlMask = %04x\n", ControlMask);
2566         e.state |= ControlMask;
2567     }
2568     if (lpKeyState[VK_NUMLOCK] & 0x01)
2569     {
2570         TRACE("NumLockMask = %04x\n", NumLockMask);
2571         e.state |= NumLockMask;
2572     }
2573
2574     /* Restore saved AltGr state */
2575     TRACE("AltGrMask = %04x\n", AltGrMask);
2576     e.state |= AltGrMask;
2577
2578     TRACE_(key)("(%04X, %04X) : faked state = 0x%04x\n",
2579                 virtKey, scanCode, e.state);
2580     wine_tsx11_lock();
2581     /* We exit on the first keycode found, to speed up the thing. */
2582     for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
2583       { /* Find a keycode that could have generated this virtual key */
2584           if  ((keyc2vkey[keyc] & 0xFF) == virtKey)
2585           { /* We filter the extended bit, we don't know it */
2586               e.keycode = keyc; /* Store it temporarily */
2587               if ((EVENT_event_to_vkey(xic,&e) & 0xFF) != virtKey) {
2588                   e.keycode = 0; /* Wrong one (ex: because of the NumLock
2589                          state), so set it to 0, we'll find another one */
2590               }
2591           }
2592       }
2593
2594     if (virtKey >= VK_LEFT && virtKey <= VK_DOWN)
2595         e.keycode = XKeysymToKeycode(e.display, virtKey - VK_LEFT + XK_Left);
2596
2597     if ((virtKey>=VK_NUMPAD0) && (virtKey<=VK_NUMPAD9))
2598         e.keycode = XKeysymToKeycode(e.display, virtKey-VK_NUMPAD0+XK_KP_0);
2599
2600     if (virtKey==VK_DECIMAL)
2601         e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2602
2603     if (virtKey==VK_SEPARATOR)
2604         e.keycode = XKeysymToKeycode(e.display, XK_KP_Separator);
2605
2606     if (!e.keycode && virtKey != VK_NONAME)
2607       {
2608         WARN("Unknown virtual key %X !!!\n", virtKey);
2609         wine_tsx11_unlock();
2610         return 0;
2611       }
2612     else TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2613
2614     TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
2615                 e.type, e.window, e.state, e.keycode);
2616
2617     /* Clients should pass only KeyPress events to XmbLookupString,
2618      * e.type was set to KeyPress above.
2619      */
2620     if (xic)
2621     {
2622         ret = XmbLookupString(xic, &e, buf, sizeof(buf), &keysym, &status);
2623         TRACE("XmbLookupString needs %d byte(s)\n", ret);
2624         if (status == XBufferOverflow)
2625         {
2626             lpChar = HeapAlloc(GetProcessHeap(), 0, ret);
2627             if (lpChar == NULL)
2628             {
2629                 ERR("Failed to allocate memory!\n");
2630                 wine_tsx11_unlock();
2631                 return 0;
2632             }
2633             ret = XmbLookupString(xic, &e, lpChar, ret, &keysym, &status);
2634         }
2635     }
2636     else
2637         ret = XLookupString(&e, buf, sizeof(buf), &keysym, NULL);
2638     wine_tsx11_unlock();
2639
2640     TRACE_(key)("nbyte = %d, status 0x%x\n", ret, status);
2641
2642     if (TRACE_ON(key))
2643     {
2644         const char *ksname;
2645
2646         wine_tsx11_lock();
2647         ksname = XKeysymToString(keysym);
2648         wine_tsx11_unlock();
2649         if (!ksname) ksname = "No Name";
2650         TRACE_(key)("%s : keysym=%lX (%s), # of chars=%d / %s\n",
2651                     (e.type == KeyPress) ? "KeyPress" : "KeyRelease",
2652                     keysym, ksname, ret, debugstr_an(lpChar, ret));
2653     }
2654
2655     if (ret == 0)
2656     {
2657         char dead_char;
2658
2659 #ifdef XK_EuroSign
2660         /* An ugly hack for EuroSign: X can't translate it to a character
2661            for some locales. */
2662         if (keysym == XK_EuroSign)
2663         {
2664             bufW[0] = 0x20AC;
2665             ret = 1;
2666             goto found;
2667         }
2668 #endif
2669         /* Special case: X turns shift-tab into ISO_Left_Tab. */
2670         /* Here we change it back. */
2671         if (keysym == XK_ISO_Left_Tab && !(e.state & ControlMask))
2672         {
2673             bufW[0] = 0x09;
2674             ret = 1;
2675             goto found;
2676         }
2677
2678         dead_char = KEYBOARD_MapDeadKeysym(keysym);
2679         if (dead_char)
2680         {
2681             MultiByteToWideChar(CP_UNIXCP, 0, &dead_char, 1, bufW, bufW_size);
2682             ret = -1;
2683             goto found;
2684         }
2685
2686         if (keysym >= 0x01000100 && keysym <= 0x0100ffff)
2687         {
2688             /* Unicode direct mapping */
2689             bufW[0] = keysym & 0xffff;
2690             ret = 1;
2691             goto found;
2692         }
2693         else if ((keysym >> 8) == 0x1008FF) {
2694             bufW[0] = 0;
2695             ret = 0;
2696             goto found;
2697         }
2698         else
2699             {
2700             const char *ksname;
2701
2702             wine_tsx11_lock();
2703             ksname = XKeysymToString(keysym);
2704             wine_tsx11_unlock();
2705             if (!ksname)
2706                 ksname = "No Name";
2707             if ((keysym >> 8) != 0xff)
2708                 {
2709                 WARN("no char for keysym %04lX (%s) :\n",
2710                     keysym, ksname);
2711                 WARN("virtKey=%X, scanCode=%X, keycode=%X, state=%X\n",
2712                     virtKey, scanCode, e.keycode, e.state);
2713                 }
2714             }
2715         }
2716     else {  /* ret != 0 */
2717         /* We have a special case to handle : Shift + arrow, shift + home, ...
2718            X returns a char for it, but Windows doesn't. Let's eat it. */
2719         if (!(e.state & NumLockMask)  /* NumLock is off */
2720             && (e.state & ShiftMask) /* Shift is pressed */
2721             && (keysym>=XK_KP_0) && (keysym<=XK_KP_9))
2722         {
2723             lpChar[0] = 0;
2724             ret = 0;
2725         }
2726
2727         /* more areas where X returns characters but Windows does not
2728            CTRL + number or CTRL + symbol */
2729         if (e.state & ControlMask)
2730         {
2731             if (((keysym>=33) && (keysym < 'A')) ||
2732                 ((keysym > 'Z') && (keysym < 'a')) ||
2733                 (keysym == XK_Tab))
2734             {
2735                 lpChar[0] = 0;
2736                 ret = 0;
2737             }
2738         }
2739
2740         /* We have another special case for delete key (XK_Delete) on an
2741          extended keyboard. X returns a char for it, but Windows doesn't */
2742         if (keysym == XK_Delete)
2743         {
2744             lpChar[0] = 0;
2745             ret = 0;
2746         }
2747         else if((lpKeyState[VK_SHIFT] & 0x80) /* Shift is pressed */
2748                 && (keysym == XK_KP_Decimal))
2749         {
2750             lpChar[0] = 0;
2751             ret = 0;
2752         }
2753         else if((lpKeyState[VK_CONTROL] & 0x80) /* Control is pressed */
2754                 && (keysym == XK_Return || keysym == XK_KP_Enter))
2755         {
2756             lpChar[0] = '\n';
2757             ret = 1;
2758         }
2759
2760         /* Hack to detect an XLookupString hard-coded to Latin1 */
2761         if (ret == 1 && keysym >= 0x00a0 && keysym <= 0x00ff && (BYTE)lpChar[0] == keysym)
2762         {
2763             bufW[0] = (BYTE)lpChar[0];
2764             goto found;
2765         }
2766
2767         /* perform translation to unicode */
2768         if(ret)
2769         {
2770             TRACE_(key)("Translating char 0x%02x to unicode\n", *(BYTE *)lpChar);
2771             ret = MultiByteToWideChar(CP_UNIXCP, 0, lpChar, ret, bufW, bufW_size);
2772         }
2773     }
2774
2775 found:
2776     if (buf != lpChar)
2777         HeapFree(GetProcessHeap(), 0, lpChar);
2778     TRACE_(key)("returning %d with %s\n", ret, debugstr_wn(bufW, ret));
2779     return ret;
2780 }
2781
2782 /***********************************************************************
2783  *              Beep (X11DRV.@)
2784  */
2785 void CDECL X11DRV_Beep(void)
2786 {
2787     wine_tsx11_lock();
2788     XBell(gdi_display, 0);
2789     wine_tsx11_unlock();
2790 }