win32ss/user/user32/windows/input.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 1998, 1999, 2000, 2001 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19 /*
  20  * PROJECT:         ReactOS user32.dll
  21  * FILE:            win32ss/user/user32/windows/input.c
  22  * PURPOSE:         Input
  23  * PROGRAMMER:      Casper S. Hornstrup (chorns@users.sourceforge.net)
  24  * UPDATE HISTORY:
  25  *      09-05-2001  CSH  Created
  26  */
  27
  28 #include <user32.h>
  29
  30 #include <strsafe.h>
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(user32);
  33
  34 /*
  35  * @implemented
  36  */
  37 BOOL
  38 WINAPI
  39 DragDetect(
  40     HWND hWnd,
  41     POINT pt)
  42 {
  43     return NtUserDragDetect(hWnd, pt);
  44 #if 0
  45     MSG msg;
  46     RECT rect;
  47     POINT tmp;
  48     ULONG dx = GetSystemMetrics(SM_CXDRAG);
  49     ULONG dy = GetSystemMetrics(SM_CYDRAG);
  50
  51     rect.left = pt.x - dx;
  52     rect.right = pt.x + dx;
  53     rect.top = pt.y - dy;
  54     rect.bottom = pt.y + dy;
  55
  56     SetCapture(hWnd);
  57
  58     for (;;)
  59     {
  60         while (
  61             PeekMessageW(&msg, 0, WM_MOUSEFIRST, WM_MOUSELAST, PM_REMOVE) ||
  62             PeekMessageW(&msg, 0, WM_KEYFIRST,   WM_KEYLAST,   PM_REMOVE)
  63         )
  64         {
  65             if (msg.message == WM_LBUTTONUP)
  66             {
  67                 ReleaseCapture();
  68                 return FALSE;
  69             }
  70             if (msg.message == WM_MOUSEMOVE)
  71             {
  72                 tmp.x = LOWORD(msg.lParam);
  73                 tmp.y = HIWORD(msg.lParam);
  74                 if (!PtInRect(&rect, tmp))
  75                 {
  76                     ReleaseCapture();
  77                     return TRUE;
  78                 }
  79             }
  80             if (msg.message == WM_KEYDOWN)
  81             {
  82                 if (msg.wParam == VK_ESCAPE)
  83                 {
  84                     ReleaseCapture();
  85                     return TRUE;
  86                 }
  87             }
  88         }
  89         WaitMessage();
  90     }
  91     return 0;
  92 #endif
  93 }
  94
  95 /*
  96  * @implemented
  97  */
  98 BOOL WINAPI
  99 EnableWindow(HWND hWnd, BOOL bEnable)
 100 {
 101     return NtUserxEnableWindow(hWnd, bEnable);
 102 }
 103
 104 /*
 105  * @implemented
 106  */
 107 SHORT
 108 WINAPI
 109 DECLSPEC_HOTPATCH
 110 GetAsyncKeyState(int vKey)
 111 {
 112     if (vKey < 0 || vKey > 256)
 113         return 0;
 114     return (SHORT)NtUserGetAsyncKeyState((DWORD)vKey);
 115 }
 116
 117
 118 /*
 119  * @implemented
 120  */
 121 HKL WINAPI
 122 GetKeyboardLayout(DWORD idThread)
 123 {
 124     return NtUserxGetKeyboardLayout(idThread);
 125 }
 126
 127
 128 /*
 129  * @implemented
 130  */
 131 UINT WINAPI
 132 GetKBCodePage(VOID)
 133 {
 134     return GetOEMCP();
 135 }
 136
 137
 138 /*
 139  * @implemented
 140  */
 141 int WINAPI
 142 GetKeyNameTextA(LONG lParam,
 143                 LPSTR lpString,
 144                 int nSize)
 145 {
 146     LPWSTR pwszBuf;
 147     UINT cchBuf = 0;
 148     int iRet = 0;
 149     BOOL defChar = FALSE;
 150
 151     pwszBuf = HeapAlloc(GetProcessHeap(), 0, nSize * sizeof(WCHAR));
 152     if (!pwszBuf)
 153         return 0;
 154
 155     cchBuf = NtUserGetKeyNameText(lParam, pwszBuf, nSize);
 156
 157     iRet = WideCharToMultiByte(CP_ACP, 0,
 158                               pwszBuf, cchBuf,
 159                               lpString, nSize, ".", &defChar); // FIXME: do we need defChar?
 160     lpString[iRet] = 0;
 161     HeapFree(GetProcessHeap(), 0, pwszBuf);
 162
 163     return iRet;
 164 }
 165
 166 /*
 167  * @implemented
 168  */
 169 int WINAPI
 170 GetKeyNameTextW(LONG lParam,
 171                 LPWSTR lpString,
 172                 int nSize)
 173 {
 174     return NtUserGetKeyNameText(lParam, lpString, nSize);
 175 }
 176
 177 /*
 178  * @implemented
 179  */
 180 SHORT
 181 WINAPI
 182 DECLSPEC_HOTPATCH
 183 GetKeyState(int nVirtKey)
 184 {
 185     return (SHORT)NtUserGetKeyState((DWORD)nVirtKey);
 186 }
 187
 188 /*
 189  * @implemented
 190  */
 191 BOOL WINAPI
 192 GetKeyboardLayoutNameA(LPSTR pwszKLID)
 193 {
 194     WCHAR buf[KL_NAMELENGTH];
 195
 196     if (!GetKeyboardLayoutNameW(buf))
 197         return FALSE;
 198
 199     if (!WideCharToMultiByte(CP_ACP, 0, buf, -1, pwszKLID, KL_NAMELENGTH, NULL, NULL))
 200         return FALSE;
 201
 202     return TRUE;
 203 }
 204
 205 /*
 206  * @implemented
 207  */
 208 BOOL WINAPI
 209 GetKeyboardLayoutNameW(LPWSTR pwszKLID)
 210 {
 211     return NtUserGetKeyboardLayoutName(pwszKLID);
 212 }
 213
 214 /*
 215  * @implemented
 216  */
 217 int WINAPI
 218 GetKeyboardType(int nTypeFlag)
 219 {
 220     return NtUserxGetKeyboardType(nTypeFlag);
 221 }
 222
 223 /*
 224  * @implemented
 225  */
 226 BOOL WINAPI
 227 GetLastInputInfo(PLASTINPUTINFO plii)
 228 {
 229     TRACE("%p\n", plii);
 230
 231     if (plii->cbSize != sizeof (*plii))
 232     {
 233         SetLastError(ERROR_INVALID_PARAMETER);
 234         return FALSE;
 235     }
 236
 237     plii->dwTime = gpsi->dwLastRITEventTickCount;
 238     return TRUE;
 239 }
 240
 241 /*
 242  * @implemented
 243  */
 244 HKL WINAPI
 245 LoadKeyboardLayoutA(LPCSTR pszKLID,
 246                     UINT Flags)
 247 {
 248     WCHAR wszKLID[16];
 249
 250     if (!MultiByteToWideChar(CP_ACP, 0, pszKLID, -1,
 251                              wszKLID, sizeof(wszKLID)/sizeof(wszKLID[0])))
 252     {
 253         return FALSE;
 254     }
 255
 256     return LoadKeyboardLayoutW(wszKLID, Flags);
 257 }
 258
 259 /*
 260  * @implemented
 261  */
 262 HKL WINAPI
 263 LoadKeyboardLayoutW(LPCWSTR pwszKLID,
 264                     UINT Flags)
 265 {
 266     DWORD dwhkl, dwType, dwSize;
 267     UNICODE_STRING ustrKbdName;
 268     UNICODE_STRING ustrKLID;
 269     WCHAR wszRegKey[256] = L"SYSTEM\\CurrentControlSet\\Control\\Keyboard Layouts\\";
 270     WCHAR wszLayoutId[10], wszNewKLID[10];
 271     HKEY hKey;
 272
 273     /* LOWORD of dwhkl is Locale Identifier */
 274     dwhkl = LOWORD(wcstoul(pwszKLID, NULL, 16));
 275
 276     if (Flags & KLF_SUBSTITUTE_OK)
 277     {
 278         /* Check substitutes key */
 279         if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Keyboard Layout\\Substitutes", 0,
 280                           KEY_READ, &hKey) == ERROR_SUCCESS)
 281         {
 282             dwSize = sizeof(wszNewKLID);
 283             if (RegQueryValueExW(hKey, pwszKLID, NULL, &dwType, (LPBYTE)wszNewKLID, &dwSize) == ERROR_SUCCESS)
 284             {
 285                 /* Use new KLID value */
 286                 pwszKLID = wszNewKLID;
 287             }
 288
 289             /* Close the key now */
 290             RegCloseKey(hKey);
 291         }
 292     }
 293
 294     /* Append KLID at the end of registry key */
 295     StringCbCatW(wszRegKey, sizeof(wszRegKey), pwszKLID);
 296
 297     /* Open layout registry key for read */
 298     if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszRegKey, 0,
 299                       KEY_READ, &hKey) == ERROR_SUCCESS)
 300     {
 301         dwSize = sizeof(wszLayoutId);
 302         if (RegQueryValueExW(hKey, L"Layout Id", NULL, &dwType, (LPBYTE)wszLayoutId, &dwSize) == ERROR_SUCCESS)
 303         {
 304             /* If Layout Id is specified, use this value | f000 as HIWORD */
 305             /* FIXME: Microsoft Office expects this value to be something specific
 306              * for Japanese and Korean Windows with an IME the value is 0xe001
 307              * We should probably check to see if an IME exists and if so then
 308              * set this word properly.
 309              */
 310             dwhkl |= (0xf000 | wcstol(wszLayoutId, NULL, 16)) << 16;
 311         }
 312
 313         /* Close the key now */
 314         RegCloseKey(hKey);
 315     }
 316     else
 317     {
 318         ERR("Could not find keyboard layout %S.\n", pwszKLID);
 319         return NULL;
 320     }
 321
 322     /* If Layout Id is not given HIWORD == LOWORD (for dwhkl) */
 323     if (!HIWORD(dwhkl))
 324         dwhkl |= dwhkl << 16;
 325
 326     ZeroMemory(&ustrKbdName, sizeof(ustrKbdName));
 327     RtlInitUnicodeString(&ustrKLID, pwszKLID);
 328     return NtUserLoadKeyboardLayoutEx(NULL, 0, &ustrKbdName,
 329                                       NULL, &ustrKLID,
 330                                       dwhkl, Flags);
 331 }
 332
 333 /*
 334  * @implemented
 335  */
 336 UINT WINAPI
 337 MapVirtualKeyA(UINT uCode,
 338                UINT uMapType)
 339 {
 340     return MapVirtualKeyExA(uCode, uMapType, GetKeyboardLayout(0));
 341 }
 342
 343 /*
 344  * @implemented
 345  */
 346 UINT WINAPI
 347 MapVirtualKeyExA(UINT uCode,
 348                  UINT uMapType,
 349                  HKL dwhkl)
 350 {
 351     return MapVirtualKeyExW(uCode, uMapType, dwhkl);
 352 }
 353
 354
 355 /*
 356  * @implemented
 357  */
 358 UINT WINAPI
 359 MapVirtualKeyExW(UINT uCode,
 360                  UINT uMapType,
 361                  HKL dwhkl)
 362 {
 363     return NtUserMapVirtualKeyEx(uCode, uMapType, 0, dwhkl);
 364 }
 365
 366
 367 /*
 368  * @implemented
 369  */
 370 UINT WINAPI
 371 MapVirtualKeyW(UINT uCode,
 372                UINT uMapType)
 373 {
 374     return MapVirtualKeyExW(uCode, uMapType, GetKeyboardLayout(0));
 375 }
 376
 377
 378 /*
 379  * @implemented
 380  */
 381 DWORD WINAPI
 382 OemKeyScan(WORD wOemChar)
 383 {
 384     WCHAR p;
 385     SHORT Vk;
 386     UINT Scan;
 387
 388     MultiByteToWideChar(CP_OEMCP, 0, (PCSTR)&wOemChar, 1, &p, 1);
 389     Vk = VkKeyScanW(p);
 390     Scan = MapVirtualKeyW((Vk & 0x00ff), 0);
 391     if (!Scan) return -1;
 392     /*
 393        Page 450-1, MS W2k SuperBible by SAMS. Return, low word has the
 394        scan code and high word has the shift state.
 395      */
 396     return ((Vk & 0xff00) << 8) | Scan;
 397 }
 398
 399
 400 /*
 401  * @implemented
 402  */
 403 BOOL WINAPI
 404 SetDoubleClickTime(UINT uInterval)
 405 {
 406     return (BOOL)NtUserSystemParametersInfo(SPI_SETDOUBLECLICKTIME,
 407                                             uInterval,
 408                                             NULL,
 409                                             0);
 410 }
 411
 412
 413 /*
 414  * @implemented
 415  */
 416 BOOL
 417 WINAPI
 418 SwapMouseButton(
 419     BOOL fSwap)
 420 {
 421     return NtUserxSwapMouseButton(fSwap);
 422 }
 423
 424
 425 /*
 426  * @implemented
 427  */
 428 int WINAPI
 429 ToAscii(UINT uVirtKey,
 430         UINT uScanCode,
 431         CONST BYTE *lpKeyState,
 432         LPWORD lpChar,
 433         UINT uFlags)
 434 {
 435     return ToAsciiEx(uVirtKey, uScanCode, lpKeyState, lpChar, uFlags, 0);
 436 }
 437
 438
 439 /*
 440  * @implemented
 441  */
 442 int WINAPI
 443 ToAsciiEx(UINT uVirtKey,
 444           UINT uScanCode,
 445           CONST BYTE *lpKeyState,
 446           LPWORD lpChar,
 447           UINT uFlags,
 448           HKL dwhkl)
 449 {
 450     WCHAR UniChars[2];
 451     int Ret, CharCount;
 452
 453     Ret = ToUnicodeEx(uVirtKey, uScanCode, lpKeyState, UniChars, 2, uFlags, dwhkl);
 454     CharCount = (Ret < 0 ? 1 : Ret);
 455     WideCharToMultiByte(CP_ACP, 0, UniChars, CharCount, (LPSTR)lpChar, 2, NULL, NULL);
 456
 457     return Ret;
 458 }
 459
 460
 461 /*
 462  * @implemented
 463  */
 464 int WINAPI
 465 ToUnicode(UINT wVirtKey,
 466           UINT wScanCode,
 467           CONST BYTE *lpKeyState,
 468           LPWSTR pwszBuff,
 469           int cchBuff,
 470           UINT wFlags)
 471 {
 472     return ToUnicodeEx(wVirtKey, wScanCode, lpKeyState, pwszBuff, cchBuff,
 473                        wFlags, 0);
 474 }
 475
 476
 477 /*
 478  * @implemented
 479  */
 480 int WINAPI
 481 ToUnicodeEx(UINT wVirtKey,
 482             UINT wScanCode,
 483             CONST BYTE *lpKeyState,
 484             LPWSTR pwszBuff,
 485             int cchBuff,
 486             UINT wFlags,
 487             HKL dwhkl)
 488 {
 489     return NtUserToUnicodeEx(wVirtKey, wScanCode, (PBYTE)lpKeyState, pwszBuff, cchBuff,
 490                              wFlags, dwhkl);
 491 }
 492
 493
 494
 495 /*
 496  * @implemented
 497  */
 498 SHORT WINAPI
 499 VkKeyScanA(CHAR ch)
 500 {
 501     WCHAR wChar;
 502
 503     if (IsDBCSLeadByte(ch))
 504         return -1;
 505
 506     MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wChar, 1);
 507     return VkKeyScanW(wChar);
 508 }
 509
 510
 511 /*
 512  * @implemented
 513  */
 514 SHORT WINAPI
 515 VkKeyScanExA(CHAR ch,
 516              HKL dwhkl)
 517 {
 518     WCHAR wChar;
 519
 520     if (IsDBCSLeadByte(ch))
 521         return -1;
 522
 523     MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wChar, 1);
 524     return VkKeyScanExW(wChar, dwhkl);
 525 }
 526
 527
 528 /*
 529  * @implemented
 530  */
 531 SHORT WINAPI
 532 VkKeyScanExW(WCHAR ch,
 533              HKL dwhkl)
 534 {
 535     return (SHORT)NtUserVkKeyScanEx(ch, dwhkl, TRUE);
 536 }
 537
 538
 539 /*
 540  * @implemented
 541  */
 542 SHORT WINAPI
 543 VkKeyScanW(WCHAR ch)
 544 {
 545     return (SHORT)NtUserVkKeyScanEx(ch, 0, FALSE);
 546 }
 547
 548
 549 /*
 550  * @implemented
 551  */
 552 VOID
 553 WINAPI
 554 keybd_event(
 555     BYTE bVk,
 556     BYTE bScan,
 557     DWORD dwFlags,
 558     ULONG_PTR dwExtraInfo)
 559 {
 560     INPUT Input;
 561
 562     Input.type = INPUT_KEYBOARD;
 563     Input.ki.wVk = bVk;
 564     Input.ki.wScan = bScan;
 565     Input.ki.dwFlags = dwFlags;
 566     Input.ki.time = 0;
 567     Input.ki.dwExtraInfo = dwExtraInfo;
 568
 569     NtUserSendInput(1, &Input, sizeof(INPUT));
 570 }
 571
 572
 573 /*
 574  * @implemented
 575  */
 576 VOID
 577 WINAPI
 578 mouse_event(
 579     DWORD dwFlags,
 580     DWORD dx,
 581     DWORD dy,
 582     DWORD dwData,
 583     ULONG_PTR dwExtraInfo)
 584 {
 585     INPUT Input;
 586
 587     Input.type = INPUT_MOUSE;
 588     Input.mi.dx = dx;
 589     Input.mi.dy = dy;
 590     Input.mi.mouseData = dwData;
 591     Input.mi.dwFlags = dwFlags;
 592     Input.mi.time = 0;
 593     Input.mi.dwExtraInfo = dwExtraInfo;
 594
 595     NtUserSendInput(1, &Input, sizeof(INPUT));
 596 }
 597
 598 /* EOF */