d48ac8b198a773ef902e220d0370be3654a623e3
[reactos.git] / reactos / subsys / win32k / ntuser / keyboard.c
1 /*
2 * ReactOS W32 Subsystem
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /*
20 * COPYRIGHT: See COPYING in the top level directory
21 * PROJECT: ReactOS kernel
22 * PURPOSE: Messages
23 * FILE: subsys/win32k/ntuser/keyboard.c
24 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
25 * REVISION HISTORY:
26 * 06-06-2001 CSH Created
27 */
28
29 /* INCLUDES ******************************************************************/
30
31 #include <w32k.h>
32
33 #define NDEBUG
34 #include <debug.h>
35
36 /* Directory to load key layouts from */
37 #define SYSTEMROOT_DIR L"\\SystemRoot\\System32\\"
38 /* Lock modifiers */
39 #define CAPITAL_BIT 0x80000000
40 #define NUMLOCK_BIT 0x40000000
41 #define MOD_BITS_MASK 0x3fffffff
42 #define MOD_KCTRL 0x02
43 /* Key States */
44 #define KS_DOWN_MASK 0xc0
45 #define KS_DOWN_BIT 0x80
46 #define KS_LOCK_BIT 0x01
47 /* lParam bits */
48 #define LP_EXT_BIT (1<<24)
49 /* From kbdxx.c -- Key changes with numlock */
50 #define KNUMP 0x400
51
52 /* Lock the keyboard state to prevent unusual concurrent access */
53 FAST_MUTEX QueueStateLock;
54
55 BYTE QueueKeyStateTable[256];
56
57 #define IntLockQueueState \
58 ExAcquireFastMutex(&QueueStateLock)
59
60 #define IntUnLockQueueState \
61 ExReleaseFastMutex(&QueueStateLock)
62
63 /* FUNCTIONS *****************************************************************/
64
65 /* Initialization -- Right now, just zero the key state and init the lock */
66 NTSTATUS FASTCALL InitKeyboardImpl(VOID) {
67 ExInitializeFastMutex(&QueueStateLock);
68 RtlZeroMemory(&QueueKeyStateTable,0x100);
69 return STATUS_SUCCESS;
70 }
71
72 /*** Statics used by TranslateMessage ***/
73
74 /*** Shift state code was out of hand, sorry. --- arty */
75
76 static UINT DontDistinguishShifts( UINT ret ) {
77 if( ret == VK_LSHIFT || ret == VK_RSHIFT ) ret = VK_LSHIFT;
78 if( ret == VK_LCONTROL || ret == VK_RCONTROL ) ret = VK_LCONTROL;
79 if( ret == VK_LMENU || ret == VK_RMENU ) ret = VK_LMENU;
80 return ret;
81 }
82
83 static VOID STDCALL SetKeyState(DWORD key, DWORD vk, DWORD ext, BOOL down) {
84 ASSERT(vk <= 0xff);
85
86 /* Special handling for toggles like numpad and caps lock */
87 if (vk == VK_CAPITAL || vk == VK_NUMLOCK) {
88 if (down) QueueKeyStateTable[vk] ^= KS_LOCK_BIT;
89 }
90
91 if (ext && vk == VK_LSHIFT)
92 vk = VK_RSHIFT;
93 if (ext && vk == VK_LCONTROL)
94 vk = VK_RCONTROL;
95 if (ext && vk == VK_LMENU)
96 vk = VK_RMENU;
97
98 if (down)
99 QueueKeyStateTable[vk] |= KS_DOWN_BIT;
100 else
101 QueueKeyStateTable[vk] &= ~KS_DOWN_MASK;
102
103 if (vk == VK_LSHIFT || vk == VK_RSHIFT) {
104 if ((QueueKeyStateTable[VK_LSHIFT] & KS_DOWN_BIT) ||
105 (QueueKeyStateTable[VK_RSHIFT] & KS_DOWN_BIT)) {
106 QueueKeyStateTable[VK_SHIFT] |= KS_DOWN_BIT;
107 } else {
108 QueueKeyStateTable[VK_SHIFT] &= ~KS_DOWN_MASK;
109 }
110 }
111
112 if (vk == VK_LCONTROL || vk == VK_RCONTROL) {
113 if ((QueueKeyStateTable[VK_LCONTROL] & KS_DOWN_BIT) ||
114 (QueueKeyStateTable[VK_RCONTROL] & KS_DOWN_BIT)) {
115 QueueKeyStateTable[VK_CONTROL] |= KS_DOWN_BIT;
116 } else {
117 QueueKeyStateTable[VK_CONTROL] &= ~KS_DOWN_MASK;
118 }
119 }
120
121 if (vk == VK_LMENU || vk == VK_RMENU) {
122 if ((QueueKeyStateTable[VK_LMENU] & KS_DOWN_BIT) ||
123 (QueueKeyStateTable[VK_RMENU] & KS_DOWN_BIT)) {
124 QueueKeyStateTable[VK_MENU] |= KS_DOWN_BIT;
125 } else {
126 QueueKeyStateTable[VK_MENU] &= ~KS_DOWN_MASK;
127 }
128 }
129 }
130
131 VOID DumpKeyState( PBYTE KeyState ) {
132 int i;
133
134 DbgPrint( "KeyState { " );
135 for( i = 0; i < 0x100; i++ ) {
136 if( KeyState[i] ) DbgPrint( "%02x(%02x) ", i, KeyState[i] );
137 }
138 DbgPrint( "};\n" );
139 }
140
141 static BYTE KeysSet( PKBDTABLES pkKT, PBYTE KeyState,
142 int FakeModLeft, int FakeModRight ) {
143 if( !KeyState || !pkKT ) return 0;
144
145 /* Search special codes first */
146 if( FakeModLeft && KeyState[FakeModLeft] )
147 return KeyState[FakeModLeft];
148 else if( FakeModRight && KeyState[FakeModRight] )
149 return KeyState[FakeModRight];
150
151 return 0;
152 }
153
154 /* Search the keyboard layout modifiers table for the shift bit. I don't
155 * want to count on the shift bit not moving, because it can be specified
156 * in the layout */
157
158 static DWORD FASTCALL GetShiftBit( PKBDTABLES pkKT, DWORD Vk ) {
159 int i;
160
161 for( i = 0; pkKT->pCharModifiers->pVkToBit[i].Vk; i++ )
162 if( pkKT->pCharModifiers->pVkToBit[i].Vk == Vk )
163 return pkKT->pCharModifiers->pVkToBit[i].ModBits;
164
165 return 0;
166 }
167
168 static DWORD ModBits( PKBDTABLES pkKT, PBYTE KeyState ) {
169 DWORD ModBits = 0;
170
171 if( !KeyState ) return 0;
172
173 /* DumpKeyState( KeyState ); */
174
175 if (KeysSet( pkKT, KeyState, VK_LSHIFT, VK_RSHIFT ) &
176 KS_DOWN_BIT)
177 ModBits |= GetShiftBit( pkKT, VK_SHIFT );
178
179 if (KeysSet( pkKT, KeyState, VK_LCONTROL, VK_RCONTROL ) &
180 KS_DOWN_BIT )
181 ModBits |= GetShiftBit( pkKT, VK_CONTROL );
182
183 if (KeysSet( pkKT, KeyState, VK_LMENU, VK_RMENU ) &
184 KS_DOWN_BIT )
185 ModBits |= GetShiftBit( pkKT, VK_MENU );
186
187 /* Handle Alt+Gr */
188 if (KeysSet( pkKT, KeyState, VK_RMENU, 0 ) &
189 KS_DOWN_BIT )
190 ModBits |= GetShiftBit( pkKT, VK_CONTROL );
191
192 /* Deal with VK_CAPITAL */
193 if (KeysSet( pkKT, KeyState, VK_CAPITAL, 0 ) & KS_LOCK_BIT)
194 {
195 ModBits |= CAPITAL_BIT;
196 }
197
198 /* Deal with VK_NUMLOCK */
199 if (KeysSet( pkKT, KeyState, VK_NUMLOCK, 0 ) & KS_LOCK_BIT)
200 {
201 ModBits |= NUMLOCK_BIT;
202 }
203
204 DPRINT( "Current Mod Bits: %x\n", ModBits );
205
206 return ModBits;
207 }
208
209 static BOOL TryToTranslateChar(WORD wVirtKey,
210 DWORD ModBits,
211 PBOOL pbDead,
212 PBOOL pbLigature,
213 PWCHAR pwcTranslatedChar,
214 PKBDTABLES keyLayout )
215 {
216 PVK_TO_WCHAR_TABLE vtwTbl;
217 PVK_TO_WCHARS10 vkPtr;
218 size_t size_this_entry;
219 int nMod;
220 DWORD CapsMod = 0, CapsState = 0;
221
222 CapsState = ModBits & ~MOD_BITS_MASK;
223 ModBits = ModBits & MOD_BITS_MASK;
224
225 DPRINT ( "TryToTranslate: %04x %x\n", wVirtKey, ModBits );
226
227 if (ModBits > keyLayout->pCharModifiers->wMaxModBits)
228 {
229 return FALSE;
230 }
231 for (nMod = 0; keyLayout->pVkToWcharTable[nMod].nModifications; nMod++)
232 {
233 vtwTbl = &keyLayout->pVkToWcharTable[nMod];
234 size_this_entry = vtwTbl->cbSize;
235 vkPtr = (PVK_TO_WCHARS10)((BYTE *)vtwTbl->pVkToWchars);
236 while(vkPtr->VirtualKey)
237 {
238 if( wVirtKey == (vkPtr->VirtualKey & 0xff) )
239 {
240 CapsMod = keyLayout->pCharModifiers->ModNumber
241 [ModBits ^
242 ((CapsState & CAPITAL_BIT) ? vkPtr->Attributes : 0)];
243
244 if( CapsMod > keyLayout->pVkToWcharTable[nMod].nModifications ) {
245 DWORD MaxBit = 1;
246 while( MaxBit <
247 keyLayout->pVkToWcharTable[nMod].nModifications )
248 MaxBit <<= 1;
249
250 CapsMod &= MaxBit - 1; /* Guarantee that CapsMod lies
251 in bounds. */
252 }
253
254 *pbDead = vkPtr->wch[CapsMod] == WCH_DEAD;
255 *pbLigature = vkPtr->wch[CapsMod] == WCH_LGTR;
256 *pwcTranslatedChar = vkPtr->wch[CapsMod];
257
258 DPRINT("%d %04x: CapsMod %08x CapsState %08x Char %04x\n",
259 nMod, wVirtKey,
260 CapsMod, CapsState, *pwcTranslatedChar);
261
262 if( *pbDead )
263 {
264 vkPtr = (PVK_TO_WCHARS10)(((BYTE *)vkPtr) + size_this_entry);
265 if( vkPtr->VirtualKey != 0xff )
266 {
267 DPRINT( "Found dead key with no trailer in the table.\n" );
268 DPRINT( "VK: %04x, ADDR: %08x\n", wVirtKey, (int)vkPtr );
269 return FALSE;
270 }
271 *pwcTranslatedChar = vkPtr->wch[CapsMod];
272 }
273 return TRUE;
274 }
275 vkPtr = (PVK_TO_WCHARS10)(((BYTE *)vkPtr) + size_this_entry);
276 }
277 }
278 return FALSE;
279 }
280
281 static
282 int STDCALL
283 ToUnicodeInner(UINT wVirtKey,
284 UINT wScanCode,
285 PBYTE lpKeyState,
286 LPWSTR pwszBuff,
287 int cchBuff,
288 UINT wFlags,
289 PKBDTABLES pkKT)
290 {
291 WCHAR wcTranslatedChar;
292 BOOL bDead;
293 BOOL bLigature;
294
295 if( !pkKT ) return 0;
296
297 if( TryToTranslateChar( wVirtKey,
298 ModBits( pkKT, lpKeyState ),
299 &bDead,
300 &bLigature,
301 &wcTranslatedChar,
302 pkKT ) )
303 {
304 if( bLigature )
305 {
306 DPRINT("Not handling ligature (yet)\n" );
307 return 0;
308 }
309
310 if( cchBuff > 0 ) pwszBuff[0] = wcTranslatedChar;
311
312 return bDead ? -1 : 1;
313 }
314
315 return 0;
316 }
317
318 DWORD
319 STDCALL
320 NtUserGetKeyState(
321 DWORD key)
322 {
323 DWORD ret = 0;
324
325 IntLockQueueState;
326 if( key < 0x100 ) {
327 ret = ((DWORD)(QueueKeyStateTable[key] & KS_DOWN_BIT) << 8 ) |
328 (QueueKeyStateTable[key] & KS_LOCK_BIT);
329 }
330 IntUnLockQueueState;
331 return ret;
332 }
333
334 DWORD
335 STDCALL
336 NtUserGetAsyncKeyState(
337 DWORD key)
338 {
339 DWORD ret = 0;
340
341 IntLockQueueState;
342 if( key < 0x100 ) {
343 ret = ((DWORD)(QueueKeyStateTable[key] & KS_DOWN_BIT) << 8 ) |
344 (QueueKeyStateTable[key] & KS_LOCK_BIT);
345 }
346 IntUnLockQueueState;
347 return ret;
348 }
349
350
351
352 int STDCALL ToUnicodeEx( UINT wVirtKey,
353 UINT wScanCode,
354 PBYTE lpKeyState,
355 LPWSTR pwszBuff,
356 int cchBuff,
357 UINT wFlags,
358 HKL dwhkl ) {
359 int ToUnicodeResult = 0;
360
361 if (0 == (lpKeyState[wVirtKey] & KS_DOWN_BIT))
362 {
363 ToUnicodeResult = 0;
364 }
365 else
366 {
367 IntLockQueueState;
368 ToUnicodeResult = ToUnicodeInner( wVirtKey,
369 wScanCode,
370 lpKeyState,
371 pwszBuff,
372 cchBuff,
373 wFlags,
374 PsGetWin32Thread() ?
375 PsGetWin32Thread()->KeyboardLayout : 0 );
376 IntUnLockQueueState;
377 }
378
379 return ToUnicodeResult;
380 }
381
382 int STDCALL ToUnicode( UINT wVirtKey,
383 UINT wScanCode,
384 PBYTE lpKeyState,
385 LPWSTR pwszBuff,
386 int cchBuff,
387 UINT wFlags ) {
388 return ToUnicodeEx( wVirtKey,
389 wScanCode,
390 QueueKeyStateTable,
391 pwszBuff,
392 cchBuff,
393 wFlags,
394 0 );
395 }
396
397 /*
398 * Utility to copy and append two unicode strings.
399 *
400 * IN OUT PUNICODE_STRING ResultFirst -> First string and result
401 * IN PUNICODE_STRING Second -> Second string to append
402 * IN BOOL Deallocate -> TRUE: Deallocate First string before
403 * overwriting.
404 *
405 * Returns NTSTATUS.
406 */
407
408 NTSTATUS NTAPI AppendUnicodeString(PUNICODE_STRING ResultFirst,
409 PUNICODE_STRING Second,
410 BOOL Deallocate) {
411 NTSTATUS Status;
412 PWSTR new_string =
413 ExAllocatePoolWithTag(PagedPool,
414 (ResultFirst->Length + Second->Length + sizeof(WCHAR)),
415 TAG_STRING);
416 if( !new_string ) {
417 return STATUS_NO_MEMORY;
418 }
419 memcpy( new_string, ResultFirst->Buffer,
420 ResultFirst->Length );
421 memcpy( new_string + ResultFirst->Length / sizeof(WCHAR),
422 Second->Buffer,
423 Second->Length );
424 if( Deallocate ) RtlFreeUnicodeString(ResultFirst);
425 ResultFirst->Length += Second->Length;
426 ResultFirst->MaximumLength = ResultFirst->Length;
427 new_string[ResultFirst->Length / sizeof(WCHAR)] = 0;
428 Status = RtlCreateUnicodeString(ResultFirst,new_string) ?
429 STATUS_SUCCESS : STATUS_NO_MEMORY;
430 ExFreePool(new_string);
431 return Status;
432 }
433
434 /*
435 * Utility function to read a value from the registry more easily.
436 *
437 * IN PUNICODE_STRING KeyName -> Name of key to open
438 * IN PUNICODE_STRING ValueName -> Name of value to open
439 * OUT PUNICODE_STRING ReturnedValue -> String contained in registry
440 *
441 * Returns NTSTATUS
442 */
443
444 static NTSTATUS NTAPI ReadRegistryValue( PUNICODE_STRING KeyName,
445 PUNICODE_STRING ValueName,
446 PUNICODE_STRING ReturnedValue ) {
447 NTSTATUS Status;
448 HANDLE KeyHandle;
449 OBJECT_ATTRIBUTES KeyAttributes;
450 PKEY_VALUE_PARTIAL_INFORMATION KeyValuePartialInfo;
451 ULONG Length = 0;
452 ULONG ResLength = 0;
453 UNICODE_STRING Temp;
454
455 InitializeObjectAttributes(&KeyAttributes, KeyName, OBJ_CASE_INSENSITIVE,
456 NULL, NULL);
457 Status = ZwOpenKey(&KeyHandle, KEY_ALL_ACCESS, &KeyAttributes);
458 if( !NT_SUCCESS(Status) ) {
459 return Status;
460 }
461
462 Status = ZwQueryValueKey(KeyHandle, ValueName, KeyValuePartialInformation,
463 0,
464 0,
465 &ResLength);
466
467 if( Status != STATUS_BUFFER_TOO_SMALL ) {
468 NtClose(KeyHandle);
469 return Status;
470 }
471
472 ResLength += sizeof( *KeyValuePartialInfo );
473 KeyValuePartialInfo =
474 ExAllocatePoolWithTag(PagedPool, ResLength, TAG_STRING);
475 Length = ResLength;
476
477 if( !KeyValuePartialInfo ) {
478 NtClose(KeyHandle);
479 return STATUS_NO_MEMORY;
480 }
481
482 Status = ZwQueryValueKey(KeyHandle, ValueName, KeyValuePartialInformation,
483 (PVOID)KeyValuePartialInfo,
484 Length,
485 &ResLength);
486
487 if( !NT_SUCCESS(Status) ) {
488 NtClose(KeyHandle);
489 ExFreePool(KeyValuePartialInfo);
490 return Status;
491 }
492
493 Temp.Length = Temp.MaximumLength = KeyValuePartialInfo->DataLength;
494 Temp.Buffer = (PWCHAR)KeyValuePartialInfo->Data;
495
496 /* At this point, KeyValuePartialInfo->Data contains the key data */
497 RtlInitUnicodeString(ReturnedValue,L"");
498 AppendUnicodeString(ReturnedValue,&Temp,FALSE);
499
500 ExFreePool(KeyValuePartialInfo);
501 NtClose(KeyHandle);
502
503 return Status;
504 }
505
506 typedef PVOID (*KbdLayerDescriptor)(VOID);
507 NTSTATUS STDCALL LdrGetProcedureAddress(PVOID module,
508 PANSI_STRING import_name,
509 DWORD flags,
510 PVOID *func_addr);
511
512 void InitKbdLayout( PVOID *pkKeyboardLayout )
513 {
514 WCHAR LocaleBuffer[16];
515 UNICODE_STRING LayoutKeyName;
516 UNICODE_STRING LayoutValueName;
517 UNICODE_STRING DefaultLocale;
518 UNICODE_STRING LayoutFile;
519 UNICODE_STRING FullLayoutPath;
520 LCID LocaleId;
521 PWCHAR KeyboardLayoutWSTR;
522 HMODULE kbModule = 0;
523 NTSTATUS Status;
524 ANSI_STRING kbdProcedureName;
525 KbdLayerDescriptor layerDescGetFn;
526
527 #define XX_STATUS(x) if (!NT_SUCCESS(Status = (x))) continue;
528
529 do {
530 Status = ZwQueryDefaultLocale(FALSE, &LocaleId);
531 if (!NT_SUCCESS(Status))
532 {
533 DPRINT1("Could not get default locale (%08lx).\n", Status);
534 }
535 else
536 {
537 DPRINT("DefaultLocale = %lx\n", LocaleId);
538 swprintf(LocaleBuffer, L"%08lx", LocaleId);
539 DPRINT("DefaultLocale = %S\n", LocaleBuffer);
540 RtlInitUnicodeString(&DefaultLocale, LocaleBuffer);
541
542 RtlInitUnicodeString(&LayoutKeyName,
543 L"\\REGISTRY\\Machine\\SYSTEM\\CurrentControlSet"
544 L"\\Control\\KeyboardLayouts\\");
545
546 AppendUnicodeString(&LayoutKeyName,&DefaultLocale,FALSE);
547
548 RtlInitUnicodeString(&LayoutValueName,L"Layout File");
549
550 Status = ReadRegistryValue(&LayoutKeyName,&LayoutValueName,&LayoutFile);
551 RtlInitUnicodeString(&FullLayoutPath,SYSTEMROOT_DIR);
552
553 if( !NT_SUCCESS(Status) ) {
554 DPRINT1("Got default locale but not layout file. (%08lx)\n",
555 Status);
556 } else {
557 DPRINT("Read registry and got %wZ\n", &LayoutFile);
558
559 RtlFreeUnicodeString(&LayoutKeyName);
560
561 AppendUnicodeString(&FullLayoutPath,&LayoutFile,FALSE);
562
563 DPRINT("Loading Keyboard DLL %wZ\n", &FullLayoutPath);
564
565 RtlFreeUnicodeString(&LayoutFile);
566
567 KeyboardLayoutWSTR =
568 ExAllocatePoolWithTag(PagedPool,
569 FullLayoutPath.Length + sizeof(WCHAR),
570 TAG_STRING);
571
572 if( !KeyboardLayoutWSTR ) {
573 DPRINT1("Couldn't allocate a string for the keyboard layout name.\n");
574 RtlFreeUnicodeString(&FullLayoutPath);
575 return;
576 }
577 memcpy(KeyboardLayoutWSTR,FullLayoutPath.Buffer,
578 FullLayoutPath.Length + sizeof(WCHAR));
579 KeyboardLayoutWSTR[FullLayoutPath.Length / sizeof(WCHAR)] = 0;
580
581 kbModule = EngLoadImage(KeyboardLayoutWSTR);
582 DPRINT( "Load Keyboard Layout: %S\n", KeyboardLayoutWSTR );
583
584 if( !kbModule )
585 DPRINT1( "Load Keyboard Layout: No %wZ\n", &FullLayoutPath );
586
587 RtlFreeUnicodeString(&FullLayoutPath);
588 }
589 }
590
591 if( !kbModule )
592 {
593 DPRINT1("Trying to load US Keyboard Layout\n");
594 kbModule = EngLoadImage(L"\\SystemRoot\\system32\\kbdus.dll");
595
596 if (!kbModule)
597 {
598 DPRINT1("Failed to load any Keyboard Layout\n");
599 return;
600 }
601 }
602
603 RtlInitAnsiString( &kbdProcedureName, "KbdLayerDescriptor" );
604
605 LdrGetProcedureAddress((PVOID)kbModule,
606 &kbdProcedureName,
607 0,
608 (PVOID*)&layerDescGetFn);
609
610 if( layerDescGetFn ) {
611 *pkKeyboardLayout = layerDescGetFn();
612 }
613 } while (FALSE);
614
615 if( !*pkKeyboardLayout ) {
616 DPRINT1("Failed to load the keyboard layout.\n");
617 }
618
619 #undef XX_STATUS
620 }
621
622 PKBDTABLES W32kGetDefaultKeyLayout() {
623 PKBDTABLES pkKeyboardLayout = 0;
624 InitKbdLayout( (PVOID) &pkKeyboardLayout );
625 return pkKeyboardLayout;
626 }
627
628 BOOL FASTCALL
629 IntTranslateKbdMessage(LPMSG lpMsg,
630 HKL dwhkl)
631 {
632 static INT dead_char = 0;
633 LONG UState = 0;
634 WCHAR wp[2] = { 0 };
635 MSG NewMsg = { 0 };
636 PKBDTABLES keyLayout;
637 BOOL Result = FALSE;
638 DWORD ScanCode = 0;
639
640
641 keyLayout = PsGetWin32Thread()->KeyboardLayout;
642 if( !keyLayout )
643 return FALSE;
644
645 if (lpMsg->message != WM_KEYDOWN && lpMsg->message != WM_SYSKEYDOWN)
646 return FALSE;
647
648 ScanCode = (lpMsg->lParam >> 16) & 0xff;
649
650 IntLockQueueState;
651
652 /* All messages have to contain the cursor point. */
653 IntGetCursorLocation(PsGetWin32Thread()->Desktop->WindowStation,
654 &NewMsg.pt);
655
656 UState = ToUnicodeInner(lpMsg->wParam, HIWORD(lpMsg->lParam) & 0xff,
657 QueueKeyStateTable, wp, 2, 0,
658 keyLayout );
659
660 if (UState == 1)
661 {
662 NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
663 if (dead_char)
664 {
665 ULONG i;
666 WCHAR first, second;
667 DPRINT("PREVIOUS DEAD CHAR: %c\n", dead_char);
668
669 for( i = 0; keyLayout->pDeadKey[i].dwBoth; i++ )
670 {
671 first = keyLayout->pDeadKey[i].dwBoth >> 16;
672 second = keyLayout->pDeadKey[i].dwBoth;
673 if (first == dead_char && second == wp[0])
674 {
675 wp[0] = keyLayout->pDeadKey[i].wchComposed;
676 dead_char = 0;
677 break;
678 }
679 }
680
681 DPRINT("FINAL CHAR: %c\n", wp[0]);
682 }
683
684 if (dead_char)
685 {
686 NewMsg.hwnd = lpMsg->hwnd;
687 NewMsg.wParam = dead_char;
688 NewMsg.lParam = lpMsg->lParam;
689 dead_char = 0;
690 MsqPostMessage(PsGetWin32Thread()->MessageQueue, &NewMsg, FALSE, QS_KEY);
691 }
692
693 NewMsg.hwnd = lpMsg->hwnd;
694 NewMsg.wParam = wp[0];
695 NewMsg.lParam = lpMsg->lParam;
696 DPRINT( "CHAR='%c' %04x %08x\n", wp[0], wp[0], lpMsg->lParam );
697 MsqPostMessage(PsGetWin32Thread()->MessageQueue, &NewMsg, FALSE, QS_KEY);
698 Result = TRUE;
699 }
700 else if (UState == -1)
701 {
702 NewMsg.message =
703 (lpMsg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
704 NewMsg.hwnd = lpMsg->hwnd;
705 NewMsg.wParam = wp[0];
706 NewMsg.lParam = lpMsg->lParam;
707 dead_char = wp[0];
708 MsqPostMessage(PsGetWin32Thread()->MessageQueue, &NewMsg, FALSE, QS_KEY);
709 Result = TRUE;
710 }
711
712 IntUnLockQueueState;
713 return Result;
714 }
715
716 DWORD
717 STDCALL
718 NtUserGetKeyboardState(
719 LPBYTE lpKeyState)
720 {
721 BOOL Result = TRUE;
722
723 IntLockQueueState;
724 if (lpKeyState) {
725 if(!NT_SUCCESS(MmCopyToCaller(lpKeyState, QueueKeyStateTable, 256)))
726 Result = FALSE;
727 }
728 IntUnLockQueueState;
729 return Result;
730 }
731
732 DWORD
733 STDCALL
734 NtUserSetKeyboardState(
735 LPBYTE lpKeyState)
736 {
737 BOOL Result = TRUE;
738
739 IntLockQueueState;
740 if (lpKeyState) {
741 if(! NT_SUCCESS(MmCopyFromCaller(QueueKeyStateTable, lpKeyState, 256)))
742 Result = FALSE;
743 }
744 IntUnLockQueueState;
745
746 return Result;
747 }
748
749 static UINT VkToScan( UINT Code, BOOL ExtCode, PKBDTABLES pkKT ) {
750 int i;
751
752 for( i = 0; i < pkKT->bMaxVSCtoVK; i++ ) {
753 if( pkKT->pusVSCtoVK[i] == Code ) { return i; }
754 }
755
756 return 0;
757 }
758
759 UINT ScanToVk( UINT Code, BOOL ExtKey, PKBDTABLES pkKT ) {
760 if( !pkKT ) {
761 DPRINT("ScanToVk: No layout\n");
762 return 0;
763 }
764
765 if( ExtKey ) {
766 int i;
767
768 for( i = 0; pkKT->pVSCtoVK_E0[i].Vsc; i++ ) {
769 if( pkKT->pVSCtoVK_E0[i].Vsc == Code )
770 return pkKT->pVSCtoVK_E0[i].Vk & 0xff;
771 }
772 for( i = 0; pkKT->pVSCtoVK_E1[i].Vsc; i++ ) {
773 if( pkKT->pVSCtoVK_E1[i].Vsc == Code )
774 return pkKT->pVSCtoVK_E1[i].Vk & 0xff;
775 }
776
777 return 0;
778 } else {
779 if( Code >= pkKT->bMaxVSCtoVK ) { return 0; }
780 return pkKT->pusVSCtoVK[Code] & 0xff;
781 }
782 }
783
784 /*
785 * Map a virtual key code, or virtual scan code, to a scan code, key code,
786 * or unshifted unicode character.
787 *
788 * Code: See Below
789 * Type:
790 * 0 -- Code is a virtual key code that is converted into a virtual scan code
791 * that does not distinguish between left and right shift keys.
792 * 1 -- Code is a virtual scan code that is converted into a virtual key code
793 * that does not distinguish between left and right shift keys.
794 * 2 -- Code is a virtual key code that is converted into an unshifted unicode
795 * character.
796 * 3 -- Code is a virtual scan code that is converted into a virtual key code
797 * that distinguishes left and right shift keys.
798 * KeyLayout: Keyboard layout handle (currently, unused)
799 *
800 * @implemented
801 */
802
803 static UINT IntMapVirtualKeyEx( UINT Code, UINT Type, PKBDTABLES keyLayout ) {
804 UINT ret = 0;
805
806 switch( Type ) {
807 case 0:
808 if( Code == VK_RSHIFT ) Code = VK_LSHIFT;
809 if( Code == VK_RMENU ) Code = VK_LMENU;
810 if( Code == VK_RCONTROL ) Code = VK_LCONTROL;
811 ret = VkToScan( Code, FALSE, keyLayout );
812 break;
813
814 case 1:
815 ret =
816 DontDistinguishShifts
817 (IntMapVirtualKeyEx( Code, 3, keyLayout ) );
818 break;
819
820 case 2: {
821 WCHAR wp[2];
822
823 ret = VkToScan( Code, FALSE, keyLayout );
824 ToUnicodeInner( Code, ret, 0, wp, 2, 0, keyLayout );
825 ret = wp[0];
826 } break;
827
828 case 3:
829
830 ret = ScanToVk( Code, FALSE, keyLayout );
831 break;
832 }
833
834 return ret;
835 }
836
837 UINT
838 STDCALL
839 NtUserMapVirtualKeyEx( UINT Code, UINT Type, DWORD keyboardId, HKL dwhkl ) {
840 PKBDTABLES keyLayout = PsGetWin32Thread() ?
841 PsGetWin32Thread()->KeyboardLayout : 0;
842
843 if( !keyLayout ) return 0;
844
845 return IntMapVirtualKeyEx( Code, Type, keyLayout );
846 }
847
848
849 int
850 STDCALL
851 NtUserToUnicodeEx(
852 UINT wVirtKey,
853 UINT wScanCode,
854 PBYTE lpKeyState,
855 LPWSTR pwszBuff,
856 int cchBuff,
857 UINT wFlags,
858 HKL dwhkl ) {
859 BYTE KeyStateBuf[0x100];
860 PWCHAR OutPwszBuff = 0;
861 int ret = 0;
862
863
864 if( !NT_SUCCESS(MmCopyFromCaller(KeyStateBuf,
865 lpKeyState,
866 sizeof(KeyStateBuf))) ) {
867 DPRINT1( "Couldn't copy key state from caller.\n" );
868 return 0;
869 }
870 OutPwszBuff = ExAllocatePoolWithTag(NonPagedPool,sizeof(WCHAR) * cchBuff, TAG_STRING);
871 if( !OutPwszBuff ) {
872 DPRINT1( "ExAllocatePool(%d) failed\n", sizeof(WCHAR) * cchBuff);
873 return 0;
874 }
875 RtlZeroMemory( OutPwszBuff, sizeof( WCHAR ) * cchBuff );
876
877 ret = ToUnicodeEx( wVirtKey,
878 wScanCode,
879 KeyStateBuf,
880 OutPwszBuff,
881 cchBuff,
882 wFlags,
883 dwhkl );
884
885 MmCopyToCaller(pwszBuff,OutPwszBuff,sizeof(WCHAR)*cchBuff);
886 ExFreePool(OutPwszBuff);
887
888 return ret;
889 }
890
891 static int W32kSimpleToupper( int ch ) {
892 if( ch >= 'a' && ch <= 'z' ) ch = ch - 'a' + 'A';
893 return ch;
894 }
895
896 DWORD
897 STDCALL
898 NtUserGetKeyNameText( LONG lParam, LPWSTR lpString, int nSize ) {
899 int i;
900 DWORD ret = 0;
901 UINT CareVk = 0;
902 UINT VkCode = 0;
903 UINT ScanCode = (lParam >> 16) & 0xff;
904 BOOL ExtKey = lParam & (1<<24) ? TRUE : FALSE;
905 PKBDTABLES keyLayout =
906 PsGetWin32Thread() ?
907 PsGetWin32Thread()->KeyboardLayout : 0;
908
909 if( !keyLayout || nSize < 1 ) return 0;
910
911 if( lParam & (1<<25) ) {
912 CareVk = VkCode = ScanToVk( ScanCode, ExtKey, keyLayout );
913 if( VkCode == VK_LSHIFT || VkCode == VK_RSHIFT )
914 VkCode = VK_LSHIFT;
915 if( VkCode == VK_LCONTROL || VkCode == VK_RCONTROL )
916 VkCode = VK_LCONTROL;
917 if( VkCode == VK_LMENU || VkCode == VK_RMENU )
918 VkCode = VK_LMENU;
919 } else {
920 VkCode = ScanToVk( ScanCode, ExtKey, keyLayout );
921 }
922
923 VSC_LPWSTR *KeyNames = 0;
924
925 if( CareVk != VkCode )
926 ScanCode = VkToScan( VkCode, ExtKey, keyLayout );
927
928 if( ExtKey )
929 KeyNames = keyLayout->pKeyNamesExt;
930 else
931 KeyNames = keyLayout->pKeyNames;
932
933 for( i = 0; KeyNames[i].pwsz; i++ ) {
934 if( KeyNames[i].vsc == ScanCode ) {
935 UINT StrLen = wcslen(KeyNames[i].pwsz);
936 UINT StrMax = StrLen > (nSize - 1) ? (nSize - 1) : StrLen;
937 WCHAR null_wc = 0;
938 if( NT_SUCCESS( MmCopyToCaller( lpString,
939 KeyNames[i].pwsz,
940 StrMax * sizeof(WCHAR) ) ) &&
941 NT_SUCCESS( MmCopyToCaller( lpString + StrMax,
942 &null_wc,
943 sizeof( WCHAR ) ) ) ) {
944 ret = StrMax;
945 break;
946 }
947 }
948 }
949
950 if( ret == 0 ) {
951 WCHAR UCName[2];
952
953 UCName[0] = W32kSimpleToupper(IntMapVirtualKeyEx( VkCode, 2, keyLayout ));
954 UCName[1] = 0;
955 ret = 1;
956
957 if( !NT_SUCCESS(MmCopyToCaller( lpString, UCName, 2 * sizeof(WCHAR) )) )
958 return 0;
959 }
960
961 return ret;
962 }
963
964 /*
965 * Filter this message according to the current key layout, setting wParam
966 * appropriately.
967 */
968
969 VOID FASTCALL W32kKeyProcessMessage(LPMSG Msg, PKBDTABLES KeyboardLayout) {
970 DWORD ScanCode = 0, ModifierBits = 0;
971 DWORD i = 0;
972 DWORD BaseMapping = 0;
973 DWORD RawVk = 0;
974 static WORD NumpadConversion[][2] =
975 { { VK_DELETE, VK_DECIMAL },
976 { VK_INSERT, VK_NUMPAD0 },
977 { VK_END, VK_NUMPAD1 },
978 { VK_DOWN, VK_NUMPAD2 },
979 { VK_NEXT, VK_NUMPAD3 },
980 { VK_LEFT, VK_NUMPAD4 },
981 { VK_CLEAR, VK_NUMPAD5 },
982 { VK_RIGHT, VK_NUMPAD6 },
983 { VK_HOME, VK_NUMPAD7 },
984 { VK_UP, VK_NUMPAD8 },
985 { VK_PRIOR, VK_NUMPAD9 },
986 { 0,0 } };
987
988 if( !KeyboardLayout || !Msg ||
989 (Msg->message != WM_KEYDOWN && Msg->message != WM_SYSKEYDOWN &&
990 Msg->message != WM_KEYUP && Msg->message != WM_SYSKEYUP) )
991 {
992 return;
993 }
994
995 IntLockQueueState;
996
997 /* arty -- handle numpad -- On real windows, the actual key produced
998 * by the messaging layer is different based on the state of numlock. */
999 ModifierBits = ModBits(KeyboardLayout,QueueKeyStateTable);
1000
1001 /* Get the raw scan code, so we can look up whether the key is a numpad
1002 * key
1003 *
1004 * Shift and the LP_EXT_BIT cancel. */
1005 ScanCode = (Msg->lParam >> 16) & 0xff;
1006 BaseMapping = Msg->wParam =
1007 IntMapVirtualKeyEx( ScanCode, 1, KeyboardLayout );
1008 if( ScanCode >= KeyboardLayout->bMaxVSCtoVK )
1009 RawVk = 0;
1010 else
1011 RawVk = KeyboardLayout->pusVSCtoVK[ScanCode];
1012
1013 if ((ModifierBits & NUMLOCK_BIT) &&
1014 !(ModifierBits & GetShiftBit(KeyboardLayout, VK_SHIFT)) &&
1015 (RawVk & KNUMP) &&
1016 !(Msg->lParam & LP_EXT_BIT))
1017 {
1018 /* The key in question is a numpad key. Search for a translation. */
1019 for (i = 0; NumpadConversion[i][0]; i++)
1020 {
1021 if ((BaseMapping & 0xff) == NumpadConversion[i][0]) /* RawVk? */
1022 {
1023 Msg->wParam = NumpadConversion[i][1];
1024 break;
1025 }
1026 }
1027 }
1028
1029 DPRINT("Key: [%04x -> %04x]\n", BaseMapping, Msg->wParam);
1030
1031 /* Now that we have the VK, we can set the keymap appropriately
1032 * This is a better place for this code, as it's guaranteed to be
1033 * run, unlike translate message. */
1034 if (Msg->message == WM_KEYDOWN || Msg->message == WM_SYSKEYDOWN)
1035 {
1036 SetKeyState( ScanCode, Msg->wParam, Msg->lParam & LP_EXT_BIT,
1037 TRUE ); /* Strike key */
1038 }
1039 else if (Msg->message == WM_KEYUP || Msg->message == WM_SYSKEYUP)
1040 {
1041 SetKeyState( ScanCode, Msg->wParam, Msg->lParam & LP_EXT_BIT,
1042 FALSE ); /* Release key */
1043 }
1044
1045 /* We need to unset SYSKEYDOWN if the ALT key is an ALT+Gr */
1046 if( QueueKeyStateTable[VK_RMENU] & KS_DOWN_BIT ) {
1047 if( Msg->message == WM_SYSKEYDOWN ) Msg->message = WM_KEYDOWN;
1048 else Msg->message = WM_KEYUP;
1049 }
1050
1051 IntUnLockQueueState;
1052 }
1053
1054 DWORD
1055 STDCALL
1056 NtUserGetKeyboardLayoutList(
1057 DWORD Items,
1058 DWORD pHklBuff)
1059 {
1060 UNIMPLEMENTED
1061
1062 return 0;
1063 }
1064
1065 DWORD
1066 STDCALL
1067 NtUserGetKeyboardLayoutName(
1068 DWORD lpszName)
1069 {
1070 UNIMPLEMENTED
1071
1072 return 0;
1073 }
1074
1075 HKL
1076 STDCALL
1077 NtUserGetKeyboardLayout(
1078 DWORD dwThreadId)
1079 {
1080 NTSTATUS Status;
1081 PETHREAD Thread;
1082 PW32THREAD W32Thread;
1083 PKBDTABLES layout;
1084
1085 if (!dwThreadId)
1086 W32Thread = PsGetWin32Thread();
1087 else
1088 {
1089 Status = PsLookupThreadByThreadId((HANDLE)dwThreadId, &Thread);
1090 if(!NT_SUCCESS(Status))
1091 {
1092 SetLastWin32Error(ERROR_INVALID_PARAMETER);
1093 return 0;
1094 }
1095 W32Thread = Thread->Tcb.Win32Thread;
1096 }
1097 layout = W32Thread->KeyboardLayout;
1098 if(!layout) return 0;
1099 return (HKL)layout;
1100 }
1101
1102
1103 DWORD
1104 STDCALL
1105 NtUserGetKeyboardType(
1106 DWORD TypeFlag)
1107 {
1108 switch(TypeFlag)
1109 {
1110 case 0: /* Keyboard type */
1111 return 4; /* AT-101 */
1112 case 1: /* Keyboard Subtype */
1113 return 0; /* There are no defined subtypes */
1114 case 2: /* Number of F-keys */
1115 return 12; /* We're doing an 101 for now, so return 12 F-keys */
1116 default:
1117 DPRINT1("Unknown type!\n");
1118 return 0; /* The book says 0 here, so 0 */
1119 }
1120 }
1121
1122
1123 /*
1124 Based on TryToTranslateChar, instead of processing VirtualKey match,
1125 look for wChar match.
1126 */
1127 DWORD
1128 STDCALL
1129 NtUserVkKeyScanEx(
1130 DWORD wChar,
1131 DWORD KeyboardLayout,
1132 DWORD Unknown2)
1133 {
1134 PKBDTABLES KeyLayout;
1135 PVK_TO_WCHAR_TABLE vtwTbl;
1136 PVK_TO_WCHARS10 vkPtr;
1137 size_t size_this_entry;
1138 int nMod;
1139 DWORD CapsMod = 0, CapsState = 0;
1140
1141 if(!KeyboardLayout) return -1;
1142 KeyLayout = (PKBDTABLES) KeyboardLayout;
1143
1144 for (nMod = 0; KeyLayout->pVkToWcharTable[nMod].nModifications; nMod++)
1145 {
1146 vtwTbl = &KeyLayout->pVkToWcharTable[nMod];
1147 size_this_entry = vtwTbl->cbSize;
1148 vkPtr = (PVK_TO_WCHARS10)((BYTE *)vtwTbl->pVkToWchars);
1149
1150 while(vkPtr->VirtualKey)
1151 {
1152 /*
1153 0x01 Shift key
1154 0x02 Ctrl key
1155 0x04 Alt key
1156 Should have only 8 valid possibilities. Including zero.
1157 */
1158 for(CapsState = 0; CapsState < vtwTbl->nModifications; CapsState++)
1159 {
1160 if(vkPtr->wch[CapsState] == wChar)
1161 {
1162 CapsMod = KeyLayout->pCharModifiers->ModNumber[CapsState];
1163 return ((CapsMod << 8)|(vkPtr->VirtualKey & 0xff));
1164 }
1165 }
1166 vkPtr = (PVK_TO_WCHARS10)(((BYTE *)vkPtr) + size_this_entry);
1167 }
1168 }
1169 return -1;
1170 }
1171
1172
1173 /* EOF */