source: trunk/src/user32/winkeyboard.cpp@ 7187

Last change on this file since 7187 was 7187, checked in by phaller, 24 years ago

.
File size: 64.0 KB
Line 
1/* $Id: winkeyboard.cpp,v 1.19 2001-10-24 11:18:19 phaller 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 "oslibwin.h"
20#include <heapstring.h>
21#include <pmscan.h>
22#include <winuser32.h>
23#include "initterm.h"
24
25#define DBG_LOCALLOG DBG_winkeyboard
26#include "dbglocal.h"
27
28
29
30
31ODINDEBUGCHANNEL(USER32-WINKBD)
32
33
34BOOL OPEN32API _O32_GetKeyboardState( PBYTE lpKeyState );
35
36inline BOOL O32_GetKeyboardState(PBYTE lpKeyState)
37{
38 BOOL yyrc;
39 USHORT sel = RestoreOS2FS();
40
41 yyrc = _O32_GetKeyboardState(lpKeyState);
42 SetFS(sel);
43
44 return yyrc;
45}
46
47
48BYTE abPMScanToWinVKey[256][2] =
49/****************************************************************************/
50/* PM Scancode * Win32 vkey Extended Key */
51/****************************************************************************/
52/* 0x00 */ { 0x00, FALSE
53/* 0x01 PMSCAN_ESC */ , VK_ESCAPE ,FALSE
54/* 0x02 PMSCAN_ONE */ , VK_1 ,FALSE
55/* 0x03 PMSCAN_TWO */ , VK_2 ,FALSE
56/* 0x04 PMSCAN_THREE */ , VK_3 ,FALSE
57/* 0x05 PMSCAN_FOUR */ , VK_4 ,FALSE
58/* 0x06 PMSCAN_FIVE */ , VK_5 ,FALSE
59/* 0x07 PMSCAN_SIX */ , VK_6 ,FALSE
60/* 0x08 PMSCAN_SEVEN */ , VK_7 ,FALSE
61/* 0x09 PMSCAN_EIGHT */ , VK_8 ,FALSE
62/* 0x0A PMSCAN_NINE */ , VK_9 ,FALSE
63/* 0x0B PMSCAN_ZERO */ , VK_0 ,FALSE
64/* 0x0C PMSCAN_HYPHEN */ , VK_HYPHEN ,FALSE
65/* 0x0D PMSCAN_EQUAL */ , VK_EQUAL ,FALSE
66/* 0x0E PMSCAN_BACKSPACE */ , VK_BACK ,FALSE
67/* 0x0F PMSCAN_TAB */ , VK_TAB ,FALSE
68/* 0x10 PMSCAN_Q */ , VK_Q ,FALSE
69/* 0x11 PMSCAN_W */ , VK_W ,FALSE
70/* 0x12 PMSCAN_E */ , VK_E ,FALSE
71/* 0x13 PMSCAN_R */ , VK_R ,FALSE
72/* 0x14 PMSCAN_T */ , VK_T ,FALSE
73/* 0x15 PMSCAN_Y */ , VK_Y ,FALSE
74/* 0x16 PMSCAN_U */ , VK_U ,FALSE
75/* 0x17 PMSCAN_I */ , VK_I ,FALSE
76/* 0x18 PMSCAN_O */ , VK_O ,FALSE
77/* 0x19 PMSCAN_P */ , VK_P ,FALSE
78/* 0x1A PMSCAN_BRACKETLEFT */ , VK_BRACKETLEFT ,FALSE
79/* 0x1B PMSCAN_BRACKETRIGHT */ , VK_BRACKETRIGHT ,FALSE
80/* 0x1C PMSCAN_ENTER */ , VK_RETURN ,FALSE
81/* 0x1D PMSCAN_CTRLLEFT */ , VK_LCONTROL ,FALSE
82/* 0x1E PMSCAN_A */ , VK_A ,FALSE
83/* 0x1F PMSCAN_S */ , VK_S ,FALSE
84/* 0x20 PMSCAN_D */ , VK_D ,FALSE
85/* 0x21 PMSCAN_F */ , VK_F ,FALSE
86/* 0x22 PMSCAN_G */ , VK_G ,FALSE
87/* 0x23 PMSCAN_H */ , VK_H ,FALSE
88/* 0x24 PMSCAN_J */ , VK_J ,FALSE
89/* 0x25 PMSCAN_K */ , VK_K ,FALSE
90/* 0x26 PMSCAN_L */ , VK_L ,FALSE
91/* 0x27 PMSCAN_SEMICOLON */ , VK_SEMICOLON ,FALSE
92/* 0x28 PMSCAN_QUOTESINGLE */ , VK_QUOTESINGLE ,FALSE
93/* 0x29 PMSCAN_GRAVE */ , VK_GRAVE ,FALSE
94/* 0x2A PMSCAN_SHIFTLEFT */ , VK_LSHIFT ,FALSE
95/* 0x2B PMSCAN_BACKSLASH */ , VK_BACKSLASH ,FALSE
96/* 0x2C PMSCAN_Z */ , VK_Z ,FALSE
97/* 0x2D PMSCAN_X */ , VK_X ,FALSE
98/* 0x2E PMSCAN_C */ , VK_C ,FALSE
99/* 0x2F PMSCAN_V */ , VK_V ,FALSE
100/* 0x30 PMSCAN_B */ , VK_B ,FALSE
101/* 0x31 PMSCAN_N */ , VK_N ,FALSE
102/* 0x32 PMSCAN_M */ , VK_M ,FALSE
103/* 0x33 PMSCAN_COMMA */ , VK_COMMA ,FALSE
104/* 0x34 PMSCAN_PERIOD */ , VK_PERIOD ,FALSE
105/* 0x35 PMSCAN_SLASH */ , VK_SLASH ,FALSE
106/* 0x36 PMSCAN_SHIFTRIGHT */ , VK_RSHIFT ,FALSE
107/* 0x37 PMSCAN_PADASTERISK */ , VK_MULTIPLY ,FALSE
108/* 0x38 PMSCAN_ALTLEFT */ , VK_LMENU ,FALSE
109/* 0x39 PMSCAN_SPACE */ , VK_SPACE ,FALSE
110/* 0x3A PMSCAN_CAPSLOCK */ , VK_CAPITAL ,FALSE
111/* 0x3B PMSCAN_F1 */ , VK_F1 ,FALSE
112/* 0x3C PMSCAN_F2 */ , VK_F2 ,FALSE
113/* 0x3D PMSCAN_F3 */ , VK_F3 ,FALSE
114/* 0x3E PMSCAN_F4 */ , VK_F4 ,FALSE
115/* 0x3F PMSCAN_F5 */ , VK_F5 ,FALSE
116/* 0x40 PMSCAN_F6 */ , VK_F6 ,FALSE
117/* 0x41 PMSCAN_F7 */ , VK_F7 ,FALSE
118/* 0x42 PMSCAN_F8 */ , VK_F8 ,FALSE
119/* 0x43 PMSCAN_F9 */ , VK_F9 ,FALSE
120/* 0x44 PMSCAN_F10 */ , VK_F10 ,FALSE
121/* 0x45 PMSCAN_NUMLOCK */ , VK_NUMLOCK ,TRUE
122/* 0x46 PMSCAN_SCROLLLOCK */ , VK_SCROLL ,FALSE
123/* 0x47 PMSCAN_PAD7 */ , VK_NUMPAD7 ,FALSE
124/* 0x48 PMSCAN_PAD8 */ , VK_NUMPAD8 ,FALSE
125/* 0x49 PMSCAN_PAD9 */ , VK_NUMPAD9 ,FALSE
126/* 0x4A PMSCAN_PADMINUS */ , VK_SUBTRACT ,FALSE
127/* 0x4B PMSCAN_PAD4 */ , VK_NUMPAD4 ,FALSE
128/* 0x4C PMSCAN_PAD5 */ , VK_NUMPAD5 ,FALSE
129/* 0x4D PMSCAN_PAD6 */ , VK_NUMPAD6 ,FALSE
130/* 0x4E PMSCAN_PADPLUS */ , VK_ADD ,FALSE
131/* 0x4F PMSCAN_PAD1 */ , VK_NUMPAD1 ,FALSE
132/* 0x50 PMSCAN_PAD2 */ , VK_NUMPAD2 ,FALSE
133/* 0x51 PMSCAN_PAD3 */ , VK_NUMPAD3 ,FALSE
134/* 0x52 PMSCAN_PAD0 */ , VK_NUMPAD0 ,FALSE
135/* 0x53 PMSCAN_PADPERIOD */ , VK_DECIMAL ,FALSE
136/* 0x54 PMSCAN_SYSREQ */ , 0x00 ,FALSE
137/* 0x55 PMSCAN_RESET */ , 0x00 ,FALSE
138/* 0x56 PMSCAN_EXTRA */ , VK_EXTRA ,FALSE
139/* 0x57 PMSCAN_F11 */ , VK_F11 ,FALSE
140/* 0x58 PMSCAN_F12 */ , VK_F12 ,FALSE
141/* 0x59 PMSCAN_BACKTAB */ , 0x00 ,FALSE
142/* 0x5A PMSCAN_PADENTER */ , VK_RETURN ,TRUE
143/* 0x5B PMSCAN_CTRLRIGHT */ , VK_CONTROL ,TRUE
144/* 0x5C PMSCAN_PADSLASH */ , VK_DIVIDE ,TRUE
145/* 0x5D PMSCAN_PRINT */ , VK_PRINT ,FALSE
146/* 0x5E PMSCAN_ALTRIGHT */ , VK_RMENU ,TRUE
147/* 0x5F PMSCAN_PAUSE */ , VK_PAUSE ,FALSE
148/* 0x60 PMSCAN_HOME */ , VK_HOME ,TRUE
149/* 0x61 PMSCAN_UP */ , VK_UP ,TRUE
150/* 0x62 PMSCAN_PAGEUP */ , VK_PRIOR ,TRUE
151/* 0x63 PMSCAN_LEFT */ , VK_LEFT ,TRUE
152/* 0x64 PMSCAN_RIGHT */ , VK_RIGHT ,TRUE
153/* 0x65 PMSCAN_END */ , VK_END ,TRUE
154/* 0x66 PMSCAN_DOWN */ , VK_DOWN ,TRUE
155/* 0x67 PMSCAN_PAGEDOWN */ , VK_NEXT ,TRUE
156/* 0x68 PMSCAN_INSERT */ , VK_INSERT ,TRUE
157/* 0x69 PMSCAN_DELETE */ , VK_DELETE ,TRUE
158/* 0x6A PMSCAN_F23 */ , VK_F23 ,FALSE
159/* 0x6B PMSCAN_F24 */ , VK_F24 ,FALSE
160/* 0x6C PMSCAN_SYSMEM */ , 0x00 ,FALSE
161/* 0x6D PMSCAN_ERASEEOF */ , VK_EREOF ,FALSE
162/* 0x6E PMSCAN_BREAK */ , VK_CANCEL ,TRUE
163/* 0x6F PMSCAN_MOVEWIN */ , 0x00 ,FALSE
164/* 0x70 PMSCAN_NLS3 */ , 0x00 ,FALSE
165/* 0x71 PMSCAN_HELP */ , VK_HELP ,FALSE
166/* 0x72 PMSCAN_TASKMAN */ , 0x00 ,FALSE
167/* 0x73 PMSCAN_B11 */ , 0x00 ,FALSE
168/* 0x74 PMSCAN_JUMP */ , 0x00 ,FALSE
169/* 0x75 PMSCAN_MINWIN */ , 0x00 ,FALSE
170/* 0x76 PMSCAN_CLEAR */ , 0x00 ,FALSE
171/* 0x77 PMSCAN_77 */ , 0x00 ,FALSE
172/* 0x78 PMSCAN_78 */ , 0x00 ,FALSE
173/* 0x79 PMSCAN_NLS2 */ , 0x00 ,FALSE
174/* 0x7a PMSCAN_SIZE */ , 0x00 ,FALSE
175/* 0x7b PMSCAN_NLS1 */ , 0x00 ,FALSE
176/* 0x7c PMSCAN_APPLICATION */ , VK_APPS ,FALSE
177/* 0x7d PMSCAN_E13 */ , 0x00 ,FALSE
178/* 0x7e PMSCAN */ , 0x00 ,FALSE
179/* 0x7f PMSCAN */ , 0x00 ,FALSE
180/* 0x80 PMSCAN_PA1 */ , VK_PA1 ,FALSE
181/* 0x81 PMSCAN_F13 */ , VK_F13 ,FALSE
182/* 0x82 PMSCAN_F14 */ , VK_F14 ,FALSE
183/* 0x83 PMSCAN_F15 */ , VK_F15 ,FALSE
184/* 0x84 PMSCAN_PA2 */ , 0x00 ,FALSE
185/* 0x85 PMSCAN_PA3 */ , 0x00 ,FALSE
186/* 0x86 PMSCAN_SPACEBREAK */ , 0x00 ,FALSE
187/* 0x87 PMSCAN_TABRIGHT */ , 0x00 ,FALSE
188/* 0x88 PMSCAN_NOOP */ , 0x00 ,FALSE
189/* 0x89 PMSCAN_F16 */ , VK_F16 ,FALSE
190/* 0x8a PMSCAN_F17 */ , VK_F17 ,FALSE
191/* 0x8b PMSCAN_F18 */ , VK_F18 ,FALSE
192/* 0x8c PMSCAN_F19 */ , VK_F19 ,FALSE
193/* 0x8d PMSCAN_F20 */ , VK_F20 ,FALSE
194/* 0x8e PMSCAN_F21 */ , VK_F21 ,FALSE
195/* 0x8f PMSCAN_F22 */ , VK_F22 ,FALSE
196/* 0x90 */ , 0x00 ,FALSE
197/* 0x91 */ , 0x00 ,FALSE
198/* 0x92 */ , 0x00 ,FALSE
199/* 0x93 */ , 0x00 ,FALSE
200/* 0x94 */ , 0x00 ,FALSE
201/* 0x95 */ , 0x00 ,FALSE
202/* 0x96 */ , 0x00 ,FALSE
203/* 0x97 */ , 0x00 ,FALSE
204/* 0x98 */ , 0x00 ,FALSE
205/* 0x99 */ , 0x00 ,FALSE
206/* 0x9A */ , 0x00 ,FALSE
207/* 0x9B */ , 0x00 ,FALSE
208/* 0x9C */ , 0x00 ,FALSE
209/* 0x9D */ , 0x00 ,FALSE
210/* 0x9E */ , 0x00 ,FALSE
211/* 0x9F */ , 0x00 ,FALSE
212/* 0xA0 */ , 0x00 ,FALSE
213/* 0xA1 */ , 0x00 ,FALSE
214/* 0xA2 */ , 0x00 ,FALSE
215/* 0xA3 */ , 0x00 ,FALSE
216/* 0xA4 */ , 0x00 ,FALSE
217/* 0xA5 */ , 0x00 ,FALSE
218/* 0xA6 */ , 0x00 ,FALSE
219/* 0xA7 */ , 0x00 ,FALSE
220/* 0xA8 */ , 0x00 ,FALSE
221/* 0xA9 */ , 0x00 ,FALSE
222/* 0xAA */ , 0x00 ,FALSE
223/* 0xAB */ , 0x00 ,FALSE
224/* 0xAC */ , 0x00 ,FALSE
225/* 0xAD */ , 0x00 ,FALSE
226/* 0xAE */ , 0x00 ,FALSE
227/* 0xAF */ , 0x00 ,FALSE
228/* 0xB0 */ , 0x00 ,FALSE
229/* 0xB1 */ , 0x00 ,FALSE
230/* 0xB2 */ , 0x00 ,FALSE
231/* 0xB3 */ , 0x00 ,FALSE
232/* 0xB4 */ , 0x00 ,FALSE
233/* 0xB5 */ , 0x00 ,FALSE
234/* 0xB6 */ , 0x00 ,FALSE
235/* 0xB7 */ , 0x00 ,FALSE
236/* 0xB8 */ , 0x00 ,FALSE
237/* 0xB9 */ , 0x00 ,FALSE
238/* 0xBA */ , 0x00 ,FALSE
239/* 0xBB */ , 0x00 ,FALSE
240/* 0xBC */ , 0x00 ,FALSE
241/* 0xBD */ , 0x00 ,FALSE
242/* 0xBE */ , 0x00 ,FALSE
243/* 0xBF */ , 0x00 ,FALSE
244/* 0xC0 */ , 0x00 ,FALSE
245/* 0xC1 */ , 0x00 ,FALSE
246/* 0xC2 */ , 0x00 ,FALSE
247/* 0xC3 */ , 0x00 ,FALSE
248/* 0xC4 */ , 0x00 ,FALSE
249/* 0xC5 */ , 0x00 ,FALSE
250/* 0xC6 */ , 0x00 ,FALSE
251/* 0xC7 */ , 0x00 ,FALSE
252/* 0xC8 */ , 0x00 ,FALSE
253/* 0xC9 */ , 0x00 ,FALSE
254/* 0xCA */ , 0x00 ,FALSE
255/* 0xCB */ , 0x00 ,FALSE
256/* 0xCC */ , 0x00 ,FALSE
257/* 0xCD */ , 0x00 ,FALSE
258/* 0xCE */ , 0x00 ,FALSE
259/* 0xCF */ , 0x00 ,FALSE
260/* 0xD0 */ , 0x00 ,FALSE
261/* 0xD1 */ , 0x00 ,FALSE
262/* 0xD2 */ , 0x00 ,FALSE
263/* 0xD3 */ , 0x00 ,FALSE
264/* 0xD4 */ , 0x00 ,FALSE
265/* 0xD5 */ , 0x00 ,FALSE
266/* 0xD6 */ , 0x00 ,FALSE
267/* 0xD7 */ , 0x00 ,FALSE
268/* 0xD8 */ , 0x00 ,FALSE
269/* 0xD9 */ , 0x00 ,FALSE
270/* 0xDA */ , 0x00 ,FALSE
271/* 0xDB */ , 0x00 ,FALSE
272/* 0xDC */ , 0x00 ,FALSE
273/* 0xDD */ , 0x00 ,FALSE
274/* 0xDE */ , 0x00 ,FALSE
275/* 0xDF */ , 0x00 ,FALSE
276/* 0xE0 */ , 0x00 ,FALSE
277/* 0xE1 */ , 0x00 ,FALSE
278/* 0xE2 */ , 0x00 ,FALSE
279/* 0xE3 */ , 0x00 ,FALSE
280/* 0xE4 */ , 0x00 ,FALSE
281/* 0xE5 */ , 0x00 ,FALSE
282/* 0xE6 */ , 0x00 ,FALSE
283/* 0xE7 */ , 0x00 ,FALSE
284/* 0xE8 */ , 0x00 ,FALSE
285/* 0xE9 */ , 0x00 ,FALSE
286/* 0xEA */ , 0x00 ,FALSE
287/* 0xEB */ , 0x00 ,FALSE
288/* 0xEC */ , 0x00 ,FALSE
289/* 0xED */ , 0x00 ,FALSE
290/* 0xEE */ , 0x00 ,FALSE
291/* 0xEF */ , 0x00 ,FALSE
292/* 0xF0 */ , 0x00 ,FALSE
293/* 0xF1 */ , 0x00 ,FALSE
294/* 0xF2 */ , 0x00 ,FALSE
295/* 0xF3 */ , 0x00 ,FALSE
296/* 0xF4 */ , 0x00 ,FALSE
297/* 0xF5 */ , 0x00 ,FALSE
298/* 0xF6 */ , 0x00 ,FALSE
299/* 0xF7 */ , 0x00 ,FALSE
300/* 0xF8 */ , 0x00 ,FALSE
301/* 0xF9 */ , 0x00 ,FALSE
302/* 0xFA */ , 0x00 ,FALSE
303/* 0xFB */ , 0x00 ,FALSE
304/* 0xFC */ , 0x00 ,FALSE
305/* 0xFD */ , 0x00 ,FALSE
306/* 0xFE */ , 0x00 ,FALSE
307/* 0xFF */ , 0x00 ,FALSE
308 };
309
310typedef struct tagWinVKeyToPMScan
311{
312 /* index is the VKey value */
313 BYTE bPMScanCode;
314 LPSTR lpstrName;
315} WINVKEYTOPMSCAN, *PWINVKEYTOPMSCAN;
316
317WINVKEYTOPMSCAN abWinVKeyToPMScan[256] =
318/**********************************************************************/
319/* Vkey * Scancode * Name */
320/**********************************************************************/
321/* 0x00 */ { 0x00 , NULL
322/* 0x01 VK_LBUTTON */ , 0x00 , NULL
323/* 0x02 VK_RBUTTON */ , 0x00 , NULL
324/* 0x03 VK_CANCEL */ , PMSCAN_BREAK , "Break"
325/* 0x04 VK_MBUTTON */ , 0x00 , NULL
326/* 0x05 */ , 0x00 , NULL
327/* 0x06 */ , 0x00 , NULL
328/* 0x07 */ , 0x00 , NULL
329/* 0x08 VK_BACK */ , PMSCAN_BACKSPACE , "Backspace"
330/* 0x09 VK_TAB */ , PMSCAN_TAB , "Tab"
331/* 0x0A */ , 0x00 , NULL
332/* 0x0B */ , 0x00 , NULL
333/* 0x0C VK_CLEAR */ , PMSCAN_PAD5 , "Num 5"
334/* 0x0D VK_RETURN */ , PMSCAN_ENTER , "Enter"
335/* 0x0E */ , 0x00 , NULL
336/* 0x0F */ , 0x00 , NULL
337/* 0x10 VK_SHIFT */ , PMSCAN_SHIFTLEFT , "Left Shift"
338/* 0x11 VK_CONTROL */ , PMSCAN_CTRLLEFT , "Left Control"
339/* 0x12 VK_MENU */ , PMSCAN_ALTLEFT , "Left Alt"
340/* 0x13 VK_PAUSE */ , PMSCAN_PAUSE , "Pause"
341/* 0x14 VK_CAPITAL */ , PMSCAN_CAPSLOCK , "Caps Lock"
342/* 0x15 */ , 0x00 , NULL
343/* 0x16 */ , 0x00 , NULL
344/* 0x17 */ , 0x00 , NULL
345/* 0x18 */ , 0x00 , NULL
346/* 0x19 */ , 0x00 , NULL
347/* 0x1A */ , 0x00 , NULL
348/* 0x1B VK_ESCAPE */ , PMSCAN_ESC , "Escape"
349/* 0x1C */ , 0x00 , NULL
350/* 0x1D */ , 0x00 , NULL
351/* 0x1E */ , 0x00 , NULL
352/* 0x1F */ , 0x00 , NULL
353/* 0x20 VK_SPACE */ , PMSCAN_SPACE , "Space"
354/* 0x21 VK_PRIOR */ , PMSCAN_PAGEUP , "Page Up"
355/* 0x22 VK_NEXT */ , PMSCAN_PAGEDOWN , "Page Down"
356/* 0x23 VK_END */ , PMSCAN_END , "End"
357/* 0x24 VK_HOME */ , PMSCAN_HOME , "Home"
358/* 0x25 VK_LEFT */ , PMSCAN_LEFT , "Left"
359/* 0x26 VK_UP */ , PMSCAN_UP , "Up"
360/* 0x27 VK_RIGHT */ , PMSCAN_RIGHT , "Right"
361/* 0x28 VK_DOWN */ , PMSCAN_DOWN , "Down"
362/* 0x29 VK_SELECT */ , 0x00 , NULL
363/* 0x2A VK_PRINT */ , PMSCAN_PRINT , "Print"
364/* 0x2B VK_EXECUTE */ , 0x00 , NULL
365/* 0x2C VK_SNAPSHOT */ , 0x00 , NULL
366/* 0x2D VK_INSERT */ , PMSCAN_INSERT , "Insert"
367/* 0x2E VK_DELETE */ , PMSCAN_DELETE , "Delete"
368/* 0x2F VK_HELP */ , PMSCAN_HELP , "Help"
369/* 0x30 VK_0 */ , PMSCAN_ZERO , "0"
370/* 0x31 VK_1 */ , PMSCAN_ONE , "1"
371/* 0x32 VK_2 */ , PMSCAN_TWO , "2"
372/* 0x33 VK_3 */ , PMSCAN_THREE , "3"
373/* 0x34 VK_4 */ , PMSCAN_FOUR , "4"
374/* 0x35 VK_5 */ , PMSCAN_FIVE , "5"
375/* 0x36 VK_6 */ , PMSCAN_SIX , "6"
376/* 0x37 VK_7 */ , PMSCAN_SEVEN , "7"
377/* 0x38 VK_8 */ , PMSCAN_EIGHT , "8"
378/* 0x39 VK_9 */ , PMSCAN_NINE , "9"
379/* 0x3A */ , 0x00 , NULL
380/* 0x3B */ , 0x00 , NULL
381/* 0x3C */ , 0x00 , NULL
382/* 0x3D */ , 0x00 , NULL
383/* 0x3E */ , 0x00 , NULL
384/* 0x3F */ , 0x00 , NULL
385/* 0x40 */ , 0x00 , NULL
386/* 0x41 VK_A */ , PMSCAN_A , "A"
387/* 0x42 VK_B */ , PMSCAN_B , "B"
388/* 0x43 VK_C */ , PMSCAN_C , "C"
389/* 0x44 VK_D */ , PMSCAN_D , "D"
390/* 0x45 VK_E */ , PMSCAN_E , "E"
391/* 0x46 VK_F */ , PMSCAN_F , "F"
392/* 0x47 VK_G */ , PMSCAN_G , "G"
393/* 0x48 VK_H */ , PMSCAN_H , "H"
394/* 0x49 VK_I */ , PMSCAN_I , "I"
395/* 0x4A VK_J */ , PMSCAN_J , "J"
396/* 0x4B VK_K */ , PMSCAN_K , "K"
397/* 0x4C VK_L */ , PMSCAN_L , "L"
398/* 0x4D VK_M */ , PMSCAN_M , "M"
399/* 0x4E VK_N */ , PMSCAN_N , "N"
400/* 0x4F VK_O */ , PMSCAN_O , "O"
401/* 0x50 VK_P */ , PMSCAN_P , "P"
402/* 0x51 VK_Q */ , PMSCAN_Q , "Q"
403/* 0x52 VK_R */ , PMSCAN_R , "R"
404/* 0x53 VK_S */ , PMSCAN_S , "S"
405/* 0x54 VK_T */ , PMSCAN_T , "T"
406/* 0x55 VK_U */ , PMSCAN_U , "U"
407/* 0x56 VK_V */ , PMSCAN_V , "V"
408/* 0x57 VK */ , PMSCAN_W , "W"
409/* 0x58 VK_X */ , PMSCAN_X , "X"
410/* 0x59 VK_Y */ , PMSCAN_Y , "Y"
411/* 0x5A VK_Z */ , PMSCAN_Z , "Z"
412/* 0x5B VK_LWIN */ , PMSCAN_WINLEFT , "Left Win"
413/* 0x5C VK_RWIN */ , PMSCAN_WINRIGHT , "Right Win"
414/* 0x5D VK_APPS */ , PMSCAN_APPLICATION , "Application"
415/* 0x5E */ , 0x00 , NULL
416/* 0x5F */ , 0x00 , NULL
417/* 0x60 VK_NUMPAD0 */ , PMSCAN_PAD0 , "Num 0"
418/* 0x61 VK_NUMPAD1 */ , PMSCAN_PAD1 , "Num 1"
419/* 0x62 VK_NUMPAD2 */ , PMSCAN_PAD2 , "Num 2"
420/* 0x63 VK_NUMPAD3 */ , PMSCAN_PAD3 , "Num 3"
421/* 0x64 VK_NUMPAD4 */ , PMSCAN_PAD4 , "Num 4"
422/* 0x65 VK_NUMPAD5 */ , PMSCAN_PAD5 , "Num 5"
423/* 0x66 VK_NUMPAD6 */ , PMSCAN_PAD6 , "Num 6"
424/* 0x67 VK_NUMPAD7 */ , PMSCAN_PAD7 , "Num 7"
425/* 0x68 VK_NUMPAD8 */ , PMSCAN_PAD8 , "Num 8"
426/* 0x69 VK_NUMPAD9 */ , PMSCAN_PAD9 , "Num 9"
427/* 0x6A VK_MULTIPLY */ , PMSCAN_PADASTERISK , "Num *"
428/* 0x6B VK_ADD */ , PMSCAN_PADPLUS , "Num +"
429/* 0x6C VK_SEPARATOR */ , 0x00 , NULL
430/* 0x6D VK_SUBTRACT */ , PMSCAN_PADMINUS , "Num -"
431/* 0x6E VK_DECIMAL */ , PMSCAN_PADPERIOD , "Num ."
432/* 0x6F VK_DIVIDE */ , PMSCAN_PADSLASH , "Num /"
433/* 0x70 VK_F1 */ , PMSCAN_F1 , "F1"
434/* 0x71 VK_F2 */ , PMSCAN_F2 , "F2"
435/* 0x72 VK_F3 */ , PMSCAN_F3 , "F3"
436/* 0x73 VK_F4 */ , PMSCAN_F4 , "F4"
437/* 0x74 VK_F5 */ , PMSCAN_F5 , "F5"
438/* 0x75 VK_F6 */ , PMSCAN_F6 , "F6"
439/* 0x76 VK_F7 */ , PMSCAN_F7 , "F7"
440/* 0x77 VK_F8 */ , PMSCAN_F8 , "F8"
441/* 0x78 VK_F9 */ , PMSCAN_F9 , "F9"
442/* 0x79 VK_F10 */ , PMSCAN_F10 , "F10"
443/* 0x7A VK_F11 */ , PMSCAN_F11 , "F11"
444/* 0x7B VK_F12 */ , PMSCAN_F12 , "F12"
445/* 0x7C VK_F13 */ , PMSCAN_F13 , "F13"
446/* 0x7D VK_F14 */ , PMSCAN_F14 , "F14"
447/* 0x7E VK_F15 */ , PMSCAN_F15 , "F15"
448/* 0x7F VK_F16 */ , PMSCAN_F16 , "F16"
449/* 0x80 VK_F17 */ , PMSCAN_F17 , "F17"
450/* 0x81 VK_F18 */ , PMSCAN_F18 , "F18"
451/* 0x82 VK_F19 */ , PMSCAN_F19 , "F19"
452/* 0x83 VK_F20 */ , PMSCAN_F20 , "F20"
453/* 0x84 VK_F21 */ , PMSCAN_F21 , "F21"
454/* 0x85 VK_F22 */ , PMSCAN_F22 , "F22"
455/* 0x86 VK_F23 */ , PMSCAN_F23 , "F23"
456/* 0x87 VK_F24 */ , PMSCAN_F24 , "F24"
457/* 0x88 */ , 0x00 , NULL
458/* 0x89 */ , 0x00 , NULL
459/* 0x8A */ , 0x00 , NULL
460/* 0x8B */ , 0x00 , NULL
461/* 0x8C */ , 0x00 , NULL
462/* 0x8D */ , 0x00 , NULL
463/* 0x8E */ , 0x00 , NULL
464/* 0x8F */ , 0x00 , NULL
465/* 0x90 VK_NUMLOCK */ , PMSCAN_NUMLOCK , "Num Lock"
466/* 0x91 VK_SCROLL */ , PMSCAN_SCROLLLOCK , "Scroll Lock"
467/* 0x92 */ , 0x00 , NULL
468/* 0x93 */ , 0x00 , NULL
469/* 0x94 */ , 0x00 , NULL
470/* 0x95 */ , 0x00 , NULL
471/* 0x96 */ , 0x00 , NULL
472/* 0x97 */ , 0x00 , NULL
473/* 0x98 */ , 0x00 , NULL
474/* 0x99 */ , 0x00 , NULL
475/* 0x9A */ , 0x00 , NULL
476/* 0x9B */ , 0x00 , NULL
477/* 0x9C */ , 0x00 , NULL
478/* 0x9D */ , 0x00 , NULL
479/* 0x9E */ , 0x00 , NULL
480/* 0x9F */ , 0x00 , NULL
481/* 0xA0 VK_LSHIFT */ , PMSCAN_SHIFTLEFT , "Left Shift"
482/* 0xA1 VK_RSHIFT */ , PMSCAN_SHIFTRIGHT , "Right Shift"
483/* 0xA2 VK_LCONTROL */ , PMSCAN_CTRLLEFT , "Left Control"
484/* 0xA3 VK_RCONTROL */ , PMSCAN_CTRLRIGHT , "Right Control"
485/* 0xA4 VK_LMENU */ , PMSCAN_ALTLEFT , "Left Alt"
486/* 0xA5 VK_RMENU */ , PMSCAN_ALTRIGHT , "Right Alt"
487/* 0xA6 */ , 0x00 , NULL
488/* 0xA7 */ , 0x00 , NULL
489/* 0xA8 */ , 0x00 , NULL
490/* 0xA9 */ , 0x00 , NULL
491/* 0xAA */ , 0x00 , NULL
492/* 0xAB */ , 0x00 , NULL
493/* 0xAC */ , 0x00 , NULL
494/* 0xAD */ , 0x00 , NULL
495/* 0xAE */ , 0x00 , NULL
496/* 0xAF */ , 0x00 , NULL
497/* 0xB0 */ , 0x00 , NULL
498/* 0xB1 */ , 0x00 , NULL
499/* 0xB2 */ , 0x00 , NULL
500/* 0xB3 */ , 0x00 , NULL
501/* 0xB4 */ , 0x00 , NULL
502/* 0xB5 */ , 0x00 , NULL
503/* 0xB6 */ , 0x00 , NULL
504/* 0xB7 */ , 0x00 , NULL
505/* 0xB8 */ , 0x00 , NULL
506/* 0xB9 */ , 0x00 , NULL
507/* 0xBA VK_SEMICOLON */ , PMSCAN_SEMICOLON , ";"
508/* 0xBB VK_EQUAL */ , PMSCAN_EQUAL , "="
509/* 0xBC VK_COMMA */ , PMSCAN_COMMA , ","
510/* 0xBD VK_HYPHEN */ , PMSCAN_HYPHEN , "-"
511/* 0xBE VK_PERIOD */ , PMSCAN_PERIOD , "."
512/* 0xBF VK_SLASH */ , PMSCAN_SLASH , "/"
513/* 0xC0 VK_GRAVE */ , PMSCAN_GRAVE , "'"
514/* 0xC1 VK_FFC1 */ , PMSCAN_JEXTRA , "JExtra" //??
515/* 0xC2 VK_YEN */ , PMSCAN_YEN , "Yen"
516/* 0xC3 */ , 0x00 , NULL
517/* 0xC4 */ , 0x00 , NULL
518/* 0xC5 */ , 0x00 , NULL
519/* 0xC6 */ , 0x00 , NULL
520/* 0xC7 */ , 0x00 , NULL
521/* 0xC8 */ , 0x00 , NULL
522/* 0xC9 */ , 0x00 , NULL
523/* 0xCA */ , 0x00 , NULL
524/* 0xCB */ , 0x00 , NULL
525/* 0xCC */ , 0x00 , NULL
526/* 0xCD */ , 0x00 , NULL
527/* 0xCE */ , 0x00 , NULL
528/* 0xCF */ , 0x00 , NULL
529/* 0xD0 */ , 0x00 , NULL
530/* 0xD1 */ , 0x00 , NULL
531/* 0xD2 */ , 0x00 , NULL
532/* 0xD3 */ , 0x00 , NULL
533/* 0xD4 */ , 0x00 , NULL
534/* 0xD5 */ , 0x00 , NULL
535/* 0xD6 */ , 0x00 , NULL
536/* 0xD7 */ , 0x00 , NULL
537/* 0xD8 */ , 0x00 , NULL
538/* 0xD9 */ , 0x00 , NULL
539/* 0xDA */ , 0x00 , NULL
540/* 0xDB VK_BRACKETLEFT */ , PMSCAN_BRACKETLEFT , "["
541/* 0xDC VK_BACKSLASH */ , PMSCAN_BACKSLASH , "\\"
542/* 0xDD VK_BRACKETRIGHT */ , PMSCAN_BRACKETRIGHT , "]"
543/* 0xDE VK_QUOTESINGLE */ , PMSCAN_QUOTESINGLE , "'"
544/* 0xDF */ , 0x00 , NULL
545/* 0xE0 */ , 0x00 , NULL
546/* 0xE1 */ , 0x00 , NULL
547/* 0xE2 VK_EXTRA */ , PMSCAN_EXTRA , "<"
548/* 0xE3 */ , 0x00 , NULL
549/* 0xE4 */ , 0x00 , NULL
550/* 0xE5 */ , 0x00 , NULL
551/* 0xE6 */ , 0x00 , NULL
552/* 0xE7 */ , 0x00 , NULL
553/* 0xE8 */ , 0x00 , NULL
554/* 0xE9 */ , 0x00 , NULL
555/* 0xEA */ , 0x00 , NULL
556/* 0xEB */ , 0x00 , NULL
557/* 0xEC */ , 0x00 , NULL
558/* 0xED */ , 0x00 , NULL
559/* 0xEE */ , 0x00 , NULL
560/* 0xEF */ , 0x00 , NULL
561/* 0xF0 */ , 0x00 , NULL
562/* 0xF1 */ , 0x00 , NULL
563/* 0xF2 */ , 0x00 , NULL
564/* 0xF3 */ , 0x00 , NULL
565/* 0xF4 */ , 0x00 , NULL
566/* 0xF5 */ , 0x00 , NULL
567/* 0xF6 VK_ATTN */ , 0x00 , NULL
568/* 0xF7 VK_CRSEL */ , 0x00 , NULL
569/* 0xF8 VK_EXSEL */ , 0x00 , NULL
570/* 0xF9 VK_EREOF */ , PMSCAN_ERASEEOF , "Erase"
571/* 0xFA VK_PLAY */ , 0x00 , NULL
572/* 0xFB VK_ZOOM */ , 0x00 , NULL
573/* 0xFC VK_NONAME */ , 0x00 , NULL
574/* 0xFD VK_PA1 */ , PMSCAN_PA1 , "PA1"
575/* 0xFE VK_OEM_CLEAR */ , 0x00 , NULL
576/* 0xFF */ , 0x00 , NULL
577 };
578
579//******************************************************************************
580//******************************************************************************
581
582ODINPROCEDURE3(KeyTranslatePMToWinBuf,
583 BYTE *, pmkey,
584 BYTE *, winkey,
585 int, nrkeys)
586{
587 for(int i=1;i<nrkeys;i++) {
588 if(abWinVKeyToPMScan[i].bPMScanCode) {
589 winkey[i] = pmkey[OSLibWinTranslateChar(abWinVKeyToPMScan[i].bPMScanCode, TC_SCANCODETOVIRTUALKEY, 0)];
590 }
591 }
592 winkey[VK_SHIFT] = winkey[VK_LSHIFT] | winkey[VK_RSHIFT];
593 winkey[VK_CONTROL] = winkey[VK_LCONTROL] | winkey[VK_RCONTROL];
594 winkey[VK_MENU] = winkey[VK_LMENU] | winkey[VK_RMENU];
595}
596//******************************************************************************
597//******************************************************************************
598BYTE KeyTranslateWinVKeyToPMScan(BYTE bWinVKey, BOOL fExtended)
599{
600 // if the extended bit didn't match, this is
601 // the closest hit
602 BYTE bAlmost = 0;
603
604 // experiment
605#if 0
606 bAlmost = abWinVKeyToPMScan[bWinVKey].bPMScanCode;
607#else
608 for(int i = 0;
609 i < 256; // sizeof(row of abPMScanToWinVKey)
610 i++)
611 {
612 if (abPMScanToWinVKey[i][0] == bWinVKey)
613 {
614 // this represents the PMScan code which is used as index
615 bAlmost = i;
616
617 // exact match!
618 if (abPMScanToWinVKey[i][1] == fExtended)
619 break;
620 }
621 }
622#endif
623
624 dprintf(("KeyTranslateWinVKeyToPMScan(%02xh,%d) = %02xh",
625 bWinVKey,
626 fExtended,
627 bAlmost));
628
629 // almost a match or no match at all.
630 return bAlmost;
631}
632//******************************************************************************
633//******************************************************************************
634BYTE KeyTranslateWinScanToPMScan(BYTE bWinScan, BOOL fExtended)
635{
636 // Mode: translate scancode to vkey
637 BYTE bWinVKey;
638 bWinVKey = MapVirtualKeyA(bWinScan ,3);
639
640 return KeyTranslateWinVKeyToPMScan(bWinVKey, fExtended);
641}
642//******************************************************************************
643//******************************************************************************
644ODINFUNCTION1(int, GetKeyboardType,
645 int, nTypeFlag)
646{
647 return O32_GetKeyboardType(nTypeFlag);
648}
649//******************************************************************************
650//******************************************************************************
651ODINFUNCTION1(BOOL, GetKeyboardState,
652 PBYTE, lpKeyState)
653{
654 BYTE PMKeyState[256];
655 BOOL rc;
656
657 memset(PMKeyState, 0, sizeof(PMKeyState));
658 memset(lpKeyState, 0, 256);
659 rc = OSLibWinGetKeyboardStateTable((PBYTE)&PMKeyState[0] );
660//// rc = O32_GetKeyboardState(lpKeyState);
661 if(rc == TRUE)
662 {
663 KeyTranslatePMToWinBuf((BYTE *)&PMKeyState[0], lpKeyState, 256);
664#ifdef DEBUG
665 for(int i=0;i<256;i++) {
666 if(PMKeyState[i] & 0x80) {
667 dprintf2(("PM key 0x%0x = %x", i, PMKeyState[i]));
668 }
669 }
670 for(i=0;i<256;i++) {
671 if(lpKeyState[i]) {
672 dprintf2(("Win key 0x%0x = %x", i, lpKeyState[i]));
673 }
674 }
675#endif
676 return TRUE;
677 }
678 return FALSE;
679}
680//******************************************************************************
681//******************************************************************************
682ODINFUNCTION1(BOOL, SetKeyboardState,
683 PBYTE, lpKeyState)
684{
685 dprintf(("USER32: SetKeyboardState %x not implemented", lpKeyState));
686 return(TRUE);
687}
688/***********************************************************************
689 * GetKeyboardLayout (USER32.250)
690 *
691 * FIXME: - device handle for keyboard layout defaulted to
692 * the language id. This is the way Windows default works.
693 * - the thread identifier (dwLayout) is also ignored.
694 */
695// * Remark : Based on Wine version (991031)
696ODINFUNCTION1(HKL, GetKeyboardLayout,
697 DWORD, dwLayout)
698{
699 HKL layout;
700 layout = GetSystemDefaultLCID(); /* FIXME */
701 layout |= (layout<<16); /* FIXME */
702 dprintf(("GetKeyboardLayout returning %08x\n",layout));
703 return layout;
704}
705/*****************************************************************************
706 * Name : BOOL WIN32API GetKeyboardLayoutNameA
707 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
708 * active keyboard layout.
709 * Parameters: LPTSTR pwszKLID address of buffer for layout name
710 * Variables :
711 * Result : If the function succeeds, the return value is TRUE.
712 * If the function fails, the return value is FALSE. To get extended
713 * error information, call GetLastError.
714 * Remark : Based on Wine version (991031)
715 * Status : UNTESTED STUB
716 *
717 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
718 *****************************************************************************/
719ODINFUNCTION1(INT, GetKeyboardLayoutNameA,
720 LPSTR, pwszKLID)
721{
722 dprintf(("not correctly implemented"));
723
724 sprintf(pwszKLID, "%08x",GetKeyboardLayout(0));
725 return 1;
726}
727
728
729/*****************************************************************************
730 * Name : BOOL WIN32API GetKeyboardLayoutNameW
731 * Purpose : The GetKeyboardLayoutName function retrieves the name of the
732 * active keyboard layout.
733 * Parameters: LPTSTR pwszKLID address of buffer for layout name
734 * Variables :
735 * Result : If the function succeeds, the return value is TRUE.
736 * If the function fails, the return value is FALSE. To get extended
737 * error information, call GetLastError.
738 * Remark : Based on Wine version (991031)
739 * Status : UNTESTED STUB
740 *
741 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
742 *****************************************************************************/
743ODINFUNCTION1(INT, GetKeyboardLayoutNameW,
744 LPWSTR, pwszKLID)
745{
746 LPSTR buf = (LPSTR)HEAP_xalloc( GetProcessHeap(), 0, strlen("00000409")+1);
747
748 int res = GetKeyboardLayoutNameA(buf);
749 lstrcpyAtoW(pwszKLID,buf);
750 HeapFree( GetProcessHeap(), 0, buf );
751 return res;
752}
753/***********************************************************************
754 * GetKeyboardLayoutList (USER32.251)
755 *
756 * FIXME: Supports only the system default language and layout and
757 * returns only 1 value.
758 *
759 * Return number of values available if either input parm is
760 * 0, per MS documentation.
761 *
762 * Remark : Based on Wine version (991031)
763 */
764ODINFUNCTION2(INT, GetKeyboardLayoutList,
765 INT, nBuff,
766 HKL *, layouts)
767{
768 dprintf(("not correctly implemented"));
769
770 if (!nBuff || !layouts)
771 return 1;
772
773 if (layouts)
774 layouts[0] = GetKeyboardLayout(0);
775
776 return 1;
777}
778/*****************************************************************************
779 * Name : int WIN32API ToAscii
780 * Purpose : The ToAscii function translates the specified virtual-key code
781 * and keyboard state to the corresponding Windows character or characters.
782 * Parameters: UINT uVirtKey virtual-key code
783 * UINT uScanCode scan code
784 * PBYTE lpbKeyState address of key-state array
785 * LPWORD lpwTransKey buffer for translated key
786 * UINT fuState active-menu flag
787 * Variables :
788 * Result : 0 The specified virtual key has no translation for the current
789 * state of the keyboard.
790 * 1 One Windows character was copied to the buffer.
791 * 2 Two characters were copied to the buffer. This usually happens
792 * when a dead-key character (accent or diacritic) stored in the
793 * keyboard layout cannot be composed with the specified virtual
794 * key to form a single character.
795 * Remark :
796 * Status : UNTESTED STUB
797 *
798 * Author : SvL
799 *****************************************************************************/
800
801ODINFUNCTION5(int, ToAscii,
802 UINT, uVirtKey,
803 UINT, uScanCode,
804 PBYTE, lpbKeyState,
805 LPWORD, lpwTransKey,
806 UINT, fuState)
807{
808 INT ret;
809
810 if (uScanCode == 0) {
811 /* This happens when doing Alt+letter : a fake 'down arrow' key press
812 event is generated by windows. Just ignore it. */
813 dprintf2(("scanCode=0, doing nothing"));
814 return 0;
815 }
816 if (uScanCode & 0x8000)
817 {
818 dprintf2(("Key UP, doing nothing"));
819 return 0;
820 }
821
822 /* We have another special case for delete key (XK_Delete) on an
823 extended keyboard. X returns a char for it, but Windows doesn't */
824 if (uVirtKey == VK_DELETE)
825 {
826 *(char*)lpwTransKey = 0;
827 ret = 0;
828 }
829 else
830 if (uVirtKey == VK_ESCAPE) {
831 //NT returns VK_ESCAPE here
832 *(char*)lpwTransKey = VK_ESCAPE;
833 ret = 1;
834 }
835 else {
836 ULONG shiftstate = 0;
837
838 //TODO: multiple characters returned (DBCS??)
839
840 if(lpbKeyState[VK_LSHIFT] & 0x80) shiftstate |= TCF_LSHIFT;
841 if(lpbKeyState[VK_RSHIFT] & 0x80) shiftstate |= TCF_RSHIFT;
842 if(lpbKeyState[VK_SHIFT] & 0x80) shiftstate |= TCF_SHIFT;
843 if(lpbKeyState[VK_LCONTROL] & 0x80) shiftstate |= TCF_LCONTROL;
844 if(lpbKeyState[VK_RCONTROL] & 0x80) shiftstate |= TCF_RCONTROL;
845 if(lpbKeyState[VK_CONTROL] & 0x80) shiftstate |= TCF_CONTROL;
846 if(lpbKeyState[VK_LMENU] & 0x80) shiftstate |= TCF_ALT;
847 if(lpbKeyState[VK_RMENU] & 0x80) shiftstate |= TCF_ALTGR;
848 if(lpbKeyState[VK_MENU] & 0x80) shiftstate |= TCF_ALT;
849 if(lpbKeyState[VK_CAPITAL] & 1) shiftstate |= TCF_CAPSLOCK;
850 if(lpbKeyState[VK_NUMLOCK] & 1) shiftstate |= TCF_NUMLOCK;
851
852 //NT only modifies the bytes it returns
853 *(char *)lpwTransKey = OSLibWinTranslateChar(uScanCode, TC_SCANCODETOCHAR, shiftstate);
854
855 if(shiftstate & TCF_CONTROL) {
856 if(uVirtKey >= VK_A && uVirtKey <= VK_Z) {
857 //NT returns key-0x60 (or so it seems) for ctrl-(shift-)-a..z
858 if(shiftstate & (TCF_SHIFT|TCF_CAPSLOCK)) {
859 *(char *)lpwTransKey -= 0x40;
860 }
861 else *(char *)lpwTransKey -= 0x60;
862 }
863 else
864 if(uVirtKey == VK_SPACE) {
865 if(shiftstate & TCF_SHIFT) {
866 //NT returns 0 for ctrl-shift-space
867 *lpwTransKey = 0;
868 }
869 }
870 else {
871 //NT returns 0 for ctrl-0, ctrl-.
872 *lpwTransKey = 0;
873 }
874 }
875
876 if(*(char *)lpwTransKey == 0) {
877 ret = 0;
878 }
879 else ret = 1;
880 }
881 dprintf2(("USER32:ToAscii returned %x, len %d", *lpwTransKey, ret));
882 return ret;
883}
884/*****************************************************************************
885 * Name : int WIN32API ToAsciiEx
886 * Purpose : The ToAscii function translates the specified virtual-key code
887 * and keyboard state to the corresponding Windows character or characters.
888 * Parameters: UINT uVirtKey virtual-key code
889 * UINT uScanCode scan code
890 * PBYTE lpbKeyState address of key-state array
891 * LPWORD lpwTransKey buffer for translated key
892 * UINT fuState active-menu flag
893 * HLK hlk keyboard layout handle
894 * Variables :
895 * Result : 0 The specified virtual key has no translation for the current
896 * state of the keyboard.
897 * 1 One Windows character was copied to the buffer.
898 * 2 Two characters were copied to the buffer. This usually happens
899 * when a dead-key character (accent or diacritic) stored in the
900 * keyboard layout cannot be composed with the specified virtual
901 * key to form a single character.
902 * Remark :
903 * Status : UNTESTED STUB
904 *
905 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
906 *****************************************************************************/
907
908ODINFUNCTION6(int, ToAsciiEx,
909 UINT, uVirtKey,
910 UINT, uScanCode,
911 PBYTE, lpbKeyState,
912 LPWORD, lpwTransKey,
913 UINT, fuState,
914 HKL, hkl)
915{
916 dprintf(("imcompletely implemented"));
917
918 return ToAscii(uVirtKey, uScanCode, lpbKeyState, lpwTransKey, fuState);
919}
920/*****************************************************************************
921 * Name : int WIN32API ToUnicode
922 * Purpose : The ToUnicode function translates the specified virtual-key code
923 * and keyboard state to the corresponding Unicode character or characters.
924 * Parameters: UINT wVirtKey virtual-key code
925 * UINT wScanCode scan code
926 * PBYTE lpKeyState address of key-state array
927 * LPWSTR pwszBuff buffer for translated key
928 * int cchBuff size of translated key buffer
929 * UINT wFlags set of function-conditioning flags
930 * Variables :
931 * Result : - 1 The specified virtual key is a dead-key character (accent or
932 * diacritic). This value is returned regardless of the keyboard
933 * layout, even if several characters have been typed and are
934 * stored in the keyboard state. If possible, even with Unicode
935 * keyboard layouts, the function has written a spacing version of
936 * the dead-key character to the buffer specified by pwszBuffer.
937 * For example, the function writes the character SPACING ACUTE
938 * (0x00B4), rather than the character NON_SPACING ACUTE (0x0301).
939 * 0 The specified virtual key has no translation for the current
940 * state of the keyboard. Nothing was written to the buffer
941 * specified by pwszBuffer.
942 * 1 One character was written to the buffer specified by pwszBuffer.
943 * 2 or more Two or more characters were written to the buffer specified by
944 * pwszBuff. The most common cause for this is that a dead-key
945 * character (accent or diacritic) stored in the keyboard layout
946 * could not be combined with the specified virtual key to form a
947 * single character.
948 * Remark :
949 * Status : UNTESTED STUB
950 *
951 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
952 *****************************************************************************/
953
954ODINFUNCTION6(int, ToUnicode,
955 UINT, uVirtKey,
956 UINT, uScanCode,
957 PBYTE, lpKeyState,
958 LPWSTR, pwszBuff,
959 int, cchBuff,
960 UINT, wFlags)
961{
962 dprintf(("not implemented.\n"));
963
964 return (0);
965}
966/*****************************************************************************
967 * Name : UINT WIN32API GetKBCodePage
968 * Purpose : The GetKBCodePage function is provided for compatibility with
969 * earlier versions of Windows. In the Win32 application programming
970 * interface (API) it just calls the GetOEMCP function.
971 * Parameters:
972 * Variables :
973 * Result : If the function succeeds, the return value is an OEM code-page
974 * identifier, or it is the default identifier if the registry
975 * value is not readable. For a list of OEM code-page identifiers,
976 * see GetOEMCP.
977 * Remark :
978 * Status : COMPLETELY IMPLEMENTED UNTESTED
979 *
980 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
981 *****************************************************************************/
982
983ODINFUNCTION0(UINT, GetKBCodePage)
984{
985 return (GetOEMCP());
986}
987//******************************************************************************
988//******************************************************************************
989ODINFUNCTION3(int, GetKeyNameTextA,
990 LPARAM, lParam,
991 LPSTR, lpString,
992 int, nSize)
993{
994 // check the scancodes if the extended key bit is set so
995 // we can easily distinguish between "left" and "right" special keys, etc.
996 BOOL fDontCare = (lParam & (1 << 25) ) != 0;
997 BOOL fExtended = (lParam & (1 << 24) ) != 0;
998 UCHAR ucWinScan = (lParam & 0x00ff0000) >> 16;
999 UCHAR ucWinVKey;
1000 int result;
1001
1002 if (fDontCare)
1003 {
1004 // map "right keys" to "universal keys"
1005 // LALT,RALT -> ALT
1006 // etc.
1007 // @@@PH
1008 }
1009
1010 // Note: Open32 expects PM Scancodes, NOT Winscancodes.
1011 ucWinVKey = MapVirtualKeyA(ucWinScan, 3);
1012
1013 // Bug in Open32:
1014 // 0 - expects PMScancodes instead of WinScancodes
1015 // 1 - the "extended key bit" is not taken into account
1016 // 2 - some keys (AltGr) have not been assigned any names
1017 // int result = O32_GetKeyNameText(lParam,lpString,nSize);
1018
1019 memset(lpString, 0, nSize);
1020
1021 LPSTR lpstrKey = abWinVKeyToPMScan[ucWinVKey].lpstrName;
1022 if (NULL == lpstrKey)
1023 {
1024 dprintf(("ERROR: keyname for winscan=%02xh winvkey=%02xh, fExtended=%d not found.\n",
1025 ucWinScan, ucWinVKey, fExtended & !fDontCare));
1026
1027 // build artificial name
1028
1029 CHAR szName[10];
1030 sprintf(szName,
1031 "VKey%02x%c",
1032 ucWinScan,
1033 fExtended ? '+' : 0);
1034 memcpy(lpString, szName, nSize);
1035
1036 // how many chars have been returned?
1037 result = min(nSize, strlen(lpString));
1038 }
1039 else
1040 {
1041 result = min(nSize, strlen(lpstrKey));
1042 strncpy (lpString, lpstrKey, result);
1043 }
1044
1045 dprintf(("keyname=[%s]\n",
1046 lpString));
1047
1048 return result;
1049}
1050//******************************************************************************
1051//******************************************************************************
1052ODINFUNCTION3(int, GetKeyNameTextW,
1053 LPARAM, lParam,
1054 LPWSTR, lpString,
1055 int, nSize)
1056{
1057 dprintf(("USER32: GetKeyNameTextW DOES NOT WORK (not implemented)\n"));
1058 // NOTE: This will not work as is (needs UNICODE support)
1059 return 0;
1060// return O32_GetKeyNameText(arg1, arg2, arg3);
1061}
1062//******************************************************************************
1063//******************************************************************************
1064ODINFUNCTION1(SHORT, GetKeyState,
1065 int, nVirtKey)
1066{
1067 return O32_GetKeyState(nVirtKey);
1068}
1069//******************************************************************************
1070//******************************************************************************
1071ODINFUNCTION1(WORD, GetAsyncKeyState,
1072 INT, nVirtKey)
1073{
1074 if(fVersionWarp3)
1075 {
1076 dprintf(("WARNING: not correctly implemented for Warp 3"));
1077 //Not present in Warp 3's PMWINX
1078 return O32_GetKeyState(nVirtKey);
1079 }
1080 else
1081 return O32_GetAsyncKeyState(nVirtKey);
1082}
1083//******************************************************************************
1084//******************************************************************************
1085ODINFUNCTION2(UINT, MapVirtualKeyA,
1086 UINT, uCode,
1087 UINT, uMapType)
1088{
1089 dprintf(("imcompletely implemented"));
1090 /* A quick fix for Commandos, very incomplete */
1091 switch (uMapType)
1092 {
1093 case 2:
1094 if (uCode >= VK_A && uCode <= VK_Z)
1095 {
1096 return 'A' + uCode - VK_A;
1097 }
1098 break;
1099 }
1100 return O32_MapVirtualKey(uCode, uMapType);
1101}
1102//******************************************************************************
1103//******************************************************************************
1104ODINFUNCTION2(UINT, MapVirtualKeyW,
1105 UINT, uCode,
1106 UINT, uMapType)
1107{
1108 dprintf(("incorrectly implemented\n"));
1109
1110 // NOTE: This will not work as is (needs UNICODE support)
1111 return O32_MapVirtualKey(uCode,uMapType);
1112}
1113/*****************************************************************************
1114 * Name : UINT WIN32API MapVirtualKeyExA
1115 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1116 * code into a scan code or character value, or translates a scan
1117 * code into a virtual-key code. The function translates the codes
1118 * using the input language and physical keyboard layout identified
1119 * by the given keyboard layout handle.
1120 * Parameters:
1121 * Variables :
1122 * Result : The return value is either a scan code, a virtual-key code, or
1123 * a character value, depending on the value of uCode and uMapType.
1124 * If there is no translation, the return value is zero.
1125 * Remark :
1126 * Status : UNTESTED STUB
1127 *
1128 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1129 *****************************************************************************/
1130ODINFUNCTION3(UINT, MapVirtualKeyExA,
1131 UINT, uCode,
1132 UINT, uMapType,
1133 HKL, dwhkl)
1134{
1135 dprintf(("incompletely implemented"));
1136
1137 return MapVirtualKeyA(uCode, uMapType);
1138}
1139/*****************************************************************************
1140 * Name : UINT WIN32API MapVirtualKeyExW
1141 * Purpose : The MapVirtualKeyEx function translates (maps) a virtual-key
1142 * code into a scan code or character value, or translates a scan
1143 * code into a virtual-key code. The function translates the codes
1144 * using the input language and physical keyboard layout identified
1145 * by the given keyboard layout handle.
1146 * Parameters:
1147 * Variables :
1148 * Result : The return value is either a scan code, a virtual-key code, or
1149 * a character value, depending on the value of uCode and uMapType.
1150 * If there is no translation, the return value is zero.
1151 * Remark :
1152 * Status : UNTESTED STUB
1153 *
1154 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1155 *****************************************************************************/
1156ODINFUNCTION3(UINT, MapVirtualKeyExW,
1157 UINT, uCode,
1158 UINT, uMapType,
1159 HKL, dwhkl)
1160{
1161 dprintf(("incompletely implemented"));
1162
1163 return MapVirtualKeyW(uCode, uMapType);
1164}
1165/*****************************************************************************
1166 * Name : DWORD WIN32API OemKeyScan
1167 * Purpose : The OemKeyScan function maps OEM ASCII codes 0 through 0x0FF
1168 * into the OEM scan codes and shift states. The function provides
1169 * information that allows a program to send OEM text to another
1170 * program by simulating keyboard input.
1171 * Parameters:
1172 * Variables :
1173 * Result :
1174 * Remark :
1175 * Status : Borrowed from NT
1176 *
1177 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1178 *****************************************************************************/
1179ODINFUNCTION1(DWORD, OemKeyScan,
1180 WORD, wOemChar)
1181{
1182 int nVirtKey;
1183
1184 OemToCharBuffA((LPCSTR)&wOemChar,
1185 (LPSTR) &nVirtKey,
1186 1);
1187 if (nVirtKey != 0)
1188 {
1189 SHORT sScan = VkKeyScanA(nVirtKey);
1190 nVirtKey = MapVirtualKeyA( (sScan & 0xff), 0);
1191 if (nVirtKey != 0)
1192 {
1193 return ( (nVirtKey & 0x00FF) ||
1194 ( (nVirtKey & 0xFF00) << 8) );
1195 }
1196 }
1197
1198 // if not found ...
1199 return 0xffffffff;
1200}
1201//******************************************************************************
1202//******************************************************************************
1203ODINFUNCTION4(BOOL, RegisterHotKey,
1204 HWND, hwnd,
1205 int, idHotKey,
1206 UINT, fuModifiers,
1207 UINT, uVirtKey)
1208{
1209 dprintf(("not implemented"));
1210
1211 hwnd = Win32ToOS2Handle(hwnd);
1212 return(TRUE);
1213}
1214//******************************************************************************
1215//******************************************************************************
1216ODINFUNCTION2(BOOL, UnregisterHotKey,
1217 HWND, hwnd,
1218 int, idHotKey)
1219{
1220 dprintf(("not implemented"));
1221
1222 hwnd = Win32ToOS2Handle(hwnd);
1223
1224 return(TRUE);
1225}
1226
1227//******************************************************************************
1228//SvL: 24-6-'97 - Added
1229//******************************************************************************
1230ODINFUNCTION1(WORD, VkKeyScanA,
1231 char, ch)
1232{
1233 return O32_VkKeyScan(ch);
1234}
1235//******************************************************************************
1236//******************************************************************************
1237ODINFUNCTION1(WORD, VkKeyScanW,
1238 WCHAR, wch)
1239{
1240 dprintf(("incorrectly implemented"));
1241 // NOTE: This will not work as is (needs UNICODE support)
1242 return O32_VkKeyScan((char)wch);
1243}
1244/*****************************************************************************
1245 * Name : SHORT WIN32API VkKeyScanExW
1246 * Purpose : The VkKeyScanEx function translates a character to the
1247 * corresponding virtual-key code and shift state. The function
1248 * translates the character using the input language and physical
1249 * keyboard layout identified by the given keyboard layout handle.
1250 * Parameters: UINT uChar character to translate
1251 * HKL hkl keyboard layout handle
1252 * Variables :
1253 * Result : see docs
1254 * Remark :
1255 * Status : UNTESTED STUB
1256 *
1257 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1258 *****************************************************************************/
1259ODINFUNCTION2(WORD, VkKeyScanExW,
1260 WCHAR, uChar,
1261 HKL, hkl)
1262{
1263 dprintf(("partially implemented"));
1264
1265 return VkKeyScanW(uChar);
1266}
1267/*****************************************************************************
1268 * Name : SHORT WIN32API VkKeyScanExA
1269 * Purpose : The VkKeyScanEx function translates a character to the
1270 * corresponding virtual-key code and shift state. The function
1271 * translates the character using the input language and physical
1272 * keyboard layout identified by the given keyboard layout handle.
1273 * Parameters: UINT uChar character to translate
1274 * HKL hkl keyboard layout handle
1275 * Variables :
1276 * Result : see docs
1277 * Remark :
1278 * Status : UNTESTED STUB
1279 *
1280 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1281 *****************************************************************************/
1282ODINFUNCTION2(WORD, VkKeyScanExA,
1283 CHAR, uChar,
1284 HKL, hkl)
1285{
1286 dprintf(("partially implemented"));
1287
1288 return VkKeyScanA(uChar);
1289}
1290/*****************************************************************************
1291 * Name : VOID WIN32API keybd_event
1292 * Purpose : The keybd_event function synthesizes a keystroke. The system
1293 * can use such a synthesized keystroke to generate a WM_KEYUP or
1294 * WM_KEYDOWN message. The keyboard driver's interrupt handler calls
1295 * the keybd_event function.
1296 * Parameters: BYTE bVk virtual-key code
1297
1298 * BYTE bScan hardware scan code
1299 * DWORD dwFlags flags specifying various function options
1300 * DWORD dwExtraInfo additional data associated with keystroke
1301 * Variables :
1302 * Result :
1303 * Remark :
1304 * Status : UNTESTED STUB
1305 *
1306 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1307 *****************************************************************************/
1308ODINPROCEDURE4(keybd_event,
1309 BYTE, bVk,
1310 BYTE, bScan,
1311 DWORD, dwFlags,
1312 DWORD, dwExtraInfo)
1313{
1314 INPUT i;
1315
1316 // format input packet
1317 i.type = INPUT_KEYBOARD;
1318 i.ki.wVk = bVk;
1319 i.ki.wScan = bScan;
1320 i.ki.dwFlags = dwFlags;
1321 i.ki.dwExtraInfo = dwExtraInfo;
1322
1323 // forward to more modern API
1324 SendInput(1, &i, sizeof(i) );
1325}
1326/*****************************************************************************
1327 * Name : HLK WIN32API LoadKeyboardLayoutA
1328 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1329 * the system. Several keyboard layouts can be loaded at a time, but
1330 * only one per process is active at a time. Loading multiple keyboard
1331 * layouts makes it possible to rapidly switch between layouts.
1332 * Parameters:
1333 * Variables :
1334 * Result : If the function succeeds, the return value is the handle of the
1335 * keyboard layout.
1336 * If the function fails, the return value is NULL. To get extended
1337 * error information, call GetLastError.
1338 * Remark :
1339 * Status : UNTESTED STUB
1340 *
1341 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1342 *****************************************************************************/
1343ODINFUNCTION2(HKL, LoadKeyboardLayoutA,
1344 LPCSTR, pwszKLID,
1345 UINT, Flags)
1346{
1347 dprintf(("USER32:LeadKeyboardLayoutA (%s,%u) not implemented.\n",
1348 pwszKLID,
1349 Flags));
1350
1351 return (NULL);
1352}
1353/*****************************************************************************
1354 * Name : HLK WIN32API LoadKeyboardLayoutW
1355 * Purpose : The LoadKeyboardLayout function loads a new keyboard layout into
1356 * the system. Several keyboard layouts can be loaded at a time, but
1357 * only one per process is active at a time. Loading multiple keyboard
1358 * layouts makes it possible to rapidly switch between layouts.
1359 * Parameters:
1360 * Variables :
1361 * Result : If the function succeeds, the return value is the handle of the
1362 * keyboard layout.
1363 * If the function fails, the return value is NULL. To get extended
1364 * error information, call GetLastError.
1365 * Remark :
1366 * Status : UNTESTED STUB
1367 *
1368 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1369 *****************************************************************************/
1370ODINFUNCTION2(HKL, LoadKeyboardLayoutW,
1371 LPCWSTR, pwszKLID,
1372 UINT, Flags)
1373{
1374 dprintf(("USER32:LoadKeyboardLayoutW (%ls,%u) not implemented.\n",
1375 pwszKLID,
1376 Flags));
1377
1378 return (NULL);
1379}
1380//******************************************************************************
1381//******************************************************************************
1382ODINFUNCTION2(BOOL, ActivateKeyboardLayout,
1383 HKL, hkl,
1384 UINT, fuFlags)
1385{
1386 dprintf(("not implemented\n"));
1387 return(TRUE);
1388}
1389/*****************************************************************************
1390 * Name : BOOL WIN32API UnloadKeyboardLayout
1391 * Purpose : The UnloadKeyboardLayout function removes a keyboard layout.
1392 * Parameters: HKL hkl handle of keyboard layout
1393 * Variables :
1394 * Result : If the function succeeds, the return value is the handle of the
1395 * keyboard layout; otherwise, it is NULL. To get extended error
1396 * information, use the GetLastError function.
1397 * Remark :
1398 * Status : UNTESTED STUB
1399 *
1400 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1401 *****************************************************************************/
1402ODINFUNCTION1(BOOL, UnloadKeyboardLayout,
1403 HKL, hkl)
1404{
1405 dprintf(("not implemented.\n"));
1406
1407 return (TRUE);
1408}
1409//******************************************************************************
1410//******************************************************************************
Note: See TracBrowser for help on using the repository browser.