dlls/user/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "config.h"
  26 #include "wine/port.h"
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32 #include <ctype.h>
  33 #include <assert.h>
  34
  35 #define NONAMELESSUNION
  36 #define NONAMELESSSTRUCT
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "wingdi.h"
  40 #include "winuser.h"
  41 #include "winnls.h"
  42 #include "wine/server.h"
  43 #include "user_private.h"
  44 #include "winternl.h"
  45 #include "wine/debug.h"
  46 #include "winerror.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(key);
  49 WINE_DECLARE_DEBUG_CHANNEL(keyboard);
  50
  51
  52 /***********************************************************************
  53  *           get_key_state
  54  */
  55 static WORD get_key_state(void)
  56 {
  57     WORD ret = 0;
  58
  59     if (GetSystemMetrics( SM_SWAPBUTTON ))
  60     {
  61         if (GetAsyncKeyState(VK_RBUTTON) & 0x80) ret |= MK_LBUTTON;
  62         if (GetAsyncKeyState(VK_LBUTTON) & 0x80) ret |= MK_RBUTTON;
  63     }
  64     else
  65     {
  66         if (GetAsyncKeyState(VK_LBUTTON) & 0x80) ret |= MK_LBUTTON;
  67         if (GetAsyncKeyState(VK_RBUTTON) & 0x80) ret |= MK_RBUTTON;
  68     }
  69     if (GetAsyncKeyState(VK_MBUTTON) & 0x80)  ret |= MK_MBUTTON;
  70     if (GetAsyncKeyState(VK_SHIFT) & 0x80)    ret |= MK_SHIFT;
  71     if (GetAsyncKeyState(VK_CONTROL) & 0x80)  ret |= MK_CONTROL;
  72     if (GetAsyncKeyState(VK_XBUTTON1) & 0x80) ret |= MK_XBUTTON1;
  73     if (GetAsyncKeyState(VK_XBUTTON2) & 0x80) ret |= MK_XBUTTON2;
  74     return ret;
  75 }
  76
  77
  78 /***********************************************************************
  79  *              SendInput  (USER32.@)
  80  */
  81 UINT WINAPI SendInput( UINT count, LPINPUT inputs, int size )
  82 {
  83     return USER_Driver->pSendInput( count, inputs, size );
  84 }
  85
  86
  87 /***********************************************************************
  88  *              keybd_event (USER32.@)
  89  */
  90 void WINAPI keybd_event( BYTE bVk, BYTE bScan,
  91                          DWORD dwFlags, ULONG_PTR dwExtraInfo )
  92 {
  93     INPUT input;
  94
  95     input.type = INPUT_KEYBOARD;
  96     input.u.ki.wVk = bVk;
  97     input.u.ki.wScan = bScan;
  98     input.u.ki.dwFlags = dwFlags;
  99     input.u.ki.time = GetTickCount();
 100     input.u.ki.dwExtraInfo = dwExtraInfo;
 101     SendInput( 1, &input, sizeof(input) );
 102 }
 103
 104
 105 /***********************************************************************
 106  *              mouse_event (USER32.@)
 107  */
 108 void WINAPI mouse_event( DWORD dwFlags, DWORD dx, DWORD dy,
 109                          DWORD dwData, ULONG_PTR dwExtraInfo )
 110 {
 111     INPUT input;
 112
 113     input.type = INPUT_MOUSE;
 114     input.u.mi.dx = dx;
 115     input.u.mi.dy = dy;
 116     input.u.mi.mouseData = dwData;
 117     input.u.mi.dwFlags = dwFlags;
 118     input.u.mi.time = GetCurrentTime();
 119     input.u.mi.dwExtraInfo = dwExtraInfo;
 120     SendInput( 1, &input, sizeof(input) );
 121 }
 122
 123
 124 /***********************************************************************
 125  *              GetCursorPos (USER32.@)
 126  */
 127 BOOL WINAPI GetCursorPos( POINT *pt )
 128 {
 129     if (!pt) return FALSE;
 130     return USER_Driver->pGetCursorPos( pt );
 131 }
 132
 133
 134 /***********************************************************************
 135  *              GetCursorInfo (USER32.@)
 136  */
 137 BOOL WINAPI GetCursorInfo( PCURSORINFO pci )
 138 {
 139     if (!pci) return 0;
 140     if (get_user_thread_info()->cursor_count >= 0) pci->flags = CURSOR_SHOWING;
 141     else pci->flags = 0;
 142     GetCursorPos(&pci->ptScreenPos);
 143     return 1;
 144 }
 145
 146
 147 /***********************************************************************
 148  *              SetCursorPos (USER32.@)
 149  */
 150 BOOL WINAPI SetCursorPos( INT x, INT y )
 151 {
 152     return USER_Driver->pSetCursorPos( x, y );
 153 }
 154
 155
 156 /**********************************************************************
 157  *              SetCapture (USER32.@)
 158  */
 159 HWND WINAPI SetCapture( HWND hwnd )
 160 {
 161     HWND previous = 0;
 162
 163     SERVER_START_REQ( set_capture_window )
 164     {
 165         req->handle = hwnd;
 166         req->flags  = 0;
 167         if (!wine_server_call_err( req ))
 168         {
 169             previous = reply->previous;
 170             hwnd = reply->full_handle;
 171         }
 172     }
 173     SERVER_END_REQ;
 174
 175     if (previous && previous != hwnd)
 176         SendMessageW( previous, WM_CAPTURECHANGED, 0, (LPARAM)hwnd );
 177     return previous;
 178 }
 179
 180
 181 /**********************************************************************
 182  *              ReleaseCapture (USER32.@)
 183  */
 184 BOOL WINAPI ReleaseCapture(void)
 185 {
 186     return (SetCapture(0) != 0);
 187 }
 188
 189
 190 /**********************************************************************
 191  *              GetCapture (USER32.@)
 192  */
 193 HWND WINAPI GetCapture(void)
 194 {
 195     HWND ret = 0;
 196
 197     SERVER_START_REQ( get_thread_input )
 198     {
 199         req->tid = GetCurrentThreadId();
 200         if (!wine_server_call_err( req )) ret = reply->capture;
 201     }
 202     SERVER_END_REQ;
 203     return ret;
 204 }
 205
 206
 207 /**********************************************************************
 208  *              GetAsyncKeyState (USER32.@)
 209  *
 210  *      Determine if a key is or was pressed.  retval has high-order
 211  * bit set to 1 if currently pressed, low-order bit set to 1 if key has
 212  * been pressed.
 213  */
 214 SHORT WINAPI GetAsyncKeyState(INT nKey)
 215 {
 216     return USER_Driver->pGetAsyncKeyState( nKey );
 217 }
 218
 219
 220 /***********************************************************************
 221  *              GetQueueStatus (USER32.@)
 222  */
 223 DWORD WINAPI GetQueueStatus( UINT flags )
 224 {
 225     DWORD ret = 0;
 226
 227     /* check for pending X events */
 228     USER_Driver->pMsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_ALLINPUT, 0 );
 229
 230     SERVER_START_REQ( get_queue_status )
 231     {
 232         req->clear = 1;
 233         wine_server_call( req );
 234         ret = MAKELONG( reply->changed_bits & flags, reply->wake_bits & flags );
 235     }
 236     SERVER_END_REQ;
 237     return ret;
 238 }
 239
 240
 241 /***********************************************************************
 242  *              GetInputState   (USER32.@)
 243  */
 244 BOOL WINAPI GetInputState(void)
 245 {
 246     DWORD ret = 0;
 247
 248     /* check for pending X events */
 249     USER_Driver->pMsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_INPUT, 0 );
 250
 251     SERVER_START_REQ( get_queue_status )
 252     {
 253         req->clear = 0;
 254         wine_server_call( req );
 255         ret = reply->wake_bits & (QS_KEY | QS_MOUSEBUTTON);
 256     }
 257     SERVER_END_REQ;
 258     return ret;
 259 }
 260
 261
 262 /******************************************************************
 263  *              GetLastInputInfo (USER32.@)
 264  */
 265 BOOL WINAPI GetLastInputInfo(PLASTINPUTINFO plii)
 266 {
 267     BOOL ret;
 268
 269     TRACE("%p\n", plii);
 270
 271     if (plii->cbSize != sizeof (*plii) )
 272     {
 273         SetLastError(ERROR_INVALID_PARAMETER);
 274         return FALSE;
 275     }
 276
 277     SERVER_START_REQ( get_last_input_time )
 278     {
 279         ret = !wine_server_call_err( req );
 280         if (ret)
 281             plii->dwTime = reply->time;
 282     }
 283     SERVER_END_REQ;
 284     return ret;
 285 }
 286
 287
 288 /**********************************************************************
 289  *              AttachThreadInput (USER32.@)
 290  *
 291  * Attaches the input processing mechanism of one thread to that of
 292  * another thread.
 293  */
 294 BOOL WINAPI AttachThreadInput( DWORD from, DWORD to, BOOL attach )
 295 {
 296     BOOL ret;
 297
 298     SERVER_START_REQ( attach_thread_input )
 299     {
 300         req->tid_from = from;
 301         req->tid_to   = to;
 302         req->attach   = attach;
 303         ret = !wine_server_call_err( req );
 304     }
 305     SERVER_END_REQ;
 306     return ret;
 307 }
 308
 309
 310 /**********************************************************************
 311  *              GetKeyState (USER32.@)
 312  *
 313  * An application calls the GetKeyState function in response to a
 314  * keyboard-input message.  This function retrieves the state of the key
 315  * at the time the input message was generated.
 316  */
 317 SHORT WINAPI GetKeyState(INT vkey)
 318 {
 319     SHORT retval = 0;
 320
 321     SERVER_START_REQ( get_key_state )
 322     {
 323         req->tid = GetCurrentThreadId();
 324         req->key = vkey;
 325         if (!wine_server_call( req )) retval = (signed char)reply->state;
 326     }
 327     SERVER_END_REQ;
 328     TRACE("key (0x%x) -> %x\n", vkey, retval);
 329     return retval;
 330 }
 331
 332
 333 /**********************************************************************
 334  *              GetKeyboardState (USER32.@)
 335  */
 336 BOOL WINAPI GetKeyboardState( LPBYTE state )
 337 {
 338     BOOL ret;
 339
 340     TRACE("(%p)\n", state);
 341
 342     memset( state, 0, 256 );
 343     SERVER_START_REQ( get_key_state )
 344     {
 345         req->tid = GetCurrentThreadId();
 346         req->key = -1;
 347         wine_server_set_reply( req, state, 256 );
 348         ret = !wine_server_call_err( req );
 349     }
 350     SERVER_END_REQ;
 351     return ret;
 352 }
 353
 354
 355 /**********************************************************************
 356  *              SetKeyboardState (USER32.@)
 357  */
 358 BOOL WINAPI SetKeyboardState( LPBYTE state )
 359 {
 360     BOOL ret;
 361
 362     TRACE("(%p)\n", state);
 363
 364     SERVER_START_REQ( set_key_state )
 365     {
 366         req->tid = GetCurrentThreadId();
 367         wine_server_add_data( req, state, 256 );
 368         ret = !wine_server_call_err( req );
 369     }
 370     SERVER_END_REQ;
 371     return ret;
 372 }
 373
 374
 375 /**********************************************************************
 376  *              VkKeyScanA (USER32.@)
 377  *
 378  * VkKeyScan translates an ANSI character to a virtual-key and shift code
 379  * for the current keyboard.
 380  * high-order byte yields :
 381  *      0       Unshifted
 382  *      1       Shift
 383  *      2       Ctrl
 384  *      3-5     Shift-key combinations that are not used for characters
 385  *      6       Ctrl-Alt
 386  *      7       Ctrl-Alt-Shift
 387  *      I.e. :  Shift = 1, Ctrl = 2, Alt = 4.
 388  * FIXME : works ok except for dead chars :
 389  * VkKeyScan '^'(0x5e, 94) ... got keycode 00 ... returning 00
 390  * VkKeyScan '`'(0x60, 96) ... got keycode 00 ... returning 00
 391  */
 392 SHORT WINAPI VkKeyScanA(CHAR cChar)
 393 {
 394     WCHAR wChar;
 395
 396     if (IsDBCSLeadByte(cChar)) return -1;
 397
 398     MultiByteToWideChar(CP_ACP, 0, &cChar, 1, &wChar, 1);
 399     return VkKeyScanW(wChar);
 400 }
 401
 402 /******************************************************************************
 403  *              VkKeyScanW (USER32.@)
 404  */
 405 SHORT WINAPI VkKeyScanW(WCHAR cChar)
 406 {
 407     return VkKeyScanExW(cChar, GetKeyboardLayout(0));
 408 }
 409
 410 /**********************************************************************
 411  *              VkKeyScanExA (USER32.@)
 412  */
 413 WORD WINAPI VkKeyScanExA(CHAR cChar, HKL dwhkl)
 414 {
 415     WCHAR wChar;
 416
 417     if (IsDBCSLeadByte(cChar)) return -1;
 418
 419     MultiByteToWideChar(CP_ACP, 0, &cChar, 1, &wChar, 1);
 420     return VkKeyScanExW(wChar, dwhkl);
 421 }
 422
 423 /******************************************************************************
 424  *              VkKeyScanExW (USER32.@)
 425  */
 426 WORD WINAPI VkKeyScanExW(WCHAR cChar, HKL dwhkl)
 427 {
 428     return USER_Driver->pVkKeyScanEx(cChar, dwhkl);
 429 }
 430
 431 /**********************************************************************
 432  *              OemKeyScan (USER32.@)
 433  */
 434 DWORD WINAPI OemKeyScan(WORD wOemChar)
 435 {
 436     TRACE("(%d)\n", wOemChar);
 437     return wOemChar;
 438 }
 439
 440 /******************************************************************************
 441  *              GetKeyboardType (USER32.@)
 442  */
 443 INT WINAPI GetKeyboardType(INT nTypeFlag)
 444 {
 445     TRACE_(keyboard)("(%d)\n", nTypeFlag);
 446     switch(nTypeFlag)
 447     {
 448     case 0:      /* Keyboard type */
 449         return 4;    /* AT-101 */
 450     case 1:      /* Keyboard Subtype */
 451         return 0;    /* There are no defined subtypes */
 452     case 2:      /* Number of F-keys */
 453         return 12;   /* We're doing an 101 for now, so return 12 F-keys */
 454     default:
 455         WARN_(keyboard)("Unknown type\n");
 456         return 0;    /* The book says 0 here, so 0 */
 457     }
 458 }
 459
 460 /******************************************************************************
 461  *              MapVirtualKeyA (USER32.@)
 462  */
 463 UINT WINAPI MapVirtualKeyA(UINT code, UINT maptype)
 464 {
 465     return MapVirtualKeyExA( code, maptype, GetKeyboardLayout(0) );
 466 }
 467
 468 /******************************************************************************
 469  *              MapVirtualKeyW (USER32.@)
 470  */
 471 UINT WINAPI MapVirtualKeyW(UINT code, UINT maptype)
 472 {
 473     return MapVirtualKeyExW(code, maptype, GetKeyboardLayout(0));
 474 }
 475
 476 /******************************************************************************
 477  *              MapVirtualKeyExA (USER32.@)
 478  */
 479 UINT WINAPI MapVirtualKeyExA(UINT code, UINT maptype, HKL hkl)
 480 {
 481     return MapVirtualKeyExW(code, maptype, hkl);
 482 }
 483
 484 /******************************************************************************
 485  *              MapVirtualKeyExW (USER32.@)
 486  */
 487 UINT WINAPI MapVirtualKeyExW(UINT code, UINT maptype, HKL hkl)
 488 {
 489     TRACE_(keyboard)("(%d, %d, %p)\n", code, maptype, hkl);
 490
 491     return USER_Driver->pMapVirtualKeyEx(code, maptype, hkl);
 492 }
 493
 494 /****************************************************************************
 495  *              GetKBCodePage (USER32.@)
 496  */
 497 UINT WINAPI GetKBCodePage(void)
 498 {
 499     return GetOEMCP();
 500 }
 501
 502 /***********************************************************************
 503  *              GetKeyboardLayout (USER32.@)
 504  *
 505  *        - device handle for keyboard layout defaulted to
 506  *          the language id. This is the way Windows default works.
 507  *        - the thread identifier (dwLayout) is also ignored.
 508  */
 509 HKL WINAPI GetKeyboardLayout(DWORD dwLayout)
 510 {
 511     return USER_Driver->pGetKeyboardLayout(dwLayout);
 512 }
 513
 514 /****************************************************************************
 515  *              GetKeyboardLayoutNameA (USER32.@)
 516  */
 517 BOOL WINAPI GetKeyboardLayoutNameA(LPSTR pszKLID)
 518 {
 519     WCHAR buf[KL_NAMELENGTH];
 520
 521     if (GetKeyboardLayoutNameW(buf))
 522         return WideCharToMultiByte( CP_ACP, 0, buf, -1, pszKLID, KL_NAMELENGTH, NULL, NULL ) != 0;
 523     return FALSE;
 524 }
 525
 526 /****************************************************************************
 527  *              GetKeyboardLayoutNameW (USER32.@)
 528  */
 529 BOOL WINAPI GetKeyboardLayoutNameW(LPWSTR pwszKLID)
 530 {
 531     return USER_Driver->pGetKeyboardLayoutName(pwszKLID);
 532 }
 533
 534 /****************************************************************************
 535  *              GetKeyNameTextA (USER32.@)
 536  */
 537 INT WINAPI GetKeyNameTextA(LONG lParam, LPSTR lpBuffer, INT nSize)
 538 {
 539     WCHAR buf[256];
 540     INT ret;
 541
 542     if (!GetKeyNameTextW(lParam, buf, 256))
 543         return 0;
 544     ret = WideCharToMultiByte(CP_ACP, 0, buf, -1, lpBuffer, nSize, NULL, NULL);
 545     if (!ret && nSize)
 546     {
 547         ret = nSize - 1;
 548         lpBuffer[ret] = 0;
 549     }
 550     return ret;
 551 }
 552
 553 /****************************************************************************
 554  *              GetKeyNameTextW (USER32.@)
 555  */
 556 INT WINAPI GetKeyNameTextW(LONG lParam, LPWSTR lpBuffer, INT nSize)
 557 {
 558     return USER_Driver->pGetKeyNameText( lParam, lpBuffer, nSize );
 559 }
 560
 561 /****************************************************************************
 562  *              ToUnicode (USER32.@)
 563  */
 564 INT WINAPI ToUnicode(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 565                      LPWSTR lpwStr, int size, UINT flags)
 566 {
 567     return ToUnicodeEx(virtKey, scanCode, lpKeyState, lpwStr, size, flags, GetKeyboardLayout(0));
 568 }
 569
 570 /****************************************************************************
 571  *              ToUnicodeEx (USER32.@)
 572  */
 573 INT WINAPI ToUnicodeEx(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 574                        LPWSTR lpwStr, int size, UINT flags, HKL hkl)
 575 {
 576     return USER_Driver->pToUnicodeEx(virtKey, scanCode, lpKeyState, lpwStr, size, flags, hkl);
 577 }
 578
 579 /****************************************************************************
 580  *              ToAscii (USER32.@)
 581  */
 582 INT WINAPI ToAscii( UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 583                     LPWORD lpChar, UINT flags )
 584 {
 585     return ToAsciiEx(virtKey, scanCode, lpKeyState, lpChar, flags, GetKeyboardLayout(0));
 586 }
 587
 588 /****************************************************************************
 589  *              ToAsciiEx (USER32.@)
 590  */
 591 INT WINAPI ToAsciiEx( UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 592                       LPWORD lpChar, UINT flags, HKL dwhkl )
 593 {
 594     WCHAR uni_chars[2];
 595     INT ret, n_ret;
 596
 597     ret = ToUnicodeEx(virtKey, scanCode, lpKeyState, uni_chars, 2, flags, dwhkl);
 598     if (ret < 0) n_ret = 1; /* FIXME: make ToUnicode return 2 for dead chars */
 599     else n_ret = ret;
 600     WideCharToMultiByte(CP_ACP, 0, uni_chars, n_ret, (LPSTR)lpChar, 2, NULL, NULL);
 601     return ret;
 602 }
 603
 604 /**********************************************************************
 605  *              ActivateKeyboardLayout (USER32.@)
 606  */
 607 HKL WINAPI ActivateKeyboardLayout(HKL hLayout, UINT flags)
 608 {
 609     TRACE_(keyboard)("(%p, %d)\n", hLayout, flags);
 610
 611     return USER_Driver->pActivateKeyboardLayout(hLayout, flags);
 612 }
 613
 614
 615 /***********************************************************************
 616  *              GetKeyboardLayoutList (USER32.@)
 617  *
 618  * Return number of values available if either input parm is
 619  *  0, per MS documentation.
 620  */
 621 UINT WINAPI GetKeyboardLayoutList(INT nBuff, HKL *layouts)
 622 {
 623     TRACE_(keyboard)("(%d,%p)\n",nBuff,layouts);
 624
 625     return USER_Driver->pGetKeyboardLayoutList(nBuff, layouts);
 626 }
 627
 628
 629 /***********************************************************************
 630  *              RegisterHotKey (USER32.@)
 631  */
 632 BOOL WINAPI RegisterHotKey(HWND hwnd,INT id,UINT modifiers,UINT vk)
 633 {
 634     FIXME_(keyboard)("(%p,%d,0x%08x,%d): stub\n",hwnd,id,modifiers,vk);
 635     return TRUE;
 636 }
 637
 638 /***********************************************************************
 639  *              UnregisterHotKey (USER32.@)
 640  */
 641 BOOL WINAPI UnregisterHotKey(HWND hwnd,INT id)
 642 {
 643     FIXME_(keyboard)("(%p,%d): stub\n",hwnd,id);
 644     return TRUE;
 645 }
 646
 647 /***********************************************************************
 648  *              LoadKeyboardLayoutW (USER32.@)
 649  */
 650 HKL WINAPI LoadKeyboardLayoutW(LPCWSTR pwszKLID, UINT Flags)
 651 {
 652     TRACE_(keyboard)("(%s, %d)\n", debugstr_w(pwszKLID), Flags);
 653
 654     return USER_Driver->pLoadKeyboardLayout(pwszKLID, Flags);
 655 }
 656
 657 /***********************************************************************
 658  *              LoadKeyboardLayoutA (USER32.@)
 659  */
 660 HKL WINAPI LoadKeyboardLayoutA(LPCSTR pwszKLID, UINT Flags)
 661 {
 662     HKL ret;
 663     UNICODE_STRING pwszKLIDW;
 664
 665     if (pwszKLID) RtlCreateUnicodeStringFromAsciiz(&pwszKLIDW, pwszKLID);
 666     else pwszKLIDW.Buffer = NULL;
 667
 668     ret = LoadKeyboardLayoutW(pwszKLIDW.Buffer, Flags);
 669     RtlFreeUnicodeString(&pwszKLIDW);
 670     return ret;
 671 }
 672
 673
 674 /***********************************************************************
 675  *              UnloadKeyboardLayout (USER32.@)
 676  */
 677 BOOL WINAPI UnloadKeyboardLayout(HKL hkl)
 678 {
 679     TRACE_(keyboard)("(%p)\n", hkl);
 680
 681     return USER_Driver->pUnloadKeyboardLayout(hkl);
 682 }
 683
 684 typedef struct __TRACKINGLIST {
 685     TRACKMOUSEEVENT tme;
 686     POINT pos; /* center of hover rectangle */
 687     INT iHoverTime; /* elapsed time the cursor has been inside of the hover rect */
 688 } _TRACKINGLIST;
 689
 690 static _TRACKINGLIST TrackingList[10];
 691 static int iTrackMax = 0;
 692 static UINT_PTR timer;
 693 static const INT iTimerInterval = 50; /* msec for timer interval */
 694
 695 static void CALLBACK TrackMouseEventProc(HWND hwndUnused, UINT uMsg, UINT_PTR idEvent,
 696     DWORD dwTime)
 697 {
 698     int i = 0;
 699     POINT pos;
 700     POINT posClient;
 701     HWND hwnd;
 702     INT nonclient;
 703     INT hoverwidth = 0, hoverheight = 0;
 704     RECT client;
 705
 706     GetCursorPos(&pos);
 707     hwnd = WindowFromPoint(pos);
 708
 709     SystemParametersInfoA(SPI_GETMOUSEHOVERWIDTH, 0, &hoverwidth, 0);
 710     SystemParametersInfoA(SPI_GETMOUSEHOVERHEIGHT, 0, &hoverheight, 0);
 711
 712     /* loop through tracking events we are processing */
 713     while (i < iTrackMax) {
 714         if (TrackingList[i].tme.dwFlags & TME_NONCLIENT) {
 715             nonclient = 1;
 716         }
 717         else {
 718             nonclient = 0;
 719         }
 720
 721         /* see if this tracking event is looking for TME_LEAVE and that the */
 722         /* mouse has left the window */
 723         if (TrackingList[i].tme.dwFlags & TME_LEAVE) {
 724             if (TrackingList[i].tme.hwndTrack != hwnd) {
 725                 if (nonclient) {
 726                     PostMessageA(TrackingList[i].tme.hwndTrack, WM_NCMOUSELEAVE, 0, 0);
 727                 }
 728                 else {
 729                     PostMessageA(TrackingList[i].tme.hwndTrack, WM_MOUSELEAVE, 0, 0);
 730                 }
 731
 732                 /* remove the TME_LEAVE flag */
 733                 TrackingList[i].tme.dwFlags ^= TME_LEAVE;
 734             }
 735             else {
 736                 GetClientRect(hwnd, &client);
 737                 MapWindowPoints(hwnd, NULL, (LPPOINT)&client, 2);
 738                 if(PtInRect(&client, pos)) {
 739                     if (nonclient) {
 740                         PostMessageA(TrackingList[i].tme.hwndTrack, WM_NCMOUSELEAVE, 0, 0);
 741                         /* remove the TME_LEAVE flag */
 742                         TrackingList[i].tme.dwFlags ^= TME_LEAVE;
 743                     }
 744                 }
 745                 else {
 746                     if (!nonclient) {
 747                         PostMessageA(TrackingList[i].tme.hwndTrack, WM_MOUSELEAVE, 0, 0);
 748                         /* remove the TME_LEAVE flag */
 749                         TrackingList[i].tme.dwFlags ^= TME_LEAVE;
 750                     }
 751                 }
 752             }
 753         }
 754
 755         /* see if we are tracking hovering for this hwnd */
 756         if(TrackingList[i].tme.dwFlags & TME_HOVER) {
 757             /* add the timer interval to the hovering time */
 758             TrackingList[i].iHoverTime+=iTimerInterval;
 759
 760             /* has the cursor moved outside the rectangle centered around pos? */
 761             if((abs(pos.x - TrackingList[i].pos.x) > (hoverwidth / 2.0))
 762               || (abs(pos.y - TrackingList[i].pos.y) > (hoverheight / 2.0)))
 763             {
 764                 /* record this new position as the current position and reset */
 765                 /* the iHoverTime variable to 0 */
 766                 TrackingList[i].pos = pos;
 767                 TrackingList[i].iHoverTime = 0;
 768             }
 769
 770             /* has the mouse hovered long enough? */
 771             if(TrackingList[i].iHoverTime <= TrackingList[i].tme.dwHoverTime)
 772             {
 773                 posClient.x = pos.x;
 774                 posClient.y = pos.y;
 775                 ScreenToClient(hwnd, &posClient);
 776                 if (nonclient) {
 777                     PostMessageW(TrackingList[i].tme.hwndTrack, WM_NCMOUSEHOVER,
 778                                 get_key_state(), MAKELPARAM( posClient.x, posClient.y ));
 779                 }
 780                 else {
 781                     PostMessageW(TrackingList[i].tme.hwndTrack, WM_MOUSEHOVER,
 782                                 get_key_state(), MAKELPARAM( posClient.x, posClient.y ));
 783                 }
 784
 785                 /* stop tracking mouse hover */
 786                 TrackingList[i].tme.dwFlags ^= TME_HOVER;
 787             }
 788         }
 789
 790         /* see if we are still tracking TME_HOVER or TME_LEAVE for this entry */
 791         if((TrackingList[i].tme.dwFlags & TME_HOVER) ||
 792            (TrackingList[i].tme.dwFlags & TME_LEAVE)) {
 793             i++;
 794         } else { /* remove this entry from the tracking list */
 795             TrackingList[i] = TrackingList[--iTrackMax];
 796         }
 797     }
 798
 799     /* stop the timer if the tracking list is empty */
 800     if(iTrackMax == 0) {
 801         KillTimer(0, timer);
 802         timer = 0;
 803     }
 804 }
 805
 806
 807 /***********************************************************************
 808  * TrackMouseEvent [USER32]
 809  *
 810  * Requests notification of mouse events
 811  *
 812  * During mouse tracking WM_MOUSEHOVER or WM_MOUSELEAVE events are posted
 813  * to the hwnd specified in the ptme structure.  After the event message
 814  * is posted to the hwnd, the entry in the queue is removed.
 815  *
 816  * If the current hwnd isn't ptme->hwndTrack the TME_HOVER flag is completely
 817  * ignored. The TME_LEAVE flag results in a WM_MOUSELEAVE message being posted
 818  * immediately and the TME_LEAVE flag being ignored.
 819  *
 820  * PARAMS
 821  *     ptme [I,O] pointer to TRACKMOUSEEVENT information structure.
 822  *
 823  * RETURNS
 824  *     Success: non-zero
 825  *     Failure: zero
 826  *
 827  */
 828
 829 BOOL WINAPI
 830 TrackMouseEvent (TRACKMOUSEEVENT *ptme)
 831 {
 832     DWORD flags = 0;
 833     int i = 0;
 834     BOOL cancel = 0, hover = 0, leave = 0, query = 0, nonclient = 0, inclient = 0;
 835     HWND hwnd;
 836     POINT pos;
 837     RECT client;
 838
 839
 840     pos.x = 0;
 841     pos.y = 0;
 842     SetRectEmpty(&client);
 843
 844     TRACE("%lx, %lx, %p, %lx\n", ptme->cbSize, ptme->dwFlags, ptme->hwndTrack, ptme->dwHoverTime);
 845
 846     if (ptme->cbSize != sizeof(TRACKMOUSEEVENT)) {
 847         WARN("wrong TRACKMOUSEEVENT size from app\n");
 848         SetLastError(ERROR_INVALID_PARAMETER); /* FIXME not sure if this is correct */
 849         return FALSE;
 850     }
 851
 852     flags = ptme->dwFlags;
 853
 854     /* if HOVER_DEFAULT was specified replace this with the systems current value */
 855     if(ptme->dwHoverTime == HOVER_DEFAULT)
 856         SystemParametersInfoA(SPI_GETMOUSEHOVERTIME, 0, &(ptme->dwHoverTime), 0);
 857
 858     GetCursorPos(&pos);
 859     hwnd = WindowFromPoint(pos);
 860
 861     if ( flags & TME_CANCEL ) {
 862         flags &= ~ TME_CANCEL;
 863         cancel = 1;
 864     }
 865
 866     if ( flags & TME_HOVER  ) {
 867         flags &= ~ TME_HOVER;
 868         hover = 1;
 869     }
 870
 871     if ( flags & TME_LEAVE ) {
 872         flags &= ~ TME_LEAVE;
 873         leave = 1;
 874     }
 875
 876     if ( flags & TME_NONCLIENT ) {
 877         flags &= ~ TME_NONCLIENT;
 878         nonclient = 1;
 879     }
 880
 881     /* fill the TRACKMOUSEEVENT struct with the current tracking for the given hwnd */
 882     if ( flags & TME_QUERY ) {
 883         flags &= ~ TME_QUERY;
 884         query = 1;
 885         i = 0;
 886
 887         /* Find the tracking list entry with the matching hwnd */
 888         while((i < iTrackMax) && (TrackingList[i].tme.hwndTrack != ptme->hwndTrack)) {
 889             i++;
 890         }
 891
 892         /* hwnd found, fill in the ptme struct */
 893         if(i < iTrackMax)
 894             *ptme = TrackingList[i].tme;
 895         else
 896             ptme->dwFlags = 0;
 897
 898         return TRUE; /* return here, TME_QUERY is retrieving information */
 899     }
 900
 901     if ( flags )
 902         FIXME("Unknown flag(s) %08lx\n", flags );
 903
 904     if(cancel) {
 905         /* find a matching hwnd if one exists */
 906         i = 0;
 907
 908         while((i < iTrackMax) && (TrackingList[i].tme.hwndTrack != ptme->hwndTrack)) {
 909           i++;
 910         }
 911
 912         if(i < iTrackMax) {
 913             TrackingList[i].tme.dwFlags &= ~(ptme->dwFlags & ~TME_CANCEL);
 914
 915             /* if we aren't tracking on hover or leave remove this entry */
 916             if(!((TrackingList[i].tme.dwFlags & TME_HOVER) ||
 917                  (TrackingList[i].tme.dwFlags & TME_LEAVE)))
 918             {
 919                 TrackingList[i] = TrackingList[--iTrackMax];
 920
 921                 if(iTrackMax == 0) {
 922                     KillTimer(0, timer);
 923                     timer = 0;
 924                 }
 925             }
 926         }
 927     } else {
 928         /* see if hwndTrack isn't the current window */
 929         if(ptme->hwndTrack != hwnd) {
 930             if(leave) {
 931                 if(nonclient) {
 932                     PostMessageA(ptme->hwndTrack, WM_NCMOUSELEAVE, 0, 0);
 933                 }
 934                 else {
 935                     PostMessageA(ptme->hwndTrack, WM_MOUSELEAVE, 0, 0);
 936                 }
 937             }
 938         } else {
 939             GetClientRect(ptme->hwndTrack, &client);
 940             MapWindowPoints(ptme->hwndTrack, NULL, (LPPOINT)&client, 2);
 941             if(PtInRect(&client, pos)) {
 942                 inclient = 1;
 943             }
 944             if(nonclient && inclient) {
 945                 PostMessageA(ptme->hwndTrack, WM_NCMOUSELEAVE, 0, 0);
 946                 return TRUE;
 947             }
 948             else if(!nonclient && !inclient) {
 949                 PostMessageA(ptme->hwndTrack, WM_MOUSELEAVE, 0, 0);
 950                 return TRUE;
 951             }
 952
 953             /* See if this hwnd is already being tracked and update the tracking flags */
 954             for(i = 0; i < iTrackMax; i++) {
 955                 if(TrackingList[i].tme.hwndTrack == ptme->hwndTrack) {
 956                     TrackingList[i].tme.dwFlags = 0;
 957
 958                     if(hover) {
 959                         TrackingList[i].tme.dwFlags |= TME_HOVER;
 960                         TrackingList[i].tme.dwHoverTime = ptme->dwHoverTime;
 961                     }
 962
 963                     if(leave)
 964                         TrackingList[i].tme.dwFlags |= TME_LEAVE;
 965
 966                     if(nonclient)
 967                         TrackingList[i].tme.dwFlags |= TME_NONCLIENT;
 968
 969                     /* reset iHoverTime as per winapi specs */
 970                     TrackingList[i].iHoverTime = 0;
 971
 972                     return TRUE;
 973                 }
 974             }
 975
 976             /* if the tracking list is full return FALSE */
 977             if (iTrackMax == sizeof (TrackingList) / sizeof(*TrackingList)) {
 978                 return FALSE;
 979             }
 980
 981             /* Adding new mouse event to the tracking list */
 982             TrackingList[iTrackMax].tme = *ptme;
 983
 984             /* Initialize HoverInfo variables even if not hover tracking */
 985             TrackingList[iTrackMax].iHoverTime = 0;
 986             TrackingList[iTrackMax].pos = pos;
 987
 988             iTrackMax++;
 989
 990             if (!timer) {
 991                 timer = SetTimer(0, 0, iTimerInterval, TrackMouseEventProc);
 992             }
 993         }
 994     }
 995
 996     return TRUE;
 997 }