dlls/user32/input.c

   1 /*
   2  * USER Input processing
   3  *
   4  * Copyright 1993 Bob Amstadt
   5  * Copyright 1996 Albrecht Kleine
   6  * Copyright 1997 David Faure
   7  * Copyright 1998 Morten Welinder
   8  * Copyright 1998 Ulrich Weigand
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  */
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29 #include <ctype.h>
  30 #include <assert.h>
  31
  32 #define NONAMELESSUNION
  33
  34 #include "ntstatus.h"
  35 #define WIN32_NO_STATUS
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "wingdi.h"
  39 #include "winuser.h"
  40 #include "winnls.h"
  41 #include "winternl.h"
  42 #include "winerror.h"
  43 #include "win.h"
  44 #include "user_private.h"
  45 #include "dbt.h"
  46 #include "wine/server.h"
  47 #include "wine/debug.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(win);
  50 WINE_DECLARE_DEBUG_CHANNEL(keyboard);
  51
  52 /***********************************************************************
  53  *           get_locale_kbd_layout
  54  */
  55 static HKL get_locale_kbd_layout(void)
  56 {
  57     ULONG_PTR layout;
  58     LANGID langid;
  59
  60     /* FIXME:
  61      *
  62      * layout = main_key_tab[kbd_layout].lcid;
  63      *
  64      * Winword uses return value of GetKeyboardLayout as a codepage
  65      * to translate ANSI keyboard messages to unicode. But we have
  66      * a problem with it: for instance Polish keyboard layout is
  67      * identical to the US one, and therefore instead of the Polish
  68      * locale id we return the US one.
  69      */
  70
  71     layout = GetUserDefaultLCID();
  72
  73     /*
  74      * Microsoft Office expects this value to be something specific
  75      * for Japanese and Korean Windows with an IME the value is 0xe001
  76      * We should probably check to see if an IME exists and if so then
  77      * set this word properly.
  78      */
  79     langid = PRIMARYLANGID( LANGIDFROMLCID( layout ) );
  80     if (langid == LANG_CHINESE || langid == LANG_JAPANESE || langid == LANG_KOREAN)
  81         layout = MAKELONG( layout, 0xe001 ); /* IME */
  82     else
  83         layout = MAKELONG( layout, layout );
  84
  85     return (HKL)layout;
  86 }
  87
  88
  89 /**********************************************************************
  90  *              set_capture_window
  91  */
  92 BOOL set_capture_window( HWND hwnd, UINT gui_flags, HWND *prev_ret )
  93 {
  94     /* FIXME: move callers to win32u or use NtUserSetCapture */
  95     return NtUserCallHwndParam( hwnd, gui_flags, NtUserSetCaptureWindow );
  96 }
  97
  98
  99 /***********************************************************************
 100  *              keybd_event (USER32.@)
 101  */
 102 void WINAPI keybd_event( BYTE bVk, BYTE bScan,
 103                          DWORD dwFlags, ULONG_PTR dwExtraInfo )
 104 {
 105     INPUT input;
 106
 107     input.type = INPUT_KEYBOARD;
 108     input.u.ki.wVk = bVk;
 109     input.u.ki.wScan = bScan;
 110     input.u.ki.dwFlags = dwFlags;
 111     input.u.ki.time = 0;
 112     input.u.ki.dwExtraInfo = dwExtraInfo;
 113     NtUserSendInput( 1, &input, sizeof(input) );
 114 }
 115
 116
 117 /***********************************************************************
 118  *              mouse_event (USER32.@)
 119  */
 120 void WINAPI mouse_event( DWORD dwFlags, DWORD dx, DWORD dy,
 121                          DWORD dwData, ULONG_PTR dwExtraInfo )
 122 {
 123     INPUT input;
 124
 125     input.type = INPUT_MOUSE;
 126     input.u.mi.dx = dx;
 127     input.u.mi.dy = dy;
 128     input.u.mi.mouseData = dwData;
 129     input.u.mi.dwFlags = dwFlags;
 130     input.u.mi.time = 0;
 131     input.u.mi.dwExtraInfo = dwExtraInfo;
 132     NtUserSendInput( 1, &input, sizeof(input) );
 133 }
 134
 135
 136 /***********************************************************************
 137  *              GetCursorPos (USER32.@)
 138  */
 139 BOOL WINAPI DECLSPEC_HOTPATCH GetCursorPos( POINT *pt )
 140 {
 141     return NtUserGetCursorPos( pt );
 142 }
 143
 144
 145 /**********************************************************************
 146  *              ReleaseCapture (USER32.@)
 147  */
 148 BOOL WINAPI DECLSPEC_HOTPATCH ReleaseCapture(void)
 149 {
 150     return NtUserReleaseCapture();
 151 }
 152
 153
 154 /**********************************************************************
 155  *              GetCapture (USER32.@)
 156  */
 157 HWND WINAPI GetCapture(void)
 158 {
 159     GUITHREADINFO info;
 160     info.cbSize = sizeof(info);
 161     return NtUserGetGUIThreadInfo( GetCurrentThreadId(), &info ) ? info.hwndCapture : 0;
 162 }
 163
 164
 165 /*****************************************************************
 166  *              DestroyCaret (USER32.@)
 167  */
 168 BOOL WINAPI DestroyCaret(void)
 169 {
 170     return NtUserDestroyCaret();
 171 }
 172
 173
 174 /*****************************************************************
 175  *              SetCaretPos (USER32.@)
 176  */
 177 BOOL WINAPI SetCaretPos( int x, int y )
 178 {
 179     return NtUserSetCaretPos( x, y );
 180 }
 181
 182
 183 /*****************************************************************
 184  *              SetCaretBlinkTime (USER32.@)
 185  */
 186 BOOL WINAPI SetCaretBlinkTime( unsigned int time )
 187 {
 188     return NtUserSetCaretBlinkTime( time );
 189 }
 190
 191
 192 /***********************************************************************
 193  *              GetInputState   (USER32.@)
 194  */
 195 BOOL WINAPI GetInputState(void)
 196 {
 197     return NtUserGetInputState();
 198 }
 199
 200
 201 /******************************************************************
 202  *              GetLastInputInfo (USER32.@)
 203  */
 204 BOOL WINAPI GetLastInputInfo(PLASTINPUTINFO plii)
 205 {
 206     BOOL ret;
 207
 208     TRACE("%p\n", plii);
 209
 210     if (plii->cbSize != sizeof (*plii) )
 211     {
 212         SetLastError(ERROR_INVALID_PARAMETER);
 213         return FALSE;
 214     }
 215
 216     SERVER_START_REQ( get_last_input_time )
 217     {
 218         ret = !wine_server_call_err( req );
 219         if (ret)
 220             plii->dwTime = reply->time;
 221     }
 222     SERVER_END_REQ;
 223     return ret;
 224 }
 225
 226
 227 /**********************************************************************
 228  *              VkKeyScanA (USER32.@)
 229  *
 230  * VkKeyScan translates an ANSI character to a virtual-key and shift code
 231  * for the current keyboard.
 232  * high-order byte yields :
 233  *      0       Unshifted
 234  *      1       Shift
 235  *      2       Ctrl
 236  *      3-5     Shift-key combinations that are not used for characters
 237  *      6       Ctrl-Alt
 238  *      7       Ctrl-Alt-Shift
 239  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
 240  * FIXME : works ok except for dead chars :
 241  * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
 242  * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
 243  */
 244 SHORT WINAPI VkKeyScanA(CHAR cChar)
 245 {
 246     WCHAR wChar;
 247
 248     if (IsDBCSLeadByte(cChar)) return -1;
 249
 250     MultiByteToWideChar(CP_ACP, 0, &cChar, 1, &wChar, 1);
 251     return VkKeyScanW(wChar);
 252 }
 253
 254 /******************************************************************************
 255  *              VkKeyScanW (USER32.@)
 256  */
 257 SHORT WINAPI VkKeyScanW(WCHAR cChar)
 258 {
 259     return NtUserVkKeyScanEx( cChar, NtUserGetKeyboardLayout(0) );
 260 }
 261
 262 /**********************************************************************
 263  *              VkKeyScanExA (USER32.@)
 264  */
 265 WORD WINAPI VkKeyScanExA(CHAR cChar, HKL dwhkl)
 266 {
 267     WCHAR wChar;
 268
 269     if (IsDBCSLeadByte(cChar)) return -1;
 270
 271     MultiByteToWideChar(CP_ACP, 0, &cChar, 1, &wChar, 1);
 272     return NtUserVkKeyScanEx( wChar, dwhkl );
 273 }
 274
 275 /**********************************************************************
 276  *              OemKeyScan (USER32.@)
 277  */
 278 DWORD WINAPI OemKeyScan( WORD oem )
 279 {
 280     WCHAR wchr;
 281     DWORD vkey, scan;
 282     char oem_char = LOBYTE( oem );
 283
 284     if (!OemToCharBuffW( &oem_char, &wchr, 1 ))
 285         return -1;
 286
 287     vkey = VkKeyScanW( wchr );
 288     scan = MapVirtualKeyW( LOBYTE( vkey ), MAPVK_VK_TO_VSC );
 289     if (!scan) return -1;
 290
 291     vkey &= 0xff00;
 292     vkey <<= 8;
 293     return vkey | scan;
 294 }
 295
 296 /******************************************************************************
 297  *              GetKeyboardType (USER32.@)
 298  */
 299 INT WINAPI GetKeyboardType(INT nTypeFlag)
 300 {
 301     TRACE_(keyboard)("(%d)\n", nTypeFlag);
 302     if (LOWORD(NtUserGetKeyboardLayout(0)) == MAKELANGID(LANG_JAPANESE, SUBLANG_JAPANESE_JAPAN))
 303     {
 304         /* scan code for `_', the key left of r-shift, in Japanese 106 keyboard */
 305         const UINT JP106_VSC_USCORE = 0x73;
 306
 307         switch(nTypeFlag)
 308         {
 309         case 0:      /* Keyboard type */
 310             return 7;    /* Japanese keyboard */
 311         case 1:      /* Keyboard Subtype */
 312             /* Test keyboard mappings to detect Japanese keyboard */
 313             if (MapVirtualKeyW(VK_OEM_102, MAPVK_VK_TO_VSC) == JP106_VSC_USCORE
 314                 && MapVirtualKeyW(JP106_VSC_USCORE, MAPVK_VSC_TO_VK) == VK_OEM_102)
 315                 return 2;    /* Japanese 106 */
 316             else
 317                 return 0;    /* AT-101 */
 318         case 2:      /* Number of F-keys */
 319             return 12;   /* It has 12 F-keys */
 320         }
 321     }
 322     else
 323     {
 324         switch(nTypeFlag)
 325         {
 326         case 0:      /* Keyboard type */
 327             return 4;    /* AT-101 */
 328         case 1:      /* Keyboard Subtype */
 329             return 0;    /* There are no defined subtypes */
 330         case 2:      /* Number of F-keys */
 331             return 12;   /* We're doing an 101 for now, so return 12 F-keys */
 332         }
 333     }
 334     WARN_(keyboard)("Unknown type\n");
 335     return 0;    /* The book says 0 here, so 0 */
 336 }
 337
 338 /******************************************************************************
 339  *              MapVirtualKeyA (USER32.@)
 340  */
 341 UINT WINAPI MapVirtualKeyA(UINT code, UINT maptype)
 342 {
 343     return MapVirtualKeyExA( code, maptype, NtUserGetKeyboardLayout(0) );
 344 }
 345
 346 /******************************************************************************
 347  *              MapVirtualKeyW (USER32.@)
 348  */
 349 UINT WINAPI MapVirtualKeyW(UINT code, UINT maptype)
 350 {
 351     return NtUserMapVirtualKeyEx( code, maptype, NtUserGetKeyboardLayout(0) );
 352 }
 353
 354 /******************************************************************************
 355  *              MapVirtualKeyExA (USER32.@)
 356  */
 357 UINT WINAPI MapVirtualKeyExA(UINT code, UINT maptype, HKL hkl)
 358 {
 359     UINT ret;
 360
 361     ret = NtUserMapVirtualKeyEx( code, maptype, hkl );
 362     if (maptype == MAPVK_VK_TO_CHAR)
 363     {
 364         BYTE ch = 0;
 365         WCHAR wch = ret;
 366
 367         WideCharToMultiByte( CP_ACP, 0, &wch, 1, (LPSTR)&ch, 1, NULL, NULL );
 368         ret = ch;
 369     }
 370     return ret;
 371 }
 372
 373 /****************************************************************************
 374  *              GetKBCodePage (USER32.@)
 375  */
 376 UINT WINAPI GetKBCodePage(void)
 377 {
 378     return GetOEMCP();
 379 }
 380
 381 /****************************************************************************
 382  *              GetKeyboardLayoutNameA (USER32.@)
 383  */
 384 BOOL WINAPI GetKeyboardLayoutNameA(LPSTR pszKLID)
 385 {
 386     WCHAR buf[KL_NAMELENGTH];
 387
 388     if (NtUserGetKeyboardLayoutName( buf ))
 389         return WideCharToMultiByte( CP_ACP, 0, buf, -1, pszKLID, KL_NAMELENGTH, NULL, NULL ) != 0;
 390     return FALSE;
 391 }
 392
 393 /****************************************************************************
 394  *              GetKeyNameTextA (USER32.@)
 395  */
 396 INT WINAPI GetKeyNameTextA(LONG lParam, LPSTR lpBuffer, INT nSize)
 397 {
 398     WCHAR buf[256];
 399     INT ret;
 400
 401     if (!nSize || !NtUserGetKeyNameText( lParam, buf, ARRAYSIZE(buf) ))
 402     {
 403         lpBuffer[0] = 0;
 404         return 0;
 405     }
 406     ret = WideCharToMultiByte(CP_ACP, 0, buf, -1, lpBuffer, nSize, NULL, NULL);
 407     if (!ret && nSize)
 408     {
 409         ret = nSize - 1;
 410         lpBuffer[ret] = 0;
 411     }
 412     else ret--;
 413
 414     return ret;
 415 }
 416
 417 /****************************************************************************
 418  *              ToUnicode (USER32.@)
 419  */
 420 INT WINAPI ToUnicode( UINT virt, UINT scan, const BYTE *state, LPWSTR str, int size, UINT flags )
 421 {
 422     return NtUserToUnicodeEx( virt, scan, state, str, size, flags, NtUserGetKeyboardLayout(0) );
 423 }
 424
 425 /****************************************************************************
 426  *              ToAscii (USER32.@)
 427  */
 428 INT WINAPI ToAscii( UINT virtKey, UINT scanCode, const BYTE *lpKeyState,
 429                     LPWORD lpChar, UINT flags )
 430 {
 431     return ToAsciiEx( virtKey, scanCode, lpKeyState, lpChar, flags,
 432                       NtUserGetKeyboardLayout(0) );
 433 }
 434
 435 /****************************************************************************
 436  *              ToAsciiEx (USER32.@)
 437  */
 438 INT WINAPI ToAsciiEx( UINT virtKey, UINT scanCode, const BYTE *lpKeyState,
 439                       LPWORD lpChar, UINT flags, HKL dwhkl )
 440 {
 441     WCHAR uni_chars[2];
 442     INT ret, n_ret;
 443
 444     ret = NtUserToUnicodeEx( virtKey, scanCode, lpKeyState, uni_chars, 2, flags, dwhkl );
 445     if (ret < 0) n_ret = 1; /* FIXME: make ToUnicode return 2 for dead chars */
 446     else n_ret = ret;
 447     WideCharToMultiByte(CP_ACP, 0, uni_chars, n_ret, (LPSTR)lpChar, 2, NULL, NULL);
 448     return ret;
 449 }
 450
 451 /**********************************************************************
 452  *              BlockInput (USER32.@)
 453  */
 454 BOOL WINAPI BlockInput(BOOL fBlockIt)
 455 {
 456     FIXME_(keyboard)("(%d): stub\n", fBlockIt);
 457     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 458
 459     return FALSE;
 460 }
 461
 462
 463 /***********************************************************************
 464  *              LoadKeyboardLayoutW (USER32.@)
 465  */
 466 HKL WINAPI LoadKeyboardLayoutW( const WCHAR *name, UINT flags )
 467 {
 468     WCHAR layout_path[MAX_PATH], value[5];
 469     DWORD value_size, tmp;
 470     HKEY hkey;
 471     HKL layout;
 472
 473     FIXME_(keyboard)( "name %s, flags %x, semi-stub!\n", debugstr_w( name ), flags );
 474
 475     tmp = wcstoul( name, NULL, 16 );
 476     if (HIWORD( tmp )) layout = UlongToHandle( tmp );
 477     else layout = UlongToHandle( MAKELONG( LOWORD( tmp ), LOWORD( tmp ) ) );
 478
 479     wcscpy( layout_path, L"System\\CurrentControlSet\\Control\\Keyboard Layouts\\" );
 480     wcscat( layout_path, name );
 481
 482     if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, layout_path, &hkey ))
 483     {
 484         value_size = sizeof(value);
 485         if (!RegGetValueW( hkey, NULL, L"Layout Id", RRF_RT_REG_SZ, NULL, (void *)&value, &value_size ))
 486             layout = UlongToHandle( MAKELONG( LOWORD( tmp ), 0xf000 | (wcstoul( value, NULL, 16 ) & 0xfff) ) );
 487
 488         RegCloseKey( hkey );
 489     }
 490
 491     if ((flags & KLF_ACTIVATE) && NtUserActivateKeyboardLayout( layout, 0 )) return layout;
 492
 493     /* FIXME: semi-stub: returning default layout */
 494     return get_locale_kbd_layout();
 495 }
 496
 497 /***********************************************************************
 498  *              LoadKeyboardLayoutA (USER32.@)
 499  */
 500 HKL WINAPI LoadKeyboardLayoutA(LPCSTR pwszKLID, UINT Flags)
 501 {
 502     HKL ret;
 503     UNICODE_STRING pwszKLIDW;
 504
 505     if (pwszKLID) RtlCreateUnicodeStringFromAsciiz(&pwszKLIDW, pwszKLID);
 506     else pwszKLIDW.Buffer = NULL;
 507
 508     ret = LoadKeyboardLayoutW(pwszKLIDW.Buffer, Flags);
 509     RtlFreeUnicodeString(&pwszKLIDW);
 510     return ret;
 511 }
 512
 513
 514 /***********************************************************************
 515  *              UnloadKeyboardLayout (USER32.@)
 516  */
 517 BOOL WINAPI UnloadKeyboardLayout( HKL layout )
 518 {
 519     FIXME_(keyboard)( "layout %p, stub!\n", layout );
 520     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
 521     return FALSE;
 522 }
 523
 524
 525 /***********************************************************************
 526  *              EnableMouseInPointer (USER32.@)
 527  */
 528 BOOL WINAPI EnableMouseInPointer(BOOL enable)
 529 {
 530     FIXME("(%#x) stub\n", enable);
 531
 532     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 533     return FALSE;
 534 }
 535
 536 static DWORD CALLBACK devnotify_window_callback(HANDLE handle, DWORD flags, DEV_BROADCAST_HDR *header)
 537 {
 538     SendMessageTimeoutW(handle, WM_DEVICECHANGE, flags, (LPARAM)header, SMTO_ABORTIFHUNG, 2000, NULL);
 539     return 0;
 540 }
 541
 542 static DWORD CALLBACK devnotify_service_callback(HANDLE handle, DWORD flags, DEV_BROADCAST_HDR *header)
 543 {
 544     FIXME("Support for service handles is not yet implemented!\n");
 545     return 0;
 546 }
 547
 548 struct device_notification_details
 549 {
 550     DWORD (CALLBACK *cb)(HANDLE handle, DWORD flags, DEV_BROADCAST_HDR *header);
 551     HANDLE handle;
 552     union
 553     {
 554         DEV_BROADCAST_HDR header;
 555         DEV_BROADCAST_DEVICEINTERFACE_W iface;
 556     } filter;
 557 };
 558
 559 extern HDEVNOTIFY WINAPI I_ScRegisterDeviceNotification( struct device_notification_details *details,
 560         void *filter, DWORD flags );
 561 extern BOOL WINAPI I_ScUnregisterDeviceNotification( HDEVNOTIFY handle );
 562
 563 /***********************************************************************
 564  *              RegisterDeviceNotificationA (USER32.@)
 565  *
 566  * See RegisterDeviceNotificationW.
 567  */
 568 HDEVNOTIFY WINAPI RegisterDeviceNotificationA( HANDLE handle, void *filter, DWORD flags )
 569 {
 570     return RegisterDeviceNotificationW( handle, filter, flags );
 571 }
 572
 573 /***********************************************************************
 574  *              RegisterDeviceNotificationW (USER32.@)
 575  */
 576 HDEVNOTIFY WINAPI RegisterDeviceNotificationW( HANDLE handle, void *filter, DWORD flags )
 577 {
 578     struct device_notification_details details;
 579     DEV_BROADCAST_HDR *header = filter;
 580
 581     TRACE("handle %p, filter %p, flags %#lx\n", handle, filter, flags);
 582
 583     if (flags & ~(DEVICE_NOTIFY_SERVICE_HANDLE | DEVICE_NOTIFY_ALL_INTERFACE_CLASSES))
 584     {
 585         SetLastError( ERROR_INVALID_PARAMETER );
 586         return NULL;
 587     }
 588
 589     if (!(flags & DEVICE_NOTIFY_SERVICE_HANDLE) && !IsWindow( handle ))
 590     {
 591         SetLastError( ERROR_INVALID_PARAMETER );
 592         return NULL;
 593     }
 594
 595     if (!header) details.filter.header.dbch_devicetype = 0;
 596     else if (header->dbch_devicetype == DBT_DEVTYP_DEVICEINTERFACE)
 597     {
 598         DEV_BROADCAST_DEVICEINTERFACE_W *iface = (DEV_BROADCAST_DEVICEINTERFACE_W *)header;
 599         details.filter.iface = *iface;
 600
 601         if (flags & DEVICE_NOTIFY_ALL_INTERFACE_CLASSES)
 602             details.filter.iface.dbcc_size = offsetof( DEV_BROADCAST_DEVICEINTERFACE_W, dbcc_classguid );
 603         else
 604             details.filter.iface.dbcc_size = offsetof( DEV_BROADCAST_DEVICEINTERFACE_W, dbcc_name );
 605     }
 606     else if (header->dbch_devicetype == DBT_DEVTYP_HANDLE)
 607     {
 608         FIXME( "DBT_DEVTYP_HANDLE filter type not implemented\n" );
 609         details.filter.header.dbch_devicetype = 0;
 610     }
 611     else
 612     {
 613         SetLastError( ERROR_INVALID_DATA );
 614         return NULL;
 615     }
 616
 617     details.handle = handle;
 618
 619     if (flags & DEVICE_NOTIFY_SERVICE_HANDLE)
 620         details.cb = devnotify_service_callback;
 621     else
 622         details.cb = devnotify_window_callback;
 623
 624     return I_ScRegisterDeviceNotification( &details, filter, 0 );
 625 }
 626
 627 /***********************************************************************
 628  *              UnregisterDeviceNotification (USER32.@)
 629  */
 630 BOOL WINAPI UnregisterDeviceNotification( HDEVNOTIFY handle )
 631 {
 632     TRACE("%p\n", handle);
 633
 634     return I_ScUnregisterDeviceNotification( handle );
 635 }