source: branches/gcc-kmk/src/user32/winkeyboard.cpp@ 21885

Last change on this file since 21885 was 21885, checked in by dmik, 14 years ago

Fix crashes in GUI apps when pressing modifier keys.

This was due the fact that BYTE is signed in the toolkit and converting it
to an unsigned int causes the sign bit to be extended in the result while
the code assumes that the extension is made with zeroes (this is how
VAC converts signed integers of smaller precisions to unsigned ones).
File size: 90.8 KB
Line 
1/* $Id: winkeyboard.cpp,v 1.45 2004-03-23 15:49:50 sandervl Exp $ */
2/*
3 * Win32 <-> PM key translation
4 *
5 *
6 * Project Odin Software License can be found in LICENSE.TXT
7 *
8 */
9
10#include <odin.h>
11#include <odinwrap.h>
12#include <os2sel.h>
13
14#include <os2win.h>
15
16#include <string.h>
17#include <stdio.h>
18#include <winkeyboard.h>
19#include "oslibkbd.h"
20#include <heapstring.h>
21#include <pmscan.h>
22#include <winscan.h>
23#include <winuser32.h>
24#include "initterm.h"
25
26#define DBG_LOCALLOG DBG_winkeyboard
27#include "dbglocal.h"
28
29
30/****************************************************************************
31 * module local variables
32 ****************************************************************************/
33
34static char arrchOverlayKeyState[256] = {0};
35
36
37
38
39/****************************************************************************
40 * implementation
41 ****************************************************************************/
42
43BOOL OPEN32API _O32_GetKeyboardState( PBYTE lpKeyState );
44
45inline BOOL O32_GetKeyboardState(PBYTE lpKeyState)
46{
47 BOOL yyrc;
48 USHORT sel = RestoreOS2FS();
49
50 yyrc = _O32_GetKeyboardState(lpKeyState);
51 SetFS(sel);
52
53 return yyrc;
54}
55
56
57static UCHAR auchPMScanToWinVKey[256][2] =
58/****************************************************************************/
59/* PM Scancode * Win32 vkey Extended Key */
60/****************************************************************************/
61/* 0x00 */ { 0x00, FALSE
62/* 0x01 PMSCAN_ESC */ , VK_ESCAPE ,FALSE
63/* 0x02 PMSCAN_ONE */ , VK_1 ,FALSE
64/* 0x03 PMSCAN_TWO */ , VK_2 ,FALSE
65/* 0x04 PMSCAN_THREE */ , VK_3 ,FALSE
66/* 0x05 PMSCAN_FOUR */ , VK_4 ,FALSE
67/* 0x06 PMSCAN_FIVE */ , VK_5 ,FALSE
68/* 0x07 PMSCAN_SIX */ , VK_6 ,FALSE
69/* 0x08 PMSCAN_SEVEN */ , VK_7 ,FALSE
70/* 0x09 PMSCAN_EIGHT */ , VK_8 ,FALSE
71/* 0x0A PMSCAN_NINE */ , VK_9 ,FALSE
72/* 0x0B PMSCAN_ZERO */ , VK_0 ,FALSE
73/* 0x0C PMSCAN_HYPHEN */ , VK_HYPHEN ,FALSE
74/* 0x0D PMSCAN_EQUAL */ , VK_EQUAL ,FALSE
75/* 0x0E PMSCAN_BACKSPACE */ , VK_BACK ,FALSE
76/* 0x0F PMSCAN_TAB */ , VK_TAB ,FALSE
77/* 0x10 PMSCAN_Q */ , VK_Q ,FALSE
78/* 0x11 PMSCAN_W */ , VK_W ,FALSE
79/* 0x12 PMSCAN_E */ , VK_E ,FALSE
80/* 0x13 PMSCAN_R */ , VK_R ,FALSE
81/* 0x14 PMSCAN_T */ , VK_T ,FALSE
82/* 0x15 PMSCAN_Y */ , VK_Y ,FALSE
83/* 0x16 PMSCAN_U */ , VK_U ,FALSE
84/* 0x17 PMSCAN_I */ , VK_I ,FALSE
85/* 0x18 PMSCAN_O */ , VK_O ,FALSE
86/* 0x19 PMSCAN_P */ , VK_P ,FALSE
87/* 0x1A PMSCAN_BRACKETLEFT */ , VK_BRACKETLEFT ,FALSE
88/* 0x1B PMSCAN_BRACKETRIGHT */ , VK_BRACKETRIGHT ,FALSE
89/* 0x1C PMSCAN_ENTER */ , VK_RETURN ,FALSE
90/* 0x1D PMSCAN_CTRLLEFT */ , VK_LCONTROL ,FALSE
91/* 0x1E PMSCAN_A */ , VK_A ,FALSE
92/* 0x1F PMSCAN_S */ , VK_S ,FALSE
93/* 0x20 PMSCAN_D */ , VK_D ,FALSE
94/* 0x21 PMSCAN_F */ , VK_F ,FALSE
95/* 0x22 PMSCAN_G */ , VK_G ,FALSE
96/* 0x23 PMSCAN_H */ , VK_H ,FALSE
97/* 0x24 PMSCAN_J */ , VK_J ,FALSE
98/* 0x25 PMSCAN_K */ , VK_K ,FALSE
99/* 0x26 PMSCAN_L */ , VK_L ,FALSE
100/* 0x27 PMSCAN_SEMICOLON */ , VK_SEMICOLON ,FALSE
101/* 0x28 PMSCAN_QUOTESINGLE */ , VK_QUOTESINGLE ,FALSE
102/* 0x29 PMSCAN_GRAVE */ , VK_GRAVE ,FALSE
103/* 0x2A PMSCAN_SHIFTLEFT */ , VK_LSHIFT ,FALSE
104/* 0x2B PMSCAN_BACKSLASH */ , VK_BACKSLASH ,FALSE
105/* 0x2C PMSCAN_Z */ , VK_Z ,FALSE
106/* 0x2D PMSCAN_X */ , VK_X ,FALSE
107/* 0x2E PMSCAN_C */ , VK_C ,FALSE
108/* 0x2F PMSCAN_V */ , VK_V ,FALSE
109/* 0x30 PMSCAN_B */ , VK_B ,FALSE
110/* 0x31 PMSCAN_N */ , VK_N ,FALSE
111/* 0x32 PMSCAN_M */ , VK_M ,FALSE
112/* 0x33 PMSCAN_COMMA */ , VK_COMMA ,FALSE
113/* 0x34 PMSCAN_PERIOD */ , VK_PERIOD ,FALSE
114/* 0x35 PMSCAN_SLASH */ , VK_SLASH ,FALSE
115/* 0x36 PMSCAN_SHIFTRIGHT */ , VK_RSHIFT ,FALSE
116/* 0x37 PMSCAN_PADASTERISK */ , VK_MULTIPLY ,FALSE
117/* 0x38 PMSCAN_ALTLEFT */ , VK_LMENU ,FALSE
118/* 0x39 PMSCAN_SPACE */ , VK_SPACE ,FALSE
119/* 0x3A PMSCAN_CAPSLOCK */ , VK_CAPITAL ,FALSE
120/* 0x3B PMSCAN_F1 */ , VK_F1 ,FALSE
121/* 0x3C PMSCAN_F2 */ , VK_F2 ,FALSE
122/* 0x3D PMSCAN_F3 */ , VK_F3 ,FALSE
123/* 0x3E PMSCAN_F4 */ , VK_F4 ,FALSE
124/* 0x3F PMSCAN_F5 */ , VK_F5 ,FALSE
125/* 0x40 PMSCAN_F6 */ , VK_F6 ,FALSE
126/* 0x41 PMSCAN_F7 */ , VK_F7 ,FALSE
127/* 0x42 PMSCAN_F8 */ , VK_F8 ,FALSE
128/* 0x43 PMSCAN_F9 */ , VK_F9 ,FALSE
129/* 0x44 PMSCAN_F10 */ , VK_F10 ,FALSE
130/* 0x45 PMSCAN_NUMLOCK */ , VK_NUMLOCK ,TRUE
131/* 0x46 PMSCAN_SCROLLLOCK */ , VK_SCROLL ,FALSE
132/* 0x47 PMSCAN_PAD7 */ , VK_NUMPAD7 ,FALSE
133/* 0x48 PMSCAN_PAD8 */ , VK_NUMPAD8 ,FALSE
134/* 0x49 PMSCAN_PAD9 */ , VK_NUMPAD9 ,FALSE
135/* 0x4A PMSCAN_PADMINUS */ , VK_SUBTRACT ,FALSE
136/* 0x4B PMSCAN_PAD4 */ , VK_NUMPAD4 ,FALSE
137/* 0x4C PMSCAN_PAD5 */ , VK_NUMPAD5 ,FALSE
138/* 0x4D PMSCAN_PAD6 */ , VK_NUMPAD6 ,FALSE
139/* 0x4E PMSCAN_PADPLUS */ , VK_ADD ,FALSE
140/* 0x4F PMSCAN_PAD1 */ , VK_NUMPAD1 ,FALSE
141/* 0x50 PMSCAN_PAD2 */ , VK_NUMPAD2 ,FALSE
142/* 0x51 PMSCAN_PAD3 */ , VK_NUMPAD3 ,FALSE
143/* 0x52 PMSCAN_PAD0 */ , VK_NUMPAD0 ,FALSE
144/* 0x53 PMSCAN_PADPERIOD */ , VK_DECIMAL ,FALSE
145/* 0x54 PMSCAN_SYSREQ */ , 0x00 ,FALSE
146/* 0x55 PMSCAN_RESET */ , 0x00 ,FALSE
147/* 0x56 PMSCAN_EXTRA */ , VK_EXTRA ,FALSE
148/* 0x57 PMSCAN_F11 */ , VK_F11 ,FALSE
149/* 0x58 PMSCAN_F12 */ , VK_F12 ,FALSE
150/* 0x59 PMSCAN_BACKTAB */ , 0x00 ,FALSE
151/* 0x5A PMSCAN_PADENTER */ , VK_RETURN ,TRUE
152/* 0x5B PMSCAN_CTRLRIGHT */ , VK_RCONTROL ,TRUE
153/* 0x5C PMSCAN_PADSLASH */ , VK_DIVIDE ,TRUE
154/* 0x5D PMSCAN_PRINT */ , VK_SNAPSHOT ,TRUE
155/* 0x5E PMSCAN_ALTRIGHT */ , VK_RMENU ,TRUE
156/* 0x5F PMSCAN_PAUSE */ , VK_PAUSE ,FALSE
157/* 0x60 PMSCAN_HOME */ , VK_HOME ,TRUE
158/* 0x61 PMSCAN_UP */ , VK_UP ,TRUE
159/* 0x62 PMSCAN_PAGEUP */ , VK_PRIOR ,TRUE
160/* 0x63 PMSCAN_LEFT */ , VK_LEFT ,TRUE
161/* 0x64 PMSCAN_RIGHT */ , VK_RIGHT ,TRUE
162/* 0x65 PMSCAN_END */ , VK_END ,TRUE
163/* 0x66 PMSCAN_DOWN */ , VK_DOWN ,TRUE
164/* 0x67 PMSCAN_PAGEDOWN */ , VK_NEXT ,TRUE
165/* 0x68 PMSCAN_INSERT */ , VK_INSERT ,TRUE
166/* 0x69 PMSCAN_DELETE */ , VK_DELETE ,TRUE
167/* 0x6A PMSCAN_F23 */ , VK_F23 ,FALSE
168/* 0x6B PMSCAN_F24 */ , VK_F24 ,FALSE
169/* 0x6C PMSCAN_SYSMEM */ , 0x00 ,FALSE
170/* 0x6D PMSCAN_ERASEEOF */ , VK_EREOF ,FALSE
171/* 0x6E PMSCAN_BREAK */ , VK_CANCEL ,TRUE
172/* 0x6F PMSCAN_MOVEWIN */ , 0x00 ,FALSE
173/* 0x70 PMSCAN_NLS3 */ , 0x00 ,FALSE
174/* 0x71 PMSCAN_HELP */ , VK_HELP ,FALSE
175/* 0x72 PMSCAN_TASKMAN */ , 0x00 ,FALSE
176/* 0x73 PMSCAN_B11 */ , 0x00 ,FALSE
177/* 0x74 PMSCAN_JUMP */ , 0x00 ,FALSE
178/* 0x75 PMSCAN_MINWIN */ , 0x00 ,FALSE
179/* 0x76 PMSCAN_CLEAR */ , 0x00 ,FALSE
180/* 0x77 PMSCAN_77 */ , 0x00 ,FALSE
181/* 0x78 PMSCAN_78 */ , 0x00 ,FALSE
182/* 0x79 PMSCAN_NLS2 */ , 0x00 ,FALSE
183/* 0x7a PMSCAN_SIZE */ , 0x00 ,FALSE
184/* 0x7b PMSCAN_NLS1 */ , 0x00 ,FALSE
185/* 0x7c PMSCAN_APPLICATION */ , VK_APPS ,TRUE
186/* 0x7d PMSCAN_E13 */ , 0x00 ,FALSE
187/* 0x7e PMSCAN_WINLEFT */ , VK_LWIN ,TRUE
188/* 0x7f PMSCAN_WINRIGHT */ , VK_RWIN ,TRUE
189/* 0x80 PMSCAN_PA1 */ , VK_PA1 ,FALSE
190/* 0x81 PMSCAN_F13 */ , VK_F13 ,FALSE
191/* 0x82 PMSCAN_F14 */ , VK_F14 ,FALSE
192/* 0x83 PMSCAN_F15 */ , VK_F15 ,FALSE
193/* 0x84 PMSCAN_PA2 */ , 0x00 ,FALSE
194/* 0x85 PMSCAN_PA3 */ , 0x00 ,FALSE
195/* 0x86 PMSCAN_SPACEBREAK */ , 0x00 ,FALSE
196/* 0x87 PMSCAN_TABRIGHT */ , 0x00 ,FALSE
197/* 0x88 PMSCAN_NOOP */ , 0x00 ,FALSE
198/* 0x89 PMSCAN_F16 */ , VK_F16 ,FALSE
199/* 0x8a PMSCAN_F17 */ , VK_F17 ,FALSE
200/* 0x8b PMSCAN_F18 */ , VK_F18 ,FALSE
201/* 0x8c PMSCAN_F19 */ , VK_F19 ,FALSE
202/* 0x8d PMSCAN_F20 */ , VK_F20 ,FALSE
203/* 0x8e PMSCAN_F21 */ , VK_F21 ,FALSE
204/* 0x8f PMSCAN_F22 */ , VK_F22 ,FALSE
205/* 0x90 */ , 0x00 ,FALSE
206/* 0x91 */ , 0x00 ,FALSE
207/* 0x92 */ , 0x00 ,FALSE
208/* 0x93 */ , 0x00 ,FALSE
209/* 0x94 */ , 0x00 ,FALSE
210/* 0x95 PMSCAN_DBE_CONV */ , 0x00 ,FALSE //TODO ??
211/* 0x96 PMSCAN_DBE_NOCONV */ , 0x00 ,FALSE //TODO ??
212/* 0x97 */ , 0x00 ,FALSE
213/* 0x98 */ , 0x00 ,FALSE
214/* 0x99 */ , 0x00 ,FALSE
215/* 0x9A */ , 0x00 ,FALSE
216/* 0x9B */ , 0x00 ,FALSE
217/* 0x9C */ , 0x00 ,FALSE
218/* 0x9D */ , 0x00 ,FALSE
219/* 0x9E */ , 0x00 ,FALSE
220/* 0x9F */ , 0x00 ,FALSE
221/* 0xA0 */ , 0x00 ,FALSE
222/* 0xA1 */ , 0x00 ,FALSE
223/* 0xA2 */ , 0x00 ,FALSE
224/* 0xA3 */ , 0x00 ,FALSE
225/* 0xA4 */ , 0x00 ,FALSE
226/* 0xA5 */ , 0x00 ,FALSE
227/* 0xA6 */ , 0x00 ,FALSE
228/* 0xA7 */ , 0x00 ,FALSE
229/* 0xA8 */ , 0x00 ,FALSE
230/* 0xA9 */ , 0x00 ,FALSE
231/* 0xAA */ , 0x00 ,FALSE
232/* 0xAB */ , 0x00 ,FALSE
233/* 0xAC */ , 0x00 ,FALSE
234/* 0xAD */ , 0x00 ,FALSE
235/* 0xAE */ , 0x00 ,FALSE
236/* 0xAF */ , 0x00 ,FALSE
237/* 0xB0 */ , 0x00 ,FALSE
238/* 0xB1 */ , 0x00 ,FALSE
239/* 0xB2 */ , 0x00 ,FALSE
240/* 0xB3 */ , 0x00 ,FALSE
241/* 0xB4 */ , 0x00 ,FALSE
242/* 0xB5 */ , 0x00 ,FALSE
243/* 0xB6 */ , 0x00 ,FALSE
244/* 0xB7 */ , 0x00 ,FALSE
245/* 0xB8 */ , 0x00 ,FALSE
246/* 0xB9 */ , 0x00 ,FALSE
247/* 0xBA */ , 0x00 ,FALSE
248/* 0xBB */ , 0x00 ,FALSE
249/* 0xBC */ , 0x00 ,FALSE
250/* 0xBD */ , 0x00 ,FALSE
251/* 0xBE */ , 0x00 ,FALSE
252/* 0xBF */ , 0x00 ,FALSE
253/* 0xC0 */ , 0x00 ,FALSE
254/* 0xC1 */ , 0x00 ,FALSE
255/* 0xC2 */ , 0x00 ,FALSE
256/* 0xC3 */ , 0x00 ,FALSE
257/* 0xC4 */ , 0x00 ,FALSE
258/* 0xC5 */ , 0x00 ,FALSE
259/* 0xC6 */ , 0x00 ,FALSE
260/* 0xC7 */ , 0x00 ,FALSE
261/* 0xC8 */ , 0x00 ,FALSE
262/* 0xC9 */ , 0x00 ,FALSE
263/* 0xCA */ , 0x00 ,FALSE
264/* 0xCB */ , 0x00 ,FALSE
265/* 0xCC */ , 0x00 ,FALSE
266/* 0xCD */ , 0x00 ,FALSE
267/* 0xCE */ , 0x00 ,FALSE
268/* 0xCF */ , 0x00 ,FALSE
269/* 0xD0 */ , 0x00 ,FALSE
270/* 0xD1 */ , 0x00 ,FALSE
271/* 0xD2 */ , 0x00 ,FALSE
272/* 0xD3 */ , 0x00 ,FALSE
273/* 0xD4 */ , 0x00 ,FALSE
274/* 0xD5 */ , 0x00 ,FALSE
275/* 0xD6 */ , 0x00 ,FALSE
276/* 0xD7 */ , 0x00 ,FALSE
277/* 0xD8 */ , 0x00 ,FALSE
278/* 0xD9 */ , 0x00 ,FALSE
279/* 0xDA */ , 0x00 ,FALSE
280/* 0xDB */ , 0x00 ,FALSE
281/* 0xDC */ , 0x00 ,FALSE
282/* 0xDD */ , 0x00 ,FALSE
283/* 0xDE */ , 0x00 ,FALSE
284/* 0xDF */ , 0x00 ,FALSE
285/* 0xE0 */ , 0x00 ,FALSE
286/* 0xE1 */ , 0x00 ,FALSE
287/* 0xE2 */ , 0x00 ,FALSE
288/* 0xE3 */ , 0x00 ,FALSE
289/* 0xE4 */ , 0x00 ,FALSE
290/* 0xE5 */ , 0x00 ,FALSE
291/* 0xE6 */ , 0x00 ,FALSE
292/* 0xE7 */ , 0x00 ,FALSE
293/* 0xE8 */ , 0x00 ,FALSE
294/* 0xE9 */ , 0x00 ,FALSE
295/* 0xEA */ , 0x00 ,FALSE
296/* 0xEB */ , 0x00 ,FALSE
297/* 0xEC */ , 0x00 ,FALSE
298/* 0xED */ , 0x00 ,FALSE
299/* 0xEE */ , 0x00 ,FALSE
300/* 0xEF */ , 0x00 ,FALSE
301/* 0xF0 */ , 0x00 ,FALSE
302/* 0xF1 */ , 0x00 ,FALSE
303/* 0xF2 */ , 0x00 ,FALSE
304/* 0xF3 */ , 0x00 ,FALSE
305/* 0xF4 */ , 0x00 ,FALSE
306/* 0xF5 */ , 0x00 ,FALSE
307/* 0xF6 */ , 0x00 ,FALSE
308/* 0xF7 */ , 0x00 ,FALSE
309/* 0xF8 */ , 0x00 ,FALSE
310/* 0xF9 */ , 0x00 ,FALSE
311/* 0xFA */ , 0x00 ,FALSE
312/* 0xFB */ , 0x00 ,FALSE
313/* 0xFC */ , 0x00 ,FALSE
314/* 0xFD */ , 0x00 ,FALSE
315/* 0xFE */ , 0x00 ,FALSE
316/* 0xFF */ , 0x00 ,FALSE
317 };
318
319typedef struct tagWinVKeyToPMScan
320{
321 /* index is the VKey value */
322 UCHAR uchPMScanCode;
323 LPCSTR lpstrName;
324} WINVKEYTOPMSCAN, *PWINVKEYTOPMSCAN;
325
326static WINVKEYTOPMSCAN auchWinVKeyToPMScan[256] =
327/**********************************************************************/
328/* Vkey * Scancode * Name */
329/**********************************************************************/
330/* 0x00 */ { 0x00 , NULL
331/* 0x01 VK_LBUTTON */ , 0x00 , NULL
332/* 0x02 VK_RBUTTON */ , 0x00 , NULL
333/* 0x03 VK_CANCEL */ , PMSCAN_BREAK , "Break"
334/* 0x04 VK_MBUTTON */ , 0x00 , NULL
335/* 0x05 */ , 0x00 , NULL
336/* 0x06 */ , 0x00 , NULL
337/* 0x07 */ , 0x00 , NULL
338/* 0x08 VK_BACK */ , PMSCAN_BACKSPACE , "Backspace"
339/* 0x09 VK_TAB */ , PMSCAN_TAB , "Tab"
340/* 0x0A */ , 0x00 , NULL
341/* 0x0B */ , 0x00 , NULL
342/* 0x0C VK_CLEAR */ , PMSCAN_PAD5 , "Num 5"
343/* 0x0D VK_RETURN */ , PMSCAN_ENTER , "Enter"
344/* 0x0E */ , 0x00 , NULL
345/* 0x0F */ , 0x00 , NULL
346/* 0x10 VK_SHIFT */ , PMSCAN_SHIFTLEFT , "Left Shift"
347/* 0x11 VK_CONTROL */ , PMSCAN_CTRLLEFT , "Left Control"
348/* 0x12 VK_MENU */ , PMSCAN_ALTLEFT , "Left Alt"
349/* 0x13 VK_PAUSE */ , PMSCAN_PAUSE , "Pause"
350/* 0x14 VK_CAPITAL */ , PMSCAN_CAPSLOCK , "Caps Lock"
351/* 0x15 */ , 0x00 , NULL
352/* 0x16 */ , 0x00 , NULL
353/* 0x17 */ , 0x00 , NULL
354/* 0x18 */ , 0x00 , NULL
355/* 0x19 */ , 0x00 , NULL
356/* 0x1A */ , 0x00 , NULL
357/* 0x1B VK_ESCAPE */ , PMSCAN_ESC , "Escape"
358/* 0x1C */ , 0x00 , NULL
359/* 0x1D */ , 0x00 , NULL
360/* 0x1E */ , 0x00 , NULL
361/* 0x1F */ , 0x00 , NULL
362/* 0x20 VK_SPACE */ , PMSCAN_SPACE , "Space"
363/* 0x21 VK_PRIOR */ , PMSCAN_PAGEUP , "Page Up"
364/* 0x22 VK_NEXT */ , PMSCAN_PAGEDOWN , "Page Down"
365/* 0x23 VK_END */ , PMSCAN_END , "End"
366/* 0x24 VK_HOME */ , PMSCAN_HOME , "Home"
367/* 0x25 VK_LEFT */ , PMSCAN_LEFT , "Left"
368/* 0x26 VK_UP */ , PMSCAN_UP , "Up"
369/* 0x27 VK_RIGHT */ , PMSCAN_RIGHT , "Right"
370/* 0x28 VK_DOWN */ , PMSCAN_DOWN , "Down"
371/* 0x29 VK_SELECT */ , 0x00 , NULL
372/* 0x2A VK_PRINT */ , 0x00 , NULL
373/* 0x2B VK_EXECUTE */ , 0x00 , NULL
374/* 0x2C VK_SNAPSHOT */ , PMSCAN_PRINT , "Print" // NT4SP6: appears to be printscreen!
375/* 0x2D VK_INSERT */ , PMSCAN_INSERT , "Insert"
376/* 0x2E VK_DELETE */ , PMSCAN_DELETE , "Delete"
377/* 0x2F VK_HELP */ , PMSCAN_HELP , "Help"
378/* 0x30 VK_0 */ , PMSCAN_ZERO , "0"
379/* 0x31 VK_1 */ , PMSCAN_ONE , "1"
380/* 0x32 VK_2 */ , PMSCAN_TWO , "2"
381/* 0x33 VK_3 */ , PMSCAN_THREE , "3"
382/* 0x34 VK_4 */ , PMSCAN_FOUR , "4"
383/* 0x35 VK_5 */ , PMSCAN_FIVE , "5"
384/* 0x36 VK_6 */ , PMSCAN_SIX , "6"
385/* 0x37 VK_7 */ , PMSCAN_SEVEN , "7"
386/* 0x38 VK_8 */ , PMSCAN_EIGHT , "8"
387/* 0x39 VK_9 */ , PMSCAN_NINE , "9"
388/* 0x3A */ , 0x00 , NULL
389/* 0x3B */ , 0x00 , NULL
390/* 0x3C */ , 0x00 , NULL
391/* 0x3D */ , 0x00 , NULL
392/* 0x3E */ , 0x00 , NULL
393/* 0x3F */ , 0x00 , NULL
394/* 0x40 */ , 0x00 , NULL
395/* 0x41 VK_A */ , PMSCAN_A , "A"
396/* 0x42 VK_B */ , PMSCAN_B , "B"
397/* 0x43 VK_C */ , PMSCAN_C , "C"
398/* 0x44 VK_D */ , PMSCAN_D , "D"
399/* 0x45 VK_E */ , PMSCAN_E , "E"
400/* 0x46 VK_F */ , PMSCAN_F , "F"
401/* 0x47 VK_G */ , PMSCAN_G , "G"
402/* 0x48 VK_H */ , PMSCAN_H , "H"
403/* 0x49 VK_I */ , PMSCAN_I , "I"
404/* 0x4A VK_J */ , PMSCAN_J , "J"
405/* 0x4B VK_K */ , PMSCAN_K , "K"
406/* 0x4C VK_L */ , PMSCAN_L , "L"
407/* 0x4D VK_M */ , PMSCAN_M , "M"
408/* 0x4E VK_N */ , PMSCAN_N , "N"
409/* 0x4F VK_O */ , PMSCAN_O , "O"
410/* 0x50 VK_P */ , PMSCAN_P , "P"
411/* 0x51 VK_Q */ , PMSCAN_Q , "Q"
412/* 0x52 VK_R */ , PMSCAN_R , "R"
413/* 0x53 VK_S */ , PMSCAN_S , "S"
414/* 0x54 VK_T */ , PMSCAN_T , "T"
415/* 0x55 VK_U */ , PMSCAN_U , "U"
416/* 0x56 VK_V */ , PMSCAN_V , "V"
417/* 0x57 VK_W */ , PMSCAN_W , "W"
418/* 0x58 VK_X */ , PMSCAN_X , "X"
419/* 0x59 VK_Y */ , PMSCAN_Y , "Y"
420/* 0x5A VK_Z */ , PMSCAN_Z , "Z"
421/* 0x5B VK_LWIN */ , PMSCAN_WINLEFT , "Left Win"
422/* 0x5C VK_RWIN */ , PMSCAN_WINRIGHT , "Right Win"
423/* 0x5D VK_APPS */ , PMSCAN_APPLICATION , "Application"
424/* 0x5E */ , 0x00 , NULL
425/* 0x5F */ , 0x00 , NULL
426/* 0x60 VK_NUMPAD0 */ , PMSCAN_PAD0 , "Num 0"
427/* 0x61 VK_NUMPAD1 */ , PMSCAN_PAD1 , "Num 1"
428/* 0x62 VK_NUMPAD2 */ , PMSCAN_PAD2 , "Num 2"
429/* 0x63 VK_NUMPAD3 */ , PMSCAN_PAD3 , "Num 3"
430/* 0x64 VK_NUMPAD4 */ , PMSCAN_PAD4 , "Num 4"
431/* 0x65 VK_NUMPAD5 */ , PMSCAN_PAD5 , "Num 5"
432/* 0x66 VK_NUMPAD6 */ , PMSCAN_PAD6 , "Num 6"
433/* 0x67 VK_NUMPAD7 */ , PMSCAN_PAD7 , "Num 7"
434/* 0x68 VK_NUMPAD8 */ , PMSCAN_PAD8 , "Num 8"
435/* 0x69 VK_NUMPAD9 */ , PMSCAN_PAD9 , "Num 9"
436/* 0x6A VK_MULTIPLY */ , PMSCAN_PADASTERISK , "Num *"
437/* 0x6B VK_ADD */ , PMSCAN_PADPLUS , "Num +"
438/* 0x6C VK_SEPARATOR */ , 0x00 , NULL
439/* 0x6D VK_SUBTRACT */ , PMSCAN_PADMINUS , "Num -"
440/* 0x6E VK_DECIMAL */ , PMSCAN_PADPERIOD , "Num ."
441/* 0x6F VK_DIVIDE */ , PMSCAN_PADSLASH , "Num /"
442/* 0x70 VK_F1 */ , PMSCAN_F1 , "F1"
443/* 0x71 VK_F2 */ , PMSCAN_F2 , "F2"
444/* 0x72 VK_F3 */ , PMSCAN_F3 , "F3"
445/* 0x73 VK_F4 */ , PMSCAN_F4 , "F4"
446/* 0x74 VK_F5 */ , PMSCAN_F5 , "F5"
447/* 0x75 VK_F6 */ , PMSCAN_F6 , "F6"
448/* 0x76 VK_F7 */ , PMSCAN_F7 , "F7"
449/* 0x77 VK_F8 */ , PMSCAN_F8 , "F8"
450/* 0x78 VK_F9 */ , PMSCAN_F9 , "F9"
451/* 0x79 VK_F10 */ , PMSCAN_F10 , "F10"
452/* 0x7A VK_F11 */ , PMSCAN_F11 , "F11"
453/* 0x7B VK_F12 */ , PMSCAN_F12 , "F12"
454/* 0x7C VK_F13 */ , PMSCAN_F13 , "F13"
455/* 0x7D VK_F14 */ , PMSCAN_F14 , "F14"
456/* 0x7E VK_F15 */ , PMSCAN_F15 , "F15"
457/* 0x7F VK_F16 */ , PMSCAN_F16 , "F16"
458/* 0x80 VK_F17 */ , PMSCAN_F17 , "F17"
459/* 0x81 VK_F18 */ , PMSCAN_F18 , "F18"
460/* 0x82 VK_F19 */ , PMSCAN_F19 , "F19"
461/* 0x83 VK_F20 */ , PMSCAN_F20 , "F20"
462/* 0x84 VK_F21 */ , PMSCAN_F21 , "F21"
463/* 0x85 VK_F22 */ , PMSCAN_F22 , "F22"
464/* 0x86 VK_F23 */ , PMSCAN_F23 , "F23"
465/* 0x87 VK_F24 */ , PMSCAN_F24 , "F24"
466/* 0x88 */ , 0x00 , NULL
467/* 0x89 */ , 0x00 , NULL
468/* 0x8A */ , 0x00 , NULL
469/* 0x8B */ , 0x00 , NULL
470/* 0x8C */ , 0x00 , NULL
471/* 0x8D */ , 0x00 , NULL
472/* 0x8E */ , 0x00 , NULL
473/* 0x8F */ , 0x00 , NULL
474/* 0x90 VK_NUMLOCK */ , PMSCAN_NUMLOCK , "Num Lock"
475/* 0x91 VK_SCROLL */ , PMSCAN_SCROLLLOCK , "Scroll Lock"
476/* 0x92 */ , 0x00 , NULL
477/* 0x93 */ , 0x00 , NULL
478/* 0x94 */ , 0x00 , NULL
479/* 0x95 */ , 0x00 , NULL
480/* 0x96 */ , 0x00 , NULL
481/* 0x97 */ , 0x00 , NULL
482/* 0x98 */ , 0x00 , NULL
483/* 0x99 */ , 0x00 , NULL
484/* 0x9A */ , 0x00 , NULL
485/* 0x9B */ , 0x00 , NULL
486/* 0x9C */ , 0x00 , NULL
487/* 0x9D */ , 0x00 , NULL
488/* 0x9E */ , 0x00 , NULL
489/* 0x9F */ , 0x00 , NULL
490/* 0xA0 VK_LSHIFT */ , PMSCAN_SHIFTLEFT , "Left Shift"
491/* 0xA1 VK_RSHIFT */ , PMSCAN_SHIFTRIGHT , "Right Shift"
492/* 0xA2 VK_LCONTROL */ , PMSCAN_CTRLLEFT , "Left Control"
493/* 0xA3 VK_RCONTROL */ , PMSCAN_CTRLRIGHT , "Right Control"
494/* 0xA4 VK_LMENU */ , PMSCAN_ALTLEFT , "Left Alt"
495/* 0xA5 VK_RMENU */ , PMSCAN_ALTRIGHT , "Right Alt"
496/* 0xA6 */ , 0x00 , NULL
497/* 0xA7 */ , 0x00 , NULL
498/* 0xA8 */ , 0x00 , NULL
499/* 0xA9 */ , 0x00 , NULL
500/* 0xAA */ , 0x00 , NULL
501/* 0xAB */ , 0x00 , NULL
502/* 0xAC */ , 0x00 , NULL
503/* 0xAD */ , 0x00 , NULL
504/* 0xAE */ , 0x00 , NULL
505/* 0xAF */ , 0x00 , NULL
506/* 0xB0 */ , 0x00 , NULL
507/* 0xB1 */ , 0x00 , NULL
508/* 0xB2 */ , 0x00 , NULL
509/* 0xB3 */ , 0x00 , NULL
510/* 0xB4 */ , 0x00 , NULL
511/* 0xB5 */ , 0x00 , NULL
512/* 0xB6 */ , 0x00 , NULL
513/* 0xB7 */ , 0x00 , NULL
514/* 0xB8 */ , 0x00 , NULL
515/* 0xB9 */ , 0x00 , NULL
516/* 0xBA VK_SEMICOLON */ , PMSCAN_SEMICOLON , ";"
517/* 0xBB VK_EQUAL */ , PMSCAN_EQUAL , "="
518/* 0xBC VK_COMMA */ , PMSCAN_COMMA , ","
519/* 0xBD VK_HYPHEN */ , PMSCAN_HYPHEN , "-"
520/* 0xBE VK_PERIOD */ , PMSCAN_PERIOD , "."
521/* 0xBF VK_SLASH */ , PMSCAN_SLASH , "/"
522/* 0xC0 VK_GRAVE */ , PMSCAN_GRAVE , "'"
523/* 0xC1 VK_FFC1 */ , PMSCAN_JEXTRA , "JExtra" //??
524/* 0xC2 VK_YEN */ , PMSCAN_YEN , "Yen"
525/* 0xC3 */ , 0x00 , NULL
526/* 0xC4 */ , 0x00 , NULL
527/* 0xC5 */ , 0x00 , NULL
528/* 0xC6 */ , 0x00 , NULL
529/* 0xC7 */ , 0x00 , NULL
530/* 0xC8 */ , 0x00 , NULL
531/* 0xC9 */ , 0x00 , NULL
532/* 0xCA */ , 0x00 , NULL
533/* 0xCB */ , 0x00 , NULL
534/* 0xCC */ , 0x00 , NULL
535/* 0xCD */ , 0x00 , NULL
536/* 0xCE */ , 0x00 , NULL
537/* 0xCF */ , 0x00 , NULL
538/* 0xD0 */ , 0x00 , NULL
539/* 0xD1 */ , 0x00 , NULL
540/* 0xD2 */ , 0x00 , NULL
541/* 0xD3 */ , 0x00 , NULL
542/* 0xD4 */ , 0x00 , NULL
543/* 0xD5 */ , 0x00 , NULL
544/* 0xD6 */ , 0x00 , NULL
545/* 0xD7 */ , 0x00 , NULL
546/* 0xD8 */ , 0x00 , NULL
547/* 0xD9 */ , 0x00 , NULL
548/* 0xDA */ , 0x00 , NULL
549/* 0xDB VK_BRACKETLEFT */ , PMSCAN_BRACKETLEFT , "["
550/* 0xDC VK_BACKSLASH */ , PMSCAN_BACKSLASH , "\\"
551/* 0xDD VK_BRACKETRIGHT */ , PMSCAN_BRACKETRIGHT , "]"
552/* 0xDE VK_QUOTESINGLE */ , PMSCAN_QUOTESINGLE , "'"
553/* 0xDF */ , 0x00 , NULL
554/* 0xE0 */ , 0x00 , NULL
555/* 0xE1 */ , 0x00 , NULL
556/* 0xE2 VK_EXTRA */ , PMSCAN_EXTRA , "<"
557/* 0xE3 */ , 0x00 , NULL
558/* 0xE4 */ , 0x00 , NULL
559/* 0xE5 */ , 0x00 , NULL
560/* 0xE6 */ , 0x00 , NULL
561/* 0xE7 */ , 0x00 , NULL
562/* 0xE8 */ , 0x00 , NULL
563/* 0xE9 */ , 0x00 , NULL
564/* 0xEA */ , 0x00 , NULL
565/* 0xEB */ , 0x00 , NULL
566/* 0xEC */ , 0x00 , NULL
567/* 0xED */ , 0x00 , NULL
568/* 0xEE */ , 0x00 , NULL
569/* 0xEF */ , 0x00 , NULL
570/* 0xF0 */ , 0x00 , NULL
571/* 0xF1 */ , 0x00 , NULL
572/* 0xF2 */ , 0x00 , NULL
573/* 0xF3 */ , 0x00 , NULL
574/* 0xF4 */ , 0x00 , NULL
575/* 0xF5 */ , 0x00 , NULL
576/* 0xF6 VK_ATTN */ , 0x00 , NULL
577/* 0xF7 VK_CRSEL */ , 0x00 , NULL
578/* 0xF8 VK_EXSEL */ , 0x00 , NULL
579/* 0xF9 VK_EREOF */ , PMSCAN_ERASEEOF , "Erase"
580/* 0xFA VK_PLAY */ , 0x00 , NULL
581/* 0xFB VK_ZOOM */ , 0x00 , NULL
582/* 0xFC VK_NONAME */ , 0x00 , NULL
583/* 0xFD VK_PA1 */ , PMSCAN_PA1 , "PA1"
584/* 0xFE VK_OEM_CLEAR */ , 0x00 , NULL
585/* 0xFF */ , 0x00 , NULL
586 };
587
588// @@PF reflect Num Enter key
589LPCSTR lpstrNumEnter = "Num Enter";
590
591// @@@PH
592// Note: windows uses different scancodes if numlock is pressed
593// This is not (yet) reflected here!
594static BYTE auchPMScanToWinScan[256][2] =
595/****************************************************************************/
596/* PM Scancode * Win32 Scancode Extended Key */
597/****************************************************************************/
598/* 0x00 */ { 0x00, FALSE
599/* 0x01 PMSCAN_ESC */ , WINSCAN_ESC ,FALSE
600/* 0x02 PMSCAN_ONE */ , WINSCAN_ONE ,FALSE
601/* 0x03 PMSCAN_TWO */ , WINSCAN_TWO ,FALSE
602/* 0x04 PMSCAN_THREE */ , WINSCAN_THREE ,FALSE
603/* 0x05 PMSCAN_FOUR */ , WINSCAN_FOUR ,FALSE
604/* 0x06 PMSCAN_FIVE */ , WINSCAN_FIVE ,FALSE
605/* 0x07 PMSCAN_SIX */ , WINSCAN_SIX ,FALSE
606/* 0x08 PMSCAN_SEVEN */ , WINSCAN_SEVEN ,FALSE
607/* 0x09 PMSCAN_EIGHT */ , WINSCAN_EIGHT ,FALSE
608/* 0x0A PMSCAN_NINE */ , WINSCAN_NINE ,FALSE
609/* 0x0B PMSCAN_ZERO */ , WINSCAN_ZERO ,FALSE
610/* 0x0C PMSCAN_HYPHEN */ , WINSCAN_HYPHEN ,FALSE
611/* 0x0D PMSCAN_EQUAL */ , WINSCAN_EQUAL ,FALSE
612/* 0x0E PMSCAN_BACKSPACE */ , WINSCAN_BACKSPACE ,FALSE
613/* 0x0F PMSCAN_TAB */ , WINSCAN_TAB ,FALSE
614/* 0x10 PMSCAN_Q */ , WINSCAN_Q ,FALSE
615/* 0x11 PMSCAN_W */ , WINSCAN_W ,FALSE
616/* 0x12 PMSCAN_E */ , WINSCAN_E ,FALSE
617/* 0x13 PMSCAN_R */ , WINSCAN_R ,FALSE
618/* 0x14 PMSCAN_T */ , WINSCAN_T ,FALSE
619/* 0x15 PMSCAN_Y */ , WINSCAN_Y ,FALSE
620/* 0x16 PMSCAN_U */ , WINSCAN_U ,FALSE
621/* 0x17 PMSCAN_I */ , WINSCAN_I ,FALSE
622/* 0x18 PMSCAN_O */ , WINSCAN_O ,FALSE
623/* 0x19 PMSCAN_P */ , WINSCAN_P ,FALSE
624/* 0x1A PMSCAN_BRACKETLEFT */ , WINSCAN_BRACKETLEFT ,FALSE
625/* 0x1B PMSCAN_BRACKETRIGHT */ , WINSCAN_BRACKETRIGHT ,FALSE
626/* 0x1C PMSCAN_ENTER */ , WINSCAN_ENTER ,FALSE
627/* 0x1D PMSCAN_CTRLLEFT */ , WINSCAN_CTRLLEFT ,FALSE
628/* 0x1E PMSCAN_A */ , WINSCAN_A ,FALSE
629/* 0x1F PMSCAN_S */ , WINSCAN_S ,FALSE
630/* 0x20 PMSCAN_D */ , WINSCAN_D ,FALSE
631/* 0x21 PMSCAN_F */ , WINSCAN_F ,FALSE
632/* 0x22 PMSCAN_G */ , WINSCAN_G ,FALSE
633/* 0x23 PMSCAN_H */ , WINSCAN_H ,FALSE
634/* 0x24 PMSCAN_J */ , WINSCAN_J ,FALSE
635/* 0x25 PMSCAN_K */ , WINSCAN_K ,FALSE
636/* 0x26 PMSCAN_L */ , WINSCAN_L ,FALSE
637/* 0x27 PMSCAN_SEMICOLON */ , WINSCAN_SEMICOLON ,FALSE
638/* 0x28 PMSCAN_QUOTESINGLE */ , WINSCAN_QUOTESINGLE ,FALSE
639/* 0x29 PMSCAN_GRAVE */ , WINSCAN_GRAVE ,FALSE
640/* 0x2A PMSCAN_SHIFTLEFT */ , WINSCAN_SHIFTLEFT ,FALSE
641/* 0x2B PMSCAN_BACKSLASH */ , WINSCAN_BACKSLASH ,FALSE
642/* 0x2C PMSCAN_Z */ , WINSCAN_Z ,FALSE
643/* 0x2D PMSCAN_X */ , WINSCAN_X ,FALSE
644/* 0x2E PMSCAN_C */ , WINSCAN_C ,FALSE
645/* 0x2F PMSCAN_V */ , WINSCAN_V ,FALSE
646/* 0x30 PMSCAN_B */ , WINSCAN_B ,FALSE
647/* 0x31 PMSCAN_N */ , WINSCAN_N ,FALSE
648/* 0x32 PMSCAN_M */ , WINSCAN_M ,FALSE
649/* 0x33 PMSCAN_COMMA */ , WINSCAN_COMMA ,FALSE
650/* 0x34 PMSCAN_PERIOD */ , WINSCAN_PERIOD ,FALSE
651/* 0x35 PMSCAN_SLASH */ , WINSCAN_SLASH ,FALSE
652/* 0x36 PMSCAN_SHIFTRIGHT */ , WINSCAN_SHIFTRIGHT ,TRUE
653/* 0x37 PMSCAN_PADASTERISK */ , WINSCAN_PADASTERISK ,FALSE
654/* 0x38 PMSCAN_ALTLEFT */ , WINSCAN_ALTLEFT ,FALSE
655/* 0x39 PMSCAN_SPACE */ , WINSCAN_SPACE ,FALSE
656/* 0x3A PMSCAN_CAPSLOCK */ , WINSCAN_CAPSLOCK ,FALSE
657/* 0x3B PMSCAN_F1 */ , WINSCAN_F1 ,FALSE
658/* 0x3C PMSCAN_F2 */ , WINSCAN_F2 ,FALSE
659/* 0x3D PMSCAN_F3 */ , WINSCAN_F3 ,FALSE
660/* 0x3E PMSCAN_F4 */ , WINSCAN_F4 ,FALSE
661/* 0x3F PMSCAN_F5 */ , WINSCAN_F5 ,FALSE
662/* 0x40 PMSCAN_F6 */ , WINSCAN_F6 ,FALSE
663/* 0x41 PMSCAN_F7 */ , WINSCAN_F7 ,FALSE
664/* 0x42 PMSCAN_F8 */ , WINSCAN_F8 ,FALSE
665/* 0x43 PMSCAN_F9 */ , WINSCAN_F9 ,FALSE
666/* 0x44 PMSCAN_F10 */ , WINSCAN_F10 ,FALSE
667/* 0x45 PMSCAN_NUMLOCK */ , WINSCAN_NUMLOCK ,TRUE
668/* 0x46 PMSCAN_SCROLLLOCK */ , WINSCAN_SCROLLLOCK ,FALSE
669/* 0x47 PMSCAN_PAD7 */ , WINSCAN_PAD7 ,FALSE
670/* 0x48 PMSCAN_PAD8 */ , WINSCAN_PAD8 ,FALSE
671/* 0x49 PMSCAN_PAD9 */ , WINSCAN_PAD9 ,FALSE
672/* 0x4A PMSCAN_PADMINUS */ , WINSCAN_PADMINUS ,FALSE
673/* 0x4B PMSCAN_PAD4 */ , WINSCAN_PAD4 ,FALSE
674/* 0x4C PMSCAN_PAD5 */ , WINSCAN_PAD5 ,FALSE
675/* 0x4D PMSCAN_PAD6 */ , WINSCAN_PAD6 ,FALSE
676/* 0x4E PMSCAN_PADPLUS */ , WINSCAN_PADPLUS ,FALSE
677/* 0x4F PMSCAN_PAD1 */ , WINSCAN_PAD1 ,FALSE
678/* 0x50 PMSCAN_PAD2 */ , WINSCAN_PAD2 ,FALSE
679/* 0x51 PMSCAN_PAD3 */ , WINSCAN_PAD3 ,FALSE
680/* 0x52 PMSCAN_PAD0 */ , WINSCAN_PAD0 ,FALSE
681/* 0x53 PMSCAN_PADPERIOD */ , WINSCAN_PADPERIOD ,FALSE
682/* 0x54 PMSCAN_SYSREQ */ , 0x00 ,FALSE
683/* 0x55 PMSCAN_RESET */ , 0x00 ,FALSE
684/* 0x56 PMSCAN_EXTRA */ , WINSCAN_EXTRA ,FALSE
685/* 0x57 PMSCAN_F11 */ , WINSCAN_F11 ,FALSE
686/* 0x58 PMSCAN_F12 */ , WINSCAN_F12 ,FALSE
687/* 0x59 PMSCAN_BACKTAB */ , 0x00 ,FALSE
688/* 0x5A PMSCAN_PADENTER */ , WINSCAN_PADENTER ,TRUE
689/* 0x5B PMSCAN_CTRLRIGHT */ , WINSCAN_CTRLRIGHT ,TRUE
690/* 0x5C PMSCAN_PADSLASH */ , WINSCAN_PADSLASH ,TRUE
691/* 0x5D PMSCAN_PRINT */ , WINSCAN_PRINT ,TRUE
692/* 0x5E PMSCAN_ALTRIGHT */ , WINSCAN_ALTRIGHT ,TRUE
693/* 0x5F PMSCAN_PAUSE */ , WINSCAN_PAUSE ,FALSE
694/* 0x60 PMSCAN_HOME */ , WINSCAN_HOME ,TRUE
695/* 0x61 PMSCAN_UP */ , WINSCAN_UP ,TRUE
696/* 0x62 PMSCAN_PAGEUP */ , WINSCAN_PAGEUP ,TRUE
697/* 0x63 PMSCAN_LEFT */ , WINSCAN_LEFT ,TRUE
698/* 0x64 PMSCAN_RIGHT */ , WINSCAN_RIGHT ,TRUE
699/* 0x65 PMSCAN_END */ , WINSCAN_END ,TRUE
700/* 0x66 PMSCAN_DOWN */ , WINSCAN_DOWN ,TRUE
701/* 0x67 PMSCAN_PAGEDOWN */ , WINSCAN_PAGEDOWN ,TRUE
702/* 0x68 PMSCAN_INSERT */ , WINSCAN_INSERT ,TRUE
703/* 0x69 PMSCAN_DELETE */ , WINSCAN_DELETE ,TRUE
704/* 0x6A PMSCAN_F23 */ , WINSCAN_F23 ,FALSE
705/* 0x6B PMSCAN_F24 */ , WINSCAN_F24 ,FALSE
706/* 0x6C PMSCAN_SYSMEM */ , 0x00 ,FALSE
707/* 0x6D PMSCAN_ERASEEOF */ , WINSCAN_ERASEEOF ,FALSE
708/* 0x6E PMSCAN_BREAK */ , WINSCAN_BREAK ,TRUE
709/* 0x6F PMSCAN_MOVEWIN */ , 0x00 ,FALSE
710/* 0x70 PMSCAN_NLS3 */ , WINSCAN_NLS3 ,FALSE
711/* 0x71 PMSCAN_HELP */ , WINSCAN_HELP ,FALSE
712/* 0x72 PMSCAN_TASKMAN */ , 0x00 ,FALSE
713/* 0x73 PMSCAN_B11 */ , WINSCAN_B11 ,FALSE
714/* 0x74 PMSCAN_JUMP */ , 0x00 ,FALSE
715/* 0x75 PMSCAN_MINWIN */ , 0x00 ,FALSE
716/* 0x76 PMSCAN_CLEAR */ , 0x00 ,FALSE
717/* 0x77 PMSCAN_77 */ , 0x00 ,FALSE
718/* 0x78 PMSCAN_78 */ , 0x00 ,FALSE
719/* 0x79 PMSCAN_NLS2 */ , WINSCAN_NLS2 ,FALSE
720/* 0x7a PMSCAN_SIZE */ , 0x00 ,FALSE
721/* 0x7b PMSCAN_NLS1 */ , WINSCAN_NLS1 ,FALSE
722/* 0x7c PMSCAN_APPLICATION */ , WINSCAN_APPLICATION ,TRUE
723/* 0x7d PMSCAN_E13 */ , WINSCAN_YEN ,FALSE
724/* 0x7e PMSCAN_WINLEFT */ , WINSCAN_WINLEFT ,TRUE
725/* 0x7f PMSCAN_WINRIGHT */ , WINSCAN_WINRIGHT ,TRUE
726/* 0x80 PMSCAN_PA1 */ , WINSCAN_PA1 ,FALSE
727/* 0x81 PMSCAN_F13 */ , WINSCAN_F13 ,FALSE
728/* 0x82 PMSCAN_F14 */ , WINSCAN_F14 ,FALSE
729/* 0x83 PMSCAN_F15 */ , WINSCAN_F15 ,FALSE
730/* 0x84 PMSCAN_PA2 */ , 0x00 ,FALSE
731/* 0x85 PMSCAN_PA3 */ , 0x00 ,FALSE
732/* 0x86 PMSCAN_SPACEBREAK */ , 0x00 ,FALSE
733/* 0x87 PMSCAN_TABRIGHT */ , 0x00 ,FALSE
734/* 0x88 PMSCAN_NOOP */ , 0x00 ,FALSE
735/* 0x89 PMSCAN_F16 */ , WINSCAN_F16 ,FALSE
736/* 0x8a PMSCAN_F17 */ , WINSCAN_F17 ,FALSE
737/* 0x8b PMSCAN_F18 */ , WINSCAN_F18 ,FALSE
738/* 0x8c PMSCAN_F19 */ , WINSCAN_F19 ,FALSE
739/* 0x8d PMSCAN_F20 */ , WINSCAN_F20 ,FALSE
740/* 0x8e PMSCAN_F21 */ , WINSCAN_F21 ,FALSE
741/* 0x8f PMSCAN_F22 */ , WINSCAN_F22 ,FALSE
742/* 0x90 */ , WINSCAN_PREVTRACK ,FALSE
743/* 0x91 */ , WINSCAN_AT ,FALSE
744/* 0x92 */ , WINSCAN_COLON ,FALSE
745/* 0x93 */ , WINSCAN_UNDERLINE ,FALSE
746/* 0x94 */ , WINSCAN_KANJI ,FALSE
747/* 0x95 PMSCAN_DBE_CONV */ , WINSCAN_NLS2 ,FALSE // CONVERT (Japanese keyboard)
748/* 0x96 PMSCAN_DBE_NOCONV */ , WINSCAN_NLS1 ,FALSE // NOCONVERT (Japanese keyboard)
749/* 0x97 */ , WINSCAN_UNLABELED ,FALSE
750/* 0x98 */ , 0x00 ,FALSE
751/* 0x99 */ , WINSCAN_NEXTTRACK ,FALSE
752/* 0x9A */ , 0x00 ,FALSE
753/* 0x9B */ , 0x00 ,FALSE
754/* 0x9C */ , 0x00 ,FALSE
755/* 0x9D */ , 0x00 ,FALSE
756/* 0x9E */ , 0x00 ,FALSE
757/* 0x9F */ , 0x00 ,FALSE
758/* 0xA0 */ , WINSCAN_MUTE ,FALSE
759/* 0xA1 */ , WINSCAN_CALCULATOR ,FALSE
760/* 0xA2 */ , WINSCAN_PLAYPAUSE ,FALSE
761/* 0xA3 */ , 0x00 ,FALSE
762/* 0xA4 */ , WINSCAN_MEDIASTOP ,FALSE
763/* 0xA5 */ , 0x00 ,FALSE
764/* 0xA6 */ , 0x00 ,FALSE
765/* 0xA7 */ , 0x00 ,FALSE
766/* 0xA8 */ , 0x00 ,FALSE
767/* 0xA9 */ , 0x00 ,FALSE
768/* 0xAA */ , 0x00 ,FALSE
769/* 0xAB */ , 0x00 ,FALSE
770/* 0xAC */ , 0x00 ,FALSE
771/* 0xAD */ , 0x00 ,FALSE
772/* 0xAE */ , WINSCAN_VOLUMEDOWN ,FALSE
773/* 0xAF */ , 0x00 ,FALSE
774/* 0xB0 */ , WINSCAN_VOLUMEUP ,FALSE
775/* 0xB1 */ , 0x00 ,FALSE
776/* 0xB2 */ , WINSCAN_WEBHOME ,FALSE
777/* 0xB3 */ , WINSCAN_NUMPADCOMMA ,FALSE
778/* 0xB4 */ , 0x00 ,FALSE
779/* 0xB5 */ , 0x00 ,FALSE
780/* 0xB6 */ , 0x00 ,FALSE
781/* 0xB7 */ , 0x00 ,FALSE
782/* 0xB8 */ , 0x00 ,FALSE
783/* 0xB9 */ , 0x00 ,FALSE
784/* 0xBA */ , 0x00 ,FALSE
785/* 0xBB */ , 0x00 ,FALSE
786/* 0xBC */ , 0x00 ,FALSE
787/* 0xBD */ , 0x00 ,FALSE
788/* 0xBE */ , 0x00 ,FALSE
789/* 0xBF */ , 0x00 ,FALSE
790/* 0xC0 */ , 0x00 ,FALSE
791/* 0xC1 */ , 0x00 ,FALSE
792/* 0xC2 */ , 0x00 ,FALSE
793/* 0xC3 */ , 0x00 ,FALSE
794/* 0xC4 */ , 0x00 ,FALSE
795/* 0xC5 */ , 0x00 ,FALSE
796/* 0xC6 */ , 0x00 ,FALSE
797/* 0xC7 */ , 0x00 ,FALSE
798/* 0xC8 */ , 0x00 ,FALSE
799/* 0xC9 */ , 0x00 ,FALSE
800/* 0xCA */ , 0x00 ,FALSE
801/* 0xCB */ , 0x00 ,FALSE
802/* 0xCC */ , 0x00 ,FALSE
803/* 0xCD */ , 0x00 ,FALSE
804/* 0xCE */ , 0x00 ,FALSE
805/* 0xCF */ , 0x00 ,FALSE
806/* 0xD0 */ , 0x00 ,FALSE
807/* 0xD1 */ , 0x00 ,FALSE
808/* 0xD2 */ , 0x00 ,FALSE
809/* 0xD3 */ , 0x00 ,FALSE
810/* 0xD4 */ , 0x00 ,FALSE
811/* 0xD5 */ , 0x00 ,FALSE
812/* 0xD6 */ , 0x00 ,FALSE
813/* 0xD7 */ , 0x00 ,FALSE
814/* 0xD8 */ , 0x00 ,FALSE
815/* 0xD9 */ , 0x00 ,FALSE
816/* 0xDA */ , 0x00 ,FALSE
817/* 0xDB */ , 0x00 ,FALSE
818/* 0xDC */ , 0x00 ,FALSE
819/* 0xDD */ , 0x00 ,FALSE
820/* 0xDE */ , WINSCAN_POWER ,FALSE
821/* 0xDF */ , WINSCAN_SLEEP ,FALSE
822/* 0xE0 */ , 0x00 ,FALSE
823/* 0xE1 */ , 0x00 ,FALSE
824/* 0xE2 */ , 0x00 ,FALSE
825/* 0xE3 */ , WINSCAN_WAKE ,FALSE
826/* 0xE4 */ , 0x00 ,FALSE
827/* 0xE5 */ , WINSCAN_WEBSEARCH ,FALSE
828/* 0xE6 */ , WINSCAN_WEBFAVORITES ,FALSE
829/* 0xE7 */ , WINSCAN_WEBREFRESH ,FALSE
830/* 0xE8 */ , WINSCAN_WEBSTOP ,FALSE
831/* 0xE9 */ , WINSCAN_WEBFORWARD ,FALSE
832/* 0xEA */ , WINSCAN_WEBBACK ,FALSE
833/* 0xEB */ , WINSCAN_MYCOMPUTER ,FALSE
834/* 0xEC */ , WINSCAN_MAIL ,FALSE
835/* 0xED */ , WINSCAN_MEDIASELECT ,FALSE
836/* 0xEE */ , 0x00 ,FALSE
837/* 0xEF */ , 0x00 ,FALSE
838/* 0xF0 */ , 0x00 ,FALSE
839/* 0xF1 */ , 0x00 ,FALSE
840/* 0xF2 */ , 0x00 ,FALSE
841/* 0xF3 */ , 0x00 ,FALSE
842/* 0xF4 */ , 0x00 ,FALSE
843/* 0xF5 */ , 0x00 ,FALSE
844/* 0xF6 */ , 0x00 ,FALSE
845/* 0xF7 */ , 0x00 ,FALSE
846/* 0xF8 */ , 0x00 ,FALSE
847/* 0xF9 */ , 0x00 ,FALSE
848/* 0xFA */ , 0x00 ,FALSE
849/* 0xFB */ , 0x00 ,FALSE
850/* 0xFC */ , 0x00 ,FALSE
851/* 0xFD */ , 0x00 ,FALSE
852/* 0xFE */ , 0x00 ,FALSE
853/* 0xFF */ , 0x00 ,FALSE
854 };
855
856
857//******************************************************************************
858//******************************************************************************
859
860VOID WIN32API KeyTranslatePMToWinBuf(PUCHAR pmkey, PUCHAR winkey,
861 int nrkeys)
862{
863 int pmvkey;
864
865#ifdef DEBUG
866 for(int j=1;j<nrkeys;j++) {
867 if(pmkey[j])
868 dprintf2(("PM vkey %x state %x", j, pmkey[j]));
869 }
870#endif
871
872 for(int i=1;i<nrkeys;i++) {
873 if(auchWinVKeyToPMScan[i].uchPMScanCode) {
874 pmvkey = OSLibWinTranslateChar(auchWinVKeyToPMScan[i].uchPMScanCode, TC_SCANCODETOVIRTUALKEY, 0);
875 if(pmvkey == 0) {
876 dprintf2(("WinTranslateChar %x (%x) FAILED!!", i, auchWinVKeyToPMScan[i].uchPMScanCode));
877 }
878 winkey[i] = pmkey[pmvkey];
879 }
880 else dprintf2(("key %x has no PM scancode", i));
881 }
882 winkey[VK_SHIFT] = winkey[VK_LSHIFT] | winkey[VK_RSHIFT];
883 winkey[VK_CONTROL] = winkey[VK_LCONTROL] | winkey[VK_RCONTROL];
884 winkey[VK_MENU] = winkey[VK_LMENU] | winkey[VK_RMENU];
885}
886//******************************************************************************
887//******************************************************************************
888UCHAR KeyTranslateWinVKeyToPMScan(UCHAR uchWinVKey, BOOL fExtended)
889{
890 // if the extended bit didn't match, this is
891 // the closest hit
892 UCHAR uchAlmost = 0;
893
894 // experiment
895
896#if 0
897 bAlmost = auchWinVKeyToPMScan[bWinVKey].uchPMScanCode;
898#else
899 for(int i = 0;
900 i < 256; // sizeof(row of auchPMScanToWinVKey)
901 i++)
902 {
903 if (auchPMScanToWinVKey[i][0] == uchWinVKey)
904 {
905 // this represents the PMScan code which is used as index
906 uchAlmost = i;
907
908 // exact match!
909 if (auchPMScanToWinVKey[i][1] == fExtended)
910 break;
911 }
912 }
913#endif
914
915 dprintf(("KeyTranslateWinVKeyToPMScan(%02xh,%d) = %02xh",
916 uchWinVKey,
917 fExtended,
918 uchAlmost));
919
920 // almost a match or no match at all.
921 return uchAlmost;
922}
923//******************************************************************************
924//******************************************************************************
925void KeyTranslatePMScanToWinVKey(UCHAR uchPMScan,
926 BOOL bNumLock,
927 PUCHAR puchWinVKey,
928 WORD *pwWinScan,
929 PBOOL pfExtended)
930{
931 // @@@PH numlock is currently ignored
932 if (puchWinVKey)
933 *puchWinVKey = auchPMScanToWinVKey[uchPMScan][0];
934
935 if (pfExtended)
936 *pfExtended = auchPMScanToWinVKey[uchPMScan][1];
937
938 if (pwWinScan)
939 *pwWinScan = auchPMScanToWinScan[uchPMScan][0];
940}
941//******************************************************************************
942//******************************************************************************
943UCHAR KeyTranslateWinScanToPMScan(UCHAR uchWinScan, BOOL fExtended)
944{
945 // Note:
946 // MapVirtualKeyA requires this function,
947 // O32_MapVirtualKeyA uses PM Scancodes only!
948
949 // if the extended bit didn't match, this is
950 // the closest hit
951 UCHAR uchAlmost = 0;
952
953 for(int i = 0;
954 i < 256; // sizeof(row of auchPMScanToWinVKey)
955 i++)
956 {
957 if (auchPMScanToWinScan[i][0] == uchWinScan)
958 {
959 // this represents the PMScan code which is used as index
960 uchAlmost = i;
961
962 // exact match!
963 if (auchPMScanToWinVKey[i][1] == fExtended)
964 break;
965 }
966 }
967
968 dprintf(("KeyTranslateWinScanToPMScan(%02xh,%d) = %02xh",
969 uchWinScan,
970 fExtended,
971 uchAlmost));
972
973 // almost a match or no match at all.
974 return uchAlmost;
975
976}
977//******************************************************************************
978//******************************************************************************
979UCHAR KeyTranslatePMScanToWinScan(UCHAR bPMScan)
980{
981 // Note:
982 // MapVirtualKeyA requires this function,
983 // O32_MapVirtualKeyA uses PM Scancodes only!
984
985 return auchPMScanToWinScan[bPMScan][0];
986}
987//******************************************************************************
988//******************************************************************************
989INT WIN32API GetKeyboardType(INT nTypeFlag)
990{
991 return O32_GetKeyboardType(nTypeFlag);
992}
993//******************************************************************************
994//******************************************************************************
995BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
996{
997#if 1
998 //temporary solution until we find out why OSLibWinGetScanStateTable always
999 //fails
1000 int state;
1001 for(int i=0;i<256;i++) {
1002 state = GetKeyState(i);
1003 lpKeyState[i] = ((state & 0x8000) >> 8) | (state & 1);
1004 if(lpKeyState[i] & 0x80) {
1005 dprintf2(("Win key 0x%0x = %x", i, lpKeyState[i]));
1006 }
1007 }
1008#else
1009 BYTE PMScanState[256];
1010 BOOL rc;
1011 int state;
1012
1013 memset(PMScanState, 0, sizeof(PMScanState));
1014 memset(lpKeyState, 0, 256);
1015
1016 //
1017 //OSLibWinGetKeyboardStateTable returns the state of PM virtual keys only and
1018 //there are far fewer PM vkeys. (e.g. 0-9, A-Z are not included)
1019 //So we need to use OSLibWinGetScanStateTable (WinSetScanState)
1020 //
1021 rc = OSLibWinGetScanStateTable((PBYTE)&PMScanState[0] );
1022 if(!rc) {
1023// DebugInt3();
1024 dprintf(("OSLibWinGetScanStateTable FAILED"));
1025 return FALSE;
1026 }
1027 for(int i=0;i<256;i++) {
1028 if(auchWinVKeyToPMScan[i].uchPMScanCode) {
1029 lpKeyState[i] = PMScanState[auchWinVKeyToPMScan[i].uchPMScanCode];
1030 }
1031 if(lpKeyState[i] & 0x80) {
1032 dprintf2(("Win key 0x%0x = %x", i, lpKeyState[i]));
1033 }
1034 }
1035#endif
1036
1037 //VK_LCONTROL needs special handling due to AltGr
1038 state = GetKeyState(VK_RMENU);
1039 if (state & 0x8000)
1040 {//if AltGr is down, then pretend VK_LCONTROL is down too
1041 lpKeyState[VK_LCONTROL] = ((state & 0x8000) >> 8) | (state & 1);
1042 lpKeyState[VK_CONTROL] = ((state & 0x8000) >> 8) | (state & 1);
1043 }
1044
1045 //now process the mouse buttons (left, middle, right)
1046 state = GetKeyState(VK_LBUTTON);
1047 lpKeyState[VK_LBUTTON] = ((state & 0x8000) >> 8) | (state & 1);
1048 state = GetKeyState(VK_MBUTTON);
1049 lpKeyState[VK_MBUTTON] = ((state & 0x8000) >> 8) | (state & 1);
1050 state = GetKeyState(VK_RBUTTON);
1051 lpKeyState[VK_RBUTTON] = ((state & 0x8000) >> 8) | (state & 1);
1052#ifdef DEBUG
1053 if(lpKeyState[VK_LBUTTON]) {
1054 dprintf2(("Win key 0x%0x = %x", VK_LBUTTON, lpKeyState[VK_LBUTTON]));
1055 }
1056 if(lpKeyState[VK_MBUTTON]) {
1057 dprintf2(("Win key 0x%0x = %x", VK_MBUTTON, lpKeyState[VK_MBUTTON]));
1058 }
1059 if(lpKeyState[VK_RBUTTON]) {
1060 dprintf2(("Win key 0x%0x = %x", VK_RBUTTON, lpKeyState[VK_RBUTTON]));
1061 }
1062#endif
1063 return TRUE;
1064}
1065//******************************************************************************
1066//******************************************************************************
1067BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
1068{
1069 dprintf(("USER32: SetKeyboardState %x not implemented", lpKeyState));
1070
1071 return(TRUE);
1072}
1073/***********************************************************************
1074 * GetKeyboardLayout (USER32.250)
1075 *
1076 * FIXME: - device handle for keyboard layout defaulted to
1077 * the language id. This is the way Windows default works.
1078 * - the thread identifier (dwLayout) is also ignored.
1079 */
1080// * Remark : Based on Wine version (991031)
1081HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
1082{
1083 HKL layout;
1084 layout = GetSystemDefaultLCID(); /* FIXME */
1085 layout |= (layout<<16); /* FIXME */
1086 dprintf(("GetKeyboardLayout returning %08x\n",layout));
1087 return layout;
1088}
1089/*****************************************************************************
1090 * Name : BOOL WIN32API GetKeyboardLayoutNameA
1091 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
1092 * active keyboard layout.
1093 * Parameters: LPTSTR pwszKLID address of buffer for layout name
1094 * Variables :
1095 * Result : If the function succeeds, the return value is TRUE.
1096 * If the function fails, the return value is FALSE. To get extended
1097 * error information, call GetLastError.
1098 * Remark : Based on Wine version (991031)
1099 * Status : UNTESTED STUB
1100 *
1101 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1102 *****************************************************************************/
1103INT WIN32API GetKeyboardLayoutNameA(LPSTR pwszKLID)
1104{
1105 sprintf(pwszKLID, "%08x", LOWORD(GetKeyboardLayout(0)));
1106 return 1;
1107}
1108
1109
1110/*****************************************************************************
1111 * Name : BOOL WIN32API GetKeyboardLayoutNameW
1112 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
1113 * active keyboard layout.
1114 * Parameters: LPTSTR pwszKLID address of buffer for layout name
1115 * Variables :
1116 * Result : If the function succeeds, the return value is TRUE.
1117 * If the function fails, the return value is FALSE. To get extended
1118 * error information, call GetLastError.
1119 * Remark : Based on Wine version (991031)
1120 * Status : UNTESTED STUB
1121 *
1122 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1123 *****************************************************************************/
1124INT WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
1125{
1126 LPSTR buf = (LPSTR)HEAP_xalloc( GetProcessHeap(), 0, strlen("00000409")+1);
1127
1128 int res = GetKeyboardLayoutNameA(buf);
1129 lstrcpyAtoW(pwszKLID,buf);
1130 HeapFree( GetProcessHeap(), 0, buf );
1131 return res;
1132}
1133/***********************************************************************
1134 * GetKeyboardLayoutList (USER32.251)
1135 *
1136 * FIXME: Supports only the system default language and layout and
1137 * returns only 1 value.
1138 *
1139 * Return number of values available if either input parm is
1140 * 0, per MS documentation.
1141 *
1142 * Remark : Based on Wine version (991031)
1143 */
1144INT WIN32API GetKeyboardLayoutList(INT nBuff, HKL *layouts)
1145{
1146 dprintf(("not correctly implemented"));
1147
1148 if (!nBuff || !layouts)
1149 return 1;
1150
1151 if (layouts)
1152 layouts[0] = GetKeyboardLayout(0);
1153
1154 return 1;
1155}
1156/*****************************************************************************
1157 * Name : int WIN32API ToAscii
1158 * Purpose : The ToAscii function translates the specified virtual-key code
1159 * and keyboard state to the corresponding Windows character or characters.
1160 * Parameters: UINT uVirtKey virtual-key code
1161 * UINT uScanCode scan code
1162 * PBYTE lpbKeyState address of key-state array
1163 * LPWORD lpwTransKey buffer for translated key
1164 * UINT fuState active-menu flag
1165 * Variables :
1166 * Result : 0 The specified virtual key has no translation for the current
1167 * state of the keyboard.
1168 * 1 One Windows character was copied to the buffer.
1169 * 2 Two characters were copied to the buffer. This usually happens
1170 * when a dead-key character (accent or diacritic) stored in the
1171 * keyboard layout cannot be composed with the specified virtual
1172 * key to form a single character.
1173 * Remark :
1174 * Status : UNTESTED STUB
1175 *
1176 * Author : SvL
1177 *****************************************************************************/
1178
1179int WIN32API ToAscii(UINT uVirtKey, UINT uScanCode, PBYTE lpbKeyState,
1180 LPWORD lpwTransKey, UINT fuState)
1181{
1182 INT ret;
1183
1184 if (uScanCode == 0) {
1185 /* This happens when doing Alt+letter : a fake 'down arrow' key press
1186 event is generated by windows. Just ignore it. */
1187 dprintf2(("scanCode=0, doing nothing"));
1188 return 0;
1189 }
1190 if (uScanCode & 0x8000)
1191 {
1192 dprintf2(("Key UP, doing nothing"));
1193 return 0;
1194 }
1195
1196 /* We have another special case for delete key (XK_Delete) on an
1197 extended keyboard. X returns a char for it, but Windows doesn't */
1198 if (uVirtKey == VK_DELETE)
1199 {
1200 *(char*)lpwTransKey = 0;
1201 ret = 0;
1202 }
1203 else
1204 if (uVirtKey == VK_ESCAPE) {
1205 //NT returns VK_ESCAPE here
1206 *(char*)lpwTransKey = VK_ESCAPE;
1207 ret = 1;
1208 }
1209 else {
1210 ULONG shiftstate = 0;
1211
1212 //TODO: multiple characters returned (DBCS??)
1213
1214 if(lpbKeyState[VK_LSHIFT] & 0x80) shiftstate |= TCF_LSHIFT;
1215 if(lpbKeyState[VK_RSHIFT] & 0x80) shiftstate |= TCF_RSHIFT;
1216 else
1217 if(lpbKeyState[VK_SHIFT] & 0x80) shiftstate |= TCF_LSHIFT;
1218
1219 if(lpbKeyState[VK_LCONTROL] & 0x80) shiftstate |= TCF_LCONTROL;
1220 if(lpbKeyState[VK_RCONTROL] & 0x80) shiftstate |= TCF_RCONTROL;
1221 else
1222 if(lpbKeyState[VK_CONTROL] & 0x80) shiftstate |= TCF_LCONTROL;
1223
1224 if(lpbKeyState[VK_LMENU] & 0x80) shiftstate |= TCF_ALT;
1225 if(lpbKeyState[VK_RMENU] & 0x80) shiftstate |= TCF_ALTGR;
1226 else
1227 if(lpbKeyState[VK_MENU] & 0x80) shiftstate |= TCF_ALT;
1228
1229 if(lpbKeyState[VK_CAPITAL] & 1) shiftstate |= TCF_CAPSLOCK;
1230 if(lpbKeyState[VK_NUMLOCK] & 1) shiftstate |= TCF_NUMLOCK;
1231
1232 //NT only modifies the bytes it returns
1233 *(char *)lpwTransKey = OSLibWinTranslateChar(uScanCode, TC_SCANCODETOCHAR, shiftstate);
1234
1235 if(shiftstate & TCF_CONTROL) {
1236 if(uVirtKey >= VK_A && uVirtKey <= VK_Z) {
1237 //NT returns key-0x60 (or so it seems) for ctrl-(shift-)-a..z
1238 if(shiftstate & (TCF_SHIFT|TCF_CAPSLOCK)) {
1239 *(char *)lpwTransKey -= 0x40;
1240 }
1241 else *(char *)lpwTransKey -= 0x60;
1242 }
1243 else
1244 if(uVirtKey == VK_SPACE) {
1245 if(shiftstate & TCF_SHIFT) {
1246 //NT returns 0 for ctrl-shift-space
1247 *lpwTransKey = 0;
1248 }
1249 }
1250 else {
1251 //NT returns 0 for ctrl-0, ctrl-.
1252 *lpwTransKey = 0;
1253 }
1254 }
1255
1256 if(*(char *)lpwTransKey == 0) {
1257 ret = 0;
1258 }
1259 else ret = 1;
1260 }
1261 dprintf(("USER32:ToAscii returned %x, len %d", *lpwTransKey, ret));
1262 return ret;
1263}
1264/*****************************************************************************
1265 * Name : int WIN32API ToAsciiEx
1266 * Purpose : The ToAscii function translates the specified virtual-key code
1267 * and keyboard state to the corresponding Windows character or characters.
1268 * Parameters: UINT uVirtKey virtual-key code
1269 * UINT uScanCode scan code
1270 * PBYTE lpbKeyState address of key-state array
1271 * LPWORD lpwTransKey buffer for translated key
1272 * UINT fuState active-menu flag
1273 * HLK hlk keyboard layout handle
1274 * Variables :
1275 * Result : 0 The specified virtual key has no translation for the current
1276 * state of the keyboard.
1277 * 1 One Windows character was copied to the buffer.
1278 * 2 Two characters were copied to the buffer. This usually happens
1279 * when a dead-key character (accent or diacritic) stored in the
1280 * keyboard layout cannot be composed with the specified virtual
1281 * key to form a single character.
1282 * Remark :
1283 * Status : UNTESTED STUB
1284 *
1285 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1286 *****************************************************************************/
1287
1288int WIN32API ToAsciiEx(UINT uVirtKey, UINT uScanCode, PBYTE lpbKeyState,
1289 LPWORD lpwTransKey, UINT fuState, HKL hkl)
1290{
1291 dprintf(("imcompletely implemented"));
1292
1293 return ToAscii(uVirtKey, uScanCode, lpbKeyState, lpwTransKey, fuState);
1294}
1295/*****************************************************************************
1296 * Name : int WIN32API ToUnicode
1297 * Purpose : The ToUnicode function translates the specified virtual-key code
1298 * and keyboard state to the corresponding Unicode character or characters.
1299 * Parameters: UINT wVirtKey virtual-key code
1300 * UINT wScanCode scan code
1301 * PBYTE lpKeyState address of key-state array
1302 * LPWSTR pwszBuff buffer for translated key
1303 * int cchBuff size of translated key buffer
1304 * UINT wFlags set of function-conditioning flags
1305 * Variables :
1306 * Result : - 1 The specified virtual key is a dead-key character (accent or
1307 * diacritic). This value is returned regardless of the keyboard
1308 * layout, even if several characters have been typed and are
1309 * stored in the keyboard state. If possible, even with Unicode
1310 * keyboard layouts, the function has written a spacing version of
1311 * the dead-key character to the buffer specified by pwszBuffer.
1312 * For example, the function writes the character SPACING ACUTE
1313 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
1314 * 0 The specified virtual key has no translation for the current
1315 * state of the keyboard. Nothing was written to the buffer
1316 * specified by pwszBuffer.
1317 * 1 One character was written to the buffer specified by pwszBuffer.
1318 * 2 or more Two or more characters were written to the buffer specified by
1319 * pwszBuff. The most common cause for this is that a dead-key
1320 * character (accent or diacritic) stored in the keyboard layout
1321 * could not be combined with the specified virtual key to form a
1322 * single character.
1323 * Remark :
1324 * Status : UNTESTED STUB
1325 *
1326 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1327 *****************************************************************************/
1328
1329int WIN32API ToUnicode(UINT uVirtKey, UINT uScanCode, PBYTE lpKeyState,
1330 LPWSTR pwszBuff, int cchBuff, UINT wFlags)
1331{
1332 dprintf(("not implemented.\n"));
1333
1334 return (0);
1335}
1336
1337extern "C"
1338int WINAPI ToUnicodeEx(UINT virtKey, UINT scanCode, const BYTE *lpKeyState,
1339 LPWSTR lpwStr, int size, UINT flags, HKL hkl)
1340{
1341 dprintf(("ToUnicodeEx not implemented.\n"));
1342 return (0);
1343}
1344
1345/*****************************************************************************
1346 * Name : UINT WIN32API GetKBCodePage
1347 * Purpose : The GetKBCodePage function is provided for compatibility with
1348 * earlier versions of Windows. In the Win32 application programming
1349 * interface (API) it just calls the GetOEMCP function.
1350 * Parameters:
1351 * Variables :
1352 * Result : If the function succeeds, the return value is an OEM code-page
1353 * identifier, or it is the default identifier if the registry
1354 * value is not readable. For a list of OEM code-page identifiers,
1355 * see GetOEMCP.
1356 * Remark :
1357 * Status : COMPLETELY IMPLEMENTED UNTESTED
1358 *
1359 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1360 *****************************************************************************/
1361
1362UINT WIN32API GetKBCodePage()
1363{
1364 return (GetOEMCP());
1365}
1366//******************************************************************************
1367//******************************************************************************
1368int WIN32API GetKeyNameTextA(LPARAM lParam, LPSTR lpString, int nSize)
1369{
1370 // check the scancodes if the extended key bit is set so
1371 // we can easily distinguish between "left" and "right" special keys, etc.
1372 BOOL fDontCare = (lParam & WIN_KEY_DONTCARE) != 0;
1373 BOOL fExtended = (lParam & WIN_KEY_EXTENDED) != 0,PMExtended;
1374 UCHAR uchWinScan = (lParam & 0x00ff0000) >> 16;
1375 UCHAR uchWinVKey;
1376 UCHAR uchPMScan;
1377 int result;
1378
1379 if (fDontCare)
1380 {
1381 fExtended = FALSE;
1382
1383 // map "right keys" to "universal keys"
1384 // LALT,RALT -> ALT
1385 // etc.
1386 // @@@PH
1387 }
1388
1389 // Note: Open32 expects PM Scancodes, NOT Winscancodes.
1390 // Note: this is the only way of loss-less conversion!
1391 uchPMScan = KeyTranslateWinScanToPMScan(uchWinScan, fExtended);
1392 dprintf(("ucWinScan=%02xh, fExtended=%d translated to PMscan=%02xh\n",
1393 uchWinScan,
1394 fExtended,
1395 uchPMScan));
1396 uchWinVKey = auchPMScanToWinVKey[uchPMScan][0];
1397 PMExtended = auchPMScanToWinVKey[uchPMScan][1];
1398
1399 dprintf(("ucPMScan=%02xh translated to ucWinVKey=%02xh PMExtended=%d\n",
1400 uchPMScan,
1401 uchWinVKey,PMExtended));
1402
1403 // Bug in Open32:
1404 // 0 - expects PMScancodes instead of WinScancodes
1405 // 1 - the "extended key bit" is not taken into account
1406 // 2 - some keys (AltGr) have not been assigned any names
1407 // int result = O32_GetKeyNameText(lParam,lpString,nSize);
1408
1409 memset(lpString, 0, nSize);
1410
1411 LPCSTR lpstrKey;
1412 lpstrKey = auchWinVKeyToPMScan[uchWinVKey].lpstrName;
1413
1414 // handle Enter on Numeric Keypad here
1415 if (PMExtended)
1416 {
1417 if (uchWinVKey==VK_RETURN) lpstrKey = lpstrNumEnter;
1418 }
1419
1420 if (NULL == lpstrKey)
1421 {
1422 dprintf(("ERROR: keyname for winscan=%02xh winvkey=%02xh, fExtended=%d not found.\n",
1423 uchWinScan, uchWinVKey, fExtended & !fDontCare));
1424
1425 // build artificial name
1426
1427 CHAR szName[10];
1428 sprintf(szName,
1429 "VKey%02x%c",
1430 uchWinScan,
1431 fExtended ? '+' : 0);
1432 memcpy(lpString, szName, nSize);
1433
1434 // how many chars have been returned?
1435 result = min(nSize, strlen(lpString));
1436 }
1437 else
1438 {
1439 result = min(nSize, strlen(lpstrKey));
1440 strncpy (lpString, lpstrKey, result);
1441 }
1442
1443 dprintf(("keyname=[%s]\n",
1444 lpString));
1445
1446 return result;
1447}
1448//******************************************************************************
1449//******************************************************************************
1450int WIN32API GetKeyNameTextW(LPARAM lParam, LPWSTR lpString, int nSize)
1451{
1452 dprintf(("USER32: GetKeyNameTextW DOES NOT WORK (not implemented)\n"));
1453 // NOTE: This will not work as is (needs UNICODE support)
1454 return 0;
1455// return O32_GetKeyNameText(arg1, arg2, arg3);
1456}
1457
1458//******************************************************************************
1459//******************************************************************************
1460ULONG WinConvertNumPadKey(ULONG winVKey)
1461{
1462 ULONG ret;
1463 BYTE winKey;
1464
1465 switch (winVKey)
1466 {
1467 case VK_HOME: ret = VK_NUMPAD7; break;
1468 case VK_UP: ret = VK_NUMPAD8; break;
1469 case VK_PRIOR: ret = VK_NUMPAD9; break;
1470 case VK_LEFT: ret = VK_NUMPAD4; break;
1471 case VK_RIGHT: ret = VK_NUMPAD6; break;
1472 case VK_END: ret = VK_NUMPAD1; break;
1473 case VK_DOWN: ret = VK_NUMPAD2; break;
1474 case VK_NEXT: ret = VK_NUMPAD3; break;
1475 case VK_INSERT:ret = VK_NUMPAD0; break;
1476 case VK_DELETE:ret = VK_DECIMAL; break;
1477 default:
1478 ret = winVKey;
1479 }
1480 dprintf(("Returning %x",ret));
1481 return ret;
1482}
1483
1484//******************************************************************************
1485//******************************************************************************
1486SHORT WIN32API GetKeyState(int nVirtKey)
1487{
1488 // check overlay array first
1489 char nState = arrchOverlayKeyState[nVirtKey & 0xff];
1490 switch (nState)
1491 {
1492 case KEYOVERLAYSTATE_DONTCARE:
1493 // forward processing ...
1494 break;
1495
1496 // @@@PH Note: key-toggle is not handled correctpy
1497 case KEYOVERLAYSTATE_DOWN:
1498 return 0x8000;
1499
1500 case KEYOVERLAYSTATE_UP:
1501 return 0x0000;
1502 }
1503
1504 //If there's a PM scancode for this virtual key, then call WinGetScanState
1505 //O32_GetKeyState converts windows virtual keys to PM virtual keys and there
1506 //are far fewer PM vkeys. (e.g. 0-9, A-Z will fail)
1507 if(nVirtKey < 256 && auchWinVKeyToPMScan[nVirtKey].uchPMScanCode)
1508 {
1509 INT nVirtKey2 = 0;
1510 WORD result;
1511
1512 if (nVirtKey == VK_CONTROL || nVirtKey == VK_LCONTROL)
1513 {//if AltGr is down, then pretend VK_LCONTROL is down too
1514 result = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_RMENU].uchPMScanCode);
1515 if(result & 0x8000) {
1516 return result;
1517 }
1518 //not down, check the control keys
1519 }
1520
1521 if ((nVirtKey >= VK_PRIOR) && (nVirtKey <= VK_DELETE))
1522 {
1523 WORD numState = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_NUMLOCK].uchPMScanCode) & 1;
1524
1525 if(!numState) {
1526 //@PF We also keep track in PM how much times the key has been pressed
1527 //in win32 we can ignore this information - if some apps will demand this
1528 //this is TO-DO
1529 nVirtKey2 = WinConvertNumPadKey(nVirtKey);
1530 }
1531 }
1532 else
1533 if (nVirtKey == VK_MENU) {
1534 nVirtKey = VK_LMENU;
1535 nVirtKey2 = VK_RMENU;
1536 }
1537 else
1538 if (nVirtKey == VK_CONTROL) {
1539 nVirtKey = VK_LCONTROL;
1540 nVirtKey2 = VK_RCONTROL;
1541 }
1542 else
1543 if (nVirtKey == VK_SHIFT) {
1544 nVirtKey = VK_LSHIFT;
1545 nVirtKey2 = VK_RSHIFT;
1546 }
1547 result = OSLibWinGetScanState(auchWinVKeyToPMScan[nVirtKey].uchPMScanCode);
1548 if(nVirtKey2) {
1549 result |= OSLibWinGetScanState(auchWinVKeyToPMScan[nVirtKey2].uchPMScanCode);
1550 }
1551 return result;
1552 }
1553
1554 return O32_GetKeyState(nVirtKey);
1555}
1556//******************************************************************************
1557//******************************************************************************
1558WORD WIN32API GetAsyncKeyState(INT nVirtKey)
1559{
1560 // check overlay array first
1561 char nState = arrchOverlayKeyState[nVirtKey & 0xff];
1562 switch (nState)
1563 {
1564 case KEYOVERLAYSTATE_DONTCARE:
1565 // forward processing ...
1566 break;
1567
1568 // @@@PH Note: key-toggle is not handled correctpy
1569 case KEYOVERLAYSTATE_DOWN:
1570 return 0x8000;
1571
1572 case KEYOVERLAYSTATE_UP:
1573 return 0x0000;
1574 }
1575
1576 //If there's a PM scancode for this virtual key, then call WinGetPhysKeyState
1577 //O32_GetAsyncKeyState converts windows virtual keys to PM virtual keys and there
1578 //are far fewer PM vkeys. (e.g. 0-9, A-Z will fail)
1579 if(nVirtKey < 256 && auchWinVKeyToPMScan[nVirtKey].uchPMScanCode)
1580 {
1581 INT nVirtKey2 = 0;
1582 WORD result;
1583
1584 if (nVirtKey == VK_CONTROL || nVirtKey == VK_LCONTROL)
1585 {//if AltGr is down, then pretend VK_LCONTROL is down too
1586 result = OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[VK_RMENU].uchPMScanCode);
1587 if(result & 0x8000) {
1588 return result;
1589 }
1590 //not down, check the control keys
1591 }
1592
1593 if ((nVirtKey >= VK_PRIOR) && (nVirtKey <= VK_DELETE))
1594 {
1595 WORD numState = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_NUMLOCK].uchPMScanCode) & 1;
1596
1597 if(!numState) {
1598 //@PF We also keep track in PM how much times the key has been pressed
1599 //in win32 we can ignore this information - if some apps will demand this
1600 //this is TO-DO
1601 nVirtKey2 = WinConvertNumPadKey(nVirtKey);
1602 }
1603 }
1604 else
1605 if (nVirtKey == VK_MENU) {
1606 nVirtKey = VK_LMENU;
1607 nVirtKey2 = VK_RMENU;
1608 }
1609 else
1610 if (nVirtKey == VK_CONTROL) {
1611 nVirtKey = VK_LCONTROL;
1612 nVirtKey2 = VK_RCONTROL;
1613 }
1614 else
1615 if (nVirtKey == VK_SHIFT) {
1616 nVirtKey = VK_LSHIFT;
1617 nVirtKey2 = VK_RSHIFT;
1618 }
1619
1620 result = OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[nVirtKey].uchPMScanCode);
1621 if(nVirtKey2) {
1622 result |= OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[nVirtKey2].uchPMScanCode);
1623 }
1624 return result;
1625 }
1626
1627 return O32_GetAsyncKeyState(nVirtKey);
1628}
1629//******************************************************************************
1630//******************************************************************************
1631UINT WIN32API MapVirtualKeyA(UINT uCode, UINT uMapType)
1632{
1633 dprintf(("MapVirtualKeyA: incompletely implemented"));
1634
1635 /* A quick fix for Commandos, very incomplete */
1636 switch (uMapType)
1637 {
1638 case 2:
1639 if (uCode >= VK_A && uCode <= VK_Z)
1640 {
1641 return 'A' + uCode - VK_A;
1642 }
1643 break;
1644
1645 case 0:
1646 {
1647 UINT ret;
1648 if( uCode >= VK_A && uCode <= VK_Z) {
1649 ret = OSLibWinTranslateChar('A' + uCode - VK_A, TC_CHARTOSCANCODE, 0);
1650 dprintf(("MapVirtualKeyA %x (%c) -> %x", uCode, 'A' + uCode - VK_A, ret));
1651 return ret;
1652 }
1653 else
1654 if( uCode >= VK_0 && uCode <= VK_0) {
1655 ret = OSLibWinTranslateChar('0' + uCode - VK_0, TC_CHARTOSCANCODE, 0);
1656 dprintf(("MapVirtualKeyA %x (%c) -> %x", uCode, '0' + uCode - VK_0, ret));
1657 return ret;
1658 }
1659 ret = O32_MapVirtualKey(uCode, uMapType);
1660
1661 // WGSS returns PM scancodes
1662 ret = KeyTranslatePMScanToWinScan(ret);
1663 return ret;
1664 }
1665
1666 case 1:
1667 case 3:
1668 // Open32 uses PMScancodes, not Windows Scancodes!!
1669 // @@@PH the extended flag is to be ignored!
1670 BYTE bPMScan = KeyTranslateWinScanToPMScan(uCode, FALSE);
1671 return O32_MapVirtualKey(bPMScan, uMapType);
1672 }
1673 return O32_MapVirtualKey(uCode, uMapType);
1674}
1675//******************************************************************************
1676//******************************************************************************
1677UINT WIN32API MapVirtualKeyW(UINT uCode, UINT uMapType)
1678{
1679 dprintf(("MapVirtualKeyW: incorrectly implemented"));
1680
1681 // NOTE: This will not work as is (needs UNICODE support)
1682 return MapVirtualKeyA(uCode,uMapType);
1683}
1684/*****************************************************************************
1685 * Name : UINT WIN32API MapVirtualKeyExA
1686 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1687 * code into a scan code or character value, or translates a scan
1688 * code into a virtual-key code. The function translates the codes
1689 * using the input language and physical keyboard layout identified
1690 * by the given keyboard layout handle.
1691 * Parameters:
1692 * Variables :
1693 * Result : The return value is either a scan code, a virtual-key code, or
1694 * a character value, depending on the value of uCode and uMapType.
1695 * If there is no translation, the return value is zero.
1696 * Remark :
1697 * Status : UNTESTED STUB
1698 *
1699 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1700 *****************************************************************************/
1701UINT WIN32API MapVirtualKeyExA(UINT uCode, UINT uMapType, HKL dwhkl)
1702{
1703 dprintf(("MapVirtualKeyExA: incompletely implemented"));
1704
1705 return MapVirtualKeyA(uCode, uMapType);
1706}
1707/*****************************************************************************
1708 * Name : UINT WIN32API MapVirtualKeyExW
1709 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1710 * code into a scan code or character value, or translates a scan
1711 * code into a virtual-key code. The function translates the codes
1712 * using the input language and physical keyboard layout identified
1713 * by the given keyboard layout handle.
1714 * Parameters:
1715 * Variables :
1716 * Result : The return value is either a scan code, a virtual-key code, or
1717 * a character value, depending on the value of uCode and uMapType.
1718 * If there is no translation, the return value is zero.
1719 * Remark :
1720 * Status : UNTESTED STUB
1721 *
1722 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1723 *****************************************************************************/
1724UINT WIN32API MapVirtualKeyExW(UINT uCode, UINT uMapType, HKL dwhkl)
1725{
1726 dprintf(("MapVirtualKeyExW: incompletely implemented"));
1727
1728 return MapVirtualKeyW(uCode, uMapType);
1729}
1730/*****************************************************************************
1731 * Name : DWORD WIN32API OemKeyScan
1732 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
1733 * into the OEM scan codes and shift states. The function provides
1734 * information that allows a program to send OEM text to another
1735 * program by simulating keyboard input.
1736 * Parameters:
1737 * Variables :
1738 * Result :
1739 * Remark :
1740 * Status : Borrowed from NT
1741 *
1742 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1743 *****************************************************************************/
1744DWORD WIN32API OemKeyScan(WORD wOemChar)
1745{
1746 int nVirtKey;
1747
1748 OemToCharBuffA((LPCSTR)&wOemChar,
1749 (LPSTR) &nVirtKey,
1750 1);
1751 if (nVirtKey != 0)
1752 {
1753 SHORT sScan = VkKeyScanA(nVirtKey);
1754 nVirtKey = MapVirtualKeyA( (sScan & 0xff), 0);
1755 if (nVirtKey != 0)
1756 {
1757 return ( (nVirtKey & 0x00FF) ||
1758 ( (nVirtKey & 0xFF00) << 8) );
1759 }
1760 }
1761
1762 // if not found ...
1763 return 0xffffffff;
1764}
1765//******************************************************************************
1766//******************************************************************************
1767BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers,
1768 UINT uVirtKey)
1769{
1770 dprintf(("not implemented"));
1771
1772 hwnd = Win32ToOS2Handle(hwnd);
1773 return(TRUE);
1774}
1775//******************************************************************************
1776//******************************************************************************
1777BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
1778{
1779 dprintf(("not implemented"));
1780
1781 hwnd = Win32ToOS2Handle(hwnd);
1782
1783 return(TRUE);
1784}
1785
1786//******************************************************************************
1787//******************************************************************************
1788WORD WIN32API VkKeyScanA(char ch)
1789{
1790 return O32_VkKeyScan(ch);
1791}
1792//******************************************************************************
1793//******************************************************************************
1794WORD WIN32API VkKeyScanW(WCHAR wch)
1795{
1796 dprintf(("incorrectly implemented"));
1797 // NOTE: This will not work as is (needs UNICODE support)
1798 return O32_VkKeyScan((char)wch);
1799}
1800/*****************************************************************************
1801 * Name : SHORT WIN32API VkKeyScanExW
1802 * Purpose : The VkKeyScanEx function translates a character to the
1803 * corresponding virtual-key code and shift state. The function
1804 * translates the character using the input language and physical
1805 * keyboard layout identified by the given keyboard layout handle.
1806 * Parameters: UINT uChar character to translate
1807 * HKL hkl keyboard layout handle
1808 * Variables :
1809 * Result : see docs
1810 * Remark :
1811 * Status : UNTESTED STUB
1812 *
1813 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1814 *****************************************************************************/
1815WORD WIN32API VkKeyScanExW(WCHAR uChar, HKL hkl)
1816{
1817 dprintf(("partially implemented"));
1818
1819 return VkKeyScanW(uChar);
1820}
1821/*****************************************************************************
1822 * Name : SHORT WIN32API VkKeyScanExA
1823 * Purpose : The VkKeyScanEx function translates a character to the
1824 * corresponding virtual-key code and shift state. The function
1825 * translates the character using the input language and physical
1826 * keyboard layout identified by the given keyboard layout handle.
1827 * Parameters: UINT uChar character to translate
1828 * HKL hkl keyboard layout handle
1829 * Variables :
1830 * Result : see docs
1831 * Remark :
1832 * Status : UNTESTED STUB
1833 *
1834 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1835 *****************************************************************************/
1836WORD WIN32API VkKeyScanExA(CHAR uChar, HKL hkl)
1837{
1838 dprintf(("partially implemented"));
1839
1840 return VkKeyScanA(uChar);
1841}
1842/*****************************************************************************
1843 * Name : VOID WIN32API keybd_event
1844 * Purpose : The keybd_event function synthesizes a keystroke. The system
1845 * can use such a synthesized keystroke to generate a WM_KEYUP or
1846 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
1847 * the keybd_event function.
1848 * Parameters: BYTE bVk virtual-key code
1849
1850 * BYTE bScan hardware scan code
1851 * DWORD dwFlags flags specifying various function options
1852 * DWORD dwExtraInfo additional data associated with keystroke
1853 * Variables :
1854 * Result :
1855 * Remark :
1856 * Status : UNTESTED STUB
1857 *
1858 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1859 *****************************************************************************/
1860VOID WIN32API keybd_event(BYTE bVk, BYTE bScan, DWORD dwFlags, DWORD dwExtraInfo)
1861{
1862 INPUT i;
1863
1864 // format input packet
1865 i.type = INPUT_KEYBOARD;
1866 i.ki.wVk = bVk;
1867 i.ki.wScan = bScan;
1868 i.ki.dwFlags = dwFlags;
1869 i.ki.dwExtraInfo = dwExtraInfo;
1870
1871 // forward to more modern API
1872 SendInput(1, &i, sizeof(i) );
1873}
1874/*****************************************************************************
1875 * Name : HLK WIN32API LoadKeyboardLayoutA
1876 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1877 * the system. Several keyboard layouts can be loaded at a time, but
1878 * only one per process is active at a time. Loading multiple keyboard
1879 * layouts makes it possible to rapidly switch between layouts.
1880 * Parameters:
1881 * Variables :
1882 * Result : If the function succeeds, the return value is the handle of the
1883 * keyboard layout.
1884 * If the function fails, the return value is NULL. To get extended
1885 * error information, call GetLastError.
1886 * Remark :
1887 * Status : UNTESTED STUB
1888 *
1889 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1890 *****************************************************************************/
1891HKL WIN32API LoadKeyboardLayoutA(LPCSTR pwszKLID, UINT Flags)
1892{
1893 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
1894 pwszKLID,
1895 Flags));
1896
1897 return (NULL);
1898}
1899/*****************************************************************************
1900 * Name : HLK WIN32API LoadKeyboardLayoutW
1901 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1902 * the system. Several keyboard layouts can be loaded at a time, but
1903 * only one per process is active at a time. Loading multiple keyboard
1904 * layouts makes it possible to rapidly switch between layouts.
1905 * Parameters:
1906 * Variables :
1907 * Result : If the function succeeds, the return value is the handle of the
1908 * keyboard layout.
1909 * If the function fails, the return value is NULL. To get extended
1910 * error information, call GetLastError.
1911 * Remark :
1912 * Status : UNTESTED STUB
1913 *
1914 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1915 *****************************************************************************/
1916HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID, UINT Flags)
1917{
1918 dprintf(("USER32:LoadKeyboardLayoutW (%ls,%u) not implemented.\n",
1919 pwszKLID,
1920 Flags));
1921
1922 return (NULL);
1923}
1924//******************************************************************************
1925//******************************************************************************
1926HKL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
1927{
1928 dprintf(("not implemented\n"));
1929 return NULL;
1930}
1931/*****************************************************************************
1932 * Name : BOOL WIN32API UnloadKeyboardLayout
1933 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
1934 * Parameters: HKL hkl handle of keyboard layout
1935 * Variables :
1936 * Result : If the function succeeds, the return value is the handle of the
1937 * keyboard layout; otherwise, it is NULL. To get extended error
1938 * information, use the GetLastError function.
1939 * Remark :
1940 * Status : UNTESTED STUB
1941 *
1942 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1943 *****************************************************************************/
1944BOOL WIN32API UnloadKeyboardLayout(HKL hkl)
1945{
1946 dprintf(("not implemented.\n"));
1947
1948 return (TRUE);
1949}
1950//******************************************************************************
1951//******************************************************************************
1952
1953// this is an internal function to emulate Alt-Gr behaviour
1954VOID WIN32API KeySetOverlayKeyState(int nVirtKey, char nState)
1955{
1956 // setup overlay array
1957 arrchOverlayKeyState[nVirtKey & 0xff] = nState;
1958}
1959
Note: See TracBrowser for help on using the repository browser.