?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980215
[wine/multimedia.git] / windows / keyboard.c
blobb99656d3ffd4ba1a1f3e7fe4607e99282d5436b6
1 /*
2 * Keyboard related functions
3 *
4 * Copyright 1993 Bob Amstadt
5 * Copyright 1996 Albrecht Kleine
6 * Copyright 1997 David Faure
7 *
8 */
9
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <string.h>
13 #include <ctype.h>
14 #include <X11/keysym.h>
15 #include "ts_xlib.h"
16 #include "ts_xresource.h"
17 #include "ts_xutil.h"
18 #include <X11/Xatom.h>
19
20 #include "windows.h"
21 #include "win.h"
22 #include "gdi.h"
23 #include "heap.h"
24 #include "keyboard.h"
25 #include "message.h"
26 #include "stddebug.h"
27 /* #define DEBUG_KEYBOARD */
28 #include "debug.h"
29 #include "struct32.h"
30
31 BOOL32 MouseButtonsStates[3];
32 BOOL32 AsyncMouseButtonsStates[3];
33 BYTE InputKeyStateTable[256];
34 BYTE QueueKeyStateTable[256];
35 BYTE AsyncKeyStateTable[256];
36
37 static int NumLockMask;
38 static int AltGrMask;
39 static int min_keycode, max_keycode;
40 static int keyc2vkey[256];
41
42 typedef union
43 {
44 struct
45 {
46 unsigned long count : 16;
47 unsigned long code : 8;
48 unsigned long extended : 1;
49 unsigned long unused : 2;
50 unsigned long win_internal : 2;
51 unsigned long context : 1;
52 unsigned long previous : 1;
53 unsigned long transition : 1;
54 } lp1;
55 unsigned long lp2;
56 } KEYLP;
57
58 /* Keyboard translation tables */
59 static const int special_key[] =
60 {
61 VK_BACK, VK_TAB, 0, VK_CLEAR, 0, VK_RETURN, 0, 0, /* FF08 */
62 0, 0, 0, VK_PAUSE, VK_SCROLL, 0, 0, 0, /* FF10 */
63 0, 0, 0, VK_ESCAPE /* FF18 */
64 };
65
66 static const int cursor_key[] =
67 {
68 VK_HOME, VK_LEFT, VK_UP, VK_RIGHT, VK_DOWN, VK_PRIOR,
69 VK_NEXT, VK_END /* FF50 */
70 };
71
72 static const int misc_key[] =
73 {
74 VK_SELECT, VK_SNAPSHOT, VK_EXECUTE, VK_INSERT, 0, 0, 0, 0, /* FF60 */
75 VK_CANCEL, VK_HELP, VK_CANCEL, VK_MENU /* FF68 */
76 };
77
78 static const int keypad_key[] =
79 {
80 0, VK_NUMLOCK, /* FF7E */
81 0, 0, 0, 0, 0, 0, 0, 0, /* FF80 */
82 0, 0, 0, 0, 0, VK_RETURN, 0, 0, /* FF88 */
83 0, 0, 0, 0, 0, VK_HOME, VK_LEFT, VK_UP, /* FF90 */
84 VK_RIGHT, VK_DOWN, VK_PRIOR, VK_NEXT, VK_END, 0,
85 VK_INSERT, VK_DELETE, /* FF98 */
86 0, 0, 0, 0, 0, 0, 0, 0, /* FFA0 */
87 0, 0, VK_MULTIPLY, VK_ADD, VK_SEPARATOR, VK_SUBTRACT,
88 VK_DECIMAL, VK_DIVIDE, /* FFA8 */
89 VK_NUMPAD0, VK_NUMPAD1, VK_NUMPAD2, VK_NUMPAD3, VK_NUMPAD4,
90 VK_NUMPAD5, VK_NUMPAD6, VK_NUMPAD7, /* FFB0 */
91 VK_NUMPAD8, VK_NUMPAD9 /* FFB8 */
92 };
93
94 static const int function_key[] =
95 {
96 VK_F1, VK_F2, /* FFBE */
97 VK_F3, VK_F4, VK_F5, VK_F6, VK_F7, VK_F8, VK_F9, VK_F10, /* FFC0 */
98 VK_F11, VK_F12, VK_F13, VK_F14, VK_F15, VK_F16 /* FFC8 */
99 };
100
101 static const int modifier_key[] =
102 {
103 VK_SHIFT, VK_SHIFT, VK_CONTROL, VK_CONTROL, VK_CAPITAL, 0, /* FFE1 */
104 VK_MENU, VK_MENU, VK_MENU, VK_MENU /* FFE7 */
105 };
106
107 /*
108 * Table for vkey to scancode translation - 5/29/97 chrisf@america.com
109 */
110 const BYTE vkey2scode[512] = {
111 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x0e,0x0f,0x00,0x00,0x00,0x1c,0x00,0x00,
112 0x2a,0x1d,0x38,0x00,0x3a,0x00,0x00,0x00, 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,
113 0x39,0x49,0x51,0x4f,0x47,0x4b,0x48,0x4d, 0x50,0x00,0x00,0x00,0x00,0x52,0x53,0x00,
114 0x0b,0x02,0x03,0x04,0x05,0x06,0x07,0x08, 0x09,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,
115 0x00,0x1e,0x30,0x2e,0x20,0x12,0x21,0x22, 0x23,0x17,0x24,0x25,0x26,0x32,0x31,0x18,
116 0x19,0x10,0x13,0x1f,0x14,0x16,0x2f,0x11, 0x2d,0x15,0x2c,0x00,0x00,0x00,0x00,0x00,
117 0x0b,0x02,0x03,0x04,0x05,0x06,0x07,0x08, 0x09,0x0a,0x37,0x4e,0x00,0x4a,0x34,0x00,
118 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
119 0x00,0x46,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
120 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
121 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
122 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x29,0x0c,0x0d,0x1a,0x1b,0x2b,
123 0x27,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
124 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x28,0x33,0x34,0x35,0x4c,
125 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
126 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
127 /* 256 */
128 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x1c,0x00,0x00,
129 0x00,0x1d,0x38,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
130 0x00,0x49,0x51,0x4f,0x47,0x4b,0x48,0x4d, 0x50,0x00,0x00,0x00,0x00,0x52,0x53,0x00,
131 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
132 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
133 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
134 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x35,
135 0x3b,0x3c,0x3d,0x3e,0x3f,0x40,0x41,0x42, 0x43,0x44,0x57,0x58,0x00,0x00,0x00,0x00,
136 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
137 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
138 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
139 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
140 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
141 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
142 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
143 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
144 };
145
146 static WORD EVENT_event_to_vkey( XKeyEvent *e)
147 {
148 KeySym keysym;
149
150 TSXLookupString(e, NULL, 0, &keysym, NULL);
151
152 if ((keysym >= 0xFFAE) && (keysym <= 0xFFB9) && (e->state & NumLockMask))
153 /* Only the Keypad keys 0-9 and . send different keysyms
154 * depending on the NumLock state */
155 return keypad_key[(keysym & 0xFF) - 0x7E];
156
157 return keyc2vkey[e->keycode];
158 }
159
160 /**********************************************************************
161 * KEYBOARD_Init
162 */
163 BOOL32 KEYBOARD_Init(void)
164 {
165 int i, keysyms_per_keycode;
166 KeySym *ksp;
167 XModifierKeymap *mmp;
168 KeySym keysym;
169 KeyCode *kcp;
170 XKeyEvent e2;
171 WORD vkey, OEMvkey;
172
173 TSXDisplayKeycodes(display, &min_keycode, &max_keycode);
174 ksp = TSXGetKeyboardMapping(display, min_keycode,
175 max_keycode + 1 - min_keycode, &keysyms_per_keycode);
176 /* We are only interested in keysyms_per_keycode.
177 There is no need to hold a local copy of the keysyms table */
178 TSXFree(ksp);
179 mmp = TSXGetModifierMapping(display);
180 kcp = mmp->modifiermap;
181 for (i = 0; i < 8; i += 1) /* There are 8 modifier keys */
182 {
183 int j;
184
185 for (j = 0; j < mmp->max_keypermod; j += 1, kcp += 1)
186 if (*kcp)
187 {
188 int k;
189
190 for (k = 0; k < keysyms_per_keycode; k += 1)
191 if (TSXKeycodeToKeysym(display, *kcp, k) == XK_Mode_switch)
192 {
193 AltGrMask = 1 << i;
194 dprintf_key(stddeb, "AltGrMask is %x\n", AltGrMask);
195 }
196 else if (TSXKeycodeToKeysym(display, *kcp, k) == XK_Num_Lock)
197 {
198 NumLockMask = 1 << i;
199 dprintf_key(stddeb, "NumLockMask is %x\n", NumLockMask);
200 }
201 }
202 }
203 TSXFreeModifiermap(mmp);
204
205 /* Now build two conversion arrays :
206 * keycode -> vkey + extended
207 * vkey + extended -> keycode */
208
209 e2.display = display;
210 e2.state = 0;
211
212 OEMvkey = 0xb9; /* first OEM virtual key available is ba */
213 for (e2.keycode=min_keycode; e2.keycode<=max_keycode; e2.keycode++)
214 {
215 TSXLookupString(&e2, NULL, 0, &keysym, NULL);
216 vkey = 0;
217 if (keysym) /* otherwise, keycode not used */
218 {
219 if ((keysym >> 8) == 0xFF) /* non-character key */
220 {
221 int key = keysym & 0xff;
222
223 if (key >= 0x08 && key <= 0x1B) /* special key */
224 vkey = special_key[key - 0x08];
225 else if (key >= 0x50 && key <= 0x57) /* cursor key */
226 vkey = cursor_key[key - 0x50];
227 else if (key >= 0x60 && key <= 0x6B) /* miscellaneous key */
228 vkey = misc_key[key - 0x60];
229 else if (key >= 0x7E && key <= 0xB9) /* keypad key */
230 vkey = keypad_key[key - 0x7E];
231 else if (key >= 0xBE && key <= 0xCD) /* function key */
232 {
233 vkey = function_key[key - 0xBE];
234 vkey |= 0x100; /* set extended bit */
235 }
236 else if (key >= 0xE1 && key <= 0xEA) /* modifier key */
237 vkey = modifier_key[key - 0xE1];
238 else if (key == 0xFF) /* DEL key */
239 vkey = VK_DELETE;
240 /* extended must also be set for ALT_R, CTRL_R,
241 INS, DEL, HOME, END, PAGE_UP, PAGE_DOWN, ARROW keys,
242 keypad / and keypad ENTER (SDK 3.1 Vol.3 p 138) */
243 /* FIXME should we set extended bit for NumLock ? My
244 * Windows does ... DF */
245 switch (keysym)
246 {
247 case XK_Control_R :
248 case XK_Alt_R :
249 case XK_Insert :
250 case XK_Delete :
251 case XK_Home :
252 case XK_End :
253 case XK_Prior :
254 case XK_Next :
255 case XK_Left :
256 case XK_Up :
257 case XK_Right :
258 case XK_Down :
259 case XK_KP_Divide :
260 case XK_KP_Enter :
261 vkey |= 0x100;
262 }
263 }
264 for (i = 0; (i < keysyms_per_keycode) && (!vkey); i++)
265 {
266 keysym = TSXLookupKeysym(&e2, i);
267 if ((keysym >= VK_0 && keysym <= VK_9)
268 || (keysym >= VK_A && keysym <= VK_Z)
269 || keysym == VK_SPACE)
270 vkey = keysym;
271 }
272
273 if (!vkey)
274 {
275 /* Others keys: let's assign OEM virtual key codes in the allowed range,
276 * that is ([0xba,0xc0], [0xdb,0xe4], 0xe6 (given up) et [0xe9,0xf5]) */
277 switch (++OEMvkey)
278 {
279 case 0xc1 : OEMvkey=0xdb; break;
280 case 0xe5 : OEMvkey=0xe9; break;
281 case 0xf6 : OEMvkey=0xf5; fprintf(stderr,"No more OEM vkey available!\n");
282 }
283
284 vkey = OEMvkey;
285
286 if (debugging_keyboard)
287 {
288 fprintf(stddeb,"OEM specific virtual key %X assigned to keycode %X :\n ("
289 ,OEMvkey,e2.keycode);
290 for (i = 0; i < keysyms_per_keycode; i += 1)
291 {
292 char *ksname;
293
294 keysym = TSXLookupKeysym(&e2, i);
295 ksname = TSXKeysymToString(keysym);
296 if (!ksname)
297 ksname = "NoSymbol";
298 fprintf(stddeb, "%lX (%s) ", keysym, ksname);
299 }
300 fprintf(stddeb, ")\n");
301 }
302 }
303 }
304 keyc2vkey[e2.keycode] = vkey;
305 } /* for */
306 return TRUE;
307 }
308
309 static BOOL32 NumState=FALSE, CapsState=FALSE;
310
311 void KEYBOARD_GenerateMsg( WORD vkey, int Evtype, INT32 event_x, INT32 event_y,
312 DWORD event_time, KEYLP localkeylp )
313 {
314 BOOL32 * State = (vkey==VK_NUMLOCK? &NumState : &CapsState);
315
316 if (*State) {
317 /* The INTERMEDIARY state means : just after a 'press' event, if a 'release' event comes,
318 don't treat it. It's from the same key press. Then the state goes to ON.
319 And from there, a 'release' event will switch off the toggle key. */
320 *State=FALSE;
321 dprintf_keyboard(stddeb,"INTERM : don\'t treat release of toggle key. InputKeyStateTable[%#x] = %#x\n",vkey,InputKeyStateTable[vkey]);
322 } else
323 {
324 if ( InputKeyStateTable[vkey] & 0x1 ) /* it was ON */
325 {
326 if (Evtype!=KeyPress)
327 {
328 dprintf_keyboard(stddeb,"ON + KeyRelease => generating DOWN and UP messages.\n");
329 localkeylp.lp1.previous = 0; /* ? */
330 localkeylp.lp1.transition = 0;
331 hardware_event( WM_KEYDOWN, vkey, localkeylp.lp2,
332 event_x, event_y, event_time, 0 );
333 hardware_event( WM_KEYUP, vkey, localkeylp.lp2,
334 event_x, event_y, event_time, 0 );
335 *State=FALSE;
336 InputKeyStateTable[vkey] &= ~0x01; /* Toggle state to off. */
337 }
338 }
339 else /* it was OFF */
340 if (Evtype==KeyPress)
341 {
342 dprintf_keyboard(stddeb,"OFF + Keypress => generating DOWN and UP messages.\n");
343 hardware_event( WM_KEYDOWN, vkey, localkeylp.lp2,
344 event_x, event_y, event_time, 0 );
345 localkeylp.lp1.previous = 1;
346 localkeylp.lp1.transition = 1;
347 hardware_event( WM_KEYUP, vkey, localkeylp.lp2,
348 event_x, event_y, event_time, 0 );
349 *State=TRUE; /* Goes to intermediary state before going to ON */
350 InputKeyStateTable[vkey] |= 0x01; /* Toggle state to on. */
351 }
352 }
353 }
354
355 /***********************************************************************
356 * KEYBOARD_HandleEvent
357 *
358 * Handle a X key event
359 */
360 void KEYBOARD_HandleEvent( WND *pWnd, XKeyEvent *event )
361 {
362 char Str[24];
363 XComposeStatus cs;
364 KeySym keysym;
365 WORD vkey = 0;
366 KEYLP keylp;
367 static BOOL32 force_extended = FALSE; /* hack for AltGr translation */
368
369 int ascii_chars = TSXLookupString(event, Str, 1, &keysym, &cs);
370
371 INT32 event_x = pWnd->rectWindow.left + event->x;
372 INT32 event_y = pWnd->rectWindow.top + event->y;
373 DWORD event_time = event->time - MSG_WineStartTicks;
374
375 dprintf_key(stddeb, "EVENT_key : state = %X\n", event->state);
376 if (keysym == XK_Mode_switch)
377 {
378 dprintf_key(stddeb, "Alt Gr key event received\n");
379 event->keycode = TSXKeysymToKeycode(event->display, XK_Control_L);
380 dprintf_key(stddeb, "Control_L is keycode 0x%x\n", event->keycode);
381 KEYBOARD_HandleEvent( pWnd, event );
382 event->keycode = TSXKeysymToKeycode(event->display, XK_Alt_L);
383 dprintf_key(stddeb, "Alt_L is keycode 0x%x\n", event->keycode);
384 force_extended = TRUE;
385 KEYBOARD_HandleEvent( pWnd, event );
386 force_extended = FALSE;
387 return;
388 }
389
390 Str[ascii_chars] = '\0';
391 if (debugging_key)
392 {
393 char *ksname;
394
395 ksname = TSXKeysymToString(keysym);
396 if (!ksname)
397 ksname = "No Name";
398 fprintf(stddeb, "%s : keysym=%lX (%s), ascii chars=%u / %X / '%s'\n",
399 (event->type == KeyPress) ? "KeyPress" : "KeyRelease",
400 keysym, ksname, ascii_chars, Str[0] & 0xff, Str);
401 }
402
403 vkey = EVENT_event_to_vkey(event);
404 if (force_extended) vkey |= 0x100;
405
406 dprintf_key(stddeb, "keycode 0x%x converted to vkey 0x%x\n",
407 event->keycode, vkey);
408
409 if (vkey)
410 {
411 keylp.lp1.count = 1;
412 keylp.lp1.code = vkey2scode[vkey]; /* 5/29/97 chrisf@america.com */
413 keylp.lp1.extended = (vkey & 0x100 ? 1 : 0);
414 keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
415 * don't remember where I read it - AK */
416 /* it's '1' under windows, when a dialog box appears
417 * and you press one of the underlined keys - DF*/
418 vkey &= 0xff;
419
420 switch(vkey)
421 {
422 case VK_NUMLOCK:
423 KEYBOARD_GenerateMsg( VK_NUMLOCK, event->type, event_x, event_y,
424 event_time, keylp);
425 break;
426 case VK_CAPITAL:
427 dprintf_keyboard(stddeb,"Caps Lock event. (type %d). State before : %#.2x\n",event->type,InputKeyStateTable[vkey]);
428 KEYBOARD_GenerateMsg( VK_CAPITAL, event->type, event_x, event_y,
429 event_time, keylp );
430 dprintf_keyboard(stddeb,"State after : %#.2x\n",InputKeyStateTable[vkey]);
431 break;
432 default:
433 {
434 WORD message;
435 if (event->type == KeyPress)
436 {
437 keylp.lp1.previous = (InputKeyStateTable[vkey] & 0x80) != 0;
438 if (!(InputKeyStateTable[vkey] & 0x80))
439 InputKeyStateTable[vkey] ^= 0x01;
440 InputKeyStateTable[vkey] |= 0x80;
441 keylp.lp1.transition = 0;
442 message = (InputKeyStateTable[VK_MENU] & 0x80)
443 && !(InputKeyStateTable[VK_CONTROL] & 0x80)
444 ? WM_SYSKEYDOWN : WM_KEYDOWN;
445 }
446 else
447 {
448 BOOL32 sysKey = (InputKeyStateTable[VK_MENU] & 0x80)
449 && !(InputKeyStateTable[VK_CONTROL] & 0x80)
450 && (force_extended == FALSE); /* for Alt from AltGr */
451
452 InputKeyStateTable[vkey] &= ~0x80;
453 keylp.lp1.previous = 1;
454 keylp.lp1.transition = 1;
455 message = sysKey ? WM_SYSKEYUP : WM_KEYUP;
456 }
457 keylp.lp1.context = ( (event->state & Mod1Mask) ||
458 (InputKeyStateTable[VK_MENU] & 0x80)) ? 1 : 0;
459 if (!(InputKeyStateTable[VK_NUMLOCK] & 0x01) != !(event->state & NumLockMask))
460 {
461 dprintf_keyboard(stddeb,"Adjusting NumLock state. \n");
462 KEYBOARD_GenerateMsg( VK_NUMLOCK, KeyPress, event_x, event_y,
463 event_time, keylp );
464 KEYBOARD_GenerateMsg( VK_NUMLOCK, KeyRelease, event_x, event_y,
465 event_time, keylp );
466 }
467 if (!(InputKeyStateTable[VK_CAPITAL] & 0x01) != !(event->state & LockMask))
468 {
469 dprintf_keyboard(stddeb,"Adjusting Caps Lock state. State before %#.2x \n",InputKeyStateTable[VK_CAPITAL]);
470 KEYBOARD_GenerateMsg( VK_CAPITAL, KeyPress, event_x, event_y,
471 event_time, keylp );
472 KEYBOARD_GenerateMsg( VK_CAPITAL, KeyRelease, event_x, event_y,
473 event_time, keylp );
474 dprintf_keyboard(stddeb,"State after %#.2x \n",InputKeyStateTable[VK_CAPITAL]);
475 }
476 /* End of intermediary states. */
477 NumState = FALSE;
478 CapsState = FALSE;
479
480 dprintf_key(stddeb," wParam=%04X, lParam=%08lX\n",
481 vkey, keylp.lp2 );
482 dprintf_key(stddeb," InputKeyState=%X\n",
483 InputKeyStateTable[vkey]);
484
485 hardware_event( message, vkey, keylp.lp2,
486 event_x, event_y, event_time, 0 );
487 }
488 }
489 }
490 }
491
492
493 /**********************************************************************
494 * GetKeyState [USER.106]
495 */
496 WORD WINAPI GetKeyState16(INT16 vkey)
497 {
498 return GetKeyState32(vkey);
499 }
500
501 /**********************************************************************
502 * GetKeyState [USER32.248]
503 * An application calls the GetKeyState function in response to a
504 * keyboard-input message. This function retrieves the state of the key
505 * at the time the input message was generated. (SDK 3.1 Vol 2. p 390)
506 */
507 WORD WINAPI GetKeyState32(INT32 vkey)
508 {
509 INT32 retval;
510
511 switch (vkey)
512 {
513 case VK_LBUTTON : /* VK_LBUTTON is 1 */
514 retval = MouseButtonsStates[0] ? 0x8000 : 0;
515 break;
516 case VK_MBUTTON : /* VK_MBUTTON is 4 */
517 retval = MouseButtonsStates[1] ? 0x8000 : 0;
518 break;
519 case VK_RBUTTON : /* VK_RBUTTON is 2 */
520 retval = MouseButtonsStates[2] ? 0x8000 : 0;
521 break;
522 default :
523 if (vkey >= 'a' && vkey <= 'z')
524 vkey += 'A' - 'a';
525 retval = ( (WORD)(QueueKeyStateTable[vkey] & 0x80) << 8 ) |
526 (WORD)(QueueKeyStateTable[vkey] & 0x01);
527 }
528 dprintf_key(stddeb, "GetKeyState(0x%x) -> %x\n", vkey, retval);
529 return retval;
530 }
531
532 /**********************************************************************
533 * GetKeyboardState [USER.222][USER32.253]
534 * An application calls the GetKeyboardState function in response to a
535 * keyboard-input message. This function retrieves the state of the keyboard
536 * at the time the input message was generated. (SDK 3.1 Vol 2. p 387)
537 */
538 VOID WINAPI GetKeyboardState(LPBYTE lpKeyState)
539 {
540 dprintf_key(stddeb, "GetKeyboardState()\n");
541 if (lpKeyState != NULL) {
542 QueueKeyStateTable[VK_LBUTTON] = MouseButtonsStates[0] ? 0x80 : 0;
543 QueueKeyStateTable[VK_MBUTTON] = MouseButtonsStates[1] ? 0x80 : 0;
544 QueueKeyStateTable[VK_RBUTTON] = MouseButtonsStates[2] ? 0x80 : 0;
545 memcpy(lpKeyState, QueueKeyStateTable, 256);
546 }
547 }
548
549 /**********************************************************************
550 * SetKeyboardState [USER.223][USER32.483]
551 */
552 VOID WINAPI SetKeyboardState(LPBYTE lpKeyState)
553 {
554 dprintf_key(stddeb, "SetKeyboardState()\n");
555 if (lpKeyState != NULL) {
556 memcpy(QueueKeyStateTable, lpKeyState, 256);
557 MouseButtonsStates[0] = (QueueKeyStateTable[VK_LBUTTON] != 0);
558 MouseButtonsStates[1] = (QueueKeyStateTable[VK_MBUTTON] != 0);
559 MouseButtonsStates[2] = (QueueKeyStateTable[VK_RBUTTON] != 0);
560 }
561 }
562
563 /**********************************************************************
564 * GetAsyncKeyState (USER32.206)
565 *
566 * Determine if a key is or was pressed. retval has high-order
567 * bit set to 1 if currently pressed, low-order bit set to 1 if key has
568 * been pressed.
569 *
570 * This uses the variable AsyncMouseButtonsStates and
571 * AsyncKeyStateTable (set in event.c) which have the mouse button
572 * number or key number (whichever is applicable) set to true if the
573 * mouse or key had been depressed since the last call to
574 * GetAsyncKeyState.
575 */
576 WORD WINAPI GetAsyncKeyState32(INT32 nKey)
577 {
578 short retval;
579
580 switch (nKey) {
581 case VK_LBUTTON:
582 retval = (AsyncMouseButtonsStates[0] ? 0x0001 : 0) |
583 (MouseButtonsStates[0] ? 0x8000 : 0);
584 break;
585 case VK_MBUTTON:
586 retval = (AsyncMouseButtonsStates[1] ? 0x0001 : 0) |
587 (MouseButtonsStates[1] ? 0x8000 : 0);
588 break;
589 case VK_RBUTTON:
590 retval = (AsyncMouseButtonsStates[2] ? 0x0001 : 0) |
591 (MouseButtonsStates[2] ? 0x8000 : 0);
592 break;
593 default:
594 retval = AsyncKeyStateTable[nKey] |
595 ((InputKeyStateTable[nKey] & 0x80) ? 0x8000 : 0);
596 break;
597 }
598
599 /* all states to false */
600 memset( AsyncMouseButtonsStates, 0, sizeof(AsyncMouseButtonsStates) );
601 memset( AsyncKeyStateTable, 0, sizeof(AsyncKeyStateTable) );
602
603 dprintf_key(stddeb, "GetAsyncKeyState(%x) -> %x\n", nKey, retval);
604 return retval;
605 }
606
607 /**********************************************************************
608 * GetAsyncKeyState (USER.249)
609 */
610 WORD WINAPI GetAsyncKeyState16(INT16 nKey)
611 {
612 return GetAsyncKeyState32(nKey);
613 }
614
615 /*********************************************************************
616 * CreateAcceleratorTable (USER.64)
617 */
618 HACCEL32 WINAPI CreateAcceleratorTable32A(LPACCEL32 lpaccel, INT32 cEntries) {
619 fprintf(stderr, "CreateAcceleratorTable32A Stub\n");
620 return NULL;
621 }
622
623 /**********************************************************************
624 * TranslateAccelerator [USER.178][USER32.551..]
625 *
626 * FIXME: should send some WM_INITMENU or/and WM_INITMENUPOPUP -messages
627 */
628 static BOOL32 KBD_translate_accelerator(HWND32 hWnd,LPMSG32 msg,
629 BYTE fVirt,WORD key,WORD cmd)
630 {
631 BOOL32 sendmsg = FALSE;
632
633 if(msg->wParam == key)
634 {
635 if (msg->message == WM_CHAR) {
636 if ( !(fVirt & FALT) && !(fVirt & FVIRTKEY) )
637 {
638 dprintf_accel(stddeb,"found accel for WM_CHAR: ('%c')",msg->wParam&0xff);
639 sendmsg=TRUE;
640 }
641 } else {
642 if(fVirt & FVIRTKEY) {
643 INT32 mask = 0;
644 dprintf_accel(stddeb,"found accel for virt_key %04x (scan %04x)",
645 msg->wParam,0xff & HIWORD(msg->lParam));
646 if(GetKeyState32(VK_SHIFT) & 0x8000) mask |= FSHIFT;
647 if(GetKeyState32(VK_CONTROL) & 0x8000) mask |= FCONTROL;
648 if(GetKeyState32(VK_MENU) & 0x8000) mask |= FALT;
649 if(mask == (fVirt & (FSHIFT | FCONTROL | FALT)))
650 sendmsg=TRUE;
651 else
652 dprintf_accel(stddeb,", but incorrect SHIFT/CTRL/ALT-state\n");
653 }
654 else
655 {
656 if (!(msg->lParam & 0x01000000)) /* no special_key */
657 {
658 if ((fVirt & FALT) && (msg->lParam & 0x20000000))
659 { /* ^^ ALT pressed */
660 dprintf_accel(stddeb,"found accel for Alt-%c", msg->wParam&0xff);
661 sendmsg=TRUE;
662 }
663 }
664 }
665 }
666
667 if (sendmsg) /* found an accelerator, but send a message... ? */
668 {
669 INT16 iSysStat,iStat,mesg=0;
670 HMENU16 hMenu;
671
672 if (msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
673 mesg=1;
674 else
675 if (GetCapture32())
676 mesg=2;
677 else
678 if (!IsWindowEnabled32(hWnd))
679 mesg=3;
680 else
681 {
682 WND* wndPtr = WIN_FindWndPtr(hWnd);
683
684 hMenu = (wndPtr->dwStyle & WS_CHILD) ? 0 : (HMENU32)wndPtr->wIDmenu;
685 iSysStat = (wndPtr->hSysMenu) ? GetMenuState32(GetSubMenu16(wndPtr->hSysMenu, 0),
686 cmd, MF_BYCOMMAND) : -1 ;
687 iStat = (hMenu) ? GetMenuState32(hMenu,
688 cmd, MF_BYCOMMAND) : -1 ;
689
690 if (iSysStat!=-1)
691 {
692 if (iSysStat & (MF_DISABLED|MF_GRAYED))
693 mesg=4;
694 else
695 mesg=WM_SYSCOMMAND;
696 }
697 else
698 {
699 if (iStat!=-1)
700 {
701 if (IsIconic32(hWnd))
702 mesg=5;
703 else
704 {
705 if (iStat & (MF_DISABLED|MF_GRAYED))
706 mesg=6;
707 else
708 mesg=WM_COMMAND;
709 }
710 }
711 else
712 mesg=WM_COMMAND;
713 }
714 }
715 if ( mesg==WM_COMMAND || mesg==WM_SYSCOMMAND )
716 {
717 dprintf_accel(stddeb,", sending %s, wParam=%0x\n",
718 mesg==WM_COMMAND ? "WM_COMMAND" : "WM_SYSCOMMAND",
719 cmd);
720 SendMessage32A(hWnd, mesg, cmd, 0x00010000L);
721 }
722 else
723 {
724 /* some reasons for NOT sending the WM_{SYS}COMMAND message:
725 * #0: unknown (please report!)
726 * #1: for WM_KEYUP,WM_SYSKEYUP
727 * #2: mouse is captured
728 * #3: window is disabled
729 * #4: it's a disabled system menu option
730 * #5: it's a menu option, but window is iconic
731 * #6: it's a menu option, but disabled
732 */
733 dprintf_accel(stddeb,", but won't send WM_{SYS}COMMAND, reason is #%d\n",mesg);
734 }
735 return TRUE;
736 }
737 }
738 return FALSE;
739 }
740
741 INT32 WINAPI TranslateAccelerator32(HWND32 hWnd, HACCEL32 hAccel, LPMSG32 msg)
742 {
743 LPACCEL32 lpAccelTbl = (LPACCEL32)LockResource32(hAccel);
744 int i;
745
746 if (hAccel == 0 || msg == NULL) return 0;
747 if (msg->message != WM_KEYDOWN &&
748 msg->message != WM_KEYUP &&
749 msg->message != WM_SYSKEYDOWN &&
750 msg->message != WM_SYSKEYUP &&
751 msg->message != WM_CHAR) return 0;
752
753 dprintf_accel(stddeb, "TranslateAccelerators hAccel=%04x, hWnd=%04x,\
754 msg->hwnd=%04x, msg->message=%04x\n", hAccel,hWnd,msg->hwnd,msg->message);
755
756 for (i = 0; lpAccelTbl[i].key ; i++)
757 if (KBD_translate_accelerator(hWnd,msg,lpAccelTbl[i].fVirt,
758 lpAccelTbl[i].key,lpAccelTbl[i].cmd))
759 return 1;
760 return 0;
761 }
762
763 INT16 WINAPI TranslateAccelerator16(HWND16 hWnd, HACCEL16 hAccel, LPMSG16 msg)
764 {
765 LPACCEL16 lpAccelTbl = (LPACCEL16)LockResource16(hAccel);
766 int i;
767 MSG32 msg32;
768
769 if (hAccel == 0 || msg == NULL) return 0;
770 if (msg->message != WM_KEYDOWN &&
771 msg->message != WM_KEYUP &&
772 msg->message != WM_SYSKEYDOWN &&
773 msg->message != WM_SYSKEYUP &&
774 msg->message != WM_CHAR) return 0;
775
776 dprintf_accel(stddeb, "TranslateAccelerators hAccel=%04x, hWnd=%04x,\
777 msg->hwnd=%04x, msg->message=%04x\n", hAccel,hWnd,msg->hwnd,msg->message);
778 STRUCT32_MSG16to32(msg,&msg32);
779
780
781 for (i=0;lpAccelTbl[i].key;i++)
782 if (KBD_translate_accelerator(hWnd,&msg32,lpAccelTbl[i].fVirt,
783 lpAccelTbl[i].key,lpAccelTbl[i].cmd))
784 return 1;
785 return 0;
786 }
787
788
789 /******************************************************************************
790 * OemKeyScan [KEYBOARD.128][USER32.400]
791 */
792 DWORD WINAPI OemKeyScan(WORD wOemChar)
793 {
794 dprintf_keyboard(stddeb,"*OemKeyScan (%d)\n",wOemChar);
795
796 return wOemChar;
797 }
798
799 /******************************************************************************
800 * VkKeyScanA [USER32.572]
801 */
802 /* VkKeyScan translates an ANSI character to a virtual-key and shift code
803 * for the current keyboard.
804 * high-order byte yields :
805 * 0 Unshifted
806 * 1 Shift
807 * 2 Ctrl
808 * 3-5 Shift-key combinations that are not used for characters
809 * 6 Ctrl-Alt
810 * 7 Ctrl-Alt-Shift
811 * I.e. : Shift = 1, Ctrl = 2, Alt = 4.
812 * FIXME : works ok except for dead chars :
813 * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
814 * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
815 */
816
817 WORD WINAPI VkKeyScan32A(CHAR cChar)
818 {
819 KeyCode keycode;
820 KeySym keysym;
821 int i,index;
822 int highbyte=0;
823
824 /* char->keysym (same for ANSI chars) */
825 keysym=(unsigned char) cChar;/* (!) cChar is signed */
826 if (keysym<=27) keysym+=0xFF00;/*special chars : return, backspace...*/
827
828 keycode = TSXKeysymToKeycode(display, keysym); /* keysym -> keycode */
829 if (!keycode)
830 { /* It didn't work ... let's try with deadchar code. */
831 keycode = TSXKeysymToKeycode(display, keysym | 0xFE00);
832 }
833
834 dprintf_keyboard(stddeb,"VkKeyScan '%c'(%#lx, %lu) : got keycode %#.2x ",
835 cChar,keysym,keysym,keycode);
836
837 if (keycode)
838 {
839 for (index=-1, i=0; (i<8) && (index<0); i++) /* find shift state */
840 if (TSXKeycodeToKeysym(display,keycode,i)==keysym) index=i;
841 switch (index) {
842 case -1 :
843 fprintf(stderr,"Keysym %lx not found while parsing the keycode table\n",keysym); break;
844 case 0 : break;
845 case 1 : highbyte = 0x0100; break;
846 case 2 : highbyte = 0X0600; break;
847 default : fprintf(stderr,"index %d found by XKeycodeToKeysym. please report! \n",index);
848 }
849 /*
850 index : 0 adds 0x0000
851 index : 1 adds 0x0100 (shift)
852 index : ? adds 0x0200 (ctrl)
853 index : 2 adds 0x0600 (ctrl+alt)
854 index : ? adds 0x0700 (ctrl+alt+shift (used?))
855 */
856 }
857 dprintf_keyboard(stddeb," ... returning %#.2x\n", keyc2vkey[keycode]+highbyte);
858 return keyc2vkey[keycode]+highbyte; /* keycode -> (keyc2vkey) vkey */
859 }
860
861 /******************************************************************************
862 * VkKeyScan [KEYBOARD.129]
863 */
864 WORD WINAPI VkKeyScan16(CHAR cChar)
865 {
866 return VkKeyScan32A(cChar);
867 }
868
869 /******************************************************************************
870 * VkKeyScanW [USER32.575]
871 */
872 WORD WINAPI VkKeyScan32W(WCHAR cChar)
873 {
874 return VkKeyScan32A((CHAR)cChar); /* FIXME: check unicode */
875 }
876
877 /******************************************************************************
878 * GetKeyboardType [KEYBOARD.130]
879 */
880 INT16 WINAPI GetKeyboardType16(INT16 nTypeFlag)
881 {
882 return GetKeyboardType32(nTypeFlag);
883 }
884
885 /******************************************************************************
886 * GetKeyboardType [USER32.254]
887 */
888 INT32 WINAPI GetKeyboardType32(INT32 nTypeFlag)
889 {
890 dprintf_keyboard(stddeb,"GetKeyboardType(%d)\n",nTypeFlag);
891 switch(nTypeFlag)
892 {
893 case 0: /* Keyboard type */
894 return 4; /* AT-101 */
895 break;
896 case 1: /* Keyboard Subtype */
897 return 0; /* There are no defined subtypes */
898 break;
899 case 2: /* Number of F-keys */
900 return 12; /* We're doing an 101 for now, so return 12 F-keys */
901 break;
902 default:
903 fprintf(stderr, "Unknown type on GetKeyboardType\n");
904 return 0; /* The book says 0 here, so 0 */
905 }
906 }
907
908
909 /******************************************************************************
910 * MapVirtualKeyA [USER32.382]
911 */
912 UINT32 WINAPI MapVirtualKey32A(UINT32 code, UINT32 maptype)
913 {
914 return MapVirtualKey16(code,maptype);
915 }
916
917 /******************************************************************************
918 * MapVirtualKeyA [USER32.384]
919 */
920 UINT32 WINAPI MapVirtualKey32W(UINT32 code, UINT32 maptype)
921 {
922 return MapVirtualKey16(code,maptype);
923 }
924
925 /******************************************************************************
926 * MapVirtualKeyA [KEYBOARD.131]
927 * MapVirtualKey translates keycodes from one format to another
928 */
929 UINT16 WINAPI MapVirtualKey16(UINT16 wCode, UINT16 wMapType)
930 {
931 #define returnMVK(value) { dprintf_keyboard(stddeb,"returning 0x%x.\n",value); return value; }
932
933 dprintf_keyboard(stddeb,"MapVirtualKey wCode=0x%x wMapType=%d ... ",wCode,wMapType);
934 switch(wMapType) {
935 case 0: { /* vkey-code to scan-code */
936 /* let's do vkey -> keycode -> scan */
937 KeyCode keyc;
938 for (keyc=min_keycode; keyc<=max_keycode; keyc++) /* see event.c */
939 if ((keyc2vkey[keyc] & 0xFF)== wCode)
940 returnMVK (keyc - 8);
941 return 0; }
942
943 case 1: /* scan-code to vkey-code */
944 /* let's do scan -> keycode -> vkey */
945
946 returnMVK (keyc2vkey[(wCode & 0xFF) + 8]);
947
948 case 2: { /* vkey-code to unshifted ANSI code */
949 /* (was FIXME) : what does unshifted mean ? 'a' or 'A' ? */
950 /* My Windows returns 'A'. */
951 /* let's do vkey -> keycode -> (XLookupString) ansi char */
952 XKeyEvent e;
953 KeySym keysym;
954 char s[2];
955 e.display = display;
956 e.state = 0; /* unshifted */
957 e.keycode = MapVirtualKey16( wCode, 0);
958 if (!TSXLookupString(&e, s , 2 , &keysym, NULL))
959 returnMVK (*s);
960
961 return 0;
962 }
963 default: /* reserved */
964 fprintf(stderr, "MapVirtualKey: unknown wMapType %d !\n",
965 wMapType);
966 return 0;
967 }
968 return 0;
969 }
970
971
972 /****************************************************************************
973 * GetKBCodePage16 (KEYBOARD.132)
974 */
975 INT16 WINAPI GetKBCodePage16(void)
976 {
977 dprintf_keyboard(stddeb,"GetKBCodePage()\n");
978 return 850;
979 }
980
981
982 /****************************************************************************
983 * GetKBCodePage32 (USER32.245)
984 */
985 UINT32 WINAPI GetKBCodePage32(void)
986 {
987 dprintf_keyboard(stddeb,"GetKbCodePage()\n");
988 return 850;
989 }
990
991
992 /****************************************************************************
993 * GetKeyNameText32W (USER32.247)
994 */
995 INT32 WINAPI GetKeyNameText32W(LONG lParam, LPWSTR lpBuffer, INT32 nSize)
996 {
997 LPSTR buf = HEAP_xalloc( GetProcessHeap(), 0, nSize );
998 int res = GetKeyNameText32A(lParam,buf,nSize);
999
1000 lstrcpynAtoW(lpBuffer,buf,nSize);
1001 HeapFree( GetProcessHeap(), 0, buf );
1002 return res;
1003 }
1004
1005 /****************************************************************************
1006 * GetKeyNameText32A (USER32.246)
1007 */
1008 INT32 WINAPI GetKeyNameText32A(LONG lParam, LPSTR lpBuffer, INT32 nSize)
1009 {
1010 return GetKeyNameText16(lParam,lpBuffer,nSize);
1011 }
1012
1013 /****************************************************************************
1014 * GetKeyNameText16 (KEYBOARD.133)
1015 */
1016 INT16 WINAPI GetKeyNameText16(LONG lParam, LPSTR lpBuffer, INT16 nSize)
1017 {
1018 /* int i; */
1019
1020 dprintf_keyboard(stddeb,"GetKeyNameText(%ld,<ptr>,%d)\n",lParam,nSize);
1021
1022 lParam >>= 16;
1023 lParam &= 0xff;
1024
1025 /* for (i = 0 ; i != KeyTableSize ; i++)
1026 if (KeyTable[i].scancode == lParam) {
1027 lstrcpyn32A( lpBuffer, KeyTable[i].name, nSize );
1028 return strlen(lpBuffer);
1029 }
1030 */
1031 /* FIXME ! GetKeyNameText is still to do...
1032 */
1033 *lpBuffer = 0;
1034 return 0;
1035 }
1036
1037
1038 /****************************************************************************
1039 * ToAscii (KEYBOARD.4)
1040 */
1041 INT16 WINAPI ToAscii16(UINT16 virtKey,UINT16 scanCode, LPBYTE lpKeyState,
1042 LPVOID lpChar, UINT16 flags)
1043 {
1044 return ToAscii32(virtKey,scanCode,lpKeyState,lpChar,flags);
1045 }
1046
1047 /****************************************************************************
1048 * ToAscii (USER32.545)
1049 */
1050 INT32 WINAPI ToAscii32( UINT32 virtKey,UINT32 scanCode,LPBYTE lpKeyState,
1051 LPWORD lpChar,UINT32 flags )
1052 {
1053 XKeyEvent e;
1054 KeySym keysym;
1055 static XComposeStatus cs;
1056 INT32 ret;
1057 WORD keyc;
1058
1059 e.display = display;
1060 e.keycode = 0;
1061 for (keyc=min_keycode; keyc<=max_keycode; keyc++)
1062 { /* this could be speeded up by making another table, an array of struct vkey,keycode
1063 * (vkey -> keycode) with vkeys sorted .... but it takes memory (512*3 bytes)! DF */
1064 if ((keyc2vkey[keyc] & 0xFF)== virtKey) /* no need to make a more precise test (with the extended bit correctly set above virtKey ... VK* are different enough... */
1065 {
1066 if ((e.keycode) && ((virtKey<0x10) || (virtKey>0x12)))
1067 /* it's normal to have 2 shift, control, and alt ! */
1068 dprintf_keyboard(stddeb,"ToAscii : The keycodes %d and %d are matching the same vkey %#X\n",
1069 e.keycode,keyc,virtKey);
1070 e.keycode = keyc;
1071 }
1072 }
1073 if ((!e.keycode) && (lpKeyState[VK_NUMLOCK] & 0x01))
1074 {
1075 if ((virtKey>=VK_NUMPAD0) && (virtKey<=VK_NUMPAD9))
1076 e.keycode = TSXKeysymToKeycode(e.display, virtKey-VK_NUMPAD0+XK_KP_0);
1077 if (virtKey==VK_DECIMAL)
1078 e.keycode = TSXKeysymToKeycode(e.display, XK_KP_Decimal);
1079 }
1080 if (!e.keycode)
1081 {
1082 fprintf(stderr,"ToAscii : Unknown virtual key %X !!! \n",virtKey);
1083 return virtKey; /* whatever */
1084 }
1085 e.state = 0;
1086 if (lpKeyState[VK_SHIFT] & 0x80)
1087 e.state |= ShiftMask;
1088 dprintf_keyboard(stddeb,"ToAscii : lpKeyState[0x14(VK_CAPITAL)]=%#x\n",lpKeyState[VK_CAPITAL]);
1089 if (lpKeyState[VK_CAPITAL] & 0x01)
1090 e.state |= LockMask;
1091 if (lpKeyState[VK_CONTROL] & 0x80)
1092 if (lpKeyState[VK_MENU] & 0x80)
1093 e.state |= AltGrMask;
1094 else
1095 e.state |= ControlMask;
1096 if (lpKeyState[VK_NUMLOCK] & 0x01)
1097 e.state |= NumLockMask;
1098 dprintf_key(stddeb, "ToAscii(%04X, %04X) : faked state = %X\n",
1099 virtKey, scanCode, e.state);
1100 ret = TSXLookupString(&e, (LPVOID)lpChar, 2, &keysym, &cs);
1101 if (ret == 0)
1102 {
1103 BYTE dead_char = 0;
1104
1105 ((char*)lpChar)[1] = '\0';
1106 switch (keysym)
1107 {
1108 /* symbolic ASCII is the same as defined in rfc1345 */
1109 #ifdef XK_dead_tilde
1110 case XK_dead_tilde :
1111 #endif
1112 case 0x1000FE7E : /* Xfree's XK_Dtilde */
1113 dead_char = '~'; /* '? */
1114 break;
1115 #ifdef XK_dead_acute
1116 case XK_dead_acute :
1117 #endif
1118 case 0x1000FE27 : /* Xfree's XK_Dacute_accent */
1119 dead_char = 0xb4; /* '' */
1120 break;
1121 #ifdef XK_dead_circumflex
1122 case XK_dead_circumflex :
1123 #endif
1124 case 0x1000FE5E : /* Xfree's XK_Dcircumflex_accent */
1125 dead_char = '^'; /* '> */
1126 break;
1127 #ifdef XK_dead_grave
1128 case XK_dead_grave :
1129 #endif
1130 case 0x1000FE60 : /* Xfree's XK_Dgrave_accent */
1131 dead_char = '`'; /* '! */
1132 break;
1133 #ifdef XK_dead_diaeresis
1134 case XK_dead_diaeresis :
1135 #endif
1136 case 0x1000FE22 : /* Xfree's XK_Ddiaeresis */
1137 dead_char = 0xa8; /* ': */
1138 break;
1139 #ifdef XK_dead_cedilla
1140 case XK_dead_cedilla :
1141 dead_char = 0xb8; /* ', */
1142 break;
1143 #endif
1144 #ifdef XK_dead_macron
1145 case XK_dead_macron :
1146 dead_char = '-'; /* 'm isn't defined on iso-8859-x */
1147 break;
1148 #endif
1149 #ifdef XK_dead_breve
1150 case XK_dead_breve :
1151 dead_char = 0xa2; /* '( */
1152 break;
1153 #endif
1154 #ifdef XK_dead_abovedot
1155 case XK_dead_abovedot :
1156 dead_char = 0xff; /* '. */
1157 break;
1158 #endif
1159 #ifdef XK_dead_abovering
1160 case XK_dead_abovering :
1161 dead_char = '0'; /* '0 isn't defined on iso-8859-x */
1162 break;
1163 #endif
1164 #ifdef XK_dead_doubleacute
1165 case XK_dead_doubleacute :
1166 dead_char = 0xbd; /* '" */
1167 break;
1168 #endif
1169 #ifdef XK_dead_caron
1170 case XK_dead_caron :
1171 dead_char = 0xb7; /* '< */
1172 break;
1173 #endif
1174 #ifdef XK_dead_ogonek
1175 case XK_dead_ogonek :
1176 dead_char = 0xb2; /* '; */
1177 break;
1178 #endif
1179 /* FIXME: I don't know this three.
1180 case XK_dead_iota :
1181 dead_char = 'i';
1182 break;
1183 case XK_dead_voiced_sound :
1184 dead_char = 'v';
1185 break;
1186 case XK_dead_semivoiced_sound :
1187 dead_char = 's';
1188 break;
1189 */
1190 }
1191 if (dead_char)
1192 {
1193 *(char*)lpChar = dead_char;
1194 ret = -1;
1195 }
1196 else
1197 {
1198 char *ksname;
1199
1200 ksname = TSXKeysymToString(keysym);
1201 if (!ksname)
1202 ksname = "No Name";
1203 if ((keysym >> 8) != 0xff)
1204 {
1205 fprintf(stderr, "Please report : no char for keysym %04lX (%s) :\n",
1206 keysym, ksname);
1207 fprintf(stderr, " virtKey = %X, scanCode = %X, keycode = %X, state = %X\n",
1208 virtKey, scanCode, e.keycode, e.state);
1209 }
1210 }
1211 }
1212 dprintf_key(stddeb, "ToAscii about to return %d with char %x\n",
1213 ret, *(char*)lpChar);
1214 return ret;
1215 }
1216
1217
1218 /***********************************************************************
1219 * GetKeyboardLayout (USER32.249)
1220 */
1221 HKL32 WINAPI GetKeyboardLayout(DWORD dwLayout)
1222 {
1223 fprintf(stderr,"GetKeyboardLayout(%ld),STUB!\n",dwLayout);
1224 return (0xcafe<<16)|GetSystemDefaultLCID(); /* FIXME */
1225 }
1226
1227 /***********************************************************************
1228 * GetKeyboardLayoutList (USER32.250)
1229 * FIXME
1230 */
1231 INT32 WINAPI GetKeyboardLayoutList(INT32 nBuff,HKL32 *layouts)
1232 {
1233 fprintf(stderr,"GetKeyboardLayoutList(%d,%p),STUB!\n",nBuff,layouts);
1234 if (layouts)
1235 layouts[0] = GetKeyboardLayout(0);
1236 return 1;
1237 }
1238
1239
1240 /***********************************************************************
1241 * RegisterHotKey (USER32.433)
1242 */
1243 BOOL32 WINAPI RegisterHotKey(HWND32 hwnd,INT32 id,UINT32 modifiers,UINT32 vk) {
1244 fprintf(stderr,"RegisterHotKey(%08x,%d,%08x,%d), STUB!\n",
1245 hwnd,id,modifiers,vk
1246 );
1247 return TRUE;
1248 }
1249
1250 /***********************************************************************
1251 * UnregisterHotKey (USER32.565)
1252 */
1253 BOOL32 WINAPI UnregisterHotKey(HWND32 hwnd,INT32 id) {
1254 fprintf(stderr,"UnregisterHotKey(%08x,%d),stub!\n",hwnd,id);
1255 return TRUE;
1256 }
Maarten's multimedia branch