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
14 #ifndef X_DISPLAY_MISSING
16 #include <X11/Xatom.h>
17 #include <X11/keysym.h>
19 #include "ts_xresource.h"
29 extern LPBYTE pKeyStateTable
;
31 int min_keycode
, max_keycode
, keysyms_per_keycode
;
32 WORD keyc2vkey
[256], keyc2scan
[256];
34 static int NumLockMask
, AltGrMask
; /* mask in the XKeyEvent state */
35 static int kcControl
, kcAlt
, kcShift
, kcNumLock
, kcCapsLock
; /* keycodes */
37 /* Keyboard translation tables */
39 static const int main_key_scan
[MAIN_LEN
] =
41 /* this is my (102-key) keyboard layout, sorry if it doesn't quite match yours */
42 0x29,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,
43 0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,
44 0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x2B,
45 0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,
46 0x56 /* the 102nd key (actually to the right of l-shift) */
49 /*** DEFINE YOUR NEW LANGUAGE-SPECIFIC MAPPINGS BELOW, SEE EXISTING TABLES */
51 /* the VK mappings for the main keyboard will be auto-assigned as before,
52 so what we have here is just the character tables */
53 /* order: Normal, Shift, AltGr, Shift-AltGr */
54 /* We recommend you write just what is guaranteed to be correct (i.e. what's
55 written on the keycaps), not the bunch of special characters behind AltGr
56 and Shift-AltGr if it can vary among different X servers */
57 /* Remember that your 102nd key (to the right of l-shift) should be on a
58 separate line, see existing tables */
59 /* If Wine fails to match your new table, use -debugmsg +key to find out why */
60 /* Remember to also add your new table to the layout index table far below! */
62 /*** United States keyboard layout (mostly contributed by Uwe Bonnes) */
63 static const char main_key_US
[MAIN_LEN
][4] =
65 "`~","1!","2@","3#","4$","5%","6^","7&","8*","9(","0)","-_","=+",
66 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
67 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'\"","\\|",
68 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?"
71 /*** British keyboard layout */
72 static const char main_key_UK
[MAIN_LEN
][4] =
74 "`","1!","2\"","3£","4$","5%","6^","7&","8*","9(","0)","-_","=+",
75 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","[{","]}",
76 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:","'@","#~",
77 "zZ","xX","cC","vV","bB","nN","mM",",<",".>","/?",
81 /*** French keyboard layout (contributed by Eric Pouech) */
82 static const char main_key_FR
[MAIN_LEN
][4] =
84 "²","&1","é2~","\"3#","'4{","(5[","-6|","è7","_8\\","ç9^±","à0@",")°]","=+}",
85 "aA","zZ","eE","rR","tT","yY","uU","iI","oO","pP","","$£¤",
86 "qQ","sSß","dD","fF","gG","hH","jJ","kK","lL","mM","ù%","*µ",
87 "wW","xX","cC","vV","bB","nN",",?",";.",":/","!§",
91 /*** German keyboard layout (contributed by Ulrich Weigand) */
92 static const char main_key_DE
[MAIN_LEN
][4] =
94 "^°","1!","2\"","3§","4$","5%","6&","7/{","8([","9)]","0=}","ß?\\","'",
95 "qQ","wW","eE","rR","tT","zZ","uU","iI","oO","pP","üÜ","+*~",
96 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","öÖ","äÄ","#´",
97 "yY","xX","cC","vV","bB","nN","mM",",;",".:","-_",
101 /*** Norwegian keyboard layout (contributed by Ove Kåven) */
102 static const char main_key_NO
[MAIN_LEN
][4] =
104 "|§","1!","2\"@","3#£","4¤$","5%","6&","7/{","8([","9)]","0=}","+?","\\`´",
105 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^~",
106 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","øØ","æÆ","'*",
107 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
111 /*** Danish keyboard layout (contributed by Bertho Stultiens) */
112 static const char main_key_DA
[MAIN_LEN
][4] =
114 "½§","1!","2\"@","3#£","4¤$","5%","6&","7/{","8([","9)]","0=}","+?","´|",
115 "qQ","wW","eE","rR","tT","yY","uU","iI","oO","pP","åÅ","¨^~",
116 "aA","sS","dD","fF","gG","hH","jJ","kK","lL","æÆ","øØ","'*",
117 "zZ","xX","cC","vV","bB","nN","mM",",;",".:","-_",
121 /*** Canadian French keyboard layout */
122 static const char main_key_CF
[MAIN_LEN
][4] =
124 "#|\\","1!±","2\"@","3/£","4$¢","5%¤","6?¬","7&¦","8*²","9(³","0)³","-_½","=+¾",
125 "qQ","wW","eE","rR","tT","yY","uU","iI","oO§","pP¶","^^[","¨]",
126 "aA","sS","dD","fF","gG","hH","jJ","kK","lL",";:~","``{","<>}",
127 "zZ","xX","cC","vV","bB","nN","mM",",'_",".","éÉ'"
130 /*** Layout table. Add your keyboard mappings to this list */
132 WORD lang
, ansi_codepage
, oem_codepage
;
133 const char (*key
)[MAIN_LEN
][4];
135 {MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_US
), 1252, 437, &main_key_US
},
136 {MAKELANGID(LANG_ENGLISH
,SUBLANG_ENGLISH_UK
), 1252, 850, &main_key_UK
},
137 {MAKELANGID(LANG_FRENCH
,SUBLANG_DEFAULT
), 1252, 850, &main_key_FR
},
138 {MAKELANGID(LANG_GERMAN
,SUBLANG_DEFAULT
), 1252, 850, &main_key_DE
},
139 {MAKELANGID(LANG_NORWEGIAN
,SUBLANG_DEFAULT
), 1252, 865, &main_key_NO
},
140 {MAKELANGID(LANG_DANISH
,SUBLANG_DEFAULT
), 1252, 865, &main_key_DA
},
141 {MAKELANGID(LANG_FRENCH
,SUBLANG_FRENCH_CANADIAN
),1252,863,&main_key_CF
},
145 static unsigned kbd_layout
=0; /* index into above table of layouts */
147 /* maybe more of these scancodes should be extended? */
148 /* extended must be set for ALT_R, CTRL_R,
149 INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
150 keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
151 /* FIXME should we set extended bit for NumLock ? My
152 * Windows does ... DF */
153 static const int special_key_vkey
[] =
155 VK_BACK
, VK_TAB
, 0, VK_CLEAR
, 0, VK_RETURN
, 0, 0, /* FF08 */
156 0, 0, 0, VK_PAUSE
, VK_SCROLL
, 0, 0, 0, /* FF10 */
157 0, 0, 0, VK_ESCAPE
/* FF18 */
159 static const int special_key_scan
[] =
161 0x0E, 0x0F, 0, /*?*/ 0, 0, 0x1C, 0, 0, /* FF08 */
162 0, 0, 0, 0x45, 0x46, 0 , 0, 0, /* FF10 */
163 0, 0, 0, 0x01 /* FF18 */
166 static const int cursor_key_vkey
[] =
168 VK_HOME
, VK_LEFT
, VK_UP
, VK_RIGHT
, VK_DOWN
, VK_PRIOR
,
169 VK_NEXT
, VK_END
/* FF50 */
171 static const int cursor_key_scan
[] =
173 0x147, 0x14B, 0x148, 0x14D, 0x150, 0x149, 0x151, 0x14F /* FF50 */
176 static const int misc_key_vkey
[] =
178 VK_SELECT
, VK_SNAPSHOT
, VK_EXECUTE
, VK_INSERT
, 0, 0, 0, 0, /* FF60 */
179 VK_CANCEL
, VK_HELP
, VK_CANCEL
, VK_MENU
/* FF68 */
181 static const int misc_key_scan
[] =
183 /*?*/ 0, 0x37, /*?*/ 0, 0x152, 0, 0, 0, 0, /* FF60 */
184 /*?*/ 0, /*?*/ 0, 0x38 /* FF68 */
187 static const int keypad_key_vkey
[] =
189 0, VK_NUMLOCK
, /* FF7E */
190 0, 0, 0, 0, 0, 0, 0, 0, /* FF80 */
191 0, 0, 0, 0, 0, VK_RETURN
, 0, 0, /* FF88 */
192 0, 0, 0, 0, 0, VK_HOME
, VK_LEFT
, VK_UP
, /* FF90 */
193 VK_RIGHT
, VK_DOWN
, VK_PRIOR
, VK_NEXT
, VK_END
, 0,
194 VK_INSERT
, VK_DELETE
, /* FF98 */
195 0, 0, 0, 0, 0, 0, 0, 0, /* FFA0 */
196 0, 0, VK_MULTIPLY
, VK_ADD
, VK_SEPARATOR
, VK_SUBTRACT
,
197 VK_DECIMAL
, VK_DIVIDE
, /* FFA8 */
198 VK_NUMPAD0
, VK_NUMPAD1
, VK_NUMPAD2
, VK_NUMPAD3
, VK_NUMPAD4
,
199 VK_NUMPAD5
, VK_NUMPAD6
, VK_NUMPAD7
, /* FFB0 */
200 VK_NUMPAD8
, VK_NUMPAD9
/* FFB8 */
202 static const int keypad_key_scan
[] =
204 0x138, 0x45, /* FF7E */
205 0, 0, 0, 0, 0, 0, 0, 0, /* FF80 */
206 0, 0, 0, 0, 0, 0x11C, 0, 0, /* FF88 */
207 0, 0, 0, 0, 0, 0x47, 0x4B, 0x48, /* FF90 */
208 0x4D, 0x50, 0x49, 0x51, 0x4F, 0x4C, 0x52, 0x53, /* FF98 */
209 0, 0, 0, 0, 0, 0, 0, 0, /* FFA0 */
210 0, 0, 0x37, 0x4E, /*?*/ 0, 0x4A, 0x53, 0x135, /* FFA8 */
211 0x52, 0x4F, 0x50, 0x51, 0x4B, 0x4C, 0x4D, 0x47, /* FFB0 */
212 0x48, 0x49 /* FFB8 */
215 static const int function_key_vkey
[] =
217 VK_F1
, VK_F2
, /* FFBE */
218 VK_F3
, VK_F4
, VK_F5
, VK_F6
, VK_F7
, VK_F8
, VK_F9
, VK_F10
, /* FFC0 */
219 VK_F11
, VK_F12
, VK_F13
, VK_F14
, VK_F15
, VK_F16
/* FFC8 */
221 static const int function_key_scan
[] =
223 0x3B, 0x3C, /* FFBE */
224 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, /* FFC0 */
225 0x57, 0x58, 0, 0, 0, 0 /* FFC8 */
228 static const int modifier_key_vkey
[] =
230 VK_SHIFT
, VK_SHIFT
, VK_CONTROL
, VK_CONTROL
, VK_CAPITAL
, 0, /* FFE1 */
231 VK_MENU
, VK_MENU
, VK_MENU
, VK_MENU
/* FFE7 */
233 static const int modifier_key_scan
[] =
235 0x2A, 0x36, 0x1D, 0x11D, 0x3A, 0, /* FFE1 */
236 0x38, 0x138, 0x38, 0x138 /* FFE7 */
239 /* Returns the Windows virtual key code associated with the X event <e> */
240 static WORD
EVENT_event_to_vkey( XKeyEvent
*e
)
244 TSXLookupString(e
, NULL
, 0, &keysym
, NULL
);
246 if ((keysym
>= 0xFFAE) && (keysym
<= 0xFFB9) && (e
->state
& NumLockMask
))
247 /* Only the Keypad keys 0-9 and . send different keysyms
248 * depending on the NumLock state */
249 return keypad_key_vkey
[(keysym
& 0xFF) - 0x7E];
251 return keyc2vkey
[e
->keycode
];
254 static BOOL NumState
=FALSE
, CapsState
=FALSE
;
256 /**********************************************************************
257 * KEYBOARD_GenerateMsg
259 * Generate Down+Up messages when NumLock or CapsLock is pressed.
261 * Convention : called with vkey only VK_NUMLOCK or VK_CAPITAL
264 void KEYBOARD_GenerateMsg( WORD vkey
, WORD scan
, int Evtype
, INT event_x
, INT event_y
,
267 BOOL
* State
= (vkey
==VK_NUMLOCK
? &NumState
: &CapsState
);
270 /* The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes,
271 don't treat it. It's from the same key press. Then the state goes to ON.
272 And from there, a 'release' event will switch off the toggle key. */
274 TRACE(keyboard
,"INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey
,pKeyStateTable
[vkey
]);
277 if ( pKeyStateTable
[vkey
] & 0x1 ) /* it was ON */
279 if (Evtype
!=KeyPress
)
281 TRACE(keyboard
,"ON + KeyRelease => generating DOWN and UP messages.\n");
282 KEYBOARD_SendEvent( vkey
, scan
, 0,
283 event_x
, event_y
, event_time
);
284 KEYBOARD_SendEvent( vkey
, scan
, KEYEVENTF_KEYUP
,
285 event_x
, event_y
, event_time
);
287 pKeyStateTable
[vkey
] &= ~0x01; /* Toggle state to off. */
290 else /* it was OFF */
291 if (Evtype
==KeyPress
)
293 TRACE(keyboard
,"OFF + Keypress => generating DOWN and UP messages.\n");
294 KEYBOARD_SendEvent( vkey
, scan
, 0,
295 event_x
, event_y
, event_time
);
296 KEYBOARD_SendEvent( vkey
, scan
, KEYEVENTF_KEYUP
,
297 event_x
, event_y
, event_time
);
298 *State
=TRUE
; /* Goes to intermediary state before going to ON */
299 pKeyStateTable
[vkey
] |= 0x01; /* Toggle state to on. */
304 /***********************************************************************
305 * KEYBOARD_UpdateOneState
307 * Updates internal state for <vkey>, depending on key <state> under X
310 void KEYBOARD_UpdateOneState ( int vkey
, int state
)
312 /* Do something if internal table state != X state for keycode */
313 if (((pKeyStateTable
[vkey
] & 0x80)!=0) != state
)
315 TRACE(keyboard
,"Adjusting state for vkey %#.2x. State before %#.2x \n",
316 vkey
, pKeyStateTable
[vkey
]);
318 /* Fake key being pressed inside wine */
319 KEYBOARD_SendEvent( vkey
, 0, state
? 0 : KEYEVENTF_KEYUP
,
320 0, 0, GetTickCount() );
322 TRACE(keyboard
,"State after %#.2x \n",pKeyStateTable
[vkey
]);
326 /***********************************************************************
327 * X11DRV_KEYBOARD_UpdateState
329 * Update modifiers state (Ctrl, Alt, Shift)
330 * when window is activated (called by EVENT_FocusIn in event.c)
332 * This handles the case where one uses Ctrl+... Alt+... or Shift+.. to switch
333 * from wine to another application and back.
334 * Toggle keys are handled in HandleEvent. (because XQueryKeymap says nothing
337 void X11DRV_KEYBOARD_UpdateState ( void )
339 /* extract a bit from the char[32] bit suite */
340 #define KeyState(keycode) ((keys_return[keycode/8] & (1<<(keycode%8)))!=0)
342 char keys_return
[32];
344 TRACE(keyboard
,"called\n");
345 if (!TSXQueryKeymap(display
, keys_return
)) {
346 ERR(keyboard
,"Error getting keymap !");
350 /* Adjust the ALT and CONTROL state if any has been changed outside wine */
351 KEYBOARD_UpdateOneState(VK_MENU
, KeyState(kcAlt
));
352 KEYBOARD_UpdateOneState(VK_CONTROL
, KeyState(kcControl
));
353 KEYBOARD_UpdateOneState(VK_SHIFT
, KeyState(kcShift
));
357 /***********************************************************************
358 * X11DRV_KEYBOARD_HandleEvent
360 * Handle a X key event
362 void X11DRV_KEYBOARD_HandleEvent( WND
*pWnd
, XKeyEvent
*event
)
367 WORD vkey
= 0, bScan
;
369 static BOOL force_extended
= FALSE
; /* hack for AltGr translation */
373 INT event_x
= (pWnd
? pWnd
->rectWindow
.left
: 0) + event
->x
;
374 INT event_y
= (pWnd
? pWnd
->rectWindow
.top
: 0) + event
->y
;
375 DWORD event_time
= event
->time
- MSG_WineStartTicks
;
377 /* this allows support for dead keys */
378 if ((event
->keycode
>> 8) == 0x10)
379 event
->keycode
=(event
->keycode
& 0xff);
381 ascii_chars
= TSXLookupString(event
, Str
, 1, &keysym
, &cs
);
383 TRACE(key
, "EVENT_key : state = %X\n", event
->state
);
384 if (keysym
== XK_Mode_switch
)
386 TRACE(key
, "Alt Gr key event received\n");
387 event
->keycode
= kcControl
; /* Simulate Control */
388 X11DRV_KEYBOARD_HandleEvent( pWnd
, event
);
390 event
->keycode
= kcAlt
; /* Simulate Alt */
391 force_extended
= TRUE
;
392 X11DRV_KEYBOARD_HandleEvent( pWnd
, event
);
393 force_extended
= FALSE
;
397 Str
[ascii_chars
] = '\0';
401 ksname
= TSXKeysymToString(keysym
);
404 TRACE(key
, "%s : keysym=%lX (%s), ascii chars=%u / %X / '%s'\n",
405 (event
->type
== KeyPress
) ? "KeyPress" : "KeyRelease",
406 keysym
, ksname
, ascii_chars
, Str
[0] & 0xff, Str
);
409 vkey
= EVENT_event_to_vkey(event
);
410 if (force_extended
) vkey
|= 0x100;
412 TRACE(key
, "keycode 0x%x converted to vkey 0x%x\n",
413 event
->keycode
, vkey
);
420 KEYBOARD_GenerateMsg( VK_NUMLOCK
, 0x45, event
->type
, event_x
, event_y
,
424 TRACE(keyboard
,"Caps Lock event. (type %d). State before : %#.2x\n",event
->type
,pKeyStateTable
[vkey
]);
425 KEYBOARD_GenerateMsg( VK_CAPITAL
, 0x3A, event
->type
, event_x
, event_y
,
427 TRACE(keyboard
,"State after : %#.2x\n",pKeyStateTable
[vkey
]);
430 /* Adjust the NUMLOCK state if it has been changed outside wine */
431 if (!(pKeyStateTable
[VK_NUMLOCK
] & 0x01) != !(event
->state
& NumLockMask
))
433 TRACE(keyboard
,"Adjusting NumLock state. \n");
434 KEYBOARD_GenerateMsg( VK_NUMLOCK
, 0x45, KeyPress
, event_x
, event_y
,
436 KEYBOARD_GenerateMsg( VK_NUMLOCK
, 0x45, KeyRelease
, event_x
, event_y
,
439 /* Adjust the CAPSLOCK state if it has been changed outside wine */
440 if (!(pKeyStateTable
[VK_CAPITAL
] & 0x01) != !(event
->state
& LockMask
))
442 TRACE(keyboard
,"Adjusting Caps Lock state.\n");
443 KEYBOARD_GenerateMsg( VK_CAPITAL
, 0x3A, KeyPress
, event_x
, event_y
,
445 KEYBOARD_GenerateMsg( VK_CAPITAL
, 0x3A, KeyRelease
, event_x
, event_y
,
448 /* Not Num nor Caps : end of intermediary states for both. */
452 bScan
= keyc2scan
[event
->keycode
] & 0xFF;
453 TRACE(key
, "bScan = 0x%02x.\n", bScan
);
456 if ( event
->type
== KeyRelease
) dwFlags
|= KEYEVENTF_KEYUP
;
457 if ( vkey
& 0x100 ) dwFlags
|= KEYEVENTF_EXTENDEDKEY
;
458 if ( force_extended
) dwFlags
|= KEYEVENTF_WINE_FORCEEXTENDED
;
460 KEYBOARD_SendEvent( vkey
& 0xff, bScan
, dwFlags
,
461 event_x
, event_y
, event_time
);
466 /**********************************************************************
467 * X11DRV_KEYBOARD_DetectLayout
469 * Called from X11DRV_KEYBOARD_Init
470 * This routine walks through the defined keyboard layouts and selects
471 * whichever matches most closely.
473 void X11DRV_KEYBOARD_DetectLayout(void)
475 unsigned current
, match
, mismatch
;
476 int max_score
= 0, ismatch
= 0;
477 int score
, keyc
, i
, key
, ok
, syms
= (keysyms_per_keycode
>4) ? 4 : keysyms_per_keycode
;
479 char ckey
[4]={0,0,0,0};
480 const char (*lkey
)[MAIN_LEN
][4];
482 for (current
=0; main_key_tab
[current
].lang
; current
++) {
483 TRACE(keyboard
,"Attempting to match against layout %04x\n",main_key_tab
[current
].lang
);
484 match
= 0; mismatch
= 0;
485 lkey
= main_key_tab
[current
].key
;
486 for (keyc
=min_keycode
; keyc
<=max_keycode
; keyc
++) {
487 /* get data for keycode from X server */
488 for (i
=0; i
<syms
; i
++) {
489 keysym
= TSXKeycodeToKeysym(display
, keyc
, i
);
490 if ((keysym
<0x100)&&(keysym
!=' ')) ckey
[i
] = keysym
;
494 /* search for a match in layout table */
495 /* right now, we just find an absolute match for defined positions */
496 /* (undefined positions are ignored, so if it's defined as "3#"
497 in the table, it's okay that the X server has "3#£", for example) */
498 for (key
=0; key
<MAIN_LEN
; key
++) {
499 for (ok
=(*lkey
)[key
][i
=0]; ok
&&(i
<4); i
++)
500 if ((*lkey
)[key
][i
] && (*lkey
)[key
][i
]!=ckey
[i
]) ok
=0;
503 /* count the matches and mismatches */
504 if (key
<MAIN_LEN
) match
++; else {
505 TRACE(key
,"mismatch for keycode %d, character %c\n",keyc
,ckey
[0]);
510 /* estimate and check score */
511 score
= match
- mismatch
;
512 TRACE(keyboard
,"matches=%d, mismatches=%d, score=%d\n",match
,mismatch
,score
);
513 if (score
> max_score
) {
514 /* best match so far */
515 kbd_layout
= current
;
520 /* we're done, report results if necessary */
522 FIXME(keyboard
,"Your keyboard layout was not found! Using closest match (%04x).\n",
523 main_key_tab
[kbd_layout
].lang
);
524 FIXME(keyboard
,"Please define your layout in windows/x11drv/keyboard.c, and submit them\n");
525 FIXME(keyboard
,"to us for inclusion into future Wine releases.\n");
526 FIXME(keyboard
,"See documentation/keyboard for more information.\n");
528 TRACE(keyboard
,"detected layout is %04x\n",main_key_tab
[kbd_layout
].lang
);
531 /**********************************************************************
532 * X11DRV_KEYBOARD_Init
534 void X11DRV_KEYBOARD_Init(void)
537 XModifierKeymap
*mmp
;
541 WORD scan
, vkey
, OEMvkey
;
542 int keyc
, i
, keyn
, syms
;
543 char ckey
[4]={0,0,0,0};
544 const char (*lkey
)[MAIN_LEN
][4];
546 TSXDisplayKeycodes(display
, &min_keycode
, &max_keycode
);
547 ksp
= TSXGetKeyboardMapping(display
, min_keycode
,
548 max_keycode
+ 1 - min_keycode
, &keysyms_per_keycode
);
549 /* We are only interested in keysyms_per_keycode.
550 There is no need to hold a local copy of the keysyms table */
552 mmp
= TSXGetModifierMapping(display
);
553 kcp
= mmp
->modifiermap
;
554 for (i
= 0; i
< 8; i
+= 1) /* There are 8 modifier keys */
558 for (j
= 0; j
< mmp
->max_keypermod
; j
+= 1, kcp
+= 1)
563 for (k
= 0; k
< keysyms_per_keycode
; k
+= 1)
564 if (TSXKeycodeToKeysym(display
, *kcp
, k
) == XK_Mode_switch
)
567 TRACE(key
, "AltGrMask is %x\n", AltGrMask
);
569 else if (TSXKeycodeToKeysym(display
, *kcp
, k
) == XK_Num_Lock
)
571 NumLockMask
= 1 << i
;
572 TRACE(key
, "NumLockMask is %x\n", NumLockMask
);
576 TSXFreeModifiermap(mmp
);
578 /* Detect the keyboard layout */
579 X11DRV_KEYBOARD_DetectLayout();
580 lkey
= main_key_tab
[kbd_layout
].key
;
581 syms
= (keysyms_per_keycode
> 4) ? 4 : keysyms_per_keycode
;
583 /* Now build two conversion arrays :
584 * keycode -> vkey + scancode + extended
585 * vkey + extended -> keycode */
587 e2
.display
= display
;
590 OEMvkey
= VK_OEM_7
; /* next is available. */
591 for (keyc
= min_keycode
; keyc
<= max_keycode
; keyc
++)
593 e2
.keycode
= (KeyCode
)keyc
;
594 TSXLookupString(&e2
, NULL
, 0, &keysym
, NULL
);
596 if (keysym
) /* otherwise, keycode not used */
598 if ((keysym
>> 8) == 0xFF) /* non-character key */
600 int key
= keysym
& 0xff;
602 if (key
>= 0x08 && key
<= 0x1B) { /* special key */
603 vkey
= special_key_vkey
[key
- 0x08];
604 scan
= special_key_scan
[key
- 0x08];
605 } else if (key
>= 0x50 && key
<= 0x57) { /* cursor key */
606 vkey
= cursor_key_vkey
[key
- 0x50];
607 scan
= cursor_key_scan
[key
- 0x50];
608 } else if (key
>= 0x60 && key
<= 0x6B) { /* miscellaneous key */
609 vkey
= misc_key_vkey
[key
- 0x60];
610 scan
= misc_key_scan
[key
- 0x60];
611 } else if (key
>= 0x7E && key
<= 0xB9) { /* keypad key */
612 vkey
= keypad_key_vkey
[key
- 0x7E];
613 scan
= keypad_key_scan
[key
- 0x7E];
614 } else if (key
>= 0xBE && key
<= 0xCD) { /* function key */
615 vkey
= function_key_vkey
[key
- 0xBE] | 0x100; /* set extended bit */
616 scan
= function_key_scan
[key
- 0xBE];
617 } else if (key
>= 0xE1 && key
<= 0xEA) { /* modifier key */
618 vkey
= modifier_key_vkey
[key
- 0xE1];
619 scan
= modifier_key_scan
[key
- 0xE1];
620 } else if (key
== 0xFF) { /* DEL key */
624 /* set extended bit when necessary */
625 if (scan
& 0x100) vkey
|= 0x100;
626 } else if (keysym
== 0x20) { /* Spacebar */
630 /* we seem to need to search the layout-dependent scancodes */
631 int maxlen
=0,maxval
=-1,ok
;
632 for (i
=0; i
<syms
; i
++) {
633 keysym
= TSXKeycodeToKeysym(display
, keyc
, i
);
634 if ((keysym
<0x100)&&(keysym
!=' ')) ckey
[i
] = keysym
;
637 /* find key with longest match streak */
638 for (keyn
=0; keyn
<MAIN_LEN
; keyn
++) {
639 for (ok
=(*lkey
)[keyn
][i
=0]; ok
&&(i
<4); i
++)
640 if ((*lkey
)[keyn
][i
] && (*lkey
)[keyn
][i
]!=ckey
[i
]) ok
=0;
641 if (ok
||(i
>maxlen
)) {
642 maxlen
=i
; maxval
=keyn
;
648 scan
= main_key_scan
[maxval
];
652 /* find a suitable layout-dependent VK code */
653 /* (most Winelib apps ought to be able to work without layout tables!) */
654 for (i
= 0; (i
< keysyms_per_keycode
) && (!vkey
); i
++)
656 keysym
= TSXLookupKeysym(&e2
, i
);
657 if ((keysym
>= VK_0
&& keysym
<= VK_9
)
658 || (keysym
>= VK_A
&& keysym
<= VK_Z
)) {
663 for (i
= 0; (i
< keysyms_per_keycode
) && (!vkey
); i
++)
665 keysym
= TSXLookupKeysym(&e2
, i
);
668 case ';': vkey
= VK_OEM_1
; break;
669 case '/': vkey
= VK_OEM_2
; break;
670 case '`': vkey
= VK_OEM_3
; break;
671 case '[': vkey
= VK_OEM_4
; break;
672 case '\\': vkey
= VK_OEM_5
; break;
673 case ']': vkey
= VK_OEM_6
; break;
674 case '\'': vkey
= VK_OEM_7
; break;
675 case ',': vkey
= VK_OEM_COMMA
; break;
676 case '.': vkey
= VK_OEM_PERIOD
; break;
677 case '-': vkey
= VK_OEM_MINUS
; break;
678 case '+': vkey
= VK_OEM_PLUS
; break;
684 /* Others keys: let's assign OEM virtual key codes in the allowed range,
685 * that is ([0xba,0xc0], [0xdb,0xe4], 0xe6 (given up) et [0xe9,0xf5]) */
688 case 0xc1 : OEMvkey
=0xdb; break;
689 case 0xe5 : OEMvkey
=0xe9; break;
690 case 0xf6 : OEMvkey
=0xf5; WARN(keyboard
,"No more OEM vkey available!\n");
695 if (TRACE_ON(keyboard
))
697 dbg_decl_str(keyboard
, 1024);
699 TRACE(keyboard
, "OEM specific virtual key %X assigned "
700 "to keycode %X:\n", OEMvkey
, e2
.keycode
);
701 for (i
= 0; i
< keysyms_per_keycode
; i
+= 1)
705 keysym
= TSXLookupKeysym(&e2
, i
);
706 ksname
= TSXKeysymToString(keysym
);
709 dsprintf(keyboard
, "%lX (%s) ", keysym
, ksname
);
711 TRACE(keyboard
, "(%s)\n", dbg_str(keyboard
));
715 keyc2vkey
[e2
.keycode
] = vkey
;
716 keyc2scan
[e2
.keycode
] = scan
;
719 /* If some keys still lack scancodes, assign some arbitrary ones to them now */
720 for (scan
= 0x60, keyc
= min_keycode
; keyc
<= max_keycode
; keyc
++)
721 if (keyc2vkey
[keyc
]&&!keyc2scan
[keyc
]) {
723 keysym
= TSXKeycodeToKeysym(display
, keyc
, 0);
724 ksname
= TSXKeysymToString(keysym
);
725 if (!ksname
) ksname
= "NoSymbol";
727 /* should make sure the scancode is unassigned here, but >=0x60 currently always is */
729 TRACE(key
,"assigning scancode %02x to unidentified keycode %02x (%s)\n",scan
,keyc
,ksname
);
730 keyc2scan
[keyc
]=scan
++;
733 /* Now store one keycode for each modifier. Used to simulate keypresses. */
734 kcControl
= TSXKeysymToKeycode(display
, XK_Control_L
);
735 kcAlt
= TSXKeysymToKeycode(display
, XK_Alt_L
);
736 if (!kcAlt
) kcAlt
= TSXKeysymToKeycode(display
, XK_Meta_L
);
737 kcShift
= TSXKeysymToKeycode(display
, XK_Shift_L
);
738 kcNumLock
= TSXKeysymToKeycode(display
, XK_Num_Lock
);
739 kcCapsLock
= TSXKeysymToKeycode(display
, XK_Caps_Lock
);
742 /***********************************************************************
743 * X11DRV_KEYBOARD_VkKeyScan
745 WORD
X11DRV_KEYBOARD_VkKeyScan(CHAR cChar
)
752 /* char->keysym (same for ANSI chars) */
753 keysym
=(unsigned char) cChar
;/* (!) cChar is signed */
754 if (keysym
<=27) keysym
+=0xFF00;/*special chars : return, backspace...*/
756 keycode
= TSXKeysymToKeycode(display
, keysym
); /* keysym -> keycode */
758 { /* It didn't work ... let's try with deadchar code. */
759 keycode
= TSXKeysymToKeycode(display
, keysym
| 0xFE00);
762 TRACE(keyboard
,"VkKeyScan '%c'(%#lx, %lu): got keycode %#.2x\n",
763 cChar
,keysym
,keysym
,keycode
);
767 for (index
=-1, i
=0; (i
<8) && (index
<0); i
++) /* find shift state */
768 if (TSXKeycodeToKeysym(display
,keycode
,i
)==keysym
) index
=i
;
771 WARN(keyboard
,"Keysym %lx not found while parsing the keycode table\n",keysym
); break;
773 case 1 : highbyte
= 0x0100; break;
774 case 2 : highbyte
= 0X0600; break;
775 default : ERR(keyboard
,"index %d found by XKeycodeToKeysym. please report! \n",index
);
778 index : 0 adds 0x0000
779 index : 1 adds 0x0100 (shift)
780 index : ? adds 0x0200 (ctrl)
781 index : 2 adds 0x0600 (ctrl+alt)
782 index : ? adds 0x0700 (ctrl+alt+shift (used?))
785 TRACE(keyboard
," ... returning %#.2x\n", keyc2vkey
[keycode
]+highbyte
);
786 return keyc2vkey
[keycode
]+highbyte
; /* keycode -> (keyc2vkey) vkey */
789 /***********************************************************************
790 * X11DRV_KEYBOARD_MapVirtualKey
792 UINT16
X11DRV_KEYBOARD_MapVirtualKey(UINT16 wCode
, UINT16 wMapType
)
794 #define returnMVK(value) { TRACE(keyboard,"returning 0x%x.\n",value); return value; }
796 TRACE(keyboard
,"MapVirtualKey wCode=0x%x wMapType=%d ... \n",
799 case 0: { /* vkey-code to scan-code */
800 /* let's do vkey -> keycode -> scan */
802 for (keyc
=min_keycode
; keyc
<=max_keycode
; keyc
++)
803 if ((keyc2vkey
[keyc
] & 0xFF) == wCode
)
804 returnMVK (keyc2scan
[keyc
] & 0xFF);
807 case 1: { /* scan-code to vkey-code */
808 /* let's do scan -> keycode -> vkey */
810 for (keyc
=min_keycode
; keyc
<=max_keycode
; keyc
++)
811 if ((keyc2scan
[keyc
] & 0xFF) == wCode
)
812 returnMVK (keyc2vkey
[keyc
] & 0xFF);
815 case 2: { /* vkey-code to unshifted ANSI code */
816 /* (was FIXME) : what does unshifted mean ? 'a' or 'A' ? */
817 /* My Windows returns 'A'. */
818 /* let's do vkey -> keycode -> (XLookupString) ansi char */
823 e
.state
= 0; /* unshifted */
824 e
.keycode
= MapVirtualKey16( wCode
, 0);
825 if (!TSXLookupString(&e
, s
, 2 , &keysym
, NULL
))
830 default: /* reserved */
831 WARN(keyboard
, "Unknown wMapType %d !\n",
838 /***********************************************************************
839 * X11DRV_KEYBOARD_GetKeyNameText
841 INT16
X11DRV_KEYBOARD_GetKeyNameText(LONG lParam
, LPSTR lpBuffer
, INT16 nSize
)
847 FIXME(keyboard
,"(%ld,<ptr>,%d): stub\n",lParam
,nSize
);
853 for (i
= 0 ; i
!= KeyTableSize
; i
++)
854 if (KeyTable
[i
].scancode
== lParam
) {
855 lstrcpynA( lpBuffer
, KeyTable
[i
].name
, nSize
);
856 return strlen(lpBuffer
);
864 /***********************************************************************
865 * X11DRV_KEYBOARD_ToAscii
867 * The ToAscii function translates the specified virtual-key code and keyboard
868 * state to the corresponding Windows character or characters.
870 * If the specified key is a dead key, the return value is negative. Otherwise,
871 * it is one of the following values:
873 * 0 The specified virtual key has no translation for the current state of the keyboard.
874 * 1 One Windows character was copied to the buffer.
875 * 2 Two characters were copied to the buffer. This usually happens when a
876 * dead-key character (accent or diacritic) stored in the keyboard layout cannot
877 * be composed with the specified virtual key to form a single character.
879 * FIXME : should do the above (return 2 for non matching deadchar+char combinations)
882 INT16
X11DRV_KEYBOARD_ToAscii(
883 UINT16 virtKey
,UINT16 scanCode
, LPBYTE lpKeyState
,
884 LPVOID lpChar
, UINT16 flags
)
888 static XComposeStatus cs
;
893 /* This happens when doing Alt+letter : a fake 'down arrow' key press
894 event is generated by windows. Just ignore it. */
895 TRACE(keyboard
,"scanCode=0, doing nothing\n");
898 if (scanCode
& 0x8000)
900 TRACE( keyboard
, "Key UP, doing nothing\n" );
906 if (lpKeyState
[VK_SHIFT
] & 0x80)
907 e
.state
|= ShiftMask
;
908 if (lpKeyState
[VK_CAPITAL
] & 0x01)
910 if (lpKeyState
[VK_CONTROL
] & 0x80)
912 if (lpKeyState
[VK_MENU
] & 0x80)
913 e
.state
|= AltGrMask
;
915 e
.state
|= ControlMask
;
917 if (lpKeyState
[VK_NUMLOCK
] & 0x01)
918 e
.state
|= NumLockMask
;
919 TRACE(key
, "(%04X, %04X) : faked state = %X\n",
920 virtKey
, scanCode
, e
.state
);
921 /* We exit on the first keycode found, to speed up the thing. */
922 for (keyc
=min_keycode
; (keyc
<=max_keycode
) && (!e
.keycode
) ; keyc
++)
923 { /* Find a keycode that could have generated this virtual key */
924 if ((keyc2vkey
[keyc
] & 0xFF) == virtKey
)
925 { /* We filter the extended bit, we don't know it */
926 e
.keycode
= keyc
; /* Store it temporarily */
927 if ((EVENT_event_to_vkey(&e
) & 0xFF) != virtKey
) {
928 e
.keycode
= 0; /* Wrong one (ex: because of the NumLock
929 state), so set it to 0, we'll find another one */
934 if ((virtKey
>=VK_NUMPAD0
) && (virtKey
<=VK_NUMPAD9
))
935 e
.keycode
= TSXKeysymToKeycode(e
.display
, virtKey
-VK_NUMPAD0
+XK_KP_0
);
937 if (virtKey
==VK_DECIMAL
)
938 e
.keycode
= TSXKeysymToKeycode(e
.display
, XK_KP_Decimal
);
942 WARN(keyboard
,"Unknown virtual key %X !!! \n",virtKey
);
943 return virtKey
; /* whatever */
945 else TRACE(keyboard
,"Found keycode %d (0x%2X)\n",e
.keycode
,e
.keycode
);
947 ret
= TSXLookupString(&e
, (LPVOID
)lpChar
, 2, &keysym
, &cs
);
952 ((char*)lpChar
)[1] = '\0';
955 /* symbolic ASCII is the same as defined in rfc1345 */
959 case 0x1000FE7E : /* Xfree's XK_Dtilde */
960 dead_char
= '~'; /* '? */
965 case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
966 dead_char
= 0xb4; /* '' */
968 #ifdef XK_dead_circumflex
969 case XK_dead_circumflex
:
971 case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
972 dead_char
= '^'; /* '> */
977 case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
978 dead_char
= '`'; /* '! */
980 #ifdef XK_dead_diaeresis
981 case XK_dead_diaeresis
:
983 case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
984 dead_char
= 0xa8; /* ': */
986 #ifdef XK_dead_cedilla
987 case XK_dead_cedilla
:
988 dead_char
= 0xb8; /* ', */
991 #ifdef XK_dead_macron
992 case XK_dead_macron
:
993 dead_char
= '-'; /* 'm isn't defined on iso-8859-x */
998 dead_char
= 0xa2; /* '( */
1001 #ifdef XK_dead_abovedot
1002 case XK_dead_abovedot
:
1003 dead_char
= 0xff; /* '. */
1006 #ifdef XK_dead_abovering
1007 case XK_dead_abovering
:
1008 dead_char
= '0'; /* '0 isn't defined on iso-8859-x */
1011 #ifdef XK_dead_doubleacute
1012 case XK_dead_doubleacute
:
1013 dead_char
= 0xbd; /* '" */
1016 #ifdef XK_dead_caron
1017 case XK_dead_caron
:
1018 dead_char
= 0xb7; /* '< */
1021 #ifdef XK_dead_ogonek
1022 case XK_dead_ogonek
:
1023 dead_char
= 0xb2; /* '; */
1026 /* FIXME: I don't know this three.
1030 case XK_dead_voiced_sound :
1033 case XK_dead_semivoiced_sound :
1040 *(char*)lpChar
= dead_char
;
1047 ksname
= TSXKeysymToString(keysym
);
1050 if ((keysym
>> 8) != 0xff)
1052 ERR(keyboard
, "Please report: no char for keysym %04lX (%s) :\n",
1054 ERR(keyboard
, "(virtKey=%X,scanCode=%X,keycode=%X,state=%X)\n",
1055 virtKey
, scanCode
, e
.keycode
, e
.state
);
1059 else { /* ret = 1 */
1060 /* We have a special case to handle : Shift + arrow, shift + home, ...
1061 X returns a char for it, but Windows doesn't. Let's eat it. */
1062 if (!(lpKeyState
[VK_NUMLOCK
] & 0x01) /* NumLock is off */
1063 && (lpKeyState
[VK_SHIFT
] & 0x80) /* Shift is pressed */
1064 && (keysym
>=XK_KP_0
) && (keysym
<=XK_KP_9
))
1071 TRACE(key
, "ToAscii about to return %d with char %x\n",
1072 ret
, *(char*)lpChar
);
1076 #endif /* !defined(X_DISPLAY_MISSING) */