reactos/win32ss/user/ntuser/keyboard.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * PURPOSE:          Keyboard functions
   5  * FILE:             subsystems/win32/win32k/ntuser/keyboard.c
   6  * PROGRAMERS:       Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  *                   Rafal Harabien (rafalh@reactos.org)
   8  */
   9
  10 #include <win32k.h>
  11 DBG_DEFAULT_CHANNEL(UserKbd);
  12
  13 BYTE gafAsyncKeyState[256 * 2 / 8]; // 2 bits per key
  14 static BYTE gafAsyncKeyStateRecentDown[256 / 8]; // 1 bit per key
  15 static PKEYBOARD_INDICATOR_TRANSLATION gpKeyboardIndicatorTrans = NULL;
  16 static KEYBOARD_INDICATOR_PARAMETERS gIndicators = {0, 0};
  17
  18 /* FUNCTIONS *****************************************************************/
  19
  20 /*
  21  * InitKeyboardImpl
  22  *
  23  * Initialization -- Right now, just zero the key state
  24  */
  25 INIT_FUNCTION
  26 NTSTATUS
  27 NTAPI
  28 InitKeyboardImpl(VOID)
  29 {
  30     RtlZeroMemory(&gafAsyncKeyState, sizeof(gafAsyncKeyState));
  31     RtlZeroMemory(&gafAsyncKeyStateRecentDown, sizeof(gafAsyncKeyStateRecentDown));
  32     return STATUS_SUCCESS;
  33 }
  34
  35 /*
  36  * IntKeyboardGetIndicatorTrans
  37  *
  38  * Asks the keyboard driver to send a small table that shows which
  39  * lights should connect with which scancodes
  40  */
  41 static
  42 NTSTATUS APIENTRY
  43 IntKeyboardGetIndicatorTrans(HANDLE hKeyboardDevice,
  44                              PKEYBOARD_INDICATOR_TRANSLATION *ppIndicatorTrans)
  45 {
  46     NTSTATUS Status;
  47     DWORD dwSize = 0;
  48     IO_STATUS_BLOCK Block;
  49     PKEYBOARD_INDICATOR_TRANSLATION pRet;
  50
  51     dwSize = sizeof(KEYBOARD_INDICATOR_TRANSLATION);
  52
  53     pRet = ExAllocatePoolWithTag(PagedPool,
  54                                  dwSize,
  55                                  USERTAG_KBDTABLE);
  56
  57     while (pRet)
  58     {
  59         Status = NtDeviceIoControlFile(hKeyboardDevice,
  60                                        NULL,
  61                                        NULL,
  62                                        NULL,
  63                                        &Block,
  64                                        IOCTL_KEYBOARD_QUERY_INDICATOR_TRANSLATION,
  65                                        NULL, 0,
  66                                        pRet, dwSize);
  67
  68         if (Status != STATUS_BUFFER_TOO_SMALL)
  69             break;
  70
  71         ExFreePoolWithTag(pRet, USERTAG_KBDTABLE);
  72
  73         dwSize += sizeof(KEYBOARD_INDICATOR_TRANSLATION);
  74
  75         pRet = ExAllocatePoolWithTag(PagedPool,
  76                                      dwSize,
  77                                      USERTAG_KBDTABLE);
  78     }
  79
  80     if (!pRet)
  81         return STATUS_INSUFFICIENT_RESOURCES;
  82
  83     if (!NT_SUCCESS(Status))
  84     {
  85         ExFreePoolWithTag(pRet, USERTAG_KBDTABLE);
  86         return Status;
  87     }
  88
  89     *ppIndicatorTrans = pRet;
  90     return Status;
  91 }
  92
  93 /*
  94  * IntKeyboardUpdateLeds
  95  *
  96  * Sends the keyboard commands to turn on/off the lights
  97  */
  98 static
  99 NTSTATUS APIENTRY
 100 IntKeyboardUpdateLeds(HANDLE hKeyboardDevice,
 101                       WORD wVk,
 102                       WORD wScanCode,
 103                       BOOL bEnabled)
 104 {
 105     NTSTATUS Status;
 106     UINT i;
 107     USHORT LedFlag = 0;
 108     IO_STATUS_BLOCK Block;
 109
 110     if (!gpKeyboardIndicatorTrans)
 111         return STATUS_NOT_SUPPORTED;
 112
 113     switch (wVk)
 114     {
 115         case VK_CAPITAL: LedFlag = KEYBOARD_CAPS_LOCK_ON; break;
 116         case VK_NUMLOCK: LedFlag = KEYBOARD_NUM_LOCK_ON; break;
 117         case VK_SCROLL: LedFlag = KEYBOARD_SCROLL_LOCK_ON; break;
 118         default:
 119             for (i = 0; i < gpKeyboardIndicatorTrans->NumberOfIndicatorKeys; i++)
 120             {
 121                 if (gpKeyboardIndicatorTrans->IndicatorList[i].MakeCode == wScanCode)
 122                 {
 123                     LedFlag = gpKeyboardIndicatorTrans->IndicatorList[i].IndicatorFlags;
 124                     break;
 125                 }
 126             }
 127     }
 128
 129     if (LedFlag)
 130     {
 131         if (bEnabled)
 132             gIndicators.LedFlags |= LedFlag;
 133         else
 134             gIndicators.LedFlags = ~LedFlag;
 135
 136         /* Update the lights on the hardware */
 137         Status = NtDeviceIoControlFile(hKeyboardDevice,
 138                                        NULL,
 139                                        NULL,
 140                                        NULL,
 141                                        &Block,
 142                                        IOCTL_KEYBOARD_SET_INDICATORS,
 143                                        &gIndicators, sizeof(gIndicators),
 144                                        NULL, 0);
 145
 146         return Status;
 147     }
 148
 149     return STATUS_SUCCESS;
 150 }
 151
 152 /*
 153  * UserInitKeyboard
 154  *
 155  * Initializes keyboard indicators translation and their state
 156  */
 157 VOID NTAPI
 158 UserInitKeyboard(HANDLE hKeyboardDevice)
 159 {
 160     NTSTATUS Status;
 161     IO_STATUS_BLOCK Block;
 162
 163     IntKeyboardGetIndicatorTrans(hKeyboardDevice, &gpKeyboardIndicatorTrans);
 164
 165     Status = NtDeviceIoControlFile(hKeyboardDevice,
 166                                    NULL,
 167                                    NULL,
 168                                    NULL,
 169                                    &Block,
 170                                    IOCTL_KEYBOARD_QUERY_INDICATORS,
 171                                    NULL, 0,
 172                                    &gIndicators, sizeof(gIndicators));
 173
 174     if (!NT_SUCCESS(Status))
 175     {
 176         WARN("NtDeviceIoControlFile() failed, ignored\n");
 177     }
 178
 179     SET_KEY_LOCKED(gafAsyncKeyState, VK_CAPITAL,
 180                    gIndicators.LedFlags & KEYBOARD_CAPS_LOCK_ON);
 181     SET_KEY_LOCKED(gafAsyncKeyState, VK_NUMLOCK,
 182                    gIndicators.LedFlags & KEYBOARD_NUM_LOCK_ON);
 183     SET_KEY_LOCKED(gafAsyncKeyState, VK_SCROLL,
 184                    gIndicators.LedFlags & KEYBOARD_SCROLL_LOCK_ON);
 185 }
 186
 187 /*
 188  * IntSimplifyVk
 189  *
 190  * Changes virtual keys which distinguish between left and right hand, to keys which don't distinguish
 191  */
 192 static
 193 WORD
 194 IntSimplifyVk(WORD wVk)
 195 {
 196     switch (wVk)
 197     {
 198         case VK_LSHIFT:
 199         case VK_RSHIFT:
 200             return VK_SHIFT;
 201
 202         case VK_LCONTROL:
 203         case VK_RCONTROL:
 204             return VK_CONTROL;
 205
 206         case VK_LMENU:
 207         case VK_RMENU:
 208             return VK_MENU;
 209
 210         default:
 211             return wVk;
 212     }
 213 }
 214
 215 /*
 216  * IntFixVk
 217  *
 218  * Changes virtual keys which don't not distinguish between left and right hand to proper keys
 219  */
 220 static
 221 WORD
 222 IntFixVk(WORD wVk, BOOL bExt)
 223 {
 224     switch (wVk)
 225     {
 226         case VK_SHIFT:
 227             return bExt ? VK_RSHIFT : VK_LSHIFT;
 228
 229         case VK_CONTROL:
 230             return bExt ? VK_RCONTROL : VK_LCONTROL;
 231
 232         case VK_MENU:
 233             return bExt ? VK_RMENU : VK_LMENU;
 234
 235         default:
 236             return wVk;
 237     }
 238 }
 239
 240 /*
 241  * IntTranslateNumpadKey
 242  *
 243  * Translates numpad keys when numlock is enabled
 244  */
 245 static
 246 WORD
 247 IntTranslateNumpadKey(WORD wVk)
 248 {
 249     switch (wVk)
 250     {
 251         case VK_INSERT: return VK_NUMPAD0;
 252         case VK_END: return VK_NUMPAD1;
 253         case VK_DOWN: return VK_NUMPAD2;
 254         case VK_NEXT: return VK_NUMPAD3;
 255         case VK_LEFT: return VK_NUMPAD4;
 256         case VK_CLEAR: return VK_NUMPAD5;
 257         case VK_RIGHT: return VK_NUMPAD6;
 258         case VK_HOME: return VK_NUMPAD7;
 259         case VK_UP: return VK_NUMPAD8;
 260         case VK_PRIOR: return VK_NUMPAD9;
 261         case VK_DELETE: return VK_DECIMAL;
 262         default: return wVk;
 263     }
 264 }
 265
 266 /*
 267  * IntGetModBits
 268  *
 269  * Gets layout specific modification bits, for example KBDSHIFT, KBDCTRL, KBDALT
 270  */
 271 static
 272 DWORD
 273 IntGetModBits(PKBDTABLES pKbdTbl, PBYTE pKeyState)
 274 {
 275     DWORD i, dwModBits = 0;
 276
 277     /* DumpKeyState( KeyState ); */
 278
 279     for (i = 0; pKbdTbl->pCharModifiers->pVkToBit[i].Vk; i++)
 280         if (IS_KEY_DOWN(pKeyState, pKbdTbl->pCharModifiers->pVkToBit[i].Vk))
 281             dwModBits |= pKbdTbl->pCharModifiers->pVkToBit[i].ModBits;
 282
 283     TRACE("Current Mod Bits: %lx\n", dwModBits);
 284
 285     return dwModBits;
 286 }
 287
 288 /*
 289  * IntTranslateChar
 290  *
 291  * Translates virtual key to character
 292  */
 293 static
 294 BOOL
 295 IntTranslateChar(WORD wVirtKey,
 296                  PBYTE pKeyState,
 297                  PBOOL pbDead,
 298                  PBOOL pbLigature,
 299                  PWCHAR pwcTranslatedChar,
 300                  PKBDTABLES pKbdTbl)
 301 {
 302     PVK_TO_WCHAR_TABLE pVkToVchTbl;
 303     PVK_TO_WCHARS10 pVkToVch;
 304     DWORD i, dwModBits, dwVkModBits, dwModNumber = 0;
 305     WCHAR wch;
 306     BOOL bAltGr;
 307     WORD wCaplokAttr;
 308
 309     dwModBits = pKeyState ? IntGetModBits(pKbdTbl, pKeyState) : 0;
 310     bAltGr = pKeyState && (pKbdTbl->fLocaleFlags & KLLF_ALTGR) && IS_KEY_DOWN(pKeyState, VK_RMENU);
 311     wCaplokAttr = bAltGr ? CAPLOKALTGR : CAPLOK;
 312
 313     TRACE("TryToTranslate: %04x %x\n", wVirtKey, dwModBits);
 314
 315     /* If ALT without CTRL has ben used, remove ALT flag */
 316     if ((dwModBits & (KBDALT|KBDCTRL)) == KBDALT)
 317         dwModBits &= ~KBDALT;
 318
 319     if (dwModBits > pKbdTbl->pCharModifiers->wMaxModBits)
 320     {
 321         TRACE("dwModBits %x > wMaxModBits %x\n", dwModBits, pKbdTbl->pCharModifiers->wMaxModBits);
 322         return FALSE;
 323     }
 324
 325     for (i = 0; pKbdTbl->pVkToWcharTable[i].pVkToWchars; i++)
 326     {
 327         pVkToVchTbl = &pKbdTbl->pVkToWcharTable[i];
 328         pVkToVch = (PVK_TO_WCHARS10)(pVkToVchTbl->pVkToWchars);
 329         while (pVkToVch->VirtualKey)
 330         {
 331             if (wVirtKey == (pVkToVch->VirtualKey & 0xFF))
 332             {
 333                 dwVkModBits = dwModBits;
 334
 335                 /* If CapsLock is enabled for this key and locked, add SHIFT bit */
 336                 if ((pVkToVch->Attributes & wCaplokAttr) &&
 337                     pKeyState &&
 338                     IS_KEY_LOCKED(pKeyState, VK_CAPITAL))
 339                 {
 340                     /* Note: we use special value here instead of getting VK_SHIFT mod bit - it's verified */
 341                     dwVkModBits ^= KBDSHIFT;
 342                 }
 343
 344                 if (dwVkModBits > pKbdTbl->pCharModifiers->wMaxModBits)
 345                     break;
 346
 347                 /* Get modification number */
 348                 dwModNumber = pKbdTbl->pCharModifiers->ModNumber[dwVkModBits];
 349                 if (dwModNumber >= pVkToVchTbl->nModifications)
 350                 {
 351                     TRACE("dwModNumber %u >= nModifications %u\n", dwModNumber, pVkToVchTbl->nModifications);
 352                     break;
 353                 }
 354
 355                 /* Read character */
 356                 wch = pVkToVch->wch[dwModNumber];
 357                 if (wch == WCH_NONE)
 358                     break;
 359
 360                 *pbDead = (wch == WCH_DEAD);
 361                 *pbLigature = (wch == WCH_LGTR);
 362                 *pwcTranslatedChar = wch;
 363
 364                 TRACE("%d %04x: dwModNumber %08x Char %04x\n",
 365                       i, wVirtKey, dwModNumber, wch);
 366
 367                 if (*pbDead)
 368                 {
 369                     /* After WCH_DEAD, real character is located */
 370                     pVkToVch = (PVK_TO_WCHARS10)(((BYTE *)pVkToVch) + pVkToVchTbl->cbSize);
 371                     if (pVkToVch->VirtualKey != 0xFF)
 372                     {
 373                         WARN("Found dead key with no trailer in the table.\n");
 374                         WARN("VK: %04x, ADDR: %p\n", wVirtKey, pVkToVch);
 375                         break;
 376                     }
 377                     *pwcTranslatedChar = pVkToVch->wch[dwModNumber];
 378                 }
 379                 return TRUE;
 380             }
 381             pVkToVch = (PVK_TO_WCHARS10)(((BYTE *)pVkToVch) + pVkToVchTbl->cbSize);
 382         }
 383     }
 384
 385     /* If nothing has been found in layout, check if this is ASCII control character.
 386        Note: we could add it to layout table, but windows does not have it there */
 387     if (wVirtKey >= 'A' && wVirtKey <= 'Z' &&
 388         IS_KEY_DOWN(pKeyState, VK_CONTROL) &&
 389         !IS_KEY_DOWN(pKeyState, VK_MENU))
 390     {
 391         *pwcTranslatedChar = (wVirtKey - 'A') + 1; /* ASCII control character */
 392         *pbDead = FALSE;
 393         *pbLigature = FALSE;
 394         return TRUE;
 395     }
 396
 397     return FALSE;
 398 }
 399
 400 /*
 401  * IntToUnicodeEx
 402  *
 403  * Translates virtual key to characters
 404  */
 405 static
 406 int APIENTRY
 407 IntToUnicodeEx(UINT wVirtKey,
 408                UINT wScanCode,
 409                PBYTE pKeyState,
 410                LPWSTR pwszBuff,
 411                int cchBuff,
 412                UINT wFlags,
 413                PKBDTABLES pKbdTbl)
 414 {
 415     WCHAR wchTranslatedChar;
 416     BOOL bDead, bLigature;
 417     static WCHAR wchDead = 0;
 418     int iRet = 0;
 419
 420     ASSERT(pKbdTbl);
 421
 422     if (!IntTranslateChar(wVirtKey,
 423                           pKeyState,
 424                           &bDead,
 425                           &bLigature,
 426                           &wchTranslatedChar,
 427                           pKbdTbl))
 428     {
 429         return 0;
 430     }
 431
 432     if (bLigature)
 433     {
 434         WARN("Not handling ligature (yet)\n" );
 435         return 0;
 436     }
 437
 438     /* If we got dead char in previous call check dead keys in keyboard layout */
 439     if (wchDead)
 440     {
 441         UINT i;
 442         WCHAR wchFirst, wchSecond;
 443         TRACE("Previous dead char: %lc (%x)\n", wchDead, wchDead);
 444
 445         for (i = 0; pKbdTbl->pDeadKey[i].dwBoth; i++)
 446         {
 447             wchFirst = pKbdTbl->pDeadKey[i].dwBoth >> 16;
 448             wchSecond = pKbdTbl->pDeadKey[i].dwBoth & 0xFFFF;
 449             if (wchFirst == wchDead && wchSecond == wchTranslatedChar)
 450             {
 451                 wchTranslatedChar = pKbdTbl->pDeadKey[i].wchComposed;
 452                 wchDead = 0;
 453                 bDead = FALSE;
 454                 break;
 455             }
 456         }
 457
 458         TRACE("Final char: %lc (%x)\n", wchTranslatedChar, wchTranslatedChar);
 459     }
 460
 461     /* Dead char has not been not found */
 462     if (wchDead)
 463     {
 464         /* Treat both characters normally */
 465         if (cchBuff > iRet)
 466             pwszBuff[iRet++] = wchDead;
 467         bDead = FALSE;
 468     }
 469
 470     /* Add character to the buffer */
 471     if (cchBuff > iRet)
 472         pwszBuff[iRet++] = wchTranslatedChar;
 473
 474     /* Save dead character */
 475     wchDead = bDead ? wchTranslatedChar : 0;
 476
 477     return bDead ? -iRet : iRet;
 478 }
 479
 480 /*
 481  * IntVkToVsc
 482  *
 483  * Translates virtual key to scan code
 484  */
 485 static
 486 WORD FASTCALL
 487 IntVkToVsc(WORD wVk, PKBDTABLES pKbdTbl)
 488 {
 489     unsigned i;
 490
 491     ASSERT(pKbdTbl);
 492
 493     /* Check standard keys first */
 494     for (i = 0; i < pKbdTbl->bMaxVSCtoVK; i++)
 495     {
 496         if ((pKbdTbl->pusVSCtoVK[i] & 0xFF) == wVk)
 497             return i;
 498     }
 499
 500     /* Check extended keys now */
 501     for (i = 0; pKbdTbl->pVSCtoVK_E0[i].Vsc; i++)
 502     {
 503         if ((pKbdTbl->pVSCtoVK_E0[i].Vk & 0xFF) == wVk)
 504             return 0xE000 | pKbdTbl->pVSCtoVK_E0[i].Vsc;
 505     }
 506
 507     for (i = 0; pKbdTbl->pVSCtoVK_E1[i].Vsc; i++)
 508     {
 509         if ((pKbdTbl->pVSCtoVK_E1[i].Vk & 0xFF) == wVk)
 510             return 0xE100 | pKbdTbl->pVSCtoVK_E1[i].Vsc;
 511     }
 512
 513     /* Virtual key has not been found */
 514     return 0;
 515 }
 516
 517 /*
 518  * IntVscToVk
 519  *
 520  * Translates prefixed scancode to virtual key
 521  */
 522 static
 523 WORD FASTCALL
 524 IntVscToVk(WORD wScanCode, PKBDTABLES pKbdTbl)
 525 {
 526     unsigned i;
 527     WORD wVk = 0;
 528
 529     ASSERT(pKbdTbl);
 530
 531     if ((wScanCode & 0xFF00) == 0xE000)
 532     {
 533         for (i = 0; pKbdTbl->pVSCtoVK_E0[i].Vsc; i++)
 534         {
 535             if (pKbdTbl->pVSCtoVK_E0[i].Vsc == (wScanCode & 0xFF))
 536             {
 537                 wVk = pKbdTbl->pVSCtoVK_E0[i].Vk;
 538             }
 539         }
 540     }
 541     else if ((wScanCode & 0xFF00) == 0xE100)
 542     {
 543         for (i = 0; pKbdTbl->pVSCtoVK_E1[i].Vsc; i++)
 544         {
 545             if (pKbdTbl->pVSCtoVK_E1[i].Vsc == (wScanCode & 0xFF))
 546             {
 547                 wVk = pKbdTbl->pVSCtoVK_E1[i].Vk;
 548             }
 549         }
 550     }
 551     else if (wScanCode < pKbdTbl->bMaxVSCtoVK)
 552     {
 553         wVk = pKbdTbl->pusVSCtoVK[wScanCode];
 554     }
 555
 556     /* 0xFF nad 0x00 are invalid VKs */
 557     return wVk != 0xFF ? wVk : 0;
 558 }
 559
 560 /*
 561  * IntVkToChar
 562  *
 563  * Translates virtual key to character, ignoring shift state
 564  */
 565 static
 566 WCHAR FASTCALL
 567 IntVkToChar(WORD wVk, PKBDTABLES pKbdTbl)
 568 {
 569     WCHAR wch;
 570     BOOL bDead, bLigature;
 571
 572     ASSERT(pKbdTbl);
 573
 574     if (IntTranslateChar(wVk,
 575                          NULL,
 576                          &bDead,
 577                          &bLigature,
 578                          &wch,
 579                          pKbdTbl))
 580     {
 581         return wch;
 582     }
 583
 584     return 0;
 585 }
 586
 587 /*
 588  * NtUserGetAsyncKeyState
 589  *
 590  * Gets key state from global bitmap
 591  */
 592 SHORT
 593 APIENTRY
 594 NtUserGetAsyncKeyState(INT Key)
 595 {
 596     WORD wRet = 0;
 597
 598     TRACE("Enter NtUserGetAsyncKeyState\n");
 599
 600     if (Key >= 0x100)
 601     {
 602         EngSetLastError(ERROR_INVALID_PARAMETER);
 603         ERR("Invalid parameter Key\n");
 604         return 0;
 605     }
 606
 607     UserEnterExclusive();
 608
 609     if (IS_KEY_DOWN(gafAsyncKeyState, Key))
 610         wRet |= 0x8000; // If down, windows returns 0x8000.
 611     if (gafAsyncKeyStateRecentDown[Key / 8] & (1 << (Key % 8)))
 612         wRet |= 0x1;
 613     gafAsyncKeyStateRecentDown[Key / 8] &= ~(1 << (Key % 8));
 614
 615     UserLeave();
 616
 617     TRACE("Leave NtUserGetAsyncKeyState, ret=%i\n", wRet);
 618     return wRet;
 619 }
 620
 621 /*
 622  * UpdateAsyncKeyState
 623  *
 624  * Updates gafAsyncKeyState array
 625  */
 626 static
 627 VOID NTAPI
 628 UpdateAsyncKeyState(WORD wVk, BOOL bIsDown)
 629 {
 630     if (bIsDown)
 631     {
 632         /* If it's first key down event, xor lock bit */
 633         if (!IS_KEY_DOWN(gafAsyncKeyState, wVk))
 634             SET_KEY_LOCKED(gafAsyncKeyState, wVk, !IS_KEY_LOCKED(gafAsyncKeyState, wVk));
 635
 636         SET_KEY_DOWN(gafAsyncKeyState, wVk, TRUE);
 637         gafAsyncKeyStateRecentDown[wVk / 8] |= (1 << (wVk % 8));
 638     }
 639     else
 640         SET_KEY_DOWN(gafAsyncKeyState, wVk, FALSE);
 641 }
 642
 643 /*
 644  * co_CallLowLevelKeyboardHook
 645  *
 646  * Calls WH_KEYBOARD_LL hook
 647  */
 648 static LRESULT
 649 co_CallLowLevelKeyboardHook(WORD wVk, WORD wScanCode, DWORD dwFlags, BOOL bInjected, DWORD dwTime, DWORD dwExtraInfo)
 650 {
 651     KBDLLHOOKSTRUCT KbdHookData;
 652     UINT uMsg;
 653
 654     KbdHookData.vkCode = wVk;
 655     KbdHookData.scanCode = wScanCode;
 656     KbdHookData.flags = 0;
 657     if (dwFlags & KEYEVENTF_EXTENDEDKEY)
 658         KbdHookData.flags |= LLKHF_EXTENDED;
 659     if (IS_KEY_DOWN(gafAsyncKeyState, VK_MENU))
 660         KbdHookData.flags |= LLKHF_ALTDOWN;
 661     if (dwFlags & KEYEVENTF_KEYUP)
 662         KbdHookData.flags |= LLKHF_UP;
 663     if (bInjected)
 664         KbdHookData.flags |= LLKHF_INJECTED;
 665     KbdHookData.time = dwTime;
 666     KbdHookData.dwExtraInfo = dwExtraInfo;
 667
 668     /* Note: it doesnt support WM_SYSKEYUP */
 669     if (dwFlags & KEYEVENTF_KEYUP)
 670         uMsg = WM_KEYUP;
 671     else if (IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) && !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL))
 672         uMsg = WM_SYSKEYDOWN;
 673     else
 674         uMsg = WM_KEYDOWN;
 675
 676     return co_HOOK_CallHooks(WH_KEYBOARD_LL, HC_ACTION, uMsg, (LPARAM)&KbdHookData);
 677 }
 678
 679 /*
 680  * SnapWindow
 681  *
 682  * Saves snapshot of specified window or whole screen in the clipboard
 683  */
 684 static VOID
 685 SnapWindow(HWND hWnd)
 686 {
 687     HBITMAP hbm = NULL, hbmOld;
 688     HDC hdc = NULL, hdcMem;
 689     SETCLIPBDATA scd;
 690     INT cx, cy;
 691     PWND pWnd = NULL;
 692
 693     TRACE("SnapWindow(%p)\n", hWnd);
 694
 695     /* If no windows is given, make snapshot of desktop window */
 696     if (!hWnd)
 697         hWnd = IntGetDesktopWindow();
 698
 699     pWnd = UserGetWindowObject(hWnd);
 700     if (!pWnd)
 701     {
 702         ERR("Invalid window\n");
 703         goto cleanup;
 704     }
 705
 706     hdc = UserGetDCEx(pWnd, NULL, DCX_USESTYLE | DCX_WINDOW);
 707     if (!hdc)
 708     {
 709         ERR("UserGetDCEx failed!\n");
 710         goto cleanup;
 711     }
 712
 713     cx = pWnd->rcWindow.right - pWnd->rcWindow.left;
 714     cy = pWnd->rcWindow.bottom - pWnd->rcWindow.top;
 715
 716     hbm = NtGdiCreateCompatibleBitmap(hdc, cx, cy);
 717     if (!hbm)
 718     {
 719         ERR("NtGdiCreateCompatibleBitmap failed!\n");
 720         goto cleanup;
 721     }
 722
 723     hdcMem = NtGdiCreateCompatibleDC(hdc);
 724     if (!hdcMem)
 725     {
 726         ERR("NtGdiCreateCompatibleDC failed!\n");
 727         goto cleanup;
 728     }
 729
 730     hbmOld = NtGdiSelectBitmap(hdcMem, hbm);
 731     NtGdiBitBlt(hdcMem, 0, 0, cx, cy, hdc, 0, 0, SRCCOPY, 0, 0);
 732     NtGdiSelectBitmap(hdcMem, hbmOld);
 733     IntGdiDeleteDC(hdcMem, FALSE);
 734
 735     /* Save snapshot in clipboard */
 736     if (UserOpenClipboard(NULL))
 737     {
 738         UserEmptyClipboard();
 739         scd.fIncSerialNumber = TRUE;
 740         scd.fGlobalHandle = FALSE;
 741         if (UserSetClipboardData(CF_BITMAP, hbm, &scd))
 742         {
 743             /* Bitmap is managed by system now */
 744             hbm = NULL;
 745         }
 746         UserCloseClipboard();
 747     }
 748
 749 cleanup:
 750     if (hbm)
 751         GreDeleteObject(hbm);
 752     if (hdc)
 753         UserReleaseDC(pWnd, hdc, FALSE);
 754 }
 755
 756 /*
 757  * UserSendKeyboardInput
 758  *
 759  * Process keyboard input from input devices and SendInput API
 760  */
 761 BOOL NTAPI
 762 ProcessKeyEvent(WORD wVk, WORD wScanCode, DWORD dwFlags, BOOL bInjected, DWORD dwTime, DWORD dwExtraInfo)
 763 {
 764     WORD wSimpleVk = 0, wFixedVk, wVk2;
 765     PUSER_MESSAGE_QUEUE pFocusQueue;
 766     BOOL bExt = (dwFlags & KEYEVENTF_EXTENDEDKEY) ? TRUE : FALSE;
 767     BOOL bIsDown = (dwFlags & KEYEVENTF_KEYUP) ? FALSE : TRUE;
 768     BOOL bPacket = (dwFlags & KEYEVENTF_UNICODE) ? TRUE : FALSE;
 769     BOOL bWasSimpleDown = FALSE, bPostMsg = TRUE, bIsSimpleDown;
 770     MSG Msg;
 771     static BOOL bMenuDownRecently = FALSE;
 772
 773     /* Get virtual key without shifts (VK_(L|R)* -> VK_*) */
 774     wSimpleVk = IntSimplifyVk(wVk);
 775     bWasSimpleDown = IS_KEY_DOWN(gafAsyncKeyState, wSimpleVk);
 776
 777     /* Update key without shifts */
 778     wVk2 = IntFixVk(wSimpleVk, !bExt);
 779     bIsSimpleDown = bIsDown || IS_KEY_DOWN(gafAsyncKeyState, wVk2);
 780     UpdateAsyncKeyState(wSimpleVk, bIsSimpleDown);
 781
 782     if (bIsDown)
 783     {
 784         /* Update keyboard LEDs */
 785         IntKeyboardUpdateLeds(ghKeyboardDevice,
 786                               wSimpleVk,
 787                               wScanCode,
 788                               IS_KEY_LOCKED(gafAsyncKeyState, wSimpleVk));
 789     }
 790
 791     /* Call WH_KEYBOARD_LL hook */
 792     if (co_CallLowLevelKeyboardHook(wVk, wScanCode, dwFlags, bInjected, dwTime, dwExtraInfo))
 793     {
 794         ERR("Kbd msg dropped by WH_KEYBOARD_LL hook\n");
 795         bPostMsg = FALSE;
 796     }
 797
 798     /* Check if this is a hotkey */
 799     if (co_UserProcessHotKeys(wSimpleVk, bIsDown))
 800         bPostMsg = FALSE;
 801
 802     wFixedVk = IntFixVk(wSimpleVk, bExt); /* LSHIFT + EXT = RSHIFT */
 803     if (wSimpleVk == VK_SHIFT) /* shift can't be extended */
 804         bExt = FALSE;
 805
 806     /* If it is F10 or ALT is down and CTRL is up, it's a system key */
 807     if (wVk == VK_F10 ||
 808         (wSimpleVk == VK_MENU && bMenuDownRecently) ||
 809         (IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) &&
 810         !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL)))
 811     {
 812         bMenuDownRecently = FALSE; // reset
 813         if (bIsDown)
 814         {
 815             Msg.message = WM_SYSKEYDOWN;
 816             if (wSimpleVk == VK_MENU)
 817             {
 818                 // Note: If only LALT is pressed WM_SYSKEYUP is generated instead of WM_KEYUP
 819                 bMenuDownRecently = TRUE;
 820             }
 821         }
 822         else
 823             Msg.message = WM_SYSKEYUP;
 824     }
 825     else
 826     {
 827         if (bIsDown)
 828             Msg.message = WM_KEYDOWN;
 829         else
 830             Msg.message = WM_KEYUP;
 831     }
 832
 833     /* Update async state of not simplified vk here.
 834        See user32_apitest:GetKeyState */
 835     UpdateAsyncKeyState(wFixedVk, bIsDown);
 836
 837     /* Alt-Tab/Esc Check. Use FocusQueue or RIT Queue */
 838     if (bIsSimpleDown && !bWasSimpleDown &&
 839         IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) &&
 840         !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL) &&
 841         (wVk == VK_ESCAPE || wVk == VK_TAB))
 842     {
 843        TRACE("Alt-Tab/Esc Pressed wParam %x\n",wVk);
 844     }
 845
 846     /* If we have a focus queue, post a keyboard message */
 847     pFocusQueue = IntGetFocusMessageQueue();
 848     if (bIsDown && wVk == VK_SNAPSHOT)
 849     {
 850         if (pFocusQueue &&
 851             IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) &&
 852             !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL))
 853         {
 854             SnapWindow(pFocusQueue->spwndFocus ? UserHMGetHandle(pFocusQueue->spwndFocus) : 0);
 855         }
 856         else
 857             SnapWindow(NULL);
 858     }
 859     else if (pFocusQueue && bPostMsg)
 860     {
 861         /* Init message */
 862         Msg.hwnd = pFocusQueue->spwndFocus ? UserHMGetHandle(pFocusQueue->spwndFocus) : 0;
 863         Msg.wParam = wFixedVk & 0xFF; /* Note: It's simplified by msg queue */
 864         Msg.lParam = MAKELPARAM(1, wScanCode);
 865         Msg.time = dwTime;
 866         Msg.pt = gpsi->ptCursor;
 867
 868         /* If it is VK_PACKET, high word of wParam is used for wchar */
 869         if (!bPacket)
 870         {
 871             if (bExt)
 872                 Msg.lParam |= KF_EXTENDED << 16;
 873             if (IS_KEY_DOWN(gafAsyncKeyState, VK_MENU))
 874                 Msg.lParam |= KF_ALTDOWN << 16;
 875             if (bWasSimpleDown)
 876                 Msg.lParam |= KF_REPEAT << 16;
 877             if (!bIsDown)
 878                 Msg.lParam |= KF_UP << 16;
 879             /* FIXME: Set KF_DLGMODE and KF_MENUMODE when needed */
 880             if (pFocusQueue->QF_flags & QF_DIALOGACTIVE)
 881                 Msg.lParam |= KF_DLGMODE << 16;
 882             if (pFocusQueue->MenuOwner) // pFocusQueue->MenuState) // MenuState needs a start flag...
 883                 Msg.lParam |= KF_MENUMODE << 16;
 884         }
 885
 886         /* Post a keyboard message */
 887         TRACE("Posting keyboard msg %u wParam 0x%x lParam 0x%x\n", Msg.message, Msg.wParam, Msg.lParam);
 888         MsqPostMessage(pFocusQueue, &Msg, TRUE, QS_KEY);
 889     }
 890
 891     return TRUE;
 892 }
 893
 894 BOOL NTAPI
 895 UserSendKeyboardInput(KEYBDINPUT *pKbdInput, BOOL bInjected)
 896 {
 897     WORD wScanCode, wVk;
 898     PKL pKl = NULL;
 899     PKBDTABLES pKbdTbl;
 900     PUSER_MESSAGE_QUEUE pFocusQueue;
 901     struct _ETHREAD *pFocusThread;
 902     LARGE_INTEGER LargeTickCount;
 903     DWORD dwTime;
 904     BOOL bExt = (pKbdInput->dwFlags & KEYEVENTF_EXTENDEDKEY) ? TRUE : FALSE;
 905
 906     gppiInputProvider = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->ppi;
 907
 908     /* Find the target thread whose locale is in effect */
 909     pFocusQueue = IntGetFocusMessageQueue();
 910
 911     if (pFocusQueue)
 912     {
 913         pFocusThread = pFocusQueue->Thread;
 914         if (pFocusThread && pFocusThread->Tcb.Win32Thread)
 915             pKl = ((PTHREADINFO)pFocusThread->Tcb.Win32Thread)->KeyboardLayout;
 916     }
 917
 918     if (!pKl)
 919         pKl = W32kGetDefaultKeyLayout();
 920     if (!pKl)
 921     {
 922         ERR("No keyboard layout!\n");
 923         return FALSE;
 924     }
 925
 926     pKbdTbl = pKl->spkf->pKbdTbl;
 927
 928     /* Note: wScan field is always used */
 929     wScanCode = pKbdInput->wScan;
 930
 931     if (pKbdInput->dwFlags & KEYEVENTF_UNICODE)
 932     {
 933         /* Generate WM_KEYDOWN msg with wParam == VK_PACKET and
 934            high order word of lParam == pKbdInput->wScan */
 935         wVk = VK_PACKET;
 936     }
 937     else
 938     {
 939         wScanCode &= 0x7F;
 940         if (pKbdInput->dwFlags & KEYEVENTF_SCANCODE)
 941         {
 942             /* Don't ignore invalid scan codes */
 943             wVk = IntVscToVk(wScanCode | (bExt ? 0xE000 : 0), pKbdTbl);
 944             if (!wVk) /* use 0xFF if vsc is invalid */
 945                 wVk = 0xFF;
 946         }
 947         else
 948         {
 949             wVk = pKbdInput->wVk & 0xFF;
 950         }
 951     }
 952
 953     /* If time is given, use it */
 954     if (pKbdInput->time)
 955         dwTime = pKbdInput->time;
 956     else
 957     {
 958         KeQueryTickCount(&LargeTickCount);
 959         dwTime = MsqCalculateMessageTime(&LargeTickCount);
 960     }
 961
 962     if (wVk == VK_RMENU && (pKbdTbl->fLocaleFlags & KLLF_ALTGR))
 963     {
 964         /* For AltGr keyboards RALT generates CTRL events */
 965         ProcessKeyEvent(VK_LCONTROL, 0, pKbdInput->dwFlags & KEYEVENTF_KEYUP, bInjected, dwTime, 0);
 966     }
 967
 968     /* Finally process this key */
 969     return ProcessKeyEvent(wVk, wScanCode, pKbdInput->dwFlags, bInjected, dwTime, pKbdInput->dwExtraInfo);
 970 }
 971
 972 /*
 973  * UserProcessKeyboardInput
 974  *
 975  * Process raw keyboard input data
 976  */
 977 VOID NTAPI
 978 UserProcessKeyboardInput(
 979     PKEYBOARD_INPUT_DATA pKbdInputData)
 980 {
 981     WORD wScanCode, wVk;
 982     PKL pKl = NULL;
 983     PKBDTABLES pKbdTbl;
 984     PUSER_MESSAGE_QUEUE pFocusQueue;
 985     struct _ETHREAD *pFocusThread;
 986
 987     /* Calculate scan code with prefix */
 988     wScanCode = pKbdInputData->MakeCode & 0x7F;
 989     if (pKbdInputData->Flags & KEY_E0)
 990         wScanCode |= 0xE000;
 991     if (pKbdInputData->Flags & KEY_E1)
 992         wScanCode |= 0xE100;
 993
 994     /* Find the target thread whose locale is in effect */
 995     pFocusQueue = IntGetFocusMessageQueue();
 996
 997     if (pFocusQueue)
 998     {
 999         pFocusThread = pFocusQueue->Thread;
1000         if (pFocusThread && pFocusThread->Tcb.Win32Thread)
1001             pKl = ((PTHREADINFO)pFocusThread->Tcb.Win32Thread)->KeyboardLayout;
1002     }
1003
1004     if (!pKl)
1005         pKl = W32kGetDefaultKeyLayout();
1006     if (!pKl)
1007         return;
1008
1009     pKbdTbl = pKl->spkf->pKbdTbl;
1010
1011     /* Convert scan code to virtual key.
1012        Note: We could call UserSendKeyboardInput using scan code,
1013              but it wouldn't interpret E1 key(s) properly */
1014     wVk = IntVscToVk(wScanCode, pKbdTbl);
1015     TRACE("UserProcessKeyboardInput: %x (break: %u) -> %x\n",
1016           wScanCode, (pKbdInputData->Flags & KEY_BREAK) ? 1 : 0, wVk);
1017
1018     if (wVk)
1019     {
1020         KEYBDINPUT KbdInput;
1021
1022         /* Support numlock */
1023         if ((wVk & KBDNUMPAD) && IS_KEY_LOCKED(gafAsyncKeyState, VK_NUMLOCK))
1024         {
1025             wVk = IntTranslateNumpadKey(wVk & 0xFF);
1026         }
1027
1028         /* Send keyboard input */
1029         KbdInput.wVk = wVk & 0xFF;
1030         KbdInput.wScan = wScanCode & 0x7F;
1031         KbdInput.dwFlags = 0;
1032         if (pKbdInputData->Flags & KEY_BREAK)
1033             KbdInput.dwFlags |= KEYEVENTF_KEYUP;
1034         if (wVk & KBDEXT)
1035             KbdInput.dwFlags |= KEYEVENTF_EXTENDEDKEY;
1036         KbdInput.time = 0;
1037         KbdInput.dwExtraInfo = pKbdInputData->ExtraInformation;
1038         UserSendKeyboardInput(&KbdInput, FALSE);
1039
1040         /* E1 keys don't have break code */
1041         if (pKbdInputData->Flags & KEY_E1)
1042         {
1043             /* Send key up event */
1044             KbdInput.dwFlags |= KEYEVENTF_KEYUP;
1045             UserSendKeyboardInput(&KbdInput, FALSE);
1046         }
1047     }
1048 }
1049
1050 /*
1051  * IntTranslateKbdMessage
1052  *
1053  * Addes WM_(SYS)CHAR messages to message queue if message
1054  * describes key which produce character.
1055  */
1056 BOOL FASTCALL
1057 IntTranslateKbdMessage(LPMSG lpMsg,
1058                        UINT flags)
1059 {
1060     PTHREADINFO pti;
1061     INT cch = 0, i;
1062     WCHAR wch[3] = { 0 };
1063     MSG NewMsg = { 0 };
1064     PKBDTABLES pKbdTbl;
1065     PWND pWnd;
1066     LARGE_INTEGER LargeTickCount;
1067     BOOL bResult = FALSE;
1068
1069     switch(lpMsg->message)
1070     {
1071        case WM_KEYDOWN:
1072        case WM_KEYUP:
1073        case WM_SYSKEYDOWN:
1074        case WM_SYSKEYUP:
1075           break;
1076        default:
1077           return FALSE;
1078     }
1079
1080     pWnd = UserGetWindowObject(lpMsg->hwnd);
1081     if (!pWnd) // Must have a window!
1082     {
1083         ERR("No Window for Translate.\n");
1084         return FALSE;
1085     }
1086
1087     pti = pWnd->head.pti;
1088
1089     if (!pti->KeyboardLayout)
1090     {
1091        pti->KeyboardLayout = W32kGetDefaultKeyLayout();
1092        pti->pClientInfo->hKL = pti->KeyboardLayout ? pti->KeyboardLayout->hkl : NULL;
1093        pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
1094     }
1095     else
1096        pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
1097     if (!pKbdTbl)
1098         return FALSE;
1099
1100     if (lpMsg->message != WM_KEYDOWN && lpMsg->message != WM_SYSKEYDOWN)
1101         return FALSE;
1102
1103     /* Init pt, hwnd and time msg fields */
1104     NewMsg.pt = gpsi->ptCursor;
1105     NewMsg.hwnd = lpMsg->hwnd;
1106     KeQueryTickCount(&LargeTickCount);
1107     NewMsg.time = MsqCalculateMessageTime(&LargeTickCount);
1108
1109     TRACE("Enter IntTranslateKbdMessage msg %s, vk %x\n",
1110         lpMsg->message == WM_SYSKEYDOWN ? "WM_SYSKEYDOWN" : "WM_KEYDOWN", lpMsg->wParam);
1111
1112     if (lpMsg->wParam == VK_PACKET)
1113     {
1114         NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
1115         NewMsg.wParam = HIWORD(lpMsg->lParam);
1116         NewMsg.lParam = LOWORD(lpMsg->lParam);
1117         MsqPostMessage(pti->MessageQueue, &NewMsg, FALSE, QS_KEY);
1118         return TRUE;
1119     }
1120
1121     cch = IntToUnicodeEx(lpMsg->wParam,
1122                          HIWORD(lpMsg->lParam) & 0xFF,
1123                          pti->MessageQueue->afKeyState,
1124                          wch,
1125                          sizeof(wch) / sizeof(wch[0]),
1126                          0,
1127                          pKbdTbl);
1128
1129     if (cch)
1130     {
1131         if (cch > 0) /* Normal characters */
1132             NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
1133         else /* Dead character */
1134         {
1135             cch = -cch;
1136             NewMsg.message =
1137                 (lpMsg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
1138         }
1139         NewMsg.lParam = lpMsg->lParam;
1140
1141         /* Send all characters */
1142         for (i = 0; i < cch; ++i)
1143         {
1144             TRACE("Msg: %x '%lc' (%04x) %08x\n", NewMsg.message, wch[i], wch[i], NewMsg.lParam);
1145             NewMsg.wParam = wch[i];
1146             MsqPostMessage(pti->MessageQueue, &NewMsg, FALSE, QS_KEY);
1147         }
1148         bResult = TRUE;
1149     }
1150
1151     TRACE("Leave IntTranslateKbdMessage ret %u, cch %d, msg %x, wch %x\n",
1152         bResult, cch, NewMsg.message, NewMsg.wParam);
1153     return bResult;
1154 }
1155
1156 /*
1157  * Map a virtual key code, or virtual scan code, to a scan code, key code,
1158  * or unshifted unicode character.
1159  *
1160  * Code: See Below
1161  * Type:
1162  * 0 -- Code is a virtual key code that is converted into a virtual scan code
1163  *      that does not distinguish between left and right shift keys.
1164  * 1 -- Code is a virtual scan code that is converted into a virtual key code
1165  *      that does not distinguish between left and right shift keys.
1166  * 2 -- Code is a virtual key code that is converted into an unshifted unicode
1167  *      character.
1168  * 3 -- Code is a virtual scan code that is converted into a virtual key code
1169  *      that distinguishes left and right shift keys.
1170  * KeyLayout: Keyboard layout handle
1171  *
1172  * @implemented
1173  */
1174 static UINT
1175 IntMapVirtualKeyEx(UINT uCode, UINT Type, PKBDTABLES pKbdTbl)
1176 {
1177     UINT uRet = 0;
1178
1179     switch (Type)
1180     {
1181         case MAPVK_VK_TO_VSC:
1182             uCode = IntFixVk(uCode, FALSE);
1183             uRet = IntVkToVsc(uCode, pKbdTbl);
1184             if (uRet > 0xFF) // Fail for scancodes with prefix (e0, e1)
1185                 uRet = 0;
1186             break;
1187
1188         case MAPVK_VSC_TO_VK:
1189             uRet = IntVscToVk(uCode, pKbdTbl) & 0xFF;
1190             uRet = IntSimplifyVk(uRet);
1191             break;
1192
1193         case MAPVK_VK_TO_CHAR:
1194             uRet = (UINT)IntVkToChar(uCode, pKbdTbl);
1195         break;
1196
1197         case MAPVK_VSC_TO_VK_EX:
1198             uRet = IntVscToVk(uCode, pKbdTbl) & 0xFF;
1199             break;
1200
1201         case MAPVK_VK_TO_VSC_EX:
1202             uRet = IntVkToVsc(uCode, pKbdTbl);
1203             break;
1204
1205         default:
1206             EngSetLastError(ERROR_INVALID_PARAMETER);
1207             ERR("Wrong type value: %u\n", Type);
1208     }
1209
1210     return uRet;
1211 }
1212
1213 /*
1214  * NtUserMapVirtualKeyEx
1215  *
1216  * Map a virtual key code, or virtual scan code, to a scan code, key code,
1217  * or unshifted unicode character. See IntMapVirtualKeyEx.
1218  */
1219 UINT
1220 APIENTRY
1221 NtUserMapVirtualKeyEx(UINT uCode, UINT uType, DWORD keyboardId, HKL dwhkl)
1222 {
1223     PKBDTABLES pKbdTbl = NULL;
1224     UINT ret = 0;
1225
1226     TRACE("Enter NtUserMapVirtualKeyEx\n");
1227     UserEnterShared();
1228
1229     if (!dwhkl)
1230     {
1231         PTHREADINFO pti;
1232
1233         pti = PsGetCurrentThreadWin32Thread();
1234         if (pti && pti->KeyboardLayout)
1235             pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
1236     }
1237     else
1238     {
1239         PKL pKl;
1240
1241         pKl = UserHklToKbl(dwhkl);
1242         if (pKl)
1243             pKbdTbl = pKl->spkf->pKbdTbl;
1244     }
1245
1246     if (pKbdTbl)
1247         ret = IntMapVirtualKeyEx(uCode, uType, pKbdTbl);
1248
1249     UserLeave();
1250     TRACE("Leave NtUserMapVirtualKeyEx, ret=%i\n", ret);
1251     return ret;
1252 }
1253
1254 /*
1255  * NtUserToUnicodeEx
1256  *
1257  * Translates virtual key to characters
1258  */
1259 int
1260 APIENTRY
1261 NtUserToUnicodeEx(
1262     UINT wVirtKey,
1263     UINT wScanCode,
1264     PBYTE pKeyStateUnsafe,
1265     LPWSTR pwszBuffUnsafe,
1266     INT cchBuff,
1267     UINT wFlags,
1268     HKL dwhkl)
1269 {
1270     PTHREADINFO pti;
1271     BYTE afKeyState[256 * 2 / 8] = {0};
1272     PWCHAR pwszBuff = NULL;
1273     INT i, iRet = 0;
1274     PKL pKl = NULL;
1275
1276     TRACE("Enter NtUserSetKeyboardState\n");
1277
1278     /* Return 0 if SC_KEY_UP bit is set */
1279     if (wScanCode & SC_KEY_UP || wVirtKey >= 0x100)
1280     {
1281         ERR("Invalid parameter\n");
1282         return 0;
1283     }
1284
1285     _SEH2_TRY
1286     {
1287         /* Probe and copy key state to smaller bitmap */
1288         ProbeForRead(pKeyStateUnsafe, 256 * sizeof(BYTE), 1);
1289         for (i = 0; i < 256; ++i)
1290         {
1291             if (pKeyStateUnsafe[i] & KS_DOWN_BIT)
1292                 SET_KEY_DOWN(afKeyState, i, TRUE);
1293             if (pKeyStateUnsafe[i] & KS_LOCK_BIT)
1294                 SET_KEY_LOCKED(afKeyState, i, TRUE);
1295         }
1296     }
1297     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1298     {
1299         ERR("Cannot copy key state\n");
1300         SetLastNtError(_SEH2_GetExceptionCode());
1301         _SEH2_YIELD(return 0);
1302     }
1303     _SEH2_END;
1304
1305     pwszBuff = ExAllocatePoolWithTag(NonPagedPool, sizeof(WCHAR) * cchBuff, TAG_STRING);
1306     if (!pwszBuff)
1307     {
1308         ERR("ExAllocatePoolWithTag(%d) failed\n", sizeof(WCHAR) * cchBuff);
1309         return 0;
1310     }
1311     RtlZeroMemory(pwszBuff, sizeof(WCHAR) * cchBuff);
1312
1313     UserEnterExclusive(); // Note: We modify wchDead static variable
1314
1315     if (dwhkl)
1316         pKl = UserHklToKbl(dwhkl);
1317
1318     if (!pKl)
1319     {
1320         pti = PsGetCurrentThreadWin32Thread();
1321         pKl = pti->KeyboardLayout;
1322     }
1323
1324     iRet = IntToUnicodeEx(wVirtKey,
1325                           wScanCode,
1326                           afKeyState,
1327                           pwszBuff,
1328                           cchBuff,
1329                           wFlags,
1330                           pKl ? pKl->spkf->pKbdTbl : NULL);
1331
1332     MmCopyToCaller(pwszBuffUnsafe, pwszBuff, cchBuff * sizeof(WCHAR));
1333     ExFreePoolWithTag(pwszBuff, TAG_STRING);
1334
1335     UserLeave();
1336     TRACE("Leave NtUserSetKeyboardState, ret=%i\n", iRet);
1337     return iRet;
1338 }
1339
1340 /*
1341  * NtUserGetKeyNameText
1342  *
1343  * Gets key name from keyboard layout
1344  */
1345 DWORD
1346 APIENTRY
1347 NtUserGetKeyNameText(LONG lParam, LPWSTR lpString, int cchSize)
1348 {
1349     PTHREADINFO pti;
1350     DWORD i, cchKeyName, dwRet = 0;
1351     WORD wScanCode = (lParam >> 16) & 0xFF;
1352     BOOL bExtKey = (HIWORD(lParam) & KF_EXTENDED) ? TRUE : FALSE;
1353     PKBDTABLES pKbdTbl;
1354     VSC_LPWSTR *pKeyNames = NULL;
1355     CONST WCHAR *pKeyName = NULL;
1356     WCHAR KeyNameBuf[2];
1357
1358     TRACE("Enter NtUserGetKeyNameText\n");
1359
1360     UserEnterShared();
1361
1362     /* Get current keyboard layout */
1363     pti = PsGetCurrentThreadWin32Thread();
1364     pKbdTbl = pti ? pti->KeyboardLayout->spkf->pKbdTbl : 0;
1365
1366     if (!pKbdTbl || cchSize < 1)
1367     {
1368         ERR("Invalid parameter\n");
1369         goto cleanup;
1370     }
1371
1372     /* "Do not care" flag */
1373     if(lParam & LP_DO_NOT_CARE_BIT)
1374     {
1375         /* Note: We could do vsc -> vk -> vsc conversion, instead of using
1376                  hardcoded scan codes, but it's not what Windows does */
1377         if (wScanCode == SCANCODE_RSHIFT && !bExtKey)
1378             wScanCode = SCANCODE_LSHIFT;
1379         else if (wScanCode == SCANCODE_CTRL || wScanCode == SCANCODE_ALT)
1380             bExtKey = FALSE;
1381     }
1382
1383     if (bExtKey)
1384         pKeyNames = pKbdTbl->pKeyNamesExt;
1385     else
1386         pKeyNames = pKbdTbl->pKeyNames;
1387
1388     for (i = 0; pKeyNames[i].pwsz; i++)
1389     {
1390         if (pKeyNames[i].vsc == wScanCode)
1391         {
1392             pKeyName = pKeyNames[i].pwsz;
1393             break;
1394         }
1395     }
1396
1397     if (!pKeyName)
1398     {
1399         WORD wVk = IntVscToVk(wScanCode, pKbdTbl);
1400
1401         if (wVk)
1402         {
1403             KeyNameBuf[0] = IntVkToChar(wVk, pKbdTbl);
1404             KeyNameBuf[1] = 0;
1405             if (KeyNameBuf[0])
1406                 pKeyName = KeyNameBuf;
1407         }
1408     }
1409
1410     if (pKeyName)
1411     {
1412         cchKeyName = wcslen(pKeyName);
1413         if (cchKeyName > (cchSize - 1UL))
1414             cchKeyName = cchSize - 1UL; // Don't count '\0'
1415
1416         _SEH2_TRY
1417         {
1418             ProbeForWrite(lpString, (cchKeyName + 1) * sizeof(WCHAR), 1);
1419             RtlCopyMemory(lpString, pKeyName, cchKeyName * sizeof(WCHAR));
1420             lpString[cchKeyName] = UNICODE_NULL;
1421             dwRet = cchKeyName;
1422         }
1423         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1424         {
1425             SetLastNtError(_SEH2_GetExceptionCode());
1426         }
1427         _SEH2_END;
1428     }
1429     else
1430     {
1431         EngSetLastError(ERROR_INVALID_PARAMETER);
1432     }
1433
1434 cleanup:
1435     UserLeave();
1436     TRACE("Leave NtUserGetKeyNameText, ret=%i\n", dwRet);
1437     return dwRet;
1438 }
1439
1440 /*
1441  * UserGetKeyboardType
1442  *
1443  * Returns some keyboard specific information
1444  */
1445 DWORD FASTCALL
1446 UserGetKeyboardType(
1447     DWORD dwTypeFlag)
1448 {
1449     switch (dwTypeFlag)
1450     {
1451         case 0:        /* Keyboard type */
1452             return 4;    /* AT-101 */
1453         case 1:        /* Keyboard Subtype */
1454             return 0;    /* There are no defined subtypes */
1455         case 2:        /* Number of F-keys */
1456             return 12;   /* We're doing an 101 for now, so return 12 F-keys */
1457         default:
1458             ERR("Unknown type!\n");
1459             return 0;    /* Note: we don't have to set last error here */
1460     }
1461 }
1462
1463 /*
1464  * NtUserVkKeyScanEx
1465  *
1466  * Based on IntTranslateChar, instead of processing VirtualKey match,
1467  * look for wChar match.
1468  */
1469 DWORD
1470 APIENTRY
1471 NtUserVkKeyScanEx(
1472     WCHAR wch,
1473     HKL dwhkl,
1474     BOOL bUsehKL)
1475 {
1476     PKBDTABLES pKbdTbl;
1477     PVK_TO_WCHAR_TABLE pVkToWchTbl;
1478     PVK_TO_WCHARS10 pVkToWch;
1479     PKL pKl = NULL;
1480     DWORD i, dwModBits = 0, dwModNumber = 0, Ret = (DWORD)-1;
1481
1482     TRACE("NtUserVkKeyScanEx() wch %d, KbdLayout 0x%p\n", wch, dwhkl);
1483     UserEnterShared();
1484
1485     if (bUsehKL)
1486     {
1487         // Use given keyboard layout
1488         if (dwhkl)
1489             pKl = UserHklToKbl(dwhkl);
1490     }
1491     else
1492     {
1493         // Use thread keyboard layout
1494         pKl = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->KeyboardLayout;
1495     }
1496
1497     if (!pKl)
1498         goto Exit;
1499
1500     pKbdTbl = pKl->spkf->pKbdTbl;
1501
1502     // Interate through all VkToWchar tables while pVkToWchars is not NULL
1503     for (i = 0; pKbdTbl->pVkToWcharTable[i].pVkToWchars; i++)
1504     {
1505         pVkToWchTbl = &pKbdTbl->pVkToWcharTable[i];
1506         pVkToWch = (PVK_TO_WCHARS10)(pVkToWchTbl->pVkToWchars);
1507
1508         // Interate through all virtual keys
1509         while (pVkToWch->VirtualKey)
1510         {
1511             for (dwModNumber = 0; dwModNumber < pVkToWchTbl->nModifications; dwModNumber++)
1512             {
1513                 if (pVkToWch->wch[dwModNumber] == wch)
1514                 {
1515                     dwModBits = pKbdTbl->pCharModifiers->ModNumber[dwModNumber];
1516                     TRACE("i %d wC %04x: dwModBits %08x dwModNumber %08x MaxModBits %08x\n",
1517                           i, wch, dwModBits, dwModNumber, pKbdTbl->pCharModifiers->wMaxModBits);
1518                     Ret = (dwModBits << 8) | (pVkToWch->VirtualKey & 0xFF);
1519                     goto Exit;
1520                 }
1521             }
1522             pVkToWch = (PVK_TO_WCHARS10)(((BYTE *)pVkToWch) + pVkToWchTbl->cbSize);
1523         }
1524     }
1525 Exit:
1526     UserLeave();
1527     return Ret;
1528 }
1529
1530 /* EOF */