source: trunk/src/user32/winkeyboard.cpp

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

Merge branch gcc-kmk to trunk.
File size: 90.8 KB
RevLine 
[10552]1/* $Id: winkeyboard.cpp,v 1.45 2004-03-23 15:49:50 sandervl Exp $ */
[2469]2/*
3 * Win32 <-> PM key translation
4 *
5 *
6 * Project Odin Software License can be found in LICENSE.TXT
7 *
8 */
[6801]9
10#include <odin.h>
11#include <odinwrap.h>
12#include <os2sel.h>
13
[2469]14#include <os2win.h>
[6801]15
[2469]16#include <string.h>
17#include <stdio.h>
18#include <winkeyboard.h>
[9810]19#include "oslibkbd.h"
[2469]20#include <heapstring.h>
[6149]21#include <pmscan.h>
[7190]22#include <winscan.h>
[6162]23#include <winuser32.h>
[6339]24#include "initterm.h"
[2469]25
[6254]26#define DBG_LOCALLOG DBG_winkeyboard
[2803]27#include "dbglocal.h"
28
[6801]29
[7306]30/****************************************************************************
31 * module local variables
32 ****************************************************************************/
33
34static char arrchOverlayKeyState[256] = {0};
35
36
37
38
39/****************************************************************************
40 * implementation
41 ****************************************************************************/
42
[6149]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;
[6254]54}
[6149]55
56
[21916]57static UCHAR auchPMScanToWinVKey[256][2] =
[2469]58/****************************************************************************/
[6254]59/* PM Scancode * Win32 vkey Extended Key */
[2469]60/****************************************************************************/
[6254]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
[8474]115/* 0x36 PMSCAN_SHIFTRIGHT */ , VK_RSHIFT ,FALSE
[6254]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
[7190]152/* 0x5B PMSCAN_CTRLRIGHT */ , VK_RCONTROL ,TRUE
[6254]153/* 0x5C PMSCAN_PADSLASH */ , VK_DIVIDE ,TRUE
[7216]154/* 0x5D PMSCAN_PRINT */ , VK_SNAPSHOT ,TRUE
[6254]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
[7191]185/* 0x7c PMSCAN_APPLICATION */ , VK_APPS ,TRUE
[6254]186/* 0x7d PMSCAN_E13 */ , 0x00 ,FALSE
[7191]187/* 0x7e PMSCAN_WINLEFT */ , VK_LWIN ,TRUE
188/* 0x7f PMSCAN_WINRIGHT */ , VK_RWIN ,TRUE
[6254]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
[8365]210/* 0x95 PMSCAN_DBE_CONV */ , 0x00 ,FALSE //TODO ??
211/* 0x96 PMSCAN_DBE_NOCONV */ , 0x00 ,FALSE //TODO ??
[6254]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
[2469]317 };
318
[7187]319typedef struct tagWinVKeyToPMScan
320{
321 /* index is the VKey value */
[21916]322 UCHAR uchPMScanCode;
323 LPCSTR lpstrName;
[7187]324} WINVKEYTOPMSCAN, *PWINVKEYTOPMSCAN;
325
[21916]326static WINVKEYTOPMSCAN auchWinVKeyToPMScan[256] =
[7187]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"
[7871]343/* 0x0D VK_RETURN */ , PMSCAN_ENTER , "Enter"
[7187]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
[7216]372/* 0x2A VK_PRINT */ , 0x00 , NULL
[7187]373/* 0x2B VK_EXECUTE */ , 0x00 , NULL
[7201]374/* 0x2C VK_SNAPSHOT */ , PMSCAN_PRINT , "Print" // NT4SP6: appears to be printscreen!
[7187]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"
[9810]417/* 0x57 VK_W */ , PMSCAN_W , "W"
[7187]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
[6149]586 };
587
[7871]588// @@PF reflect Num Enter key
[21916]589LPCSTR lpstrNumEnter = "Num Enter";
[7190]590
591// @@@PH
[7612]592// Note: windows uses different scancodes if numlock is pressed
[7190]593// This is not (yet) reflected here!
[21916]594static BYTE auchPMScanToWinScan[256][2] =
[7190]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
[7212]652/* 0x36 PMSCAN_SHIFTRIGHT */ , WINSCAN_SHIFTRIGHT ,TRUE
[7190]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
[7201]691/* 0x5D PMSCAN_PRINT */ , WINSCAN_PRINT ,TRUE
[7190]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
[7617]707/* 0x6D PMSCAN_ERASEEOF */ , WINSCAN_ERASEEOF ,FALSE
708/* 0x6E PMSCAN_BREAK */ , WINSCAN_BREAK ,TRUE
[7190]709/* 0x6F PMSCAN_MOVEWIN */ , 0x00 ,FALSE
[7612]710/* 0x70 PMSCAN_NLS3 */ , WINSCAN_NLS3 ,FALSE
[7617]711/* 0x71 PMSCAN_HELP */ , WINSCAN_HELP ,FALSE
[7190]712/* 0x72 PMSCAN_TASKMAN */ , 0x00 ,FALSE
[7612]713/* 0x73 PMSCAN_B11 */ , WINSCAN_B11 ,FALSE
[7190]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
[7612]719/* 0x79 PMSCAN_NLS2 */ , WINSCAN_NLS2 ,FALSE
[7190]720/* 0x7a PMSCAN_SIZE */ , 0x00 ,FALSE
[7612]721/* 0x7b PMSCAN_NLS1 */ , WINSCAN_NLS1 ,FALSE
[7617]722/* 0x7c PMSCAN_APPLICATION */ , WINSCAN_APPLICATION ,TRUE
[7612]723/* 0x7d PMSCAN_E13 */ , WINSCAN_YEN ,FALSE
[7722]724/* 0x7e PMSCAN_WINLEFT */ , WINSCAN_WINLEFT ,TRUE
725/* 0x7f PMSCAN_WINRIGHT */ , WINSCAN_WINRIGHT ,TRUE
[7617]726/* 0x80 PMSCAN_PA1 */ , WINSCAN_PA1 ,FALSE
[7190]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
[7617]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
[7612]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
[8365]747/* 0x95 PMSCAN_DBE_CONV */ , WINSCAN_NLS2 ,FALSE // CONVERT (Japanese keyboard)
748/* 0x96 PMSCAN_DBE_NOCONV */ , WINSCAN_NLS1 ,FALSE // NOCONVERT (Japanese keyboard)
[7612]749/* 0x97 */ , WINSCAN_UNLABELED ,FALSE
[7190]750/* 0x98 */ , 0x00 ,FALSE
[7612]751/* 0x99 */ , WINSCAN_NEXTTRACK ,FALSE
[7190]752/* 0x9A */ , 0x00 ,FALSE
753/* 0x9B */ , 0x00 ,FALSE
754/* 0x9C */ , 0x00 ,FALSE
755/* 0x9D */ , 0x00 ,FALSE
756/* 0x9E */ , 0x00 ,FALSE
757/* 0x9F */ , 0x00 ,FALSE
[7612]758/* 0xA0 */ , WINSCAN_MUTE ,FALSE
759/* 0xA1 */ , WINSCAN_CALCULATOR ,FALSE
760/* 0xA2 */ , WINSCAN_PLAYPAUSE ,FALSE
[7190]761/* 0xA3 */ , 0x00 ,FALSE
[7612]762/* 0xA4 */ , WINSCAN_MEDIASTOP ,FALSE
[7190]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
[7612]772/* 0xAE */ , WINSCAN_VOLUMEDOWN ,FALSE
[7190]773/* 0xAF */ , 0x00 ,FALSE
[7612]774/* 0xB0 */ , WINSCAN_VOLUMEUP ,FALSE
[7190]775/* 0xB1 */ , 0x00 ,FALSE
[7612]776/* 0xB2 */ , WINSCAN_WEBHOME ,FALSE
777/* 0xB3 */ , WINSCAN_NUMPADCOMMA ,FALSE
[7190]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
[7612]820/* 0xDE */ , WINSCAN_POWER ,FALSE
821/* 0xDF */ , WINSCAN_SLEEP ,FALSE
[7190]822/* 0xE0 */ , 0x00 ,FALSE
823/* 0xE1 */ , 0x00 ,FALSE
824/* 0xE2 */ , 0x00 ,FALSE
[7612]825/* 0xE3 */ , WINSCAN_WAKE ,FALSE
[7190]826/* 0xE4 */ , 0x00 ,FALSE
[7612]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
[7190]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
[2469]857//******************************************************************************
858//******************************************************************************
[6801]859
[21916]860VOID WIN32API KeyTranslatePMToWinBuf(PUCHAR pmkey, PUCHAR winkey,
[7875]861 int nrkeys)
[2469]862{
[9810]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
[6149]872 for(int i=1;i<nrkeys;i++) {
[21916]873 if(auchWinVKeyToPMScan[i].uchPMScanCode) {
874 pmvkey = OSLibWinTranslateChar(auchWinVKeyToPMScan[i].uchPMScanCode, TC_SCANCODETOVIRTUALKEY, 0);
[9810]875 if(pmvkey == 0) {
[21916]876 dprintf2(("WinTranslateChar %x (%x) FAILED!!", i, auchWinVKeyToPMScan[i].uchPMScanCode));
[9810]877 }
878 winkey[i] = pmkey[pmvkey];
[6149]879 }
[9810]880 else dprintf2(("key %x has no PM scancode", i));
[2469]881 }
[6149]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];
[2469]885}
886//******************************************************************************
887//******************************************************************************
[21916]888UCHAR KeyTranslateWinVKeyToPMScan(UCHAR uchWinVKey, BOOL fExtended)
[7166]889{
[7187]890 // if the extended bit didn't match, this is
891 // the closest hit
[21916]892 UCHAR uchAlmost = 0;
[7166]893
[7187]894 // experiment
[10552]895
[7187]896#if 0
[21916]897 bAlmost = auchWinVKeyToPMScan[bWinVKey].uchPMScanCode;
[7187]898#else
899 for(int i = 0;
[21916]900 i < 256; // sizeof(row of auchPMScanToWinVKey)
[7187]901 i++)
902 {
[21916]903 if (auchPMScanToWinVKey[i][0] == uchWinVKey)
[7187]904 {
905 // this represents the PMScan code which is used as index
[21916]906 uchAlmost = i;
[7187]907
908 // exact match!
[21916]909 if (auchPMScanToWinVKey[i][1] == fExtended)
[7187]910 break;
911 }
912 }
913#endif
914
915 dprintf(("KeyTranslateWinVKeyToPMScan(%02xh,%d) = %02xh",
[21916]916 uchWinVKey,
[7187]917 fExtended,
[21916]918 uchAlmost));
[7187]919
920 // almost a match or no match at all.
[21916]921 return uchAlmost;
[7166]922}
923//******************************************************************************
924//******************************************************************************
[21916]925void KeyTranslatePMScanToWinVKey(UCHAR uchPMScan,
[7212]926 BOOL bNumLock,
[21916]927 PUCHAR puchWinVKey,
928 WORD *pwWinScan,
[7212]929 PBOOL pfExtended)
930{
931 // @@@PH numlock is currently ignored
[21916]932 if (puchWinVKey)
933 *puchWinVKey = auchPMScanToWinVKey[uchPMScan][0];
[7212]934
935 if (pfExtended)
[21916]936 *pfExtended = auchPMScanToWinVKey[uchPMScan][1];
[7212]937
938 if (pwWinScan)
[21916]939 *pwWinScan = auchPMScanToWinScan[uchPMScan][0];
[7212]940}
941//******************************************************************************
942//******************************************************************************
[21916]943UCHAR KeyTranslateWinScanToPMScan(UCHAR uchWinScan, BOOL fExtended)
[7187]944{
[7190]945 // Note:
946 // MapVirtualKeyA requires this function,
947 // O32_MapVirtualKeyA uses PM Scancodes only!
[7187]948
[7190]949 // if the extended bit didn't match, this is
950 // the closest hit
[21916]951 UCHAR uchAlmost = 0;
[7190]952
953 for(int i = 0;
[21916]954 i < 256; // sizeof(row of auchPMScanToWinVKey)
[7190]955 i++)
956 {
[21916]957 if (auchPMScanToWinScan[i][0] == uchWinScan)
[7190]958 {
959 // this represents the PMScan code which is used as index
[21916]960 uchAlmost = i;
[7190]961
962 // exact match!
[21916]963 if (auchPMScanToWinVKey[i][1] == fExtended)
[7190]964 break;
965 }
966 }
967
968 dprintf(("KeyTranslateWinScanToPMScan(%02xh,%d) = %02xh",
[21916]969 uchWinScan,
[7190]970 fExtended,
[21916]971 uchAlmost));
[7190]972
973 // almost a match or no match at all.
[21916]974 return uchAlmost;
[7190]975
[7187]976}
977//******************************************************************************
978//******************************************************************************
[21916]979UCHAR KeyTranslatePMScanToWinScan(UCHAR bPMScan)
[10552]980{
981 // Note:
982 // MapVirtualKeyA requires this function,
983 // O32_MapVirtualKeyA uses PM Scancodes only!
984
[21916]985 return auchPMScanToWinScan[bPMScan][0];
[10552]986}
987//******************************************************************************
988//******************************************************************************
[7875]989INT WIN32API GetKeyboardType(INT nTypeFlag)
[5196]990{
991 return O32_GetKeyboardType(nTypeFlag);
992}
993//******************************************************************************
994//******************************************************************************
[7875]995BOOL WIN32API GetKeyboardState(PBYTE lpKeyState)
[2469]996{
[9810]997#if 1
[9814]998 //temporary solution until we find out why OSLibWinGetScanStateTable always
999 //fails
[9810]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++) {
[21916]1028 if(auchWinVKeyToPMScan[i].uchPMScanCode) {
1029 lpKeyState[i] = PMScanState[auchWinVKeyToPMScan[i].uchPMScanCode];
[9810]1030 }
1031 if(lpKeyState[i] & 0x80) {
1032 dprintf2(("Win key 0x%0x = %x", i, lpKeyState[i]));
1033 }
1034 }
[9814]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
[9810]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;
[2469]1064}
1065//******************************************************************************
1066//******************************************************************************
[7875]1067BOOL WIN32API SetKeyboardState(PBYTE lpKeyState)
[2469]1068{
[10190]1069 dprintf(("USER32: SetKeyboardState %x not implemented", lpKeyState));
1070
1071 return(TRUE);
[2469]1072}
1073/***********************************************************************
[6254]1074 * GetKeyboardLayout (USER32.250)
[2469]1075 *
[6254]1076 * FIXME: - device handle for keyboard layout defaulted to
[2469]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)
[7875]1081HKL WIN32API GetKeyboardLayout(DWORD dwLayout)
[2469]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 *****************************************************************************/
[7875]1103INT WIN32API GetKeyboardLayoutNameA(LPSTR pwszKLID)
[2469]1104{
[10517]1105 sprintf(pwszKLID, "%08x", LOWORD(GetKeyboardLayout(0)));
[2469]1106 return 1;
1107}
[6801]1108
1109
[2469]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 *****************************************************************************/
[7875]1124INT WIN32API GetKeyboardLayoutNameW(LPWSTR pwszKLID)
[2469]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/***********************************************************************
[6254]1134 * GetKeyboardLayoutList (USER32.251)
[2469]1135 *
[6254]1136 * FIXME: Supports only the system default language and layout and
[2469]1137 * returns only 1 value.
1138 *
[6254]1139 * Return number of values available if either input parm is
[2469]1140 * 0, per MS documentation.
1141 *
1142 * Remark : Based on Wine version (991031)
1143 */
[7875]1144INT WIN32API GetKeyboardLayoutList(INT nBuff, HKL *layouts)
[2469]1145{
[6801]1146 dprintf(("not correctly implemented"));
1147
1148 if (!nBuff || !layouts)
[6254]1149 return 1;
[6801]1150
1151 if (layouts)
1152 layouts[0] = GetKeyboardLayout(0);
1153
1154 return 1;
[2469]1155}
[4498]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 *
[6157]1176 * Author : SvL
[4498]1177 *****************************************************************************/
[6801]1178
[7875]1179int WIN32API ToAscii(UINT uVirtKey, UINT uScanCode, PBYTE lpbKeyState,
1180 LPWORD lpwTransKey, UINT fuState)
[4498]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 }
[6156]1195
[4498]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 }
[6157]1203 else
1204 if (uVirtKey == VK_ESCAPE) {
1205 //NT returns VK_ESCAPE here
1206 *(char*)lpwTransKey = VK_ESCAPE;
1207 ret = 1;
1208 }
[4498]1209 else {
[6156]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;
[10190]1216 else
1217 if(lpbKeyState[VK_SHIFT] & 0x80) shiftstate |= TCF_LSHIFT;
1218
[6156]1219 if(lpbKeyState[VK_LCONTROL] & 0x80) shiftstate |= TCF_LCONTROL;
1220 if(lpbKeyState[VK_RCONTROL] & 0x80) shiftstate |= TCF_RCONTROL;
[10190]1221 else
1222 if(lpbKeyState[VK_CONTROL] & 0x80) shiftstate |= TCF_LCONTROL;
1223
[6156]1224 if(lpbKeyState[VK_LMENU] & 0x80) shiftstate |= TCF_ALT;
1225 if(lpbKeyState[VK_RMENU] & 0x80) shiftstate |= TCF_ALTGR;
[10190]1226 else
1227 if(lpbKeyState[VK_MENU] & 0x80) shiftstate |= TCF_ALT;
1228
[6156]1229 if(lpbKeyState[VK_CAPITAL] & 1) shiftstate |= TCF_CAPSLOCK;
1230 if(lpbKeyState[VK_NUMLOCK] & 1) shiftstate |= TCF_NUMLOCK;
1231
[6157]1232 //NT only modifies the bytes it returns
1233 *(char *)lpwTransKey = OSLibWinTranslateChar(uScanCode, TC_SCANCODETOCHAR, shiftstate);
[6156]1234
[6157]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
[6162]1238 if(shiftstate & (TCF_SHIFT|TCF_CAPSLOCK)) {
[6157]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;
[4498]1260 }
[8512]1261 dprintf(("USER32:ToAscii returned %x, len %d", *lpwTransKey, ret));
[4498]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 *****************************************************************************/
[6801]1287
[7875]1288int WIN32API ToAsciiEx(UINT uVirtKey, UINT uScanCode, PBYTE lpbKeyState,
1289 LPWORD lpwTransKey, UINT fuState, HKL hkl)
[4498]1290{
[6801]1291 dprintf(("imcompletely implemented"));
[4498]1292
[6162]1293 return ToAscii(uVirtKey, uScanCode, lpbKeyState, lpwTransKey, fuState);
[4498]1294}
[6156]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 *****************************************************************************/
[6801]1328
[7875]1329int WIN32API ToUnicode(UINT uVirtKey, UINT uScanCode, PBYTE lpKeyState,
1330 LPWSTR pwszBuff, int cchBuff, UINT wFlags)
[6156]1331{
[6801]1332 dprintf(("not implemented.\n"));
[6156]1333
1334 return (0);
1335}
[21303]1336
[21916]1337extern "C"
[21303]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
[6162]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
[7871]1362UINT WIN32API GetKBCodePage()
[6162]1363{
1364 return (GetOEMCP());
1365}
[2469]1366//******************************************************************************
1367//******************************************************************************
[7871]1368int WIN32API GetKeyNameTextA(LPARAM lParam, LPSTR lpString, int nSize)
[6162]1369{
[7187]1370 // check the scancodes if the extended key bit is set so
1371 // we can easily distinguish between "left" and "right" special keys, etc.
[7612]1372 BOOL fDontCare = (lParam & WIN_KEY_DONTCARE) != 0;
[7871]1373 BOOL fExtended = (lParam & WIN_KEY_EXTENDED) != 0,PMExtended;
[21916]1374 UCHAR uchWinScan = (lParam & 0x00ff0000) >> 16;
1375 UCHAR uchWinVKey;
1376 UCHAR uchPMScan;
[7187]1377 int result;
1378
1379 if (fDontCare)
1380 {
[7190]1381 fExtended = FALSE;
1382
[7187]1383 // map "right keys" to "universal keys"
1384 // LALT,RALT -> ALT
1385 // etc.
1386 // @@@PH
1387 }
1388
[7166]1389 // Note: Open32 expects PM Scancodes, NOT Winscancodes.
[7190]1390 // Note: this is the only way of loss-less conversion!
[21916]1391 uchPMScan = KeyTranslateWinScanToPMScan(uchWinScan, fExtended);
[7190]1392 dprintf(("ucWinScan=%02xh, fExtended=%d translated to PMscan=%02xh\n",
[21916]1393 uchWinScan,
[7190]1394 fExtended,
[21916]1395 uchPMScan));
1396 uchWinVKey = auchPMScanToWinVKey[uchPMScan][0];
1397 PMExtended = auchPMScanToWinVKey[uchPMScan][1];
[7871]1398
1399 dprintf(("ucPMScan=%02xh translated to ucWinVKey=%02xh PMExtended=%d\n",
[21916]1400 uchPMScan,
1401 uchWinVKey,PMExtended));
[7190]1402
[7187]1403 // Bug in Open32:
1404 // 0 - expects PMScancodes instead of WinScancodes
[7166]1405 // 1 - the "extended key bit" is not taken into account
[7187]1406 // 2 - some keys (AltGr) have not been assigned any names
1407 // int result = O32_GetKeyNameText(lParam,lpString,nSize);
[7166]1408
[7187]1409 memset(lpString, 0, nSize);
1410
[21916]1411 LPCSTR lpstrKey;
1412 lpstrKey = auchWinVKeyToPMScan[uchWinVKey].lpstrName;
[7871]1413
1414 // handle Enter on Numeric Keypad here
1415 if (PMExtended)
1416 {
[21916]1417 if (uchWinVKey==VK_RETURN) lpstrKey = lpstrNumEnter;
[7871]1418 }
1419
[7187]1420 if (NULL == lpstrKey)
1421 {
1422 dprintf(("ERROR: keyname for winscan=%02xh winvkey=%02xh, fExtended=%d not found.\n",
[21916]1423 uchWinScan, uchWinVKey, fExtended & !fDontCare));
[7187]1424
1425 // build artificial name
1426
1427 CHAR szName[10];
1428 sprintf(szName,
1429 "VKey%02x%c",
[21916]1430 uchWinScan,
[7187]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
[7166]1446 return result;
[6162]1447}
1448//******************************************************************************
1449//******************************************************************************
[7871]1450int WIN32API GetKeyNameTextW(LPARAM lParam, LPWSTR lpString, int nSize)
[6162]1451{
[6801]1452 dprintf(("USER32: GetKeyNameTextW DOES NOT WORK (not implemented)\n"));
[6162]1453 // NOTE: This will not work as is (needs UNICODE support)
1454 return 0;
1455// return O32_GetKeyNameText(arg1, arg2, arg3);
1456}
[9922]1457
[6162]1458//******************************************************************************
1459//******************************************************************************
[9922]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//******************************************************************************
[7875]1486SHORT WIN32API GetKeyState(int nVirtKey)
[6162]1487{
[7306]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;
[8474]1502 }
[9810]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)
[21916]1507 if(nVirtKey < 256 && auchWinVKeyToPMScan[nVirtKey].uchPMScanCode)
[9810]1508 {
1509 INT nVirtKey2 = 0;
1510 WORD result;
1511
[9814]1512 if (nVirtKey == VK_CONTROL || nVirtKey == VK_LCONTROL)
1513 {//if AltGr is down, then pretend VK_LCONTROL is down too
[21916]1514 result = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_RMENU].uchPMScanCode);
[9814]1515 if(result & 0x8000) {
1516 return result;
1517 }
1518 //not down, check the control keys
1519 }
1520
[9922]1521 if ((nVirtKey >= VK_PRIOR) && (nVirtKey <= VK_DELETE))
1522 {
[21916]1523 WORD numState = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_NUMLOCK].uchPMScanCode) & 1;
[9922]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
[9810]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 }
[21916]1547 result = OSLibWinGetScanState(auchWinVKeyToPMScan[nVirtKey].uchPMScanCode);
[9810]1548 if(nVirtKey2) {
[21916]1549 result |= OSLibWinGetScanState(auchWinVKeyToPMScan[nVirtKey2].uchPMScanCode);
[9810]1550 }
1551 return result;
1552 }
1553
[6801]1554 return O32_GetKeyState(nVirtKey);
[6162]1555}
1556//******************************************************************************
1557//******************************************************************************
[7875]1558WORD WIN32API GetAsyncKeyState(INT nVirtKey)
[6162]1559{
[7306]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;
[7612]1574 }
[9810]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)
[21916]1579 if(nVirtKey < 256 && auchWinVKeyToPMScan[nVirtKey].uchPMScanCode)
[9810]1580 {
1581 INT nVirtKey2 = 0;
1582 WORD result;
1583
[9814]1584 if (nVirtKey == VK_CONTROL || nVirtKey == VK_LCONTROL)
1585 {//if AltGr is down, then pretend VK_LCONTROL is down too
[21916]1586 result = OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[VK_RMENU].uchPMScanCode);
[9814]1587 if(result & 0x8000) {
1588 return result;
1589 }
1590 //not down, check the control keys
1591 }
[9922]1592
1593 if ((nVirtKey >= VK_PRIOR) && (nVirtKey <= VK_DELETE))
1594 {
[21916]1595 WORD numState = OSLibWinGetScanState(auchWinVKeyToPMScan[VK_NUMLOCK].uchPMScanCode) & 1;
[9922]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
[9810]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
[21916]1620 result = OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[nVirtKey].uchPMScanCode);
[9810]1621 if(nVirtKey2) {
[21916]1622 result |= OSLibWinGetPhysKeyState(auchWinVKeyToPMScan[nVirtKey2].uchPMScanCode);
[9810]1623 }
1624 return result;
1625 }
1626
[7612]1627 return O32_GetAsyncKeyState(nVirtKey);
[6162]1628}
1629//******************************************************************************
1630//******************************************************************************
[7875]1631UINT WIN32API MapVirtualKeyA(UINT uCode, UINT uMapType)
[6162]1632{
[21340]1633 dprintf(("MapVirtualKeyA: incompletely implemented"));
[7190]1634
[6801]1635 /* A quick fix for Commandos, very incomplete */
1636 switch (uMapType)
1637 {
[6162]1638 case 2:
[6801]1639 if (uCode >= VK_A && uCode <= VK_Z)
1640 {
[21344]1641 return 'A' + uCode - VK_A;
[6162]1642 }
[7190]1643 break;
1644
[10190]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 }
[10552]1659 ret = O32_MapVirtualKey(uCode, uMapType);
1660
1661 // WGSS returns PM scancodes
1662 ret = KeyTranslatePMScanToWinScan(ret);
1663 return ret;
[10190]1664 }
1665
[7190]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);
[6801]1672 }
1673 return O32_MapVirtualKey(uCode, uMapType);
[6162]1674}
1675//******************************************************************************
1676//******************************************************************************
[7875]1677UINT WIN32API MapVirtualKeyW(UINT uCode, UINT uMapType)
[6162]1678{
[21340]1679 dprintf(("MapVirtualKeyW: incorrectly implemented"));
[6801]1680
1681 // NOTE: This will not work as is (needs UNICODE support)
[9810]1682 return MapVirtualKeyA(uCode,uMapType);
[6162]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 *****************************************************************************/
[7875]1701UINT WIN32API MapVirtualKeyExA(UINT uCode, UINT uMapType, HKL dwhkl)
[6162]1702{
[21340]1703 dprintf(("MapVirtualKeyExA: incompletely implemented"));
[6162]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 *****************************************************************************/
[7875]1724UINT WIN32API MapVirtualKeyExW(UINT uCode, UINT uMapType, HKL dwhkl)
[6162]1725{
[21340]1726 dprintf(("MapVirtualKeyExW: incompletely implemented"));
[6162]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 :
[6806]1740 * Status : Borrowed from NT
[6162]1741 *
1742 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1743 *****************************************************************************/
[7875]1744DWORD WIN32API OemKeyScan(WORD wOemChar)
[6162]1745{
[6806]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;
[6162]1764}
1765//******************************************************************************
1766//******************************************************************************
[7875]1767BOOL WIN32API RegisterHotKey(HWND hwnd, int idHotKey, UINT fuModifiers,
1768 UINT uVirtKey)
[6162]1769{
[6801]1770 dprintf(("not implemented"));
1771
[6162]1772 hwnd = Win32ToOS2Handle(hwnd);
1773 return(TRUE);
1774}
1775//******************************************************************************
1776//******************************************************************************
[7875]1777BOOL WIN32API UnregisterHotKey(HWND hwnd, int idHotKey)
[6162]1778{
[6801]1779 dprintf(("not implemented"));
1780
[6162]1781 hwnd = Win32ToOS2Handle(hwnd);
1782
1783 return(TRUE);
1784}
[6801]1785
[6162]1786//******************************************************************************
1787//******************************************************************************
[7875]1788WORD WIN32API VkKeyScanA(char ch)
[6162]1789{
[6801]1790 return O32_VkKeyScan(ch);
[6162]1791}
1792//******************************************************************************
1793//******************************************************************************
[7875]1794WORD WIN32API VkKeyScanW(WCHAR wch)
[6162]1795{
[6801]1796 dprintf(("incorrectly implemented"));
1797 // NOTE: This will not work as is (needs UNICODE support)
1798 return O32_VkKeyScan((char)wch);
[6162]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 *****************************************************************************/
[7875]1815WORD WIN32API VkKeyScanExW(WCHAR uChar, HKL hkl)
[6162]1816{
[6801]1817 dprintf(("partially implemented"));
[6162]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 *****************************************************************************/
[7875]1836WORD WIN32API VkKeyScanExA(CHAR uChar, HKL hkl)
[6162]1837{
[6801]1838 dprintf(("partially implemented"));
[6162]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 *****************************************************************************/
[7875]1860VOID WIN32API keybd_event(BYTE bVk, BYTE bScan, DWORD dwFlags, DWORD dwExtraInfo)
[6162]1861{
[6972]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) );
[6162]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 *****************************************************************************/
[7875]1891HKL WIN32API LoadKeyboardLayoutA(LPCSTR pwszKLID, UINT Flags)
[6162]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 *****************************************************************************/
[7875]1916HKL WIN32API LoadKeyboardLayoutW(LPCWSTR pwszKLID, UINT Flags)
[6162]1917{
[6801]1918 dprintf(("USER32:LoadKeyboardLayoutW (%ls,%u) not implemented.\n",
[6162]1919 pwszKLID,
1920 Flags));
1921
1922 return (NULL);
1923}
1924//******************************************************************************
1925//******************************************************************************
[9974]1926HKL WIN32API ActivateKeyboardLayout(HKL hkl, UINT fuFlags)
[6162]1927{
[6801]1928 dprintf(("not implemented\n"));
[9974]1929 return NULL;
[6162]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 *****************************************************************************/
[7866]1944BOOL WIN32API UnloadKeyboardLayout(HKL hkl)
[6162]1945{
[6801]1946 dprintf(("not implemented.\n"));
[6162]1947
[6801]1948 return (TRUE);
[6162]1949}
1950//******************************************************************************
1951//******************************************************************************
[7306]1952
1953// this is an internal function to emulate Alt-Gr behaviour
[7875]1954VOID WIN32API KeySetOverlayKeyState(int nVirtKey, char nState)
[7306]1955{
1956 // setup overlay array
1957 arrchOverlayKeyState[nVirtKey & 0xff] = nState;
1958}
1959
Note: See TracBrowser for help on using the repository browser.