Use X11 XIM callbacks to enable full IME support.
[wine] / dlls / x11drv / 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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_XKB
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 "wine/winuser16.h"
48 #include "winnls.h"
49 #include "win.h"
50 #include "x11drv.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 WINE_DECLARE_DEBUG_CHANNEL(dinput);
57
58 static int min_keycode, max_keycode, keysyms_per_keycode;
59 static WORD keyc2vkey[256], keyc2scan[256];
60
61 static LPBYTE pKeyStateTable;
62 static int NumLockMask, AltGrMask; /* mask in the XKeyEvent state */
63 static int kcControl, kcAlt, kcShift, kcNumLock, kcCapsLock; /* keycodes */
64
65 static char KEYBOARD_MapDeadKeysym(KeySym keysym);
66
67 /* Keyboard translation tables */
68 #define MAIN_LEN 49
69 static const WORD main_key_scan_qwerty[MAIN_LEN] =
70 {
71 /* this is my (102-key) keyboard layout, sorry if it doesn't quite match yours */
72  /* `    1    2    3    4    5    6    7    8    9    0    -    = */
73    0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
74  /* q    w    e    r    t    y    u    i    o    p    [    ] */
75    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
76  /* a    s    d    f    g    h    j    k    l    ;    '    \ */
77    0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
78  /* z    x    c    v    b    n    m    ,    .    / */
79    0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
80    0x56 /* the 102nd key (actually to the right of l-shift) */
81 };
82
83 static const WORD main_key_scan_abnt_qwerty[MAIN_LEN] =
84 {
85  /* `    1    2    3    4    5    6    7    8    9    0    -    = */
86    0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
87  /* q    w    e    r    t    y    u    i    o    p    [    ] */
88    0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
89  /* a    s    d    f    g    h    j    k    l    ;    '    \ */
90    0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
91  /* \      z    x    c    v    b    n    m    ,    .    / */
92    0x5e,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
93    0x56, /* the 102nd key (actually to the right of l-shift) */
94 };
95
96 static const WORD main_key_scan_dvorak[MAIN_LEN] =
97 {
98  /* `    1    2    3    4    5    6    7    8    9    0    [    ] */
99    0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x1A,0x1B,
100  /* '    ,    .    p    y    f    g    c    r    l    /    = */
101    0x28,0x33,0x34,0x19,0x15,0x21,0x22,0x2E,0x13,0x26,0x35,0x0D,
102  /* a    o    e    u    i    d    h    t    n    s    -    \ */
103    0x1E,0x18,0x12,0x16,0x17,0x20,0x23,0x14,0x31,0x1F,0x0C,0x2B,
104  /* ;    q    j    k    x    b    m    w    v    z */
105    0x27,0x10,0x24,0x25,0x2D,0x30,0x32,0x11,0x2F,0x2C,
106    0x56 /* the 102nd key (actually to the right of l-shift) */
107 };
108
109 static const WORD main_key_vkey_qwerty[MAIN_LEN] =
110 {
111 /* NOTE: this layout must concur with the scan codes layout above */
112    VK_OEM_3,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_MINUS,VK_OEM_PLUS,
113    VK_Q,VK_W,VK_E,VK_R,VK_T,VK_Y,VK_U,VK_I,VK_O,VK_P,VK_OEM_4,VK_OEM_6,
114    VK_A,VK_S,VK_D,VK_F,VK_G,VK_H,VK_J,VK_K,VK_L,VK_OEM_1,VK_OEM_7,VK_OEM_5,
115    VK_Z,VK_X,VK_C,VK_V,VK_B,VK_N,VK_M,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
116    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
117 };
118
119 static const WORD main_key_vkey_qwerty_v2[MAIN_LEN] =
120 {
121 /* NOTE: this layout must concur with the scan codes layout above */
122    VK_OEM_5,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_PLUS,VK_OEM_4,
123    VK_Q,VK_W,VK_E,VK_R,VK_T,VK_Y,VK_U,VK_I,VK_O,VK_P,VK_OEM_6,VK_OEM_1,
124    VK_A,VK_S,VK_D,VK_F,VK_G,VK_H,VK_J,VK_K,VK_L,VK_OEM_3,VK_OEM_7,VK_OEM_2,
125    VK_Z,VK_X,VK_C,VK_V,VK_B,VK_N,VK_M,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_MINUS,
126    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
127 };
128
129 static const WORD main_key_vkey_qwertz[MAIN_LEN] =
130 {
131 /* NOTE: this layout must concur with the scan codes layout above */
132    VK_OEM_3,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_MINUS,VK_OEM_PLUS,
133    VK_Q,VK_W,VK_E,VK_R,VK_T,VK_Z,VK_U,VK_I,VK_O,VK_P,VK_OEM_4,VK_OEM_6,
134    VK_A,VK_S,VK_D,VK_F,VK_G,VK_H,VK_J,VK_K,VK_L,VK_OEM_1,VK_OEM_7,VK_OEM_5,
135    VK_Y,VK_X,VK_C,VK_V,VK_B,VK_N,VK_M,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
136    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
137 };
138
139 static const WORD main_key_vkey_qwertz_105[MAIN_LEN] =
140 {
141 /* NOTE: this layout must concur with the scan codes layout above */
142    VK_OEM_3,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_MINUS,VK_OEM_PLUS,
143    VK_Q,VK_W,VK_E,VK_R,VK_T,VK_Z,VK_U,VK_I,VK_O,VK_P,VK_OEM_4,VK_OEM_6,
144    VK_A,VK_S,VK_D,VK_F,VK_G,VK_H,VK_J,VK_K,VK_L,VK_OEM_1,VK_OEM_7,VK_OEM_5,
145    VK_OEM_102,VK_Y,VK_X,VK_C,VK_V,VK_B,VK_N,VK_M,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2
146 };
147
148 static const WORD main_key_vkey_abnt_qwerty[MAIN_LEN] =
149 {
150 /* NOTE: this layout must concur with the scan codes layout above */
151    VK_OEM_3,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_MINUS,VK_OEM_PLUS,
152    VK_Q,VK_W,VK_E,VK_R,VK_T,VK_Y,VK_U,VK_I,VK_O,VK_P,VK_OEM_4,VK_OEM_6,
153    VK_A,VK_S,VK_D,VK_F,VK_G,VK_H,VK_J,VK_K,VK_L,VK_OEM_1,VK_OEM_8,VK_OEM_5,
154    VK_OEM_7,VK_Z,VK_X,VK_C,VK_V,VK_B,VK_N,VK_M,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,
155    VK_OEM_102, /* the 102nd key (actually to the right of l-shift) */
156 };
157
158 static const WORD main_key_vkey_azerty[MAIN_LEN] =
159 {
160 /* NOTE: this layout must concur with the scan codes layout above */
161    VK_OEM_7,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_4,VK_OEM_PLUS,
162    VK_A,VK_Z,VK_E,VK_R,VK_T,VK_Y,VK_U,VK_I,VK_O,VK_P,VK_OEM_6,VK_OEM_1,
163    VK_Q,VK_S,VK_D,VK_F,VK_G,VK_H,VK_J,VK_K,VK_L,VK_M,VK_OEM_3,VK_OEM_5,
164    VK_W,VK_X,VK_C,VK_V,VK_B,VK_N,VK_OEM_COMMA,VK_OEM_PERIOD,VK_OEM_2,VK_OEM_8,
165    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
166 };
167
168 static const WORD main_key_vkey_dvorak[MAIN_LEN] =
169 {
170 /* NOTE: this layout must concur with the scan codes layout above */
171    VK_OEM_3,VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_0,VK_OEM_4,VK_OEM_6,
172    VK_OEM_7,VK_OEM_COMMA,VK_OEM_PERIOD,VK_P,VK_Y,VK_F,VK_G,VK_C,VK_R,VK_L,VK_OEM_2,VK_OEM_PLUS,
173    VK_A,VK_O,VK_E,VK_U,VK_I,VK_D,VK_H,VK_T,VK_N,VK_S,VK_OEM_MINUS,VK_OEM_5,
174    VK_OEM_1,VK_Q,VK_J,VK_K,VK_X,VK_B,VK_M,VK_W,VK_V,VK_Z,
175    VK_OEM_102 /* the 102nd key (actually to the right of l-shift) */
176 };
177
178 /*** DEFINE YOUR NEW LANGUAGE-SPECIFIC MAPPINGS BELOW, SEE EXISTING TABLES */
179
180 /* the VK mappings for the main keyboard will be auto-assigned as before,
181    so what we have here is just the character tables */
182 /* order: Normal, Shift, AltGr, Shift-AltGr */
183 /* We recommend you write just what is guaranteed to be correct (i.e. what's
184    written on the keycaps), not the bunch of special characters behind AltGr
185    and Shift-AltGr if it can vary among different X servers */
186 /* Remember that your 102nd key (to the right of l-shift) should be on a
187    separate line, see existing tables */
188 /* If Wine fails to match your new table, use -debugmsg +key to find out why */
189 /* Remember to also add your new table to the layout index table far below! */
190
191 /*** German Logitech Desktop Pro keyboard layout */
192 static const char main_key_DE_logitech[MAIN_LEN][4] =
193 {
194  "^\xb0","1!","2\"","3\xa7","4$","5%","6&","7/{","8([","9)]","0=}","\xdf?\\","'`",
195  "qQ@","wW","eE","rR","tT","zZ","uU","iI","oO","pP","\xfc\xdc","+*~",
196  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","\xf6\xd6","\xe4\xc4","#'",
197  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
198  "<>|"
199 };
200
201 /*** United States keyboard layout (mostly contributed by Uwe Bonnes) */
202 static const char main_key_US[MAIN_LEN][4] =
203 {
204  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
205  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
206  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
207  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
208 };
209
210 /*** United States keyboard layout (phantom key version) */
211 /* (XFree86 reports the <> key even if it's not physically there) */
212 static const char main_key_US_phantom[MAIN_LEN][4] =
213 {
214  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
215  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
216  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
217  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
218  "<>" /* the phantom key */
219 };
220
221 /*** United States keyboard layout (dvorak version) */
222 static const char main_key_US_dvorak[MAIN_LEN][4] =
223 {
224  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","[{","]}",
225  "'\"",",<",".>","pP","yY","fF","gG","cC","rR","lL","/?","=+",
226  "aA","oO","eE","uU","iI","dD","hH","tT","nN","sS","-_","\\|",
227  ";:","qQ","jJ","kK","xX","bB","mM","wW","vV","zZ"
228 };
229
230 /*** British keyboard layout */
231 static const char main_key_UK[MAIN_LEN][4] =
232 {
233  "`","1!","2\"","3£","4$","5%","6^","7&","8*","9(","0)","-_","=+",
234  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
235  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'@","#~",
236  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
237  "\\|"
238 };
239
240 /*** French keyboard layout (contributed by Eric Pouech) */
241 static const char main_key_FR[MAIN_LEN][4] =
242 {
243  "²","&1","é2~","\"3#","'4{","(5[","-6|","è7`","_8\\","ç9^±","à0@",")°]","=+}",
244  "aA","zZ","eE¿","rR","tT","yY","uU","iI","oO","pP","^¨","$£¤",
245  "qQ","sSß","dD","fF","gG","hH","jJ","kK","lL","mM","ù%","*µ",
246  "wW","xX","cC","vV","bB","nN",",?",";.",":/","!§",
247  "<>"
248 };
249
250 /*** Icelandic keyboard layout (setxkbmap is) */
251 static const char main_key_IS[MAIN_LEN][4] =
252 {
253  "°","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","öÖ","-_",
254  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","ðÐ","'?",
255  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","æÆ","´Ä","+*",
256  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","þÞ",
257  "<>"
258 };
259
260 /*** German keyboard layout (contributed by Ulrich Weigand) */
261 static const char main_key_DE[MAIN_LEN][4] =
262 {
263  "^°","1!","2\"²","3§³","4$","5%","6&","7/{","8([","9)]","0=}","ß?\\","'`",
264  "qQ@","wW","eE\80","rR","tT","zZ","uU","iI","oO","pP","üÜ","+*~",
265  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","#´",
266  "yY","xX","cC","vV","bB","nN","mMµ",",;",".:","-_",
267  "<>|"
268 };
269
270 /*** German keyboard layout without dead keys */
271 static const char main_key_DE_nodead[MAIN_LEN][4] =
272 {
273  "^°","1!","2\"","3§","4$","5%","6&","7/{","8([","9)]","0=}","ß?\\","´",
274  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üÜ","+*~",
275  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","#'",
276  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
277  "<>"
278 };
279
280 /*** German keyboard layout without dead keys 105 Keys (contributed by Matthias Fechner)*/
281 static const char main_key_DE_nodead_105[MAIN_LEN][4] =
282 {
283  "^°","1!","2\"²","3§³","4$","5%","6&","7/{","8([","9)]","0=}","ß?\\","'`",
284  "qQ@","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üÜ","+*~",
285  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","#'",
286  "<>|","yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
287 };
288
289 /*** Swiss German keyboard layout (contributed by Jonathan Naylor) */
290 static const char main_key_SG[MAIN_LEN][4] =
291 {
292  "§°","1+|","2\"@","3*#","4ç","5%","6&¬","7/¦","8(¢","9)","0=","'?´","^`~",
293  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üè[","¨!]",
294  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öé","äà{","$£}",
295  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
296  "<>\\"
297 };
298
299 /*** Swiss French keyboard layout (contributed by Philippe Froidevaux) */
300 static const char main_key_SF[MAIN_LEN][4] =
301 {
302  "§°","1+|","2\"@","3*#","4ç","5%","6&¬","7/¦","8(¢","9)","0=","'?´","^`~",
303  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","èü[","¨!]",
304  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","éö","àä{","$£}",
305  "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
306  "<>\\"
307 };
308
309 /*** Norwegian keyboard layout (contributed by Ove Kåven) */
310 static const char main_key_NO[MAIN_LEN][4] =
311 {
312  "|§","1!","2\"@","3#£","4¤$","5%","6&","7/{","8([","9)]","0=}","+?","\\`´",
313  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^~",
314  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","øØ","æÆ","'*",
315  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
316  "<>"
317 };
318
319 /*** Danish keyboard layout (setxkbmap dk) */
320 static const char main_key_DA[MAIN_LEN][4] =
321 {
322  "½§","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
323  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^",
324  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","æÆ","øØ","'*",
325  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
326  "<>"
327 };
328
329 /*** Swedish keyboard layout (setxkbmap se) */
330 static const char main_key_SE[MAIN_LEN][4] =
331 {
332  "§½","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
333  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^",
334  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","'*",
335  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
336  "<>"
337 };
338
339 /*** Estonian keyboard layout (contributed by Raul Metsma zombi82@hot.ee) */
340 static const char main_key_ET[MAIN_LEN][4] =
341 {
342  "·~","1!","2\"@","3#£","4¤$","5%","6&","7/{","8([","9)]","0=}","+?\\","´`",
343  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","üÜ","õÕ§",
344  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","'*½",
345  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
346  "<>|"
347 };
348
349 /*** Canadian French keyboard layout */
350 static const char main_key_CF[MAIN_LEN][4] =
351 {
352  "#|\\","1!±","2\"@","3/£","4$¢","5%¤","6?¬","7&¦","8*²","9(³","0)¼","-_½","=+¾",
353  "qQ","wW","eE","rR","tT","yY","uU","iI","oO§","pP¶","^^[","¸¨]",
354  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:~","``{","<>}",
355  "zZ","xX","cC","vV","bB","nN","mM",",'-",".","éÉ",
356  "«»°"
357 };
358
359 /*** Portuguese keyboard layout (setxkbmap pt) */
360 static const char main_key_PT[MAIN_LEN][4] =
361 {
362  "\\|","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?","«»",
363  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","+*","´`",
364  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","çÇ","ºª","~^",
365  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
366  "<>"
367 };
368
369 /*** Italian keyboard layout (setxkbmap it) */
370 static const char main_key_IT[MAIN_LEN][4] =
371 {
372  "\\|","1!","2\"","3£","4$","5%","6&","7/","8(","9)","0=","'?","ì^",
373  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","èé","+*",
374  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","òç","à°","ù§",
375  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
376  "<>"
377 };
378
379 /*** Finnish keyboard layout (setxkbmap fi) */
380 static const char main_key_FI[MAIN_LEN][4] =
381 {
382  "§½","1!","2\"","3#","4¤","5%","6&","7/","8(","9)","0=","+?","´`",
383  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^",
384  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","'*",
385  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
386  "<>"
387 };
388
389 /*** Bulgarian bds keyboard layout */
390 static const char main_key_BG_bds[MAIN_LEN][4] =
391 {
392  "`~()","1!","2@2?","3#3+","4$4\"","5%","6^6=","7&7:","8*8/","9(","0)","-_-I","=+.V",
393  "qQ,û","wWóÓ","eEåÅ","rRèÈ","tTøØ","yYùÙ","uUêÊ","iIñÑ","oOäÄ","pPçÇ","[{öÖ","]};",
394  "aAüÜ","sSÿß","dDàÀ","fFîÎ","gGæÆ","hHãÃ","jJòÒ","kKíÍ","lLâÂ",";:ìÌ","'\"÷×","\\|'Û",
395  "zZþÞ","xXéÉ","cCúÚ","vVýÝ","bBôÔ","nNõÕ","mMïÏ",",<ðÐ",".>ëË","/?áÁ",
396  "<>" /* the phantom key */
397 };
398
399 /*** Bulgarian phonetic keyboard layout */
400 static const char main_key_BG_phonetic[MAIN_LEN][4] =
401 {
402  "`~÷×","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
403  "qQÿß","wWâÂ","eEåÅ","rRðÐ","tTòÒ","yYúÚ","uUóÓ","iIèÈ","oOîÎ","pPïÏ","[{øØ","]}ùÙ",
404  "aAàÀ","sSñÑ","dDäÄ","fFôÔ","gGãÃ","hHõÕ","jJéÉ","kKêÊ","lLëË",";:","'\"","\\|þÞ",
405  "zZçÇ","xXüÜ","cCöÖ","vVæÆ","bBáÁ","nNíÍ","mMìÌ",",<",".>","/?",
406  "<>" /* the phantom key */
407 };
408
409 /*** Belarusian standard keyboard layout (contributed by Hleb Valoska) */
410 /*** It matches belarusian layout for XKB from Alexander Mikhailian    */
411 static const char main_key_BY[MAIN_LEN][4] =
412 {
413  "`~£³","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
414  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oO®¾","pPÚú","[{Èè","]}''",
415  "aAÆæ","sSÙù","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"Üü","\\|/|",
416  "zZÑñ","xXÞþ","cCÓó","vVÍí","bB¦¶","nNÔô","mMØø",",<Ââ",".>Àà","/?.,", "<>|¦",
417 };
418
419
420 /*** Russian keyboard layout (contributed by Pavel Roskin) */
421 static const char main_key_RU[MAIN_LEN][4] =
422 {
423  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
424  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oOÝý","pPÚú","[{Èè","]}ßÿ",
425  "aAÆæ","sSÙù","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"Üü","\\|",
426  "zZÑñ","xXÞþ","cCÓó","vVÍí","bBÉé","nNÔô","mMØø",",<Ââ",".>Àà","/?"
427 };
428
429 /*** Russian keyboard layout (phantom key version) */
430 static const char main_key_RU_phantom[MAIN_LEN][4] =
431 {
432  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
433  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oOÝý","pPÚú","[{Èè","]}ßÿ",
434  "aAÆæ","sSÙù","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"Üü","\\|",
435  "zZÑñ","xXÞþ","cCÓó","vVÍí","bBÉé","nNÔô","mMØø",",<Ââ",".>Àà","/?",
436  "<>" /* the phantom key */
437 };
438
439 /*** Russian keyboard layout KOI8-R */
440 static const char main_key_RU_koi8r[MAIN_LEN][4] =
441 {
442  "()","1!","2\"","3/","4$","5:","6,","7.","8;","9?","0%","-_","=+",
443  "Êê","Ãã","Õõ","Ëë","Åå","Îî","Çç","Ûû","Ýý","Úú","Èè","ßÿ",
444  "Ææ","Ùù","×÷","Áá","Ðð","Òò","Ïï","Ìì","Ää","Öö","Üü","\\|",
445  "Ññ","Þþ","Óó","Íí","Éé","Ôô","Øø","Ââ","Àà","/?",
446  "<>" /* the phantom key */
447 };
448
449 /*** Russian keyboard layout cp1251 */
450 static const char main_key_RU_cp1251[MAIN_LEN][4] =
451 {
452  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
453  "qQéÉ","wWöÖ","eEóÓ","rRêÊ","tTåÅ","yYíÍ","uUãÃ","iIøØ","oOùÙ","pPçÇ","[{õÕ","]}úÚ",
454  "aAôÔ","sSûÛ","dDâÂ","fFàÀ","gGïÏ","hHðÐ","jJîÎ","kKëË","lLäÄ",";:æÆ","'\"ýÝ","\\|",
455  "zZÿß","xX÷×","cCñÑ","vVìÌ","bBèÈ","nNòÒ","mMüÜ",",<áÁ",".>þÞ","/?",
456  "<>" /* the phantom key */
457 };
458
459 /*** Russian phonetic keyboard layout */
460 static const char main_key_RU_phonetic[MAIN_LEN][4] =
461 {
462  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
463  "qQÑñ","wW×÷","eEÅå","rRÒò","tTÔô","yYÙù","uUÕõ","iIÉé","oOÏï","pPÐð","[{Ûû","]}Ýý",
464  "aAÁá","sSÓó","dDÄä","fFÆæ","gGÇç","hHÈè","jJÊê","kKËë","lLÌì",";:","'\"","\\|",
465  "zZÚú","xXØø","cCÃã","vVÖö","bBÂâ","nNÎî","mMÍí",",<",".>","/?",
466  "<>" /* the phantom key */
467 };
468
469 /*** Ukrainian keyboard layout KOI8-U */
470 static const char main_key_UA[MAIN_LEN][4] =
471 {
472  "`~­½","1!1!","2@2\"","3#3'","4$4*","5%5:","6^6,","7&7.","8*8;","9(9(","0)0)","-_-_","=+=+",
473  "qQÊê","wWÃã","eEÕõ","rRËë","tTÅå","yYÎî","uUÇç","iIÛû","oOÝý","pPÚú","[{Èè","]}§·",
474  "aAÆæ","sS¦¶","dD×÷","fFÁá","gGÐð","hHÒò","jJÏï","kKÌì","lLÄä",";:Öö","'\"¤´","\\|\\|",
475  "zZÑñ","xXÞþ","cCÓó","vVÍí","bBÉé","nNÔô","mMØø",",<Ââ",".>Àà","/?/?",
476  "<>" /* the phantom key */
477 };
478
479 /*** Spanish keyboard layout (setxkbmap es) */
480 static const char main_key_ES[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 /*** Belgian keyboard layout ***/
490 static const char main_key_BE[MAIN_LEN][4] =
491 {
492  "","&1|","é2@","\"3#","'4","(5","§6^","è7","!8","ç9{","à0}",")°","-_",
493  "aA","zZ","eE¤","rR","tT","yY","uU","iI","oO","pP","^¨[","$*]",
494  "qQ","sSß","dD","fF","gG","hH","jJ","kK","lL","mM","ù%´","µ£`",
495  "wW","xX","cC","vV","bB","nN",",?",";.",":/","=+~",
496  "<>\\"
497 };
498
499 /*** Hungarian keyboard layout (contributed by Zoltán Kovács) */
500 static const char main_key_HU[MAIN_LEN][4] =
501 {
502  "0§","1'~","2\"·","3+^","4!¢","5%°","6/²","7=`","8(ÿ","9)´","öÖ½","üܨ","óÓ¸",
503  "qQ\\","wW|","eE","rR","tT","zZ","uU","iIÍ","oOø","pP","õÕ÷","úÚ×",
504  "aA","sSð","dDÐ","fF[","gG]","hH","jJí","kK³","lL£","éÉ$","áÁß","ûÛ¤",
505  "yY>","xX#","cC&","vV@","bB{","nN}","mM",",?;",".:>","-_*",
506  "íÍ<"
507 };
508
509 /*** Polish (programmer's) keyboard layout ***/
510 static const char main_key_PL[MAIN_LEN][4] =
511 {
512  "`~","1!","2@","3#","4$","5%","6^","7&§","8*","9(","0)","-_","=+",
513  "qQ","wW","eEêÊ","rR","tT","yY","uU","iI","oOóÓ","pP","[{","]}",
514  "aA±¡","sS¶¦","dD","fF","gG","hH","jJ","kK","lL³£",";:","'\"","\\|",
515  "zZ¿¯","xX¼¬","cCæÆ","vV","bB","nNñÑ","mM",",<",".>","/?",
516  "<>|"
517 };
518
519 /*** Slovenian keyboard layout by Rok Mandeljc <rok.mandeljc@gimb.org> ***/
520 static const char main_key_SI[MAIN_LEN][4] =
521 {
522  "¸¨","1!","2\"·","3#^","4$¢","5%°","6&²","7/`","8(ÿ","9)´","0=½","'?¨","+*¸",
523  "qQ\\","wW|","eE","rR","tT","zZ","uU","iI","oO","pP","¹©÷","ðÐ×",
524  "aA","sS","dD","fF[","gG]","hH","jJ","kK³","lL£","èÈ","æÆß","¾®¤",
525  "yY","xX","cC","vV@","bB{","nN}","mM§",",;",".:","-_",
526  "<>"
527 };
528
529 /*** Croatian keyboard layout specific for me <jelly@srk.fer.hr> ***/
530 static const char main_key_HR_jelly[MAIN_LEN][4] =
531 {
532  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
533  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{¹©","]}ðÐ",
534  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:èÈ","'\"æÆ","\\|¾®",
535  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
536  "<>|"
537 };
538
539 /*** Croatian keyboard layout ***/
540 static const char main_key_HR[MAIN_LEN][4] =
541 {
542  "¸¨","1!","2\"·","3#^","4$¢","5%°","6&²","7/`","8(ÿ","9)´","0=½","'?¨","+*¸",
543  "qQ\\","wW|","eE","rR","tT","zZ","uU","iI","oO","pP","¹©÷","ðÐ×",
544  "aA","sS","dD","fF[","gG]","hH","jJ","kK³","lL£","èÈ","æÆß","¾®¤",
545  "yY","xX","cC","vV@","bB{","nN}","mM§",",;",".:","-_/",
546  "<>"
547 };
548
549 /*** Japanese 106 keyboard layout ***/
550 static const char main_key_JA_jp106[MAIN_LEN][4] =
551 {
552  "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0~","-=","^~","\\|",
553  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@`","[{",
554  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
555  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
556  "\\_",
557 };
558
559 /*** Japanese pc98x1 keyboard layout ***/
560 static const char main_key_JA_pc98x1[MAIN_LEN][4] =
561 {
562  "1!","2\"","3#","4$","5%","6&","7'","8(","9)","0","-=","^`","\\|",
563  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","@~","[{",
564  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";+",":*","]}",
565  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
566  "\\_",
567 };
568
569 /*** Brazilian ABNT-2 keyboard layout (contributed by Raul Gomes Fernandes) */
570 static const char main_key_PT_br[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 /*** Brazilian ABNT-2 keyboard layout with <ALT GR> (contributed by Mauro Carvalho Chehab) */
580 static const char main_key_PT_br_alt_gr[MAIN_LEN][4] =
581 {
582  "'\"","1!9","2@2","3#3","4$#","5%\"","6(,","7&","8*","9(","0)","-_","=+'",
583  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","4`","[{*",
584  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","gG","~^","]}:",
585  "zZ","xX","cC","vV","bB","nN","mM",",<",".>",";:","/?0",
586  "\\|"
587 };
588
589 /*** US international keyboard layout (contributed by Gustavo Noronha (kov@debian.org)) */
590 static const char main_key_US_intl[MAIN_LEN][4] =
591 {
592   "`~", "1!", "2@", "3#", "4$", "5%", "6^", "7&", "8*", "9(", "0)", "-_", "=+", "\\|",
593   "qQ", "wW", "eE", "rR", "tT", "yY", "uU", "iI", "oO", "pP", "[{", "]}",
594   "aA", "sS", "dD", "fF", "gG", "hH", "jJ", "kK", "lL", ";:", "'\"",
595   "zZ", "xX", "cC", "vV", "bB", "nN", "mM", ",<", ".>", "/?"
596 };
597
598 /*** Slovak keyboard layout (see cssk_ibm(sk_qwerty) in xkbsel)
599   - dead_abovering replaced with degree - no symbol in iso8859-2
600   - brokenbar replaced with bar                                 */
601 static const char main_key_SK[MAIN_LEN][4] =
602 {
603  ";0","+1","µ2","¹3","è4","»5","¾6","ý7","á8","í9","é0","=%","'v",
604  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","ú/","ä(",
605  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ô\"","§!","ò)",
606  "zZ","xX","cC","vV","bB","nN","mM",",?",".:","-_",
607  "<>"
608 };
609
610 /*** Czech keyboard layout (setxkbmap cz) */
611 static const char main_key_CZ[MAIN_LEN][4] =
612 {
613  ";","+1","ì2","¹3","è4","ø5","¾6","ý7","á8","í9","é0","=%","´·",
614  "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","ú/",")(",
615  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ù\"","§!","¨'",
616  "yY","xX","cC","vV","bB","nN","mM",",?",".:","-_",
617  "\\"
618 };
619
620 /*** Czech keyboard layout (setxkbmap cz_qwerty) */
621 static const char main_key_CZ_qwerty[MAIN_LEN][4] =
622 {
623  ";","+1","ì2","¹3","è4","ø5","¾6","ý7","á8","í9","é0","=%","´·",
624  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","ú/",")(",
625  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ù\"","§!","¨'",
626  "zZ","xX","cC","vV","bB","nN","mM",",?",".:","-_",
627  "\\"
628 };
629
630 /*** Slovak and Czech (programmer's) keyboard layout (see cssk_dual(cs_sk_ucw)) */
631 static const char main_key_SK_prog[MAIN_LEN][4] =
632 {
633  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
634  "qQäÄ","wWìÌ","eEéÉ","rRøØ","tT»«","yYýÝ","uUùÙ","iIíÍ","oOóÓ","pPöÖ","[{","]}",
635  "aAáÁ","sS¹©","dDïÏ","fFëË","gGàÀ","hHúÚ","jJüÜ","kKôÔ","lLµ¥",";:","'\"","\\|",
636  "zZ¾®","xX¤","cCèÈ","vVçÇ","bB","nNòÒ","mMåÅ",",<",".>","/?",
637  "<>"
638 };
639
640 /*** Czech keyboard layout (see cssk_ibm(cs_qwerty) in xkbsel) */
641 static const char main_key_CS[MAIN_LEN][4] =
642 {
643  ";","+1","ì2","¹3","è4","ø5","¾6","ý7","á8","í9","é0½)","=%","",
644  "qQ\\","wW|","eE","rR","tT","yY","uU","iI","oO","pP","ú/[{",")(]}",
645  "aA","sSð","dDÐ","fF[","gG]","hH","jJ","kK³","lL£","ù\"$","§!ß","¨'",
646  "zZ>","xX#","cC&","vV@","bB{","nN}","mM",",?<",".:>","-_*",
647  "<>\\|"
648 };
649
650 /*** Latin American keyboard layout (contributed by Gabriel Orlando Garcia) */
651 static const char main_key_LA[MAIN_LEN][4] =
652 {
653  "|°¬","1!","2\"","3#","4$","5%","6&","7/","8(","9)","0=","'?\\","¿¡",
654  "qQ@","wW","eE","rR","tT","yY","uU","iI","oO","pP","´¨","+*~",
655  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","ñÑ","{[^","}]`",
656  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
657  "<>"
658 };
659
660 /*** Lithuanian (Baltic) keyboard layout (pc/lt in XFree86 4.3.0, contributed by Nerijus Baliûnas) */
661 static const char main_key_LT_B[MAIN_LEN][4] =
662 {
663  "`~","àÀ","èÈ","æÆ","ëË","áÁ","ðÐ","øØ","ûÛ","¥(","´)","-_","þÞ","\\|",
664  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
665  "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"",
666  "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
667 };
668
669 /*** Turkish keyboard Layout */
670 static const char main_key_TK[MAIN_LEN][4] =
671 {
672 "\"é","1!","2'","3^#","4+$","5%","6&","7/{","8([","9)]","0=}","*?\\","-_",
673 "qQ@","wW","eE","rR","tT","yY","uU","ýIî","oO","pP","ðÐ","üÜ~",
674 "aAæ","sSß","dD","fF","gG","hH","jJ","kK","lL","þÞ","iÝ",",;`",
675 "zZ","xX","cC","vV","bB","nN","mM","öÖ","çÇ",".:"
676 };
677
678 /*** Israelian keyboard layout (setxkbmap us,il) */
679 static const char main_key_IL[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 /*** Israelian phonetic keyboard layout (setxkbmap us,il_phonetic) */
689 static const char main_key_IL_phonetic[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
698 /*** Israelian Saharon keyboard layout (setxkbmap -symbols "us(pc105)+il_saharon") */
699 static const char main_key_IL_saharon[MAIN_LEN][4] =
700 {
701  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
702  "qQ÷","wWñ","eE","rRø","tTè","yYã","uU","iI","oO","pPô","[{","]}",
703  "aAà","sSå","dDì","fFú","gGâ","hHä","jJù","kKë","lLé",";:","'\"","\\|",
704  "zZæ","xXç","cCö","vVò","bBá","nNð","mMî",",<",".>","/?",
705  "<>"
706 };
707
708 /*** Greek keyboard layout (contributed by Kriton Kyrimis <kyrimis@cti.gr>)
709   Greek characters for "wW" and "sS" are omitted to not produce a mismatch
710   message since they have different characters in gr and el XFree86 layouts. */
711 static const char main_key_EL[MAIN_LEN][4] =
712 {
713  "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
714  "qQ;:","wW","eEåÅ","rRñÑ","tTôÔ","yYõÕ","uUèÈ","iIéÉ","oOïÏ","pPðÐ","[{","]}",
715  "aAáÁ","sS","dDäÄ","fFöÖ","gGãÃ","hHçÇ","jJîÎ","kKêÊ","lLëË",";:´¨","'\"","\\|",
716  "zZæÆ","xX÷×","cCøØ","vVùÙ","bBâÂ","nNíÍ","mMìÌ",",<",".>","/?",
717  "<>"
718 };
719
720 /*** Thai (Kedmanee) keyboard layout by Supphachoke Suntiwichaya <mrchoke@opentle.org> */
721 static const char main_key_th[MAIN_LEN][4] =
722 {
723  "`~_%","1!å+","2@/ñ","3#-ò","4$Àó","5%¶ô","6^ØÙ","7&Öß","8*¤õ","9(µö","0)¨÷","-_¢ø","=+ªù",
724  "qQæð","wWä\"","eEÓ®","rR¾±","tTи","yYÑí","uUÕê","iIó","oO¹Ï","pP­","[{º°","]}Å,",
725  "aA¿Ä","sS˦","dD¡¯","fF´â","gGà¬","hHéç","jJèë","kKÒÉ","lLÊÈ",";:Ç«","\'\"§.","\\|£¥",
726  "zZ¼(","xX»)","cCá©","vVÍÎ","bBÚ","nN×ì","mM·?",",<Á²",".>ãÌ","/?½Æ"
727 }; 
728
729 /*** VNC keyboard layout */
730 static const WORD main_key_scan_vnc[MAIN_LEN] =
731 {
732    0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x1A,0x1B,0x27,0x28,0x29,0x33,0x34,0x35,0x2B,
733    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,
734    0x56
735 };
736
737 static const WORD main_key_vkey_vnc[MAIN_LEN] =
738 {
739    VK_1,VK_2,VK_3,VK_4,VK_5,VK_6,VK_7,VK_8,VK_9,VK_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,
740    VK_A,VK_B,VK_C,VK_D,VK_E,VK_F,VK_G,VK_H,VK_I,VK_J,VK_K,VK_L,VK_M,VK_N,VK_O,VK_P,VK_Q,VK_R,VK_S,VK_T,VK_U,VK_V,VK_W,VK_X,VK_Y,VK_Z,
741    VK_OEM_102
742 };
743
744 static const char main_key_vnc[MAIN_LEN][4] =
745 {
746  "1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+","[{","]}",";:","'\"","`~",",<",".>","/?","\\|",
747  "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"
748 };
749
750 /*** Dutch keyboard layout (setxkbmap nl) ***/
751 static const char main_key_NL[MAIN_LEN][4] =
752 {
753  "@§","1!","2\"","3#","4$","5%","6&","7_","8(","9)","0'","/?","°~",
754  "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","¨~","*|",
755  "aA","sS","dD","fF","gG","hH","jJ","kK","lL","+±","'`","<>",
756  "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-=",
757  "[]"
758 };
759
760
761
762 /*** Layout table. Add your keyboard mappings to this list */
763 static const struct {
764     LCID lcid; /* input locale identifier, look for LOCALE_ILANGUAGE
765                  in the appropriate dlls/kernel/nls/.nls file */
766     const char *comment;
767     const char (*key)[MAIN_LEN][4];
768     const WORD (*scan)[MAIN_LEN]; /* scan codes mapping */
769     const WORD (*vkey)[MAIN_LEN]; /* virtual key codes mapping */
770 } main_key_tab[]={
771  {0x0409, "United States keyboard layout", &main_key_US, &main_key_scan_qwerty, &main_key_vkey_qwerty},
772  {0x0409, "United States keyboard layout (phantom key version)", &main_key_US_phantom, &main_key_scan_qwerty, &main_key_vkey_qwerty},
773  {0x0409, "United States keyboard layout (dvorak)", &main_key_US_dvorak, &main_key_scan_dvorak, &main_key_vkey_dvorak},
774  {0x0409, "United States International keyboard layout", &main_key_US_intl, &main_key_scan_qwerty, &main_key_vkey_qwerty},
775  {0x0809, "British keyboard layout", &main_key_UK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
776  {0x0407, "German keyboard layout", &main_key_DE, &main_key_scan_qwerty, &main_key_vkey_qwertz},
777  {0x0407, "German keyboard layout without dead keys", &main_key_DE_nodead, &main_key_scan_qwerty, &main_key_vkey_qwertz},
778  {0x0407, "German keyboard layout for logitech desktop pro", &main_key_DE_logitech,  &main_key_scan_qwerty, &main_key_vkey_qwertz},
779  {0x0407, "German keyboard layout without dead keys 105", &main_key_DE_nodead_105, &main_key_scan_qwerty, &main_key_vkey_qwertz_105},
780  {0x0807, "Swiss German keyboard layout", &main_key_SG, &main_key_scan_qwerty, &main_key_vkey_qwertz},
781  {0x100c, "Swiss French keyboard layout", &main_key_SF, &main_key_scan_qwerty, &main_key_vkey_qwertz},
782  {0x041d, "Swedish keyboard layout", &main_key_SE, &main_key_scan_qwerty, &main_key_vkey_qwerty_v2},
783  {0x0425, "Estonian keyboard layout", &main_key_ET, &main_key_scan_qwerty, &main_key_vkey_qwerty},
784  {0x0414, "Norwegian keyboard layout", &main_key_NO, &main_key_scan_qwerty, &main_key_vkey_qwerty},
785  {0x0406, "Danish keyboard layout", &main_key_DA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
786  {0x040c, "French keyboard layout", &main_key_FR, &main_key_scan_qwerty, &main_key_vkey_azerty},
787  {0x0c0c, "Canadian French keyboard layout", &main_key_CF, &main_key_scan_qwerty, &main_key_vkey_qwerty},
788  {0x080c, "Belgian keyboard layout", &main_key_BE, &main_key_scan_qwerty, &main_key_vkey_azerty},
789  {0x0816, "Portuguese keyboard layout", &main_key_PT, &main_key_scan_qwerty, &main_key_vkey_qwerty},
790  {0x0416, "Brazilian ABNT-2 keyboard layout", &main_key_PT_br, &main_key_scan_abnt_qwerty, &main_key_vkey_abnt_qwerty},
791  {0x0416, "Brazilian ABNT-2 keyboard layout ALT GR", &main_key_PT_br_alt_gr,&main_key_scan_abnt_qwerty, &main_key_vkey_abnt_qwerty},
792  {0x040b, "Finnish keyboard layout", &main_key_FI, &main_key_scan_qwerty, &main_key_vkey_qwerty},
793  {0x0402, "Bulgarian bds keyboard layout", &main_key_BG_bds, &main_key_scan_qwerty, &main_key_vkey_qwerty},
794  {0x0402, "Bulgarian phonetic keyboard layout", &main_key_BG_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
795  {0x0423, "Belarusian keyboard layout", &main_key_BY, &main_key_scan_qwerty, &main_key_vkey_qwerty},
796  {0x0419, "Russian keyboard layout", &main_key_RU, &main_key_scan_qwerty, &main_key_vkey_qwerty},
797  {0x0419, "Russian keyboard layout (phantom key version)", &main_key_RU_phantom, &main_key_scan_qwerty, &main_key_vkey_qwerty},
798  {0x0419, "Russian keyboard layout KOI8-R", &main_key_RU_koi8r, &main_key_scan_qwerty, &main_key_vkey_qwerty},
799  {0x0419, "Russian keyboard layout cp1251", &main_key_RU_cp1251, &main_key_scan_qwerty, &main_key_vkey_qwerty},
800  {0x0419, "Russian phonetic keyboard layout", &main_key_RU_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
801  {0x0422, "Ukrainian keyboard layout KOI8-U", &main_key_UA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
802  {0x040a, "Spanish keyboard layout", &main_key_ES, &main_key_scan_qwerty, &main_key_vkey_qwerty},
803  {0x0410, "Italian keyboard layout", &main_key_IT, &main_key_scan_qwerty, &main_key_vkey_qwerty},
804  {0x040f, "Icelandic keyboard layout", &main_key_IS, &main_key_scan_qwerty, &main_key_vkey_qwerty},
805  {0x040e, "Hungarian keyboard layout", &main_key_HU, &main_key_scan_qwerty, &main_key_vkey_qwertz},
806  {0x0415, "Polish (programmer's) keyboard layout", &main_key_PL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
807  {0x0424, "Slovenian keyboard layout", &main_key_SI, &main_key_scan_qwerty, &main_key_vkey_qwertz},
808  {0x041a, "Croatian keyboard layout", &main_key_HR, &main_key_scan_qwerty, &main_key_vkey_qwertz},
809  {0x041a, "Croatian keyboard layout (specific)", &main_key_HR_jelly, &main_key_scan_qwerty, &main_key_vkey_qwerty},
810  {0xe0010411, "Japanese 106 keyboard layout", &main_key_JA_jp106, &main_key_scan_qwerty, &main_key_vkey_qwerty},
811  {0xe0010411, "Japanese pc98x1 keyboard layout", &main_key_JA_pc98x1, &main_key_scan_qwerty, &main_key_vkey_qwerty},
812  {0x041b, "Slovak keyboard layout", &main_key_SK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
813  {0x041b, "Slovak and Czech keyboard layout without dead keys", &main_key_SK_prog, &main_key_scan_qwerty, &main_key_vkey_qwerty},
814  {0x0405, "Czech keyboard layout", &main_key_CS, &main_key_scan_qwerty, &main_key_vkey_qwerty},
815  {0x0405, "Czech keyboard layout cz", &main_key_CZ, &main_key_scan_qwerty, &main_key_vkey_qwertz},
816  {0x0405, "Czech keyboard layout cz_qwerty", &main_key_CZ_qwerty, &main_key_scan_qwerty, &main_key_vkey_qwerty},
817  {0x040a, "Latin American keyboard layout", &main_key_LA, &main_key_scan_qwerty, &main_key_vkey_qwerty},
818  {0x0427, "Lithuanian (Baltic) keyboard layout", &main_key_LT_B, &main_key_scan_qwerty, &main_key_vkey_qwerty},
819  {0x041f, "Turkish keyboard layout", &main_key_TK, &main_key_scan_qwerty, &main_key_vkey_qwerty},
820  {0x040d, "Israelian keyboard layout", &main_key_IL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
821  {0x040d, "Israelian phonetic keyboard layout", &main_key_IL_phonetic, &main_key_scan_qwerty, &main_key_vkey_qwerty},
822  {0x040d, "Israelian Saharon keyboard layout", &main_key_IL_saharon, &main_key_scan_qwerty, &main_key_vkey_qwerty},
823  {0x0409, "VNC keyboard layout", &main_key_vnc, &main_key_scan_vnc, &main_key_vkey_vnc},
824  {0x0408, "Greek keyboard layout", &main_key_EL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
825  {0x041e, "Thai (Kedmanee)  keyboard layout", &main_key_th, &main_key_scan_qwerty, &main_key_vkey_qwerty},
826  {0x0413, "Dutch keyboard layout", &main_key_NL, &main_key_scan_qwerty, &main_key_vkey_qwerty},
827
828  {0, NULL, NULL, NULL, NULL} /* sentinel */
829 };
830 static unsigned kbd_layout=0; /* index into above table of layouts */
831
832 /* maybe more of these scancodes should be extended? */
833                 /* extended must be set for ALT_R, CTRL_R,
834                    INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
835                    keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
836                 /* FIXME should we set extended bit for NumLock ? My
837                  * Windows does ... DF */
838                 /* Yes, to distinguish based on scan codes, also
839                    for PrtScn key ... GA */
840
841 static const WORD nonchar_key_vkey[256] =
842 {
843     /* unused */
844     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF00 */
845     /* special keys */
846     VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0,           /* FF08 */
847     0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0,                      /* FF10 */
848     0, 0, 0, VK_ESCAPE, 0, 0, 0, 0,                             /* FF18 */
849     /* unused */
850     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF20 */
851     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF28 */
852     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF30 */
853     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF38 */
854     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF40 */
855     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF48 */
856     /* cursor keys */
857     VK_HOME, VK_LEFT, VK_UP, VK_RIGHT,                          /* FF50 */
858     VK_DOWN, VK_PRIOR, VK_NEXT, VK_END,
859     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF58 */
860     /* misc keys */
861     VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0, 0, 0, 0,  /* FF60 */
862     VK_CANCEL, VK_HELP, VK_CANCEL, VK_CANCEL, 0, 0, 0, 0,       /* FF68 */
863     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF70 */
864     /* keypad keys */
865     0, 0, 0, 0, 0, 0, 0, VK_NUMLOCK,                            /* FF78 */
866     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FF80 */
867     0, 0, 0, 0, 0, VK_RETURN, 0, 0,                             /* FF88 */
868     0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP,                     /* FF90 */
869     VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT,                       /* FF98 */
870     VK_END, 0, VK_INSERT, VK_DELETE,
871     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFA0 */
872     0, 0, VK_MULTIPLY, VK_ADD,                                  /* FFA8 */
873     VK_SEPARATOR, VK_SUBTRACT, VK_DECIMAL, VK_DIVIDE,
874     VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3,             /* FFB0 */
875     VK_NUMPAD4, VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7,
876     VK_NUMPAD8, VK_NUMPAD9, 0, 0, 0, 0,                         /* FFB8 */
877     /* function keys */
878     VK_F1, VK_F2,
879     VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10,    /* FFC0 */
880     VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16, 0, 0,       /* FFC8 */
881     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFD0 */
882     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFD8 */
883     /* modifier keys */
884     0, VK_SHIFT, VK_SHIFT, VK_CONTROL,                          /* FFE0 */
885     VK_CONTROL, VK_CAPITAL, 0, VK_MENU,
886     VK_MENU, VK_MENU, VK_MENU, 0, 0, 0, 0, 0,                   /* FFE8 */
887     0, 0, 0, 0, 0, 0, 0, 0,                                     /* FFF0 */
888     0, 0, 0, 0, 0, 0, 0, VK_DELETE                              /* FFF8 */
889 };
890
891 static const WORD nonchar_key_scan[256] =
892 {
893     /* unused */
894     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF00 */
895     /* special keys */
896     0x0E, 0x0F, 0x00, /*?*/ 0, 0x00, 0x1C, 0x00, 0x00,           /* FF08 */
897     0x00, 0x00, 0x00, 0x45, 0x46, 0x00, 0x00, 0x00,              /* FF10 */
898     0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,              /* FF18 */
899     /* unused */
900     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF20 */
901     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF28 */
902     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF30 */
903     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF38 */
904     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF40 */
905     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF48 */
906     /* cursor keys */
907     0x147, 0x14B, 0x148, 0x14D, 0x150, 0x149, 0x151, 0x14F,      /* FF50 */
908     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF58 */
909     /* misc keys */
910     /*?*/ 0, 0x137, /*?*/ 0, 0x152, 0x00, 0x00, 0x00, 0x00,      /* FF60 */
911     /*?*/ 0, /*?*/ 0, 0x38, 0x146, 0x00, 0x00, 0x00, 0x00,       /* FF68 */
912     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF70 */
913     /* keypad keys */
914     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x138, 0x145,            /* FF78 */
915     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FF80 */
916     0x00, 0x00, 0x00, 0x00, 0x00, 0x11C, 0x00, 0x00,             /* FF88 */
917     0x00, 0x00, 0x00, 0x00, 0x00, 0x47, 0x4B, 0x48,              /* FF90 */
918     0x4D, 0x50, 0x49, 0x51, 0x4F, 0x4C, 0x52, 0x53,              /* FF98 */
919     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFA0 */
920     0x00, 0x00, 0x37, 0x4E, /*?*/ 0, 0x4A, 0x53, 0x135,          /* FFA8 */
921     0x52, 0x4F, 0x50, 0x51, 0x4B, 0x4C, 0x4D, 0x47,              /* FFB0 */
922     0x48, 0x49, 0x00, 0x00, 0x00, 0x00,                          /* FFB8 */
923     /* function keys */
924     0x3B, 0x3C,
925     0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44,              /* FFC0 */
926     0x57, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFC8 */
927     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFD0 */
928     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFD8 */
929     /* modifier keys */
930     0x00, 0x2A, 0x36, 0x1D, 0x11D, 0x3A, 0x00, 0x38,             /* FFE0 */
931     0x138, 0x38, 0x138, 0x00, 0x00, 0x00, 0x00, 0x00,            /* FFE8 */
932     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,              /* FFF0 */
933     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x153              /* FFF8 */
934 };
935
936
937 /* Returns the Windows virtual key code associated with the X event <e> */
938 /* x11 lock must be held */
939 static WORD EVENT_event_to_vkey( XIC xic, XKeyEvent *e)
940 {
941     KeySym keysym = 0;
942
943     if (xic)
944         XmbLookupString(xic, e, NULL, 0, &keysym, NULL);
945     else
946         XLookupString(e, NULL, 0, &keysym, NULL);
947
948     if ((keysym >= 0xFFAE) && (keysym <= 0xFFB9) && (keysym != 0xFFAF)
949         && (e->state & NumLockMask))
950         /* Only the Keypad keys 0-9 and . send different keysyms
951          * depending on the NumLock state */
952         return nonchar_key_vkey[keysym & 0xFF];
953
954     TRACE_(key)("e->keycode = %x\n", e->keycode);
955
956     return keyc2vkey[e->keycode];
957 }
958
959 static BOOL NumState=FALSE, CapsState=FALSE;
960
961
962 /***********************************************************************
963  *           send_keyboard_input
964  */
965 static void send_keyboard_input( WORD wVk, WORD wScan, DWORD dwFlags, DWORD time )
966 {
967     INPUT input;
968
969     input.type             = WINE_INTERNAL_INPUT_KEYBOARD;
970     input.u.ki.wVk         = wVk;
971     input.u.ki.wScan       = wScan;
972     input.u.ki.dwFlags     = dwFlags;
973     input.u.ki.time        = time;
974     input.u.ki.dwExtraInfo = 0;
975     SendInput( 1, &input, sizeof(input) );
976 }
977
978
979 /**********************************************************************
980  *              KEYBOARD_GenerateMsg
981  *
982  * Generate Down+Up messages when NumLock or CapsLock is pressed.
983  *
984  * Convention : called with vkey only VK_NUMLOCK or VK_CAPITAL
985  *
986  */
987 static void KEYBOARD_GenerateMsg( WORD vkey, WORD scan, int Evtype, DWORD event_time )
988 {
989   BOOL * State = (vkey==VK_NUMLOCK? &NumState : &CapsState);
990   DWORD up, down;
991
992   if (*State) {
993     /* The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes,
994        don't treat it. It's from the same key press. Then the state goes to ON.
995        And from there, a 'release' event will switch off the toggle key. */
996     *State=FALSE;
997     TRACE("INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,pKeyStateTable[vkey]);
998   } else
999     {
1000         down = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0);
1001         up = (vkey==VK_NUMLOCK ? KEYEVENTF_EXTENDEDKEY : 0) | KEYEVENTF_KEYUP;
1002         if ( pKeyStateTable[vkey] & 0x1 ) /* it was ON */
1003           {
1004             if (Evtype!=KeyPress)
1005               {
1006                 TRACE("ON + KeyRelease => generating DOWN and UP messages.\n");
1007                 send_keyboard_input( vkey, scan, down, event_time );
1008                 send_keyboard_input( vkey, scan, up, event_time );
1009                 *State=FALSE;
1010                 pKeyStateTable[vkey] &= ~0x01; /* Toggle state to off. */
1011               }
1012           }
1013         else /* it was OFF */
1014           if (Evtype==KeyPress)
1015             {
1016               TRACE("OFF + Keypress => generating DOWN and UP messages.\n");
1017               send_keyboard_input( vkey, scan, down, event_time );
1018               send_keyboard_input( vkey, scan, up, event_time );
1019               *State=TRUE; /* Goes to intermediary state before going to ON */
1020               pKeyStateTable[vkey] |= 0x01; /* Toggle state to on. */
1021             }
1022     }
1023 }
1024
1025 /***********************************************************************
1026  *           KEYBOARD_UpdateOneState
1027  *
1028  * Updates internal state for <vkey>, depending on key <state> under X
1029  *
1030  */
1031 inline static void KEYBOARD_UpdateOneState ( int vkey, int state, DWORD time )
1032 {
1033     /* Do something if internal table state != X state for keycode */
1034     if (((pKeyStateTable[vkey] & 0x80)!=0) != state)
1035     {
1036         TRACE("Adjusting state for vkey %#.2x. State before %#.2x\n",
1037               vkey, pKeyStateTable[vkey]);
1038
1039         /* Fake key being pressed inside wine */
1040         send_keyboard_input( vkey, 0, state? 0 : KEYEVENTF_KEYUP, time );
1041
1042         TRACE("State after %#.2x\n",pKeyStateTable[vkey]);
1043     }
1044 }
1045
1046 /***********************************************************************
1047  *           X11DRV_KeymapNotify
1048  *
1049  * Update modifiers state (Ctrl, Alt, Shift) when window is activated.
1050  *
1051  * This handles the case where one uses Ctrl+... Alt+... or Shift+.. to switch
1052  * from wine to another application and back.
1053  * Toggle keys are handled in HandleEvent.
1054  */
1055 void X11DRV_KeymapNotify( HWND hwnd, XKeymapEvent *event )
1056 {
1057     int i, j, alt, control, shift;
1058     DWORD time = GetCurrentTime();
1059
1060     alt = control = shift = 0;
1061     for (i = 0; i < 32; i++)
1062     {
1063         if (!event->key_vector[i]) continue;
1064         for (j = 0; j < 8; j++)
1065         {
1066             if (!(event->key_vector[i] & (1<<j))) continue;
1067             switch(keyc2vkey[(i * 8) + j] & 0xff)
1068             {
1069             case VK_MENU:    alt = 1; break;
1070             case VK_CONTROL: control = 1; break;
1071             case VK_SHIFT:   shift = 1; break;
1072             }
1073         }
1074     }
1075     KEYBOARD_UpdateOneState( VK_MENU, alt, time );
1076     KEYBOARD_UpdateOneState( VK_CONTROL, control, time );
1077     KEYBOARD_UpdateOneState( VK_SHIFT, shift, time );
1078 }
1079
1080 /***********************************************************************
1081  *           X11DRV_KeyEvent
1082  *
1083  * Handle a X key event
1084  */
1085 void X11DRV_KeyEvent( HWND hwnd, XKeyEvent *event )
1086 {
1087     char Str[24];
1088     KeySym keysym = 0;
1089     WORD vkey = 0, bScan;
1090     DWORD dwFlags;
1091     int ascii_chars;
1092     XIC xic = X11DRV_get_ic( hwnd );
1093     DWORD event_time = event->time - X11DRV_server_startticks;
1094     Status status = 0;
1095
1096     TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
1097                 event->type, event->window, event->state, event->keycode);
1098
1099     wine_tsx11_lock();
1100     if (xic)
1101         ascii_chars = XmbLookupString(xic, event, Str, sizeof(Str), &keysym, &status);
1102     else
1103         ascii_chars = XLookupString(event, Str, sizeof(Str), &keysym, NULL);
1104     wine_tsx11_unlock();
1105
1106     /* Ignore some unwanted events */
1107     if ((keysym >= XK_ISO_Lock && keysym <= XK_ISO_Last_Group_Lock) ||
1108          keysym == XK_Mode_switch)
1109     {
1110         wine_tsx11_lock();
1111         TRACE("Ignoring %s keyboard event\n", XKeysymToString(keysym));
1112         wine_tsx11_unlock();
1113         return;
1114     }
1115
1116     TRACE_(key)("state = %X nbyte = %d, status 0x%x\n", event->state, ascii_chars, status);
1117
1118     if (status == XBufferOverflow)
1119         ERR("Buffer Overflow need %i!\n",ascii_chars);
1120
1121     if (status == XLookupChars)
1122     {
1123         X11DRV_XIMLookupChars( Str, ascii_chars );
1124         return;
1125     }
1126
1127     /* If XKB extensions are used, the state mask for AltGr will use the group
1128        index instead of the modifier mask. The group index is set in bits
1129        13-14 of the state field in the XKeyEvent structure. So if AltGr is
1130        pressed, look if the group index is different than 0. From XKB
1131        extension documentation, the group index for AltGr should be 2
1132        (event->state = 0x2000). It's probably better to not assume a
1133        predefined group index and find it dynamically
1134
1135        Ref: X Keyboard Extension: Library specification (section 14.1.1 and 17.1.1) */
1136     /* Save also all possible modifier states. */
1137     AltGrMask = event->state & (0x6000 | Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask);
1138
1139     Str[ascii_chars] = '\0';
1140     if (TRACE_ON(key)){
1141         char    *ksname;
1142
1143         wine_tsx11_lock();
1144         ksname = XKeysymToString(keysym);
1145         wine_tsx11_unlock();
1146         if (!ksname)
1147           ksname = "No Name";
1148         TRACE_(key)("%s : keysym=%lX (%s), # of chars=%d / 0x%02x / '%s'\n",
1149                     (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
1150                     keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
1151     }
1152
1153     wine_tsx11_lock();
1154     vkey = EVENT_event_to_vkey(xic,event);
1155     /* X returns keycode 0 for composed characters */
1156     if (!vkey && ascii_chars) vkey = VK_NONAME;
1157     wine_tsx11_unlock();
1158
1159     TRACE_(key)("keycode 0x%x converted to vkey 0x%x\n",
1160                 event->keycode, vkey);
1161
1162    if (vkey)
1163    {
1164     switch (vkey & 0xff)
1165     {
1166     case VK_NUMLOCK:
1167       KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, event->type, event_time );
1168       break;
1169     case VK_CAPITAL:
1170       TRACE("Caps Lock event. (type %d). State before : %#.2x\n",event->type,pKeyStateTable[vkey]);
1171       KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, event->type, event_time );
1172       TRACE("State after : %#.2x\n",pKeyStateTable[vkey]);
1173       break;
1174     default:
1175         /* Adjust the NUMLOCK state if it has been changed outside wine */
1176         if (!(pKeyStateTable[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
1177           {
1178             TRACE("Adjusting NumLock state.\n");
1179             KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyPress, event_time );
1180             KEYBOARD_GenerateMsg( VK_NUMLOCK, 0x45, KeyRelease, event_time );
1181           }
1182         /* Adjust the CAPSLOCK state if it has been changed outside wine */
1183         if (!(pKeyStateTable[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
1184           {
1185               TRACE("Adjusting Caps Lock state.\n");
1186             KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyPress, event_time );
1187             KEYBOARD_GenerateMsg( VK_CAPITAL, 0x3A, KeyRelease, event_time );
1188           }
1189         /* Not Num nor Caps : end of intermediary states for both. */
1190         NumState = FALSE;
1191         CapsState = FALSE;
1192
1193         bScan = keyc2scan[event->keycode] & 0xFF;
1194         TRACE_(key)("bScan = 0x%02x.\n", bScan);
1195
1196         dwFlags = 0;
1197         if ( event->type == KeyRelease ) dwFlags |= KEYEVENTF_KEYUP;
1198         if ( vkey & 0x100 )              dwFlags |= KEYEVENTF_EXTENDEDKEY;
1199
1200         send_keyboard_input( vkey & 0xff, bScan, dwFlags, event_time );
1201     }
1202    }
1203 }
1204
1205 /**********************************************************************
1206  *              X11DRV_KEYBOARD_DetectLayout
1207  *
1208  * Called from X11DRV_InitKeyboard
1209  *  This routine walks through the defined keyboard layouts and selects
1210  *  whichever matches most closely.
1211  * X11 lock must be held.
1212  */
1213 static void
1214 X11DRV_KEYBOARD_DetectLayout (void)
1215 {
1216   Display *display = thread_display();
1217   unsigned current, match, mismatch, seq;
1218   int score, keyc, i, key, pkey, ok, syms;
1219   KeySym keysym;
1220   const char (*lkey)[MAIN_LEN][4];
1221   unsigned max_seq = 0;
1222   int max_score = 0, ismatch = 0;
1223   char ckey[4] =
1224   {0, 0, 0, 0};
1225
1226   syms = keysyms_per_keycode;
1227   if (syms > 4) {
1228     WARN("%d keysyms per keycode not supported, set to 4\n", syms);
1229     syms = 4;
1230   }
1231   for (current = 0; main_key_tab[current].comment; current++) {
1232     TRACE("Attempting to match against \"%s\"\n", main_key_tab[current].comment);
1233     match = 0;
1234     mismatch = 0;
1235     score = 0;
1236     seq = 0;
1237     lkey = main_key_tab[current].key;
1238     pkey = -1;
1239     for (keyc = min_keycode; keyc <= max_keycode; keyc++) {
1240       /* get data for keycode from X server */
1241       for (i = 0; i < syms; i++) {
1242         keysym = XKeycodeToKeysym (display, keyc, i);
1243         /* Allow both one-byte and two-byte national keysyms */
1244         if ((keysym < 0x8000) && (keysym != ' '))
1245         {
1246 #ifdef HAVE_XKB
1247             if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[i], 1, NULL))
1248 #endif
1249             {
1250                 TRACE("XKB could not translate keysym %ld\n", keysym);
1251                 /* FIXME: query what keysym is used as Mode_switch, fill XKeyEvent
1252                  * with appropriate ShiftMask and Mode_switch, use XLookupString
1253                  * to get character in the local encoding.
1254                  */
1255                 ckey[i] = keysym & 0xFF;
1256             }
1257         }
1258         else {
1259           ckey[i] = KEYBOARD_MapDeadKeysym(keysym);
1260         }
1261       }
1262       if (ckey[0]) {
1263         /* search for a match in layout table */
1264         /* right now, we just find an absolute match for defined positions */
1265         /* (undefined positions are ignored, so if it's defined as "3#" in */
1266         /* the table, it's okay that the X server has "3#£", for example) */
1267         /* however, the score will be higher for longer matches */
1268         for (key = 0; key < MAIN_LEN; key++) {
1269           for (ok = 0, i = 0; (ok >= 0) && (i < syms); i++) {
1270             if ((*lkey)[key][i] && ((*lkey)[key][i] == ckey[i]))
1271               ok++;
1272             if ((*lkey)[key][i] && ((*lkey)[key][i] != ckey[i]))
1273               ok = -1;
1274           }
1275           if (ok > 0) {
1276             score += ok;
1277             break;
1278           }
1279         }
1280         /* count the matches and mismatches */
1281         if (ok > 0) {
1282           match++;
1283           /* and how much the keycode order matches */
1284           if (key > pkey) seq++;
1285           pkey = key;
1286         } else {
1287           /* print spaces instead of \0's */
1288           for (i = 0; i < sizeof(ckey); i++) if (!ckey[i]) ckey[i] = ' ';
1289           TRACE_(key)("mismatch for keysym 0x%04lX, keycode %d, got %c%c%c%c\n",
1290                       keysym, keyc, ckey[0], ckey[1], ckey[2], ckey[3]);
1291           mismatch++;
1292           score -= syms;
1293         }
1294       }
1295     }
1296     TRACE("matches=%d, mismatches=%d, seq=%d, score=%d\n",
1297            match, mismatch, seq, score);
1298     if ((score > max_score) ||
1299         ((score == max_score) && (seq > max_seq))) {
1300       /* best match so far */
1301       kbd_layout = current;
1302       max_score = score;
1303       max_seq = seq;
1304       ismatch = !mismatch;
1305     }
1306   }
1307   /* we're done, report results if necessary */
1308   if (!ismatch) {
1309     FIXME(
1310            "Your keyboard layout was not found!\n"
1311            "Using closest match instead (%s) for scancode mapping.\n"
1312            "Please define your layout in dlls/x11drv/keyboard.c and submit them\n"
1313            "to us for inclusion into future Wine releases.\n"
1314            "See the Wine User Guide, chapter \"Keyboard\" for more information.\n",
1315            main_key_tab[kbd_layout].comment);
1316   }
1317
1318   TRACE("detected layout is \"%s\"\n", main_key_tab[kbd_layout].comment);
1319 }
1320
1321 /**********************************************************************
1322  *              InitKeyboard (X11DRV.@)
1323  */
1324 void X11DRV_InitKeyboard( BYTE *key_state_table )
1325 {
1326     Display *display = thread_display();
1327     KeySym *ksp;
1328     XModifierKeymap *mmp;
1329     KeySym keysym;
1330     KeyCode *kcp;
1331     XKeyEvent e2;
1332     WORD scan, vkey, OEMvkey;
1333     int keyc, i, keyn, syms;
1334     char ckey[4]={0,0,0,0};
1335     const char (*lkey)[MAIN_LEN][4];
1336
1337     pKeyStateTable = key_state_table;
1338
1339     wine_tsx11_lock();
1340     XDisplayKeycodes(display, &min_keycode, &max_keycode);
1341     ksp = XGetKeyboardMapping(display, min_keycode,
1342                               max_keycode + 1 - min_keycode, &keysyms_per_keycode);
1343     /* We are only interested in keysyms_per_keycode.
1344        There is no need to hold a local copy of the keysyms table */
1345     XFree(ksp);
1346
1347     mmp = XGetModifierMapping(display);
1348     kcp = mmp->modifiermap;
1349     for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
1350     {
1351         int j;
1352
1353         for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
1354             if (*kcp)
1355             {
1356                 int k;
1357
1358                 for (k = 0; k < keysyms_per_keycode; k += 1)
1359                     if (XKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
1360                     {
1361                         NumLockMask = 1 << i;
1362                         TRACE_(key)("NumLockMask is %x\n", NumLockMask);
1363                     }
1364             }
1365     }
1366     XFreeModifiermap(mmp);
1367
1368     /* Detect the keyboard layout */
1369     X11DRV_KEYBOARD_DetectLayout();
1370     lkey = main_key_tab[kbd_layout].key;
1371     syms = (keysyms_per_keycode > 4) ? 4 : keysyms_per_keycode;
1372
1373     /* Now build two conversion arrays :
1374      * keycode -> vkey + scancode + extended
1375      * vkey + extended -> keycode */
1376
1377     e2.display = display;
1378     e2.state = 0;
1379
1380     OEMvkey = VK_OEM_7; /* next is available.  */
1381     for (keyc = min_keycode; keyc <= max_keycode; keyc++)
1382     {
1383         keysym = 0;
1384         e2.keycode = (KeyCode)keyc;
1385         XLookupString(&e2, NULL, 0, &keysym, NULL);
1386         vkey = 0; scan = 0;
1387         if (keysym)  /* otherwise, keycode not used */
1388         {
1389             if ((keysym >> 8) == 0xFF)         /* non-character key */
1390             {
1391                 vkey = nonchar_key_vkey[keysym & 0xff];
1392                 scan = nonchar_key_scan[keysym & 0xff];
1393                 /* set extended bit when necessary */
1394                 if (scan & 0x100) vkey |= 0x100;
1395             } else if (keysym == 0x20) {                 /* Spacebar */
1396                 vkey = VK_SPACE;
1397                 scan = 0x39;
1398             } else {
1399               /* we seem to need to search the layout-dependent scancodes */
1400               int maxlen=0,maxval=-1,ok;
1401               for (i=0; i<syms; i++) {
1402                 keysym = XKeycodeToKeysym(display, keyc, i);
1403                 if ((keysym<0x8000) && (keysym!=' '))
1404                 {
1405 #ifdef HAVE_XKB
1406                     if (!use_xkb || !XkbTranslateKeySym(display, &keysym, 0, &ckey[i], 1, NULL))
1407 #endif
1408                     {
1409                         /* FIXME: query what keysym is used as Mode_switch, fill XKeyEvent
1410                          * with appropriate ShiftMask and Mode_switch, use XLookupString
1411                          * to get character in the local encoding.
1412                          */
1413                         ckey[i] = keysym & 0xFF;
1414                     }
1415                 } else {
1416                   ckey[i] = KEYBOARD_MapDeadKeysym(keysym);
1417                 }
1418               }
1419               /* find key with longest match streak */
1420               for (keyn=0; keyn<MAIN_LEN; keyn++) {
1421                 for (ok=(*lkey)[keyn][i=0]; ok&&(i<4); i++)
1422                   if ((*lkey)[keyn][i] && (*lkey)[keyn][i]!=ckey[i]) ok=0;
1423                 if (ok||(i>maxlen)) {
1424                   maxlen=i; maxval=keyn;
1425                 }
1426                 if (ok) break;
1427               }
1428               if (maxval>=0) {
1429                 /* got it */
1430                 const WORD (*lscan)[MAIN_LEN] = main_key_tab[kbd_layout].scan;
1431                 const WORD (*lvkey)[MAIN_LEN] = main_key_tab[kbd_layout].vkey;
1432                 scan = (*lscan)[maxval];
1433                 vkey = (*lvkey)[maxval];
1434               }
1435             }
1436
1437             /* find a suitable layout-dependent VK code */
1438             /* (most Winelib apps ought to be able to work without layout tables!) */
1439             for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
1440             {
1441                 keysym = XLookupKeysym(&e2, i);
1442                 if ((keysym >= VK_0 && keysym <= VK_9)
1443                     || (keysym >= VK_A && keysym <= VK_Z)) {
1444                     vkey = keysym;
1445                 }
1446             }
1447
1448             for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
1449             {
1450                 keysym = XLookupKeysym(&e2, i);
1451                 switch (keysym)
1452                 {
1453                 case ';':             vkey = VK_OEM_1; break;
1454                 case '/':             vkey = VK_OEM_2; break;
1455                 case '`':             vkey = VK_OEM_3; break;
1456                 case '[':             vkey = VK_OEM_4; break;
1457                 case '\\':            vkey = VK_OEM_5; break;
1458                 case ']':             vkey = VK_OEM_6; break;
1459                 case '\'':            vkey = VK_OEM_7; break;
1460                 case ',':             vkey = VK_OEM_COMMA; break;
1461                 case '.':             vkey = VK_OEM_PERIOD; break;
1462                 case '-':             vkey = VK_OEM_MINUS; break;
1463                 case '+':             vkey = VK_OEM_PLUS; break;
1464                 }
1465             }
1466
1467             if (!vkey)
1468             {
1469                 /* Others keys: let's assign OEM virtual key codes in the allowed range,
1470                  * that is ([0xba,0xc0], [0xdb,0xe4], 0xe6 (given up) et [0xe9,0xf5]) */
1471                 switch (++OEMvkey)
1472                 {
1473                 case 0xc1 : OEMvkey=0xdb; break;
1474                 case 0xe5 : OEMvkey=0xe9; break;
1475                 case 0xf6 : OEMvkey=0xf5; WARN("No more OEM vkey available!\n");
1476                 }
1477
1478                 vkey = OEMvkey;
1479
1480                 if (TRACE_ON(keyboard))
1481                 {
1482                     TRACE("OEM specific virtual key %X assigned to keycode %X:\n",
1483                                      OEMvkey, e2.keycode);
1484                     TRACE("(");
1485                     for (i = 0; i < keysyms_per_keycode; i += 1)
1486                     {
1487                         char    *ksname;
1488
1489                         keysym = XLookupKeysym(&e2, i);
1490                         ksname = XKeysymToString(keysym);
1491                         if (!ksname)
1492                             ksname = "NoSymbol";
1493                         TRACE( "%lX (%s) ", keysym, ksname);
1494                     }
1495                     TRACE(")\n");
1496                 }
1497             }
1498         }
1499         keyc2vkey[e2.keycode] = vkey;
1500         keyc2scan[e2.keycode] = scan;
1501     } /* for */
1502
1503     /* If some keys still lack scancodes, assign some arbitrary ones to them now */
1504     for (scan = 0x60, keyc = min_keycode; keyc <= max_keycode; keyc++)
1505       if (keyc2vkey[keyc]&&!keyc2scan[keyc]) {
1506         char *ksname;
1507         keysym = XKeycodeToKeysym(display, keyc, 0);
1508         ksname = XKeysymToString(keysym);
1509         if (!ksname) ksname = "NoSymbol";
1510
1511         /* should make sure the scancode is unassigned here, but >=0x60 currently always is */
1512
1513         TRACE_(key)("assigning scancode %02x to unidentified keycode %02x (%s)\n",scan,keyc,ksname);
1514         keyc2scan[keyc]=scan++;
1515       }
1516
1517     /* Now store one keycode for each modifier. Used to simulate keypresses. */
1518     kcControl = XKeysymToKeycode(display, XK_Control_L);
1519     kcAlt = XKeysymToKeycode(display, XK_Alt_L);
1520     if (!kcAlt) kcAlt = XKeysymToKeycode(display, XK_Meta_L);
1521     kcShift = XKeysymToKeycode(display, XK_Shift_L);
1522     kcNumLock = XKeysymToKeycode(display, XK_Num_Lock);
1523     kcCapsLock = XKeysymToKeycode(display, XK_Caps_Lock);
1524     wine_tsx11_unlock();
1525 }
1526
1527
1528 /***********************************************************************
1529  *              GetKeyboardLayoutList (X11DRV.@)
1530  */
1531 UINT X11DRV_GetKeyboardLayoutList(INT size, HKL *hkl)
1532 {
1533     INT i;
1534
1535     TRACE("%d, %p\n", size, hkl);
1536
1537     if (!size)
1538     {
1539         size = 4096; /* hope we will never have that many */
1540         hkl = NULL;
1541     }
1542
1543     for (i = 0; main_key_tab[i].comment && (i < size); i++)
1544     {
1545         if (hkl)
1546             hkl[i] = (HKL)main_key_tab[i].lcid;
1547     }
1548     return i;
1549 }
1550
1551
1552 /***********************************************************************
1553  *              GetKeyboardLayout (X11DRV.@)
1554  */
1555 HKL X11DRV_GetKeyboardLayout(DWORD dwThreadid)
1556 {
1557     DWORD layout;
1558     LANGID langid;
1559
1560     if (dwThreadid)
1561         FIXME("couldn't return keyboard layout for thread %04lx\n", dwThreadid);
1562
1563     layout = main_key_tab[kbd_layout].lcid;
1564     /* 
1565      * Microsoft Office expects this value to be something specific
1566      * for Japanese and Korean Windows with an IME the value is 0xe001
1567      * We should probibly check to see if an IME exists and if so then
1568      * set this word properly.
1569      */
1570     langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
1571     if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
1572         layout = 0xe001 << 16; /* FIXME */
1573
1574     return (HKL)layout;
1575 }
1576
1577
1578 /***********************************************************************
1579  *              GetKeyboardLayoutName (X11DRV.@)
1580  */
1581 BOOL X11DRV_GetKeyboardLayoutName(LPWSTR name)
1582 {
1583     static const WCHAR formatW[] = {'%','0','8','l','x',0};
1584     DWORD layout;
1585     LANGID langid;
1586
1587     layout = main_key_tab[kbd_layout].lcid;
1588     /* see comment above */
1589     langid = PRIMARYLANGID(LANGIDFROMLCID(layout));
1590     if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
1591         layout |= 0xe001 << 16; /* FIXME */
1592
1593     sprintfW(name, formatW, layout);
1594     TRACE("returning %s\n", debugstr_w(name));
1595     return TRUE;
1596 }
1597
1598
1599 /***********************************************************************
1600  *              LoadKeyboardLayout (X11DRV.@)
1601  */
1602 HKL X11DRV_LoadKeyboardLayout(LPCWSTR name, UINT flags)
1603 {
1604     FIXME("%s, %04x: stub!\n", debugstr_w(name), flags);
1605     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1606     return 0;
1607 }
1608
1609
1610 /***********************************************************************
1611  *              UnloadKeyboardLayout (X11DRV.@)
1612  */
1613 BOOL X11DRV_UnloadKeyboardLayout(HKL hkl)
1614 {
1615     FIXME("%p: stub!\n", hkl);
1616     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1617     return FALSE;
1618 }
1619
1620
1621 /***********************************************************************
1622  *              ActivateKeyboardLayout (X11DRV.@)
1623  */
1624 HKL X11DRV_ActivateKeyboardLayout(HKL hkl, UINT flags)
1625 {
1626     FIXME("%p, %04x: stub!\n", hkl, flags);
1627     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1628     return 0;
1629 }
1630
1631
1632 /***********************************************************************
1633  *           X11DRV_MappingNotify
1634  */
1635 void X11DRV_MappingNotify( XMappingEvent *event )
1636 {
1637     HWND hwnd;
1638
1639     wine_tsx11_lock();
1640     XRefreshKeyboardMapping(event);
1641     wine_tsx11_unlock();
1642     X11DRV_InitKeyboard( pKeyStateTable );
1643
1644     hwnd = GetFocus();
1645     if (!hwnd) hwnd = GetActiveWindow();
1646     PostMessageW(hwnd, WM_INPUTLANGCHANGEREQUEST,
1647                  0 /*FIXME*/, (LPARAM)X11DRV_GetKeyboardLayout(0));
1648 }
1649
1650
1651 /***********************************************************************
1652  *              VkKeyScanEx (X11DRV.@)
1653  *
1654  * Note: Windows ignores HKL parameter and uses current active layout instead
1655  */
1656 SHORT X11DRV_VkKeyScanEx(WCHAR wChar, HKL hkl)
1657 {
1658     Display *display = thread_display();
1659     KeyCode keycode;
1660     KeySym keysym;
1661     int i, index;
1662     CHAR cChar;
1663     SHORT ret;
1664
1665     if (!WideCharToMultiByte(CP_UNIXCP, 0, &wChar, 1, &cChar, 1, NULL, NULL))
1666     {
1667         WARN("no translation from unicode to CP_UNIXCP for 0x%02x\n", wChar);
1668         return -1;
1669     }
1670
1671     TRACE("wChar 0x%02x -> cChar '%c'\n", wChar, cChar);
1672
1673     /* char->keysym (same for ANSI chars) */
1674     keysym = (unsigned char)cChar; /* (!) cChar is signed */
1675     if (keysym <= 27) keysym += 0xFF00; /* special chars : return, backspace... */
1676
1677     wine_tsx11_lock();
1678     keycode = XKeysymToKeycode(display, keysym);  /* keysym -> keycode */
1679     if (!keycode)
1680     { /* It didn't work ... let's try with deadchar code. */
1681         TRACE("retrying with | 0xFE00\n");
1682         keycode = XKeysymToKeycode(display, keysym | 0xFE00);
1683     }
1684     wine_tsx11_unlock();
1685
1686     TRACE("'%c'(%#lx, %lu): got keycode %#.2x (%d)\n",
1687             cChar, keysym, keysym, keycode, keycode);
1688
1689     /* keycode -> (keyc2vkey) vkey */
1690     ret = keyc2vkey[keycode];
1691
1692     if (!keycode || !ret)
1693     {
1694         TRACE("keycode for '%c' not found, returning -1\n", cChar);
1695         return -1;
1696     }
1697
1698     index = -1;
1699     wine_tsx11_lock();
1700     for (i = 0; i < 4; i++) /* find shift state */
1701     {
1702         if (XKeycodeToKeysym(display, keycode, i) == keysym)
1703         {
1704             index = i;
1705             break;
1706         }
1707     }
1708     wine_tsx11_unlock();
1709
1710     switch (index)
1711     {
1712         default:
1713         case -1:
1714             WARN("Keysym %lx not found while parsing the keycode table\n", keysym);
1715             return -1;
1716
1717         case 0: break;
1718         case 1: ret += 0x0100; break;
1719         case 2: ret += 0x0600; break;
1720         case 3: ret += 0x0700; break;
1721     }
1722     /*
1723       index : 0     adds 0x0000
1724       index : 1     adds 0x0100 (shift)
1725       index : ?     adds 0x0200 (ctrl)
1726       index : 2     adds 0x0600 (ctrl+alt)
1727       index : 3     adds 0x0700 (ctrl+alt+shift)
1728      */
1729
1730     TRACE(" ... returning %#.2x\n", ret);
1731     return ret;
1732 }
1733
1734 /***********************************************************************
1735  *              MapVirtualKeyEx (X11DRV.@)
1736  */
1737 UINT X11DRV_MapVirtualKeyEx(UINT wCode, UINT wMapType, HKL hkl)
1738 {
1739     Display *display = thread_display();
1740
1741 #define returnMVK(value) { TRACE("returning 0x%x.\n",value); return value; }
1742
1743     TRACE("wCode=0x%x, wMapType=%d, hkl %p\n", wCode, wMapType, hkl);
1744     if (hkl != X11DRV_GetKeyboardLayout(0))
1745         FIXME("keyboard layout %p is not supported\n", hkl);
1746
1747         switch(wMapType) {
1748                 case 0: { /* vkey-code to scan-code */
1749                         /* let's do vkey -> keycode -> scan */
1750                         int keyc;
1751                         for (keyc=min_keycode; keyc<=max_keycode; keyc++)
1752                                 if ((keyc2vkey[keyc] & 0xFF) == wCode)
1753                                         returnMVK (keyc2scan[keyc] & 0xFF);
1754                         TRACE("returning no scan-code.\n");
1755                         return 0; }
1756
1757                 case 1: { /* scan-code to vkey-code */
1758                         /* let's do scan -> keycode -> vkey */
1759                         int keyc;
1760                         for (keyc=min_keycode; keyc<=max_keycode; keyc++)
1761                                 if ((keyc2scan[keyc] & 0xFF) == (wCode & 0xFF))
1762                                         returnMVK (keyc2vkey[keyc] & 0xFF);
1763                         TRACE("returning no vkey-code.\n");
1764                         return 0; }
1765
1766                 case 2: { /* vkey-code to unshifted ANSI code */
1767                         /* we still don't know what "unshifted" means. in windows VK_W (0x57)
1768                          * returns 0x57, which is upercase 'W'. So we have to return the uppercase
1769                          * key.. Looks like something is wrong with the MS docs?
1770                          * This is only true for letters, for example VK_0 returns '0' not ')'.
1771                          * - hence we use the lock mask to ensure this happens.
1772                          */
1773                         /* let's do vkey -> keycode -> (XLookupString) ansi char */
1774                         XKeyEvent e;
1775                         KeySym keysym;
1776                         int keyc;
1777                         char s[2];
1778                         e.display = display;
1779
1780                         e.state = LockMask;
1781                         /* LockMask should behave exactly like caps lock - upercase
1782                          * the letter keys and thats about it. */
1783
1784                         wine_tsx11_lock();
1785
1786                         e.keycode = 0;
1787                         /* We exit on the first keycode found, to speed up the thing. */
1788                         for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
1789                         { /* Find a keycode that could have generated this virtual key */
1790                             if  ((keyc2vkey[keyc] & 0xFF) == wCode)
1791                             { /* We filter the extended bit, we don't know it */
1792                                 e.keycode = keyc; /* Store it temporarily */
1793                                 if ((EVENT_event_to_vkey(0,&e) & 0xFF) != wCode) {
1794                                     e.keycode = 0; /* Wrong one (ex: because of the NumLock
1795                                          state), so set it to 0, we'll find another one */
1796                                 }
1797                             }
1798                         }
1799
1800                         if ((wCode>=VK_NUMPAD0) && (wCode<=VK_NUMPAD9))
1801                           e.keycode = XKeysymToKeycode(e.display, wCode-VK_NUMPAD0+XK_KP_0);
1802
1803                         if (wCode==VK_DECIMAL)
1804                           e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
1805
1806                         if (!e.keycode)
1807                         {
1808                           WARN("Unknown virtual key %X !!! \n", wCode);
1809                           wine_tsx11_unlock();
1810                           return 0; /* whatever */
1811                         }
1812                         TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
1813
1814                         if (XLookupString(&e, s, 2, &keysym, NULL))
1815                         {
1816                             wine_tsx11_unlock();
1817                             returnMVK (*s);
1818                         }
1819
1820                         TRACE("returning no ANSI.\n");
1821                         wine_tsx11_unlock();
1822                         return 0;
1823                         }
1824
1825                 case 3:   /* **NT only** scan-code to vkey-code but distinguish between  */
1826                           /*             left and right  */
1827                           FIXME(" stub for NT\n");
1828                           return 0;
1829
1830                 default: /* reserved */
1831                         WARN("Unknown wMapType %d !\n", wMapType);
1832                         return 0;
1833         }
1834         return 0;
1835 }
1836
1837 /***********************************************************************
1838  *              GetKeyNameText (X11DRV.@)
1839  */
1840 INT X11DRV_GetKeyNameText(LONG lParam, LPWSTR lpBuffer, INT nSize)
1841 {
1842   int vkey, ansi, scanCode;
1843   KeyCode keyc;
1844   int keyi;
1845   KeySym keys;
1846   char *name;
1847
1848   scanCode = lParam >> 16;
1849   scanCode &= 0x1ff;  /* keep "extended-key" flag with code */
1850
1851   /* FIXME: should use MVK type 3 (NT version that distinguishes right and left */
1852   vkey = X11DRV_MapVirtualKeyEx(scanCode, 1, X11DRV_GetKeyboardLayout(0));
1853
1854   /*  handle "don't care" bit (0x02000000) */
1855   if (!(lParam & 0x02000000)) {
1856     switch (vkey) {
1857          case VK_LSHIFT:
1858          case VK_RSHIFT:
1859                           vkey = VK_SHIFT;
1860                           break;
1861        case VK_LCONTROL:
1862        case VK_RCONTROL:
1863                           vkey = VK_CONTROL;
1864                           break;
1865           case VK_LMENU:
1866           case VK_RMENU:
1867                           vkey = VK_MENU;
1868                           break;
1869                default:
1870                           break;
1871     }
1872   }
1873
1874   ansi = X11DRV_MapVirtualKeyEx(vkey, 2, X11DRV_GetKeyboardLayout(0));
1875   TRACE("scan 0x%04x, vkey 0x%04x, ANSI 0x%04x\n", scanCode, vkey, ansi);
1876
1877   /* first get the name of the "regular" keys which is the Upper case
1878      value of the keycap imprint.                                     */
1879   if ( ((ansi >= 0x21) && (ansi <= 0x7e)) &&
1880        (scanCode != 0x137) &&   /* PrtScn   */
1881        (scanCode != 0x135) &&   /* numpad / */
1882        (scanCode != 0x37 ) &&   /* numpad * */
1883        (scanCode != 0x4a ) &&   /* numpad - */
1884        (scanCode != 0x4e ) )    /* numpad + */
1885       {
1886         if ((nSize >= 2) && lpBuffer)
1887         {
1888           *lpBuffer = toupperW((WCHAR)ansi);
1889           *(lpBuffer+1) = 0;
1890           return 1;
1891         }
1892      else
1893         return 0;
1894   }
1895
1896   /* FIXME: horrible hack to fix function keys. Windows reports scancode
1897             without "extended-key" flag. However Wine generates scancode
1898             *with* "extended-key" flag. Seems to occur *only* for the
1899             function keys. Soooo.. We will leave the table alone and
1900             fudge the lookup here till the other part is found and fixed!!! */
1901
1902   if ( ((scanCode >= 0x13b) && (scanCode <= 0x144)) ||
1903        (scanCode == 0x157) || (scanCode == 0x158))
1904     scanCode &= 0xff;   /* remove "extended-key" flag for Fx keys */
1905
1906   /* let's do scancode -> keycode -> keysym -> String */
1907
1908   for (keyi=min_keycode; keyi<=max_keycode; keyi++)
1909       if ((keyc2scan[keyi]) == scanCode)
1910          break;
1911   if (keyi <= max_keycode)
1912   {
1913       wine_tsx11_lock();
1914       keyc = (KeyCode) keyi;
1915       keys = XKeycodeToKeysym(thread_display(), keyc, 0);
1916       name = XKeysymToString(keys);
1917       wine_tsx11_unlock();
1918       TRACE("found scan=%04x keyc=%04x keysym=%04x string=%s\n",
1919             scanCode, keyc, (int)keys, name);
1920       if (lpBuffer && nSize && name)
1921       {
1922           MultiByteToWideChar(CP_UNIXCP, 0, name, -1, lpBuffer, nSize);
1923           lpBuffer[nSize - 1] = 0;
1924           return 1;
1925       }
1926   }
1927
1928   /* Finally issue FIXME for unknown keys   */
1929
1930   FIXME("(%08lx,%p,%d): unsupported key, vkey=%04x, ansi=%04x\n",lParam,lpBuffer,nSize,vkey,ansi);
1931   if (lpBuffer && nSize)
1932     *lpBuffer = 0;
1933   return 0;
1934 }
1935
1936 /***********************************************************************
1937  *              X11DRV_KEYBOARD_MapDeadKeysym
1938  */
1939 static char KEYBOARD_MapDeadKeysym(KeySym keysym)
1940 {
1941         switch (keysym)
1942             {
1943         /* symbolic ASCII is the same as defined in rfc1345 */
1944 #ifdef XK_dead_tilde
1945             case XK_dead_tilde :
1946 #endif
1947             case 0x1000FE7E : /* Xfree's XK_Dtilde */
1948                 return '~';     /* '? */
1949 #ifdef XK_dead_acute
1950             case XK_dead_acute :
1951 #endif
1952             case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
1953                 return 0xb4;    /* '' */
1954 #ifdef XK_dead_circumflex
1955             case XK_dead_circumflex:
1956 #endif
1957             case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
1958                 return '^';     /* '> */
1959 #ifdef XK_dead_grave
1960             case XK_dead_grave :
1961 #endif
1962             case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
1963                 return '`';     /* '! */
1964 #ifdef XK_dead_diaeresis
1965             case XK_dead_diaeresis :
1966 #endif
1967             case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
1968                 return 0xa8;    /* ': */
1969 #ifdef XK_dead_cedilla
1970             case XK_dead_cedilla :
1971                 return 0xb8;    /* ', */
1972 #endif
1973 #ifdef XK_dead_macron
1974             case XK_dead_macron :
1975                 return '-';     /* 'm isn't defined on iso-8859-x */
1976 #endif
1977 #ifdef XK_dead_breve
1978             case XK_dead_breve :
1979                 return 0xa2;    /* '( */
1980 #endif
1981 #ifdef XK_dead_abovedot
1982             case XK_dead_abovedot :
1983                 return 0xff;    /* '. */
1984 #endif
1985 #ifdef XK_dead_abovering
1986             case XK_dead_abovering :
1987                 return '0';     /* '0 isn't defined on iso-8859-x */
1988 #endif
1989 #ifdef XK_dead_doubleacute
1990             case XK_dead_doubleacute :
1991                 return 0xbd;    /* '" */
1992 #endif
1993 #ifdef XK_dead_caron
1994             case XK_dead_caron :
1995                 return 0xb7;    /* '< */
1996 #endif
1997 #ifdef XK_dead_ogonek
1998             case XK_dead_ogonek :
1999                 return 0xb2;    /* '; */
2000 #endif
2001 /* FIXME: I don't know this three.
2002             case XK_dead_iota :
2003                 return 'i';
2004             case XK_dead_voiced_sound :
2005                 return 'v';
2006             case XK_dead_semivoiced_sound :
2007                 return 's';
2008 */
2009             }
2010         TRACE("no character for dead keysym 0x%08lx\n",keysym);
2011         return 0;
2012 }
2013
2014 /***********************************************************************
2015  *              ToUnicodeEx (X11DRV.@)
2016  *
2017  * The ToUnicode function translates the specified virtual-key code and keyboard
2018  * state to the corresponding Windows character or characters.
2019  *
2020  * If the specified key is a dead key, the return value is negative. Otherwise,
2021  * it is one of the following values:
2022  * Value        Meaning
2023  * 0    The specified virtual key has no translation for the current state of the keyboard.
2024  * 1    One Windows character was copied to the buffer.
2025  * 2    Two characters were copied to the buffer. This usually happens when a
2026  *      dead-key character (accent or diacritic) stored in the keyboard layout cannot
2027  *      be composed with the specified virtual key to form a single character.
2028  *
2029  * FIXME : should do the above (return 2 for non matching deadchar+char combinations)
2030  *
2031  */
2032 INT X11DRV_ToUnicodeEx(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
2033                      LPWSTR bufW, int bufW_size, UINT flags, HKL hkl)
2034 {
2035     Display *display = thread_display();
2036     XKeyEvent e;
2037     KeySym keysym = 0;
2038     INT ret;
2039     int keyc;
2040     char lpChar[10];
2041     HWND focus;
2042     XIC xic;
2043
2044     if (scanCode & 0x8000)
2045     {
2046         TRACE("Key UP, doing nothing\n" );
2047         return 0;
2048     }
2049
2050     if (hkl != X11DRV_GetKeyboardLayout(0))
2051         FIXME("keyboard layout %p is not supported\n", hkl);
2052
2053     e.display = display;
2054     e.keycode = 0;
2055     e.state = 0;
2056     e.type = KeyPress;
2057
2058     focus = GetFocus();
2059     if (focus) focus = GetAncestor( focus, GA_ROOT );
2060     if (!focus) focus = GetActiveWindow();
2061     e.window = X11DRV_get_whole_window( focus );
2062     xic = X11DRV_get_ic( focus );
2063
2064     if (lpKeyState[VK_SHIFT] & 0x80)
2065     {
2066         TRACE("ShiftMask = %04x\n", ShiftMask);
2067         e.state |= ShiftMask;
2068     }
2069     if (lpKeyState[VK_CAPITAL] & 0x01)
2070     {
2071         TRACE("LockMask = %04x\n", LockMask);
2072         e.state |= LockMask;
2073     }
2074     if (lpKeyState[VK_CONTROL] & 0x80)
2075     {
2076         TRACE("ControlMask = %04x\n", ControlMask);
2077         e.state |= ControlMask;
2078     }
2079     if (lpKeyState[VK_NUMLOCK] & 0x01)
2080     {
2081         TRACE("NumLockMask = %04x\n", NumLockMask);
2082         e.state |= NumLockMask;
2083     }
2084
2085     /* Restore saved AltGr state */
2086     TRACE("AltGrMask = %04x\n", AltGrMask);
2087     e.state |= AltGrMask;
2088
2089     TRACE_(key)("(%04X, %04X) : faked state = 0x%04x\n",
2090                 virtKey, scanCode, e.state);
2091     wine_tsx11_lock();
2092     /* We exit on the first keycode found, to speed up the thing. */
2093     for (keyc=min_keycode; (keyc<=max_keycode) && (!e.keycode) ; keyc++)
2094       { /* Find a keycode that could have generated this virtual key */
2095           if  ((keyc2vkey[keyc] & 0xFF) == virtKey)
2096           { /* We filter the extended bit, we don't know it */
2097               e.keycode = keyc; /* Store it temporarily */
2098               if ((EVENT_event_to_vkey(xic,&e) & 0xFF) != virtKey) {
2099                   e.keycode = 0; /* Wrong one (ex: because of the NumLock
2100                          state), so set it to 0, we'll find another one */
2101               }
2102           }
2103       }
2104
2105     if ((virtKey>=VK_NUMPAD0) && (virtKey<=VK_NUMPAD9))
2106         e.keycode = XKeysymToKeycode(e.display, virtKey-VK_NUMPAD0+XK_KP_0);
2107
2108     if (virtKey==VK_DECIMAL)
2109         e.keycode = XKeysymToKeycode(e.display, XK_KP_Decimal);
2110
2111     if (!e.keycode && virtKey != VK_NONAME)
2112       {
2113         WARN("Unknown virtual key %X !!! \n",virtKey);
2114         wine_tsx11_unlock();
2115         return virtKey; /* whatever */
2116       }
2117     else TRACE("Found keycode %d (0x%2X)\n",e.keycode,e.keycode);
2118
2119     TRACE_(key)("type %d, window %lx, state 0x%04x, keycode 0x%04x\n",
2120                 e.type, e.window, e.state, e.keycode);
2121
2122     if (xic)
2123         ret = XmbLookupString(xic, &e, lpChar, sizeof(lpChar), &keysym, NULL);
2124     else
2125         ret = XLookupString(&e, lpChar, sizeof(lpChar), &keysym, NULL);
2126     wine_tsx11_unlock();
2127
2128     if (ret == 0)
2129         {
2130         BYTE dead_char;
2131
2132         /* An ugly hack for EuroSign: X can't translate it to a character
2133            for some locales. */
2134         if (keysym == XK_EuroSign)
2135         {
2136             bufW[0] = 0x20AC;
2137             ret = 1;
2138             goto found;
2139         }
2140
2141         dead_char = KEYBOARD_MapDeadKeysym(keysym);
2142         if (dead_char)
2143             {
2144             MultiByteToWideChar(CP_UNIXCP, 0, &dead_char, 1, bufW, bufW_size);
2145             ret = -1;
2146             }
2147         else
2148             {
2149             char        *ksname;
2150
2151             wine_tsx11_lock();
2152             ksname = XKeysymToString(keysym);
2153             wine_tsx11_unlock();
2154             if (!ksname)
2155                 ksname = "No Name";
2156             if ((keysym >> 8) != 0xff)
2157                 {
2158                 ERR("Please report: no char for keysym %04lX (%s) :\n",
2159                     keysym, ksname);
2160                 ERR("(virtKey=%X,scanCode=%X,keycode=%X,state=%X)\n",
2161                     virtKey, scanCode, e.keycode, e.state);
2162                 }
2163             }
2164         }
2165     else {  /* ret != 0 */
2166         /* We have a special case to handle : Shift + arrow, shift + home, ...
2167            X returns a char for it, but Windows doesn't. Let's eat it. */
2168         if (!(e.state & NumLockMask)  /* NumLock is off */
2169             && (e.state & ShiftMask) /* Shift is pressed */
2170             && (keysym>=XK_KP_0) && (keysym<=XK_KP_9))
2171         {
2172             lpChar[0] = 0;
2173             ret = 0;
2174         }
2175
2176         /* more areas where X returns characters but Windows does not
2177            CTRL + number or CTRL + symbol */
2178         if (e.state & ControlMask)
2179         {
2180             if (((keysym>=33) && (keysym < 'A')) ||
2181                 ((keysym > 'Z') && (keysym < 'a')))
2182             {
2183                 lpChar[0] = 0;
2184                 ret = 0;
2185             }
2186         }
2187
2188         /* We have another special case for delete key (XK_Delete) on an
2189          extended keyboard. X returns a char for it, but Windows doesn't */
2190         if (keysym == XK_Delete)
2191         {
2192             lpChar[0] = 0;
2193             ret = 0;
2194         }
2195         else if((lpKeyState[VK_SHIFT] & 0x80) /* Shift is pressed */
2196                 && (keysym == XK_KP_Decimal))
2197         {
2198             lpChar[0] = 0;
2199             ret = 0;
2200         }
2201
2202         /* perform translation to unicode */
2203         if(ret)
2204         {
2205             TRACE_(key)("Translating char 0x%02x to unicode\n", *(BYTE *)lpChar);
2206             ret = MultiByteToWideChar(CP_UNIXCP, 0, lpChar, ret, bufW, bufW_size);
2207         }
2208     }
2209
2210 found:
2211     TRACE_(key)("ToUnicode about to return %d with char %x %s\n",
2212                 ret, (ret && bufW) ? bufW[0] : 0, bufW ? "" : "(no buffer)");
2213     return ret;
2214 }
2215
2216 /***********************************************************************
2217  *              Beep (X11DRV.@)
2218  */
2219 void X11DRV_Beep(void)
2220 {
2221     wine_tsx11_lock();
2222     XBell(thread_display(), 0);
2223     wine_tsx11_unlock();
2224 }