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 we have a focus queue, post a keyboard message */
 807     pFocusQueue = IntGetFocusMessageQueue();
 808     TRACE("ProcessKeyEvent Q 0x%p Active pWnd 0x%p Focus pWnd 0x%p\n",
 809            pFocusQueue,
 810            (pFocusQueue ?  pFocusQueue->spwndActive : 0),
 811            (pFocusQueue ?  pFocusQueue->spwndFocus : 0));
 812
 813     /* If it is F10 or ALT is down and CTRL is up, it's a system key */
 814     if ( wVk == VK_F10 ||
 815         (wSimpleVk == VK_MENU && bMenuDownRecently) ||
 816         (IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) &&
 817         !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL)) ||
 818          // See MSDN WM_SYSKEYDOWN/UP fixes last wine Win test_keyboard_input.
 819         (pFocusQueue && !pFocusQueue->spwndFocus) )
 820     {
 821         bMenuDownRecently = FALSE; // reset
 822         if (bIsDown)
 823         {
 824             Msg.message = WM_SYSKEYDOWN;
 825             if (wSimpleVk == VK_MENU)
 826             {
 827                 // Note: If only LALT is pressed WM_SYSKEYUP is generated instead of WM_KEYUP
 828                 bMenuDownRecently = TRUE;
 829             }
 830         }
 831         else
 832             Msg.message = WM_SYSKEYUP;
 833     }
 834     else
 835     {
 836         if (bIsDown)
 837             Msg.message = WM_KEYDOWN;
 838         else
 839             Msg.message = WM_KEYUP;
 840     }
 841
 842     /* Update async state of not simplified vk here.
 843        See user32_apitest:GetKeyState */
 844     UpdateAsyncKeyState(wFixedVk, bIsDown);
 845
 846     /* Alt-Tab/Esc Check. Use FocusQueue or RIT Queue */
 847     if (bIsSimpleDown && !bWasSimpleDown &&
 848         IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) &&
 849         !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL) &&
 850         (wVk == VK_ESCAPE || wVk == VK_TAB))
 851     {
 852        TRACE("Alt-Tab/Esc Pressed wParam %x\n",wVk);
 853     }
 854
 855     if (bIsDown && wVk == VK_SNAPSHOT)
 856     {
 857         if (pFocusQueue &&
 858             IS_KEY_DOWN(gafAsyncKeyState, VK_MENU) &&
 859             !IS_KEY_DOWN(gafAsyncKeyState, VK_CONTROL))
 860         {
 861             // Snap from Active Window, Focus can be null.
 862             SnapWindow(pFocusQueue->spwndActive ? UserHMGetHandle(pFocusQueue->spwndActive) : 0);
 863         }
 864         else
 865             SnapWindow(NULL); // Snap Desktop.
 866     }
 867     else if (pFocusQueue && bPostMsg)
 868     {
 869         PWND Wnd = pFocusQueue->spwndFocus;
 870         if (!Wnd)
 871         {
 872            // Focus can be null so going with Active. WM_SYSKEYXXX last wine Win test_keyboard_input.
 873            Wnd = pFocusQueue->spwndActive;
 874         }
 875
 876         /* Init message */
 877         Msg.hwnd = UserHMGetHandle(Wnd);
 878         Msg.wParam = wFixedVk & 0xFF; /* Note: It's simplified by msg queue */
 879         Msg.lParam = MAKELPARAM(1, wScanCode);
 880         Msg.time = dwTime;
 881         Msg.pt = gpsi->ptCursor;
 882
 883         /* If it is VK_PACKET, high word of wParam is used for wchar */
 884         if (!bPacket)
 885         {
 886             if (bExt)
 887                 Msg.lParam |= KF_EXTENDED << 16;
 888             if (IS_KEY_DOWN(gafAsyncKeyState, VK_MENU))
 889                 Msg.lParam |= KF_ALTDOWN << 16;
 890             if (bWasSimpleDown)
 891                 Msg.lParam |= KF_REPEAT << 16;
 892             if (!bIsDown)
 893                 Msg.lParam |= KF_UP << 16;
 894             /* FIXME: Set KF_DLGMODE and KF_MENUMODE when needed */
 895             if (pFocusQueue->QF_flags & QF_DIALOGACTIVE)
 896                 Msg.lParam |= KF_DLGMODE << 16;
 897             if (pFocusQueue->MenuOwner) // pFocusQueue->MenuState) // MenuState needs a start flag...
 898                 Msg.lParam |= KF_MENUMODE << 16;
 899         }
 900
 901         /* Post a keyboard message */
 902         TRACE("Posting keyboard msg %u wParam 0x%x lParam 0x%x\n", Msg.message, Msg.wParam, Msg.lParam);
 903         MsqPostMessage(pFocusQueue, &Msg, TRUE, QS_KEY, 0);
 904     }
 905
 906     return TRUE;
 907 }
 908
 909 BOOL NTAPI
 910 UserSendKeyboardInput(KEYBDINPUT *pKbdInput, BOOL bInjected)
 911 {
 912     WORD wScanCode, wVk;
 913     PKL pKl = NULL;
 914     PKBDTABLES pKbdTbl;
 915     PUSER_MESSAGE_QUEUE pFocusQueue;
 916     struct _ETHREAD *pFocusThread;
 917     LARGE_INTEGER LargeTickCount;
 918     DWORD dwTime;
 919     BOOL bExt = (pKbdInput->dwFlags & KEYEVENTF_EXTENDEDKEY) ? TRUE : FALSE;
 920
 921     gppiInputProvider = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->ppi;
 922
 923     /* Find the target thread whose locale is in effect */
 924     pFocusQueue = IntGetFocusMessageQueue();
 925
 926     if (pFocusQueue)
 927     {
 928         pFocusThread = pFocusQueue->Thread;
 929         if (pFocusThread && pFocusThread->Tcb.Win32Thread)
 930             pKl = ((PTHREADINFO)pFocusThread->Tcb.Win32Thread)->KeyboardLayout;
 931     }
 932
 933     if (!pKl)
 934         pKl = W32kGetDefaultKeyLayout();
 935     if (!pKl)
 936     {
 937         ERR("No keyboard layout!\n");
 938         return FALSE;
 939     }
 940
 941     pKbdTbl = pKl->spkf->pKbdTbl;
 942
 943     /* Note: wScan field is always used */
 944     wScanCode = pKbdInput->wScan;
 945
 946     if (pKbdInput->dwFlags & KEYEVENTF_UNICODE)
 947     {
 948         /* Generate WM_KEYDOWN msg with wParam == VK_PACKET and
 949            high order word of lParam == pKbdInput->wScan */
 950         wVk = VK_PACKET;
 951     }
 952     else
 953     {
 954         wScanCode &= 0x7F;
 955         if (pKbdInput->dwFlags & KEYEVENTF_SCANCODE)
 956         {
 957             /* Don't ignore invalid scan codes */
 958             wVk = IntVscToVk(wScanCode | (bExt ? 0xE000 : 0), pKbdTbl);
 959             if (!wVk) /* use 0xFF if vsc is invalid */
 960                 wVk = 0xFF;
 961         }
 962         else
 963         {
 964             wVk = pKbdInput->wVk & 0xFF;
 965         }
 966     }
 967
 968     /* If time is given, use it */
 969     if (pKbdInput->time)
 970         dwTime = pKbdInput->time;
 971     else
 972     {
 973         KeQueryTickCount(&LargeTickCount);
 974         dwTime = MsqCalculateMessageTime(&LargeTickCount);
 975     }
 976
 977     if (wVk == VK_RMENU && (pKbdTbl->fLocaleFlags & KLLF_ALTGR))
 978     {
 979         /* For AltGr keyboards RALT generates CTRL events */
 980         ProcessKeyEvent(VK_LCONTROL, 0, pKbdInput->dwFlags & KEYEVENTF_KEYUP, bInjected, dwTime, 0);
 981     }
 982
 983     /* Finally process this key */
 984     return ProcessKeyEvent(wVk, wScanCode, pKbdInput->dwFlags, bInjected, dwTime, pKbdInput->dwExtraInfo);
 985 }
 986
 987 /*
 988  * UserProcessKeyboardInput
 989  *
 990  * Process raw keyboard input data
 991  */
 992 VOID NTAPI
 993 UserProcessKeyboardInput(
 994     PKEYBOARD_INPUT_DATA pKbdInputData)
 995 {
 996     WORD wScanCode, wVk;
 997     PKL pKl = NULL;
 998     PKBDTABLES pKbdTbl;
 999     PUSER_MESSAGE_QUEUE pFocusQueue;
1000     struct _ETHREAD *pFocusThread;
1001
1002     /* Calculate scan code with prefix */
1003     wScanCode = pKbdInputData->MakeCode & 0x7F;
1004     if (pKbdInputData->Flags & KEY_E0)
1005         wScanCode |= 0xE000;
1006     if (pKbdInputData->Flags & KEY_E1)
1007         wScanCode |= 0xE100;
1008
1009     /* Find the target thread whose locale is in effect */
1010     pFocusQueue = IntGetFocusMessageQueue();
1011
1012     if (pFocusQueue)
1013     {
1014         pFocusThread = pFocusQueue->Thread;
1015         if (pFocusThread && pFocusThread->Tcb.Win32Thread)
1016             pKl = ((PTHREADINFO)pFocusThread->Tcb.Win32Thread)->KeyboardLayout;
1017     }
1018
1019     if (!pKl)
1020         pKl = W32kGetDefaultKeyLayout();
1021     if (!pKl)
1022         return;
1023
1024     pKbdTbl = pKl->spkf->pKbdTbl;
1025
1026     /* Convert scan code to virtual key.
1027        Note: We could call UserSendKeyboardInput using scan code,
1028              but it wouldn't interpret E1 key(s) properly */
1029     wVk = IntVscToVk(wScanCode, pKbdTbl);
1030     TRACE("UserProcessKeyboardInput: %x (break: %u) -> %x\n",
1031           wScanCode, (pKbdInputData->Flags & KEY_BREAK) ? 1 : 0, wVk);
1032
1033     if (wVk)
1034     {
1035         KEYBDINPUT KbdInput;
1036
1037         /* Support numlock */
1038         if ((wVk & KBDNUMPAD) && IS_KEY_LOCKED(gafAsyncKeyState, VK_NUMLOCK))
1039         {
1040             wVk = IntTranslateNumpadKey(wVk & 0xFF);
1041         }
1042
1043         /* Send keyboard input */
1044         KbdInput.wVk = wVk & 0xFF;
1045         KbdInput.wScan = wScanCode & 0x7F;
1046         KbdInput.dwFlags = 0;
1047         if (pKbdInputData->Flags & KEY_BREAK)
1048             KbdInput.dwFlags |= KEYEVENTF_KEYUP;
1049         if (wVk & KBDEXT)
1050             KbdInput.dwFlags |= KEYEVENTF_EXTENDEDKEY;
1051         KbdInput.time = 0;
1052         KbdInput.dwExtraInfo = pKbdInputData->ExtraInformation;
1053         UserSendKeyboardInput(&KbdInput, FALSE);
1054
1055         /* E1 keys don't have break code */
1056         if (pKbdInputData->Flags & KEY_E1)
1057         {
1058             /* Send key up event */
1059             KbdInput.dwFlags |= KEYEVENTF_KEYUP;
1060             UserSendKeyboardInput(&KbdInput, FALSE);
1061         }
1062     }
1063 }
1064
1065 /*
1066  * IntTranslateKbdMessage
1067  *
1068  * Addes WM_(SYS)CHAR messages to message queue if message
1069  * describes key which produce character.
1070  */
1071 BOOL FASTCALL
1072 IntTranslateKbdMessage(LPMSG lpMsg,
1073                        UINT flags)
1074 {
1075     PTHREADINFO pti;
1076     INT cch = 0, i;
1077     WCHAR wch[3] = { 0 };
1078     MSG NewMsg = { 0 };
1079     PKBDTABLES pKbdTbl;
1080     LARGE_INTEGER LargeTickCount;
1081     BOOL bResult = FALSE;
1082
1083     switch(lpMsg->message)
1084     {
1085        case WM_KEYDOWN:
1086        case WM_KEYUP:
1087        case WM_SYSKEYDOWN:
1088        case WM_SYSKEYUP:
1089           break;
1090        default:
1091           return FALSE;
1092     }
1093
1094     pti = PsGetCurrentThreadWin32Thread();
1095
1096     if (!pti->KeyboardLayout)
1097     {
1098        pti->KeyboardLayout = W32kGetDefaultKeyLayout();
1099        pti->pClientInfo->hKL = pti->KeyboardLayout ? pti->KeyboardLayout->hkl : NULL;
1100        pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
1101     }
1102     else
1103        pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
1104     if (!pKbdTbl)
1105         return FALSE;
1106
1107     if (lpMsg->message != WM_KEYDOWN && lpMsg->message != WM_SYSKEYDOWN)
1108         return FALSE;
1109
1110     /* Init pt, hwnd and time msg fields */
1111     NewMsg.pt = gpsi->ptCursor;
1112     NewMsg.hwnd = lpMsg->hwnd;
1113     KeQueryTickCount(&LargeTickCount);
1114     NewMsg.time = MsqCalculateMessageTime(&LargeTickCount);
1115
1116     TRACE("Enter IntTranslateKbdMessage msg %s, vk %x\n",
1117         lpMsg->message == WM_SYSKEYDOWN ? "WM_SYSKEYDOWN" : "WM_KEYDOWN", lpMsg->wParam);
1118
1119     if (lpMsg->wParam == VK_PACKET)
1120     {
1121         NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
1122         NewMsg.wParam = HIWORD(lpMsg->lParam);
1123         NewMsg.lParam = LOWORD(lpMsg->lParam);
1124         MsqPostMessage(pti->MessageQueue, &NewMsg, FALSE, QS_KEY, 0);
1125         return TRUE;
1126     }
1127
1128     cch = IntToUnicodeEx(lpMsg->wParam,
1129                          HIWORD(lpMsg->lParam) & 0xFF,
1130                          pti->MessageQueue->afKeyState,
1131                          wch,
1132                          sizeof(wch) / sizeof(wch[0]),
1133                          0,
1134                          pKbdTbl);
1135
1136     if (cch)
1137     {
1138         if (cch > 0) /* Normal characters */
1139             NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
1140         else /* Dead character */
1141         {
1142             cch = -cch;
1143             NewMsg.message =
1144                 (lpMsg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
1145         }
1146         NewMsg.lParam = lpMsg->lParam;
1147
1148         /* Send all characters */
1149         for (i = 0; i < cch; ++i)
1150         {
1151             TRACE("Msg: %x '%lc' (%04x) %08x\n", NewMsg.message, wch[i], wch[i], NewMsg.lParam);
1152             NewMsg.wParam = wch[i];
1153             MsqPostMessage(pti->MessageQueue, &NewMsg, FALSE, QS_KEY, 0);
1154         }
1155         bResult = TRUE;
1156     }
1157
1158     TRACE("Leave IntTranslateKbdMessage ret %u, cch %d, msg %x, wch %x\n",
1159         bResult, cch, NewMsg.message, NewMsg.wParam);
1160     return bResult;
1161 }
1162
1163 /*
1164  * Map a virtual key code, or virtual scan code, to a scan code, key code,
1165  * or unshifted unicode character.
1166  *
1167  * Code: See Below
1168  * Type:
1169  * 0 -- Code is a virtual key code that is converted into a virtual scan code
1170  *      that does not distinguish between left and right shift keys.
1171  * 1 -- Code is a virtual scan code that is converted into a virtual key code
1172  *      that does not distinguish between left and right shift keys.
1173  * 2 -- Code is a virtual key code that is converted into an unshifted unicode
1174  *      character.
1175  * 3 -- Code is a virtual scan code that is converted into a virtual key code
1176  *      that distinguishes left and right shift keys.
1177  * KeyLayout: Keyboard layout handle
1178  *
1179  * @implemented
1180  */
1181 static UINT
1182 IntMapVirtualKeyEx(UINT uCode, UINT Type, PKBDTABLES pKbdTbl)
1183 {
1184     UINT uRet = 0;
1185
1186     switch (Type)
1187     {
1188         case MAPVK_VK_TO_VSC:
1189             uCode = IntFixVk(uCode, FALSE);
1190             uRet = IntVkToVsc(uCode, pKbdTbl);
1191             if (uRet > 0xFF) // Fail for scancodes with prefix (e0, e1)
1192                 uRet = 0;
1193             break;
1194
1195         case MAPVK_VSC_TO_VK:
1196             uRet = IntVscToVk(uCode, pKbdTbl) & 0xFF;
1197             uRet = IntSimplifyVk(uRet);
1198             break;
1199
1200         case MAPVK_VK_TO_CHAR:
1201             uRet = (UINT)IntVkToChar(uCode, pKbdTbl);
1202         break;
1203
1204         case MAPVK_VSC_TO_VK_EX:
1205             uRet = IntVscToVk(uCode, pKbdTbl) & 0xFF;
1206             break;
1207
1208         case MAPVK_VK_TO_VSC_EX:
1209             uRet = IntVkToVsc(uCode, pKbdTbl);
1210             break;
1211
1212         default:
1213             EngSetLastError(ERROR_INVALID_PARAMETER);
1214             ERR("Wrong type value: %u\n", Type);
1215     }
1216
1217     return uRet;
1218 }
1219
1220 /*
1221  * NtUserMapVirtualKeyEx
1222  *
1223  * Map a virtual key code, or virtual scan code, to a scan code, key code,
1224  * or unshifted unicode character. See IntMapVirtualKeyEx.
1225  */
1226 UINT
1227 APIENTRY
1228 NtUserMapVirtualKeyEx(UINT uCode, UINT uType, DWORD keyboardId, HKL dwhkl)
1229 {
1230     PKBDTABLES pKbdTbl = NULL;
1231     UINT ret = 0;
1232
1233     TRACE("Enter NtUserMapVirtualKeyEx\n");
1234     UserEnterShared();
1235
1236     if (!dwhkl)
1237     {
1238         PTHREADINFO pti;
1239
1240         pti = PsGetCurrentThreadWin32Thread();
1241         if (pti && pti->KeyboardLayout)
1242             pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
1243     }
1244     else
1245     {
1246         PKL pKl;
1247
1248         pKl = UserHklToKbl(dwhkl);
1249         if (pKl)
1250             pKbdTbl = pKl->spkf->pKbdTbl;
1251     }
1252
1253     if (pKbdTbl)
1254         ret = IntMapVirtualKeyEx(uCode, uType, pKbdTbl);
1255
1256     UserLeave();
1257     TRACE("Leave NtUserMapVirtualKeyEx, ret=%i\n", ret);
1258     return ret;
1259 }
1260
1261 /*
1262  * NtUserToUnicodeEx
1263  *
1264  * Translates virtual key to characters
1265  */
1266 int
1267 APIENTRY
1268 NtUserToUnicodeEx(
1269     UINT wVirtKey,
1270     UINT wScanCode,
1271     PBYTE pKeyStateUnsafe,
1272     LPWSTR pwszBuffUnsafe,
1273     INT cchBuff,
1274     UINT wFlags,
1275     HKL dwhkl)
1276 {
1277     PTHREADINFO pti;
1278     BYTE afKeyState[256 * 2 / 8] = {0};
1279     PWCHAR pwszBuff = NULL;
1280     INT i, iRet = 0;
1281     PKL pKl = NULL;
1282
1283     TRACE("Enter NtUserSetKeyboardState\n");
1284
1285     /* Return 0 if SC_KEY_UP bit is set */
1286     if (wScanCode & SC_KEY_UP || wVirtKey >= 0x100)
1287     {
1288         ERR("Invalid parameter\n");
1289         return 0;
1290     }
1291
1292     _SEH2_TRY
1293     {
1294         /* Probe and copy key state to smaller bitmap */
1295         ProbeForRead(pKeyStateUnsafe, 256 * sizeof(BYTE), 1);
1296         for (i = 0; i < 256; ++i)
1297         {
1298             if (pKeyStateUnsafe[i] & KS_DOWN_BIT)
1299                 SET_KEY_DOWN(afKeyState, i, TRUE);
1300             if (pKeyStateUnsafe[i] & KS_LOCK_BIT)
1301                 SET_KEY_LOCKED(afKeyState, i, TRUE);
1302         }
1303     }
1304     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1305     {
1306         ERR("Cannot copy key state\n");
1307         SetLastNtError(_SEH2_GetExceptionCode());
1308         _SEH2_YIELD(return 0);
1309     }
1310     _SEH2_END;
1311
1312     pwszBuff = ExAllocatePoolWithTag(NonPagedPool, sizeof(WCHAR) * cchBuff, TAG_STRING);
1313     if (!pwszBuff)
1314     {
1315         ERR("ExAllocatePoolWithTag(%d) failed\n", sizeof(WCHAR) * cchBuff);
1316         return 0;
1317     }
1318     RtlZeroMemory(pwszBuff, sizeof(WCHAR) * cchBuff);
1319
1320     UserEnterExclusive(); // Note: We modify wchDead static variable
1321
1322     if (dwhkl)
1323         pKl = UserHklToKbl(dwhkl);
1324
1325     if (!pKl)
1326     {
1327         pti = PsGetCurrentThreadWin32Thread();
1328         pKl = pti->KeyboardLayout;
1329     }
1330
1331     iRet = IntToUnicodeEx(wVirtKey,
1332                           wScanCode,
1333                           afKeyState,
1334                           pwszBuff,
1335                           cchBuff,
1336                           wFlags,
1337                           pKl ? pKl->spkf->pKbdTbl : NULL);
1338
1339     MmCopyToCaller(pwszBuffUnsafe, pwszBuff, cchBuff * sizeof(WCHAR));
1340     ExFreePoolWithTag(pwszBuff, TAG_STRING);
1341
1342     UserLeave();
1343     TRACE("Leave NtUserSetKeyboardState, ret=%i\n", iRet);
1344     return iRet;
1345 }
1346
1347 /*
1348  * NtUserGetKeyNameText
1349  *
1350  * Gets key name from keyboard layout
1351  */
1352 DWORD
1353 APIENTRY
1354 NtUserGetKeyNameText(LONG lParam, LPWSTR lpString, int cchSize)
1355 {
1356     PTHREADINFO pti;
1357     DWORD i, cchKeyName, dwRet = 0;
1358     WORD wScanCode = (lParam >> 16) & 0xFF;
1359     BOOL bExtKey = (HIWORD(lParam) & KF_EXTENDED) ? TRUE : FALSE;
1360     PKBDTABLES pKbdTbl;
1361     VSC_LPWSTR *pKeyNames = NULL;
1362     CONST WCHAR *pKeyName = NULL;
1363     WCHAR KeyNameBuf[2];
1364
1365     TRACE("Enter NtUserGetKeyNameText\n");
1366
1367     UserEnterShared();
1368
1369     /* Get current keyboard layout */
1370     pti = PsGetCurrentThreadWin32Thread();
1371     pKbdTbl = pti ? pti->KeyboardLayout->spkf->pKbdTbl : 0;
1372
1373     if (!pKbdTbl || cchSize < 1)
1374     {
1375         ERR("Invalid parameter\n");
1376         goto cleanup;
1377     }
1378
1379     /* "Do not care" flag */
1380     if(lParam & LP_DO_NOT_CARE_BIT)
1381     {
1382         /* Note: We could do vsc -> vk -> vsc conversion, instead of using
1383                  hardcoded scan codes, but it's not what Windows does */
1384         if (wScanCode == SCANCODE_RSHIFT && !bExtKey)
1385             wScanCode = SCANCODE_LSHIFT;
1386         else if (wScanCode == SCANCODE_CTRL || wScanCode == SCANCODE_ALT)
1387             bExtKey = FALSE;
1388     }
1389
1390     if (bExtKey)
1391         pKeyNames = pKbdTbl->pKeyNamesExt;
1392     else
1393         pKeyNames = pKbdTbl->pKeyNames;
1394
1395     for (i = 0; pKeyNames[i].pwsz; i++)
1396     {
1397         if (pKeyNames[i].vsc == wScanCode)
1398         {
1399             pKeyName = pKeyNames[i].pwsz;
1400             break;
1401         }
1402     }
1403
1404     if (!pKeyName)
1405     {
1406         WORD wVk = IntVscToVk(wScanCode, pKbdTbl);
1407
1408         if (wVk)
1409         {
1410             KeyNameBuf[0] = IntVkToChar(wVk, pKbdTbl);
1411             KeyNameBuf[1] = 0;
1412             if (KeyNameBuf[0])
1413                 pKeyName = KeyNameBuf;
1414         }
1415     }
1416
1417     if (pKeyName)
1418     {
1419         cchKeyName = wcslen(pKeyName);
1420         if (cchKeyName > (cchSize - 1UL))
1421             cchKeyName = cchSize - 1UL; // Don't count '\0'
1422
1423         _SEH2_TRY
1424         {
1425             ProbeForWrite(lpString, (cchKeyName + 1) * sizeof(WCHAR), 1);
1426             RtlCopyMemory(lpString, pKeyName, cchKeyName * sizeof(WCHAR));
1427             lpString[cchKeyName] = UNICODE_NULL;
1428             dwRet = cchKeyName;
1429         }
1430         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1431         {
1432             SetLastNtError(_SEH2_GetExceptionCode());
1433         }
1434         _SEH2_END;
1435     }
1436     else
1437     {
1438         EngSetLastError(ERROR_INVALID_PARAMETER);
1439     }
1440
1441 cleanup:
1442     UserLeave();
1443     TRACE("Leave NtUserGetKeyNameText, ret=%i\n", dwRet);
1444     return dwRet;
1445 }
1446
1447 /*
1448  * UserGetKeyboardType
1449  *
1450  * Returns some keyboard specific information
1451  */
1452 DWORD FASTCALL
1453 UserGetKeyboardType(
1454     DWORD dwTypeFlag)
1455 {
1456     switch (dwTypeFlag)
1457     {
1458         case 0:        /* Keyboard type */
1459             return 4;    /* AT-101 */
1460         case 1:        /* Keyboard Subtype */
1461             return 0;    /* There are no defined subtypes */
1462         case 2:        /* Number of F-keys */
1463             return 12;   /* We're doing an 101 for now, so return 12 F-keys */
1464         default:
1465             ERR("Unknown type!\n");
1466             return 0;    /* Note: we don't have to set last error here */
1467     }
1468 }
1469
1470 /*
1471  * NtUserVkKeyScanEx
1472  *
1473  * Based on IntTranslateChar, instead of processing VirtualKey match,
1474  * look for wChar match.
1475  */
1476 DWORD
1477 APIENTRY
1478 NtUserVkKeyScanEx(
1479     WCHAR wch,
1480     HKL dwhkl,
1481     BOOL bUsehKL)
1482 {
1483     PKBDTABLES pKbdTbl;
1484     PVK_TO_WCHAR_TABLE pVkToWchTbl;
1485     PVK_TO_WCHARS10 pVkToWch;
1486     PKL pKl = NULL;
1487     DWORD i, dwModBits = 0, dwModNumber = 0, Ret = (DWORD)-1;
1488
1489     TRACE("NtUserVkKeyScanEx() wch %d, KbdLayout 0x%p\n", wch, dwhkl);
1490     UserEnterShared();
1491
1492     if (bUsehKL)
1493     {
1494         // Use given keyboard layout
1495         if (dwhkl)
1496             pKl = UserHklToKbl(dwhkl);
1497     }
1498     else
1499     {
1500         // Use thread keyboard layout
1501         pKl = ((PTHREADINFO)PsGetCurrentThreadWin32Thread())->KeyboardLayout;
1502     }
1503
1504     if (!pKl)
1505         goto Exit;
1506
1507     pKbdTbl = pKl->spkf->pKbdTbl;
1508
1509     // Interate through all VkToWchar tables while pVkToWchars is not NULL
1510     for (i = 0; pKbdTbl->pVkToWcharTable[i].pVkToWchars; i++)
1511     {
1512         pVkToWchTbl = &pKbdTbl->pVkToWcharTable[i];
1513         pVkToWch = (PVK_TO_WCHARS10)(pVkToWchTbl->pVkToWchars);
1514
1515         // Interate through all virtual keys
1516         while (pVkToWch->VirtualKey)
1517         {
1518             for (dwModNumber = 0; dwModNumber < pVkToWchTbl->nModifications; dwModNumber++)
1519             {
1520                 if (pVkToWch->wch[dwModNumber] == wch)
1521                 {
1522                     dwModBits = pKbdTbl->pCharModifiers->ModNumber[dwModNumber];
1523                     TRACE("i %d wC %04x: dwModBits %08x dwModNumber %08x MaxModBits %08x\n",
1524                           i, wch, dwModBits, dwModNumber, pKbdTbl->pCharModifiers->wMaxModBits);
1525                     Ret = (dwModBits << 8) | (pVkToWch->VirtualKey & 0xFF);
1526                     goto Exit;
1527                 }
1528             }
1529             pVkToWch = (PVK_TO_WCHARS10)(((BYTE *)pVkToWch) + pVkToWchTbl->cbSize);
1530         }
1531     }
1532 Exit:
1533     UserLeave();
1534     return Ret;
1535 }
1536
1537 /* EOF */