windows/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  */
  11
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <stdio.h>
  15 #include <ctype.h>
  16 #include <assert.h>
  17
  18 #include "windef.h"
  19 #include "wingdi.h"
  20 #include "winuser.h"
  21 #include "wine/winbase16.h"
  22 #include "wine/winuser16.h"
  23 #include "wine/winestring.h"
  24 #include "wine/keyboard16.h"
  25 #include "win.h"
  26 #include "heap.h"
  27 #include "input.h"
  28 #include "keyboard.h"
  29 #include "mouse.h"
  30 #include "message.h"
  31 #include "queue.h"
  32 #include "module.h"
  33 #include "debugtools.h"
  34 #include "winerror.h"
  35 #include "task.h"
  36
  37 DECLARE_DEBUG_CHANNEL(event);
  38 DECLARE_DEBUG_CHANNEL(key);
  39 DECLARE_DEBUG_CHANNEL(keyboard);
  40 DECLARE_DEBUG_CHANNEL(win);
  41
  42 static BOOL InputEnabled = TRUE;
  43 BOOL SwappedButtons = FALSE;
  44
  45 BOOL MouseButtonsStates[3];
  46 BOOL AsyncMouseButtonsStates[3];
  47 BYTE InputKeyStateTable[256];
  48 BYTE QueueKeyStateTable[256];
  49 BYTE AsyncKeyStateTable[256];
  50
  51 /* Storage for the USER-maintained mouse positions */
  52 DWORD PosX, PosY;
  53
  54 typedef union
  55 {
  56     struct
  57     {
  58         unsigned long count : 16;
  59         unsigned long code : 8;
  60         unsigned long extended : 1;
  61         unsigned long unused : 2;
  62         unsigned long win_internal : 2;
  63         unsigned long context : 1;
  64         unsigned long previous : 1;
  65         unsigned long transition : 1;
  66     } lp1;
  67     unsigned long lp2;
  68 } KEYLP;
  69
  70 /***********************************************************************
  71  *           keybd_event   (USER32.583)
  72  */
  73 void WINAPI keybd_event( BYTE bVk, BYTE bScan,
  74                          DWORD dwFlags, DWORD dwExtraInfo )
  75 {
  76     DWORD time, extra;
  77     WORD message;
  78     KEYLP keylp;
  79     keylp.lp2 = 0;
  80
  81     if (!InputEnabled) return;
  82
  83     /*
  84      * If we are called by the Wine keyboard driver, use the additional
  85      * info pointed to by the dwExtraInfo argument.
  86      * Otherwise, we need to determine that info ourselves (probably
  87      * less accurate, but we can't help that ...).
  88      */
  89     if (   !IsBadReadPtr( (LPVOID)dwExtraInfo, sizeof(WINE_KEYBDEVENT) )
  90         && ((WINE_KEYBDEVENT *)dwExtraInfo)->magic == WINE_KEYBDEVENT_MAGIC )
  91     {
  92         WINE_KEYBDEVENT *wke = (WINE_KEYBDEVENT *)dwExtraInfo;
  93         time = wke->time;
  94         extra = 0;
  95     }
  96     else
  97     {
  98         time = GetTickCount();
  99         extra = dwExtraInfo;
 100     }
 101
 102
 103     keylp.lp1.count = 1;
 104     keylp.lp1.code = bScan;
 105     keylp.lp1.extended = (dwFlags & KEYEVENTF_EXTENDEDKEY) != 0;
 106     keylp.lp1.win_internal = 0; /* this has something to do with dialogs,
 107                                 * don't remember where I read it - AK */
 108                                 /* it's '1' under windows, when a dialog box appears
 109                                  * and you press one of the underlined keys - DF*/
 110
 111     if ( dwFlags & KEYEVENTF_KEYUP )
 112     {
 113         BOOL sysKey = (InputKeyStateTable[VK_MENU] & 0x80)
 114                 && !(InputKeyStateTable[VK_CONTROL] & 0x80)
 115                 && !(dwFlags & KEYEVENTF_WINE_FORCEEXTENDED); /* for Alt from AltGr */
 116
 117         InputKeyStateTable[bVk] &= ~0x80;
 118         keylp.lp1.previous = 1;
 119         keylp.lp1.transition = 1;
 120         message = sysKey ? WM_SYSKEYUP : WM_KEYUP;
 121     }
 122     else
 123     {
 124         keylp.lp1.previous = (InputKeyStateTable[bVk] & 0x80) != 0;
 125         keylp.lp1.transition = 0;
 126
 127         if (!(InputKeyStateTable[bVk] & 0x80))
 128             InputKeyStateTable[bVk] ^= 0x01;
 129         InputKeyStateTable[bVk] |= 0x80;
 130
 131         message = (InputKeyStateTable[VK_MENU] & 0x80)
 132               && !(InputKeyStateTable[VK_CONTROL] & 0x80)
 133               ? WM_SYSKEYDOWN : WM_KEYDOWN;
 134     }
 135
 136     if ( message == WM_SYSKEYDOWN || message == WM_SYSKEYUP )
 137         keylp.lp1.context = (InputKeyStateTable[VK_MENU] & 0x80) != 0; /* 1 if alt */
 138
 139
 140     TRACE_(key)("            wParam=%04X, lParam=%08lX\n", bVk, keylp.lp2 );
 141     TRACE_(key)("            InputKeyState=%X\n", InputKeyStateTable[bVk] );
 142
 143     hardware_event( message, bVk, keylp.lp2, PosX, PosY, time, extra );
 144 }
 145
 146 /***********************************************************************
 147  *           WIN16_keybd_event   (USER.289)
 148  */
 149 void WINAPI WIN16_keybd_event( CONTEXT86 *context )
 150 {
 151     DWORD dwFlags = 0;
 152
 153     if (AH_reg(context) & 0x80) dwFlags |= KEYEVENTF_KEYUP;
 154     if (BH_reg(context) & 1   ) dwFlags |= KEYEVENTF_EXTENDEDKEY;
 155
 156     keybd_event( AL_reg(context), BL_reg(context),
 157                  dwFlags, MAKELONG(SI_reg(context), DI_reg(context)) );
 158 }
 159
 160 /***********************************************************************
 161  *           mouse_event   (USER32.584)
 162  */
 163 void WINAPI mouse_event( DWORD dwFlags, DWORD dx, DWORD dy,
 164                          DWORD cButtons, DWORD dwExtraInfo )
 165 {
 166     DWORD time, extra;
 167     DWORD keyState;
 168
 169     if (!InputEnabled) return;
 170
 171     if ( dwFlags & MOUSEEVENTF_MOVE )
 172       {
 173         if ( dwFlags & MOUSEEVENTF_ABSOLUTE )
 174           {
 175             PosX = (dx * GetSystemMetrics(SM_CXSCREEN)) >> 16;
 176             PosY = (dy * GetSystemMetrics(SM_CYSCREEN)) >> 16;
 177           }
 178         else
 179           {
 180             int width  = GetSystemMetrics(SM_CXSCREEN);
 181             int height = GetSystemMetrics(SM_CYSCREEN);
 182             long posX = (long) PosX, posY = (long) PosY;
 183
 184             /* dx and dy can be negative numbers for relative movements */
 185             posX += (long) dx;
 186             posY += (long) dy;
 187
 188             /* Clip to the current screen size */
 189             if (posX < 0) PosX = 0;
 190             else if (posX >= width) PosX = width - 1;
 191             else PosX = posX;
 192
 193             if (posY < 0) PosY = 0;
 194             else if (posY >= height) PosY = height - 1;
 195             else PosY = posY;
 196           }
 197       }
 198
 199     /*
 200      * If we are called by the Wine mouse driver, use the additional
 201      * info pointed to by the dwExtraInfo argument.
 202      * Otherwise, we need to determine that info ourselves (probably
 203      * less accurate, but we can't help that ...).
 204      */
 205     if (   !IsBadReadPtr( (LPVOID)dwExtraInfo, sizeof(WINE_MOUSEEVENT) )
 206         && ((WINE_MOUSEEVENT *)dwExtraInfo)->magic == WINE_MOUSEEVENT_MAGIC )
 207     {
 208         WINE_MOUSEEVENT *wme = (WINE_MOUSEEVENT *)dwExtraInfo;
 209         time = wme->time;
 210         extra = (DWORD)wme->hWnd;
 211         keyState = wme->keyState;
 212
 213         if (keyState != GET_KEYSTATE()) {
 214           /* We need to update the keystate with what X provides us */
 215           MouseButtonsStates[SwappedButtons ? 2 : 0] = (keyState & MK_LBUTTON ? TRUE : FALSE);
 216           MouseButtonsStates[SwappedButtons ? 0 : 2] = (keyState & MK_RBUTTON ? TRUE : FALSE);
 217           MouseButtonsStates[1]                      = (keyState & MK_MBUTTON ? TRUE : FALSE);
 218           InputKeyStateTable[VK_SHIFT]               = (keyState & MK_SHIFT   ? 0x80 : 0);
 219           InputKeyStateTable[VK_CONTROL]             = (keyState & MK_CONTROL ? 0x80 : 0);
 220         }
 221     }
 222     else
 223     {
 224         time = GetTickCount();
 225         extra = dwExtraInfo;
 226         keyState = GET_KEYSTATE();
 227
 228         if ( dwFlags & MOUSEEVENTF_MOVE )
 229           {
 230             /* We have to actually move the cursor */
 231             SetCursorPos( PosX, PosY );
 232           }
 233     }
 234
 235
 236     if ( dwFlags & MOUSEEVENTF_MOVE )
 237     {
 238         hardware_event( WM_MOUSEMOVE,
 239                         keyState, 0L, PosX, PosY, time, extra );
 240     }
 241     if ( dwFlags & (!SwappedButtons? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_RIGHTDOWN) )
 242     {
 243         MouseButtonsStates[0] = AsyncMouseButtonsStates[0] = TRUE;
 244         hardware_event( WM_LBUTTONDOWN,
 245                         keyState, 0L, PosX, PosY, time, extra );
 246     }
 247     if ( dwFlags & (!SwappedButtons? MOUSEEVENTF_LEFTUP : MOUSEEVENTF_RIGHTUP) )
 248     {
 249         MouseButtonsStates[0] = FALSE;
 250         hardware_event( WM_LBUTTONUP,
 251                         keyState, 0L, PosX, PosY, time, extra );
 252     }
 253     if ( dwFlags & (!SwappedButtons? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_LEFTDOWN) )
 254     {
 255         MouseButtonsStates[2] = AsyncMouseButtonsStates[2] = TRUE;
 256         hardware_event( WM_RBUTTONDOWN,
 257                         keyState, 0L, PosX, PosY, time, extra );
 258     }
 259     if ( dwFlags & (!SwappedButtons? MOUSEEVENTF_RIGHTUP : MOUSEEVENTF_LEFTUP) )
 260     {
 261         MouseButtonsStates[2] = FALSE;
 262         hardware_event( WM_RBUTTONUP,
 263                         keyState, 0L, PosX, PosY, time, extra );
 264     }
 265     if ( dwFlags & MOUSEEVENTF_MIDDLEDOWN )
 266     {
 267         MouseButtonsStates[1] = AsyncMouseButtonsStates[1] = TRUE;
 268         hardware_event( WM_MBUTTONDOWN,
 269                         keyState, 0L, PosX, PosY, time, extra );
 270     }
 271     if ( dwFlags & MOUSEEVENTF_MIDDLEUP )
 272     {
 273         MouseButtonsStates[1] = FALSE;
 274         hardware_event( WM_MBUTTONUP,
 275                         keyState, 0L, PosX, PosY, time, extra );
 276     }
 277     if ( dwFlags & MOUSEEVENTF_WHEEL )
 278     {
 279         hardware_event( WM_MOUSEWHEEL,
 280                         keyState, 0L, PosX, PosY, time, extra );
 281     }
 282 }
 283
 284 /***********************************************************************
 285  *           WIN16_mouse_event   (USER.299)
 286  */
 287 void WINAPI WIN16_mouse_event( CONTEXT86 *context )
 288 {
 289     mouse_event( AX_reg(context), BX_reg(context), CX_reg(context),
 290                  DX_reg(context), MAKELONG(SI_reg(context), DI_reg(context)) );
 291 }
 292
 293 /***********************************************************************
 294  *           GetMouseEventProc   (USER.337)
 295  */
 296 FARPROC16 WINAPI GetMouseEventProc16(void)
 297 {
 298     HMODULE16 hmodule = GetModuleHandle16("USER");
 299     return NE_GetEntryPoint( hmodule, NE_GetOrdinal( hmodule, "mouse_event" ));
 300 }
 301
 302
 303 /**********************************************************************
 304  *                      EnableHardwareInput   (USER.331)
 305  */
 306 BOOL16 WINAPI EnableHardwareInput16(BOOL16 bEnable)
 307 {
 308   BOOL16 bOldState = InputEnabled;
 309   FIXME_(event)("(%d) - stub\n", bEnable);
 310   InputEnabled = bEnable;
 311   return bOldState;
 312 }
 313
 314
 315 /***********************************************************************
 316  *           SwapMouseButton16   (USER.186)
 317  */
 318 BOOL16 WINAPI SwapMouseButton16( BOOL16 fSwap )
 319 {
 320     BOOL16 ret = SwappedButtons;
 321     SwappedButtons = fSwap;
 322     return ret;
 323 }
 324
 325
 326 /***********************************************************************
 327  *           SwapMouseButton   (USER32.537)
 328  */
 329 BOOL WINAPI SwapMouseButton( BOOL fSwap )
 330 {
 331     BOOL ret = SwappedButtons;
 332     SwappedButtons = fSwap;
 333     return ret;
 334 }
 335
 336 /**********************************************************************
 337  *              EVENT_Capture
 338  *
 339  * We need this to be able to generate double click messages
 340  * when menu code captures mouse in the window without CS_DBLCLK style.
 341  */
 342 HWND EVENT_Capture(HWND hwnd, INT16 ht)
 343 {
 344     HWND capturePrev = 0, captureWnd = 0;
 345     MESSAGEQUEUE *pMsgQ = 0, *pCurMsgQ = 0;
 346     WND* wndPtr = 0;
 347     INT16 captureHT = 0;
 348
 349     /* Get the messageQ for the current thread */
 350     if (!(pCurMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() )))
 351     {
 352         WARN_(win)("\tCurrent message queue not found. Exiting!\n" );
 353         goto CLEANUP;
 354     }
 355
 356     /* Get the current capture window from the perQ data of the current message Q */
 357     capturePrev = PERQDATA_GetCaptureWnd( pCurMsgQ->pQData );
 358
 359     if (!hwnd)
 360     {
 361         captureWnd = 0L;
 362         captureHT = 0;
 363     }
 364     else
 365     {
 366         wndPtr = WIN_FindWndPtr( hwnd );
 367         if (wndPtr)
 368         {
 369             TRACE_(win)("(0x%04x)\n", hwnd );
 370             captureWnd   = hwnd;
 371             captureHT    = ht;
 372         }
 373     }
 374
 375     /* Update the perQ capture window and send messages */
 376     if( capturePrev != captureWnd )
 377     {
 378         if (wndPtr)
 379         {
 380             /* Retrieve the message queue associated with this window */
 381             pMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( wndPtr->hmemTaskQ );
 382             if ( !pMsgQ )
 383             {
 384                 WARN_(win)("\tMessage queue not found. Exiting!\n" );
 385                 goto CLEANUP;
 386             }
 387
 388             /* Make sure that message queue for the window we are setting capture to
 389              * shares the same perQ data as the current threads message queue.
 390              */
 391             if ( pCurMsgQ->pQData != pMsgQ->pQData )
 392                 goto CLEANUP;
 393         }
 394
 395         PERQDATA_SetCaptureWnd( pCurMsgQ->pQData, captureWnd );
 396         PERQDATA_SetCaptureInfo( pCurMsgQ->pQData, captureHT );
 397
 398         if( capturePrev )
 399     {
 400         WND* xwndPtr = WIN_FindWndPtr( capturePrev );
 401         if( xwndPtr && (xwndPtr->flags & WIN_ISWIN32) )
 402             SendMessageA( capturePrev, WM_CAPTURECHANGED, 0L, hwnd);
 403         WIN_ReleaseWndPtr(xwndPtr);
 404     }
 405 }
 406
 407 CLEANUP:
 408     /* Unlock the queues before returning */
 409     if ( pMsgQ )
 410         QUEUE_Unlock( pMsgQ );
 411     if ( pCurMsgQ )
 412         QUEUE_Unlock( pCurMsgQ );
 413
 414     WIN_ReleaseWndPtr(wndPtr);
 415     return capturePrev;
 416 }
 417
 418
 419 /**********************************************************************
 420  *              SetCapture16   (USER.18)
 421  */
 422 HWND16 WINAPI SetCapture16( HWND16 hwnd )
 423 {
 424     return (HWND16)EVENT_Capture( hwnd, HTCLIENT );
 425 }
 426
 427
 428 /**********************************************************************
 429  *              SetCapture   (USER32.464)
 430  */
 431 HWND WINAPI SetCapture( HWND hwnd )
 432 {
 433     return EVENT_Capture( hwnd, HTCLIENT );
 434 }
 435
 436
 437 /**********************************************************************
 438  *              ReleaseCapture   (USER.19) (USER32.439)
 439  */
 440 BOOL WINAPI ReleaseCapture(void)
 441 {
 442     return (EVENT_Capture( 0, 0 ) != 0);
 443 }
 444
 445
 446 /**********************************************************************
 447  *              GetCapture16   (USER.236)
 448  */
 449 HWND16 WINAPI GetCapture16(void)
 450 {
 451     return (HWND16)GetCapture();
 452 }
 453
 454 /**********************************************************************
 455  *              GetCapture   (USER32.208)
 456  */
 457 HWND WINAPI GetCapture(void)
 458 {
 459     MESSAGEQUEUE *pCurMsgQ = 0;
 460     HWND hwndCapture = 0;
 461
 462     /* Get the messageQ for the current thread */
 463     if (!(pCurMsgQ = (MESSAGEQUEUE *)QUEUE_Lock( GetFastQueue16() )))
 464 {
 465         TRACE_(win)("GetCapture: Current message queue not found. Exiting!\n" );
 466         return 0;
 467     }
 468
 469     /* Get the current capture window from the perQ data of the current message Q */
 470     hwndCapture = PERQDATA_GetCaptureWnd( pCurMsgQ->pQData );
 471
 472     QUEUE_Unlock( pCurMsgQ );
 473     return hwndCapture;
 474 }
 475
 476 /**********************************************************************
 477  *           GetKeyState      (USER.106)
 478  */
 479 INT16 WINAPI GetKeyState16(INT16 vkey)
 480 {
 481     return GetKeyState(vkey);
 482 }
 483
 484 /**********************************************************************
 485  *           GetKeyState      (USER32.249)
 486  *
 487  * An application calls the GetKeyState function in response to a
 488  * keyboard-input message.  This function retrieves the state of the key
 489  * at the time the input message was generated.  (SDK 3.1 Vol 2. p 390)
 490  */
 491 SHORT WINAPI GetKeyState(INT vkey)
 492 {
 493     INT retval;
 494
 495     switch (vkey)
 496         {
 497         case VK_LBUTTON : /* VK_LBUTTON is 1 */
 498             retval = MouseButtonsStates[0] ? 0x8000 : 0;
 499             break;
 500         case VK_MBUTTON : /* VK_MBUTTON is 4 */
 501             retval = MouseButtonsStates[1] ? 0x8000 : 0;
 502             break;
 503         case VK_RBUTTON : /* VK_RBUTTON is 2 */
 504             retval = MouseButtonsStates[2] ? 0x8000 : 0;
 505             break;
 506         default :
 507             if (vkey >= 'a' && vkey <= 'z')
 508                 vkey += 'A' - 'a';
 509             retval = ( (WORD)(QueueKeyStateTable[vkey] & 0x80) << 8 ) |
 510                        (WORD)(QueueKeyStateTable[vkey] & 0x01);
 511         }
 512     /* TRACE(key, "(0x%x) -> %x\n", vkey, retval); */
 513     return retval;
 514 }
 515
 516 /**********************************************************************
 517  *           GetKeyboardState      (USER.222)(USER32.254)
 518  *
 519  * An application calls the GetKeyboardState function in response to a
 520  * keyboard-input message.  This function retrieves the state of the keyboard
 521  * at the time the input message was generated.  (SDK 3.1 Vol 2. p 387)
 522  */
 523 BOOL WINAPI GetKeyboardState(LPBYTE lpKeyState)
 524 {
 525     TRACE_(key)("(%p)\n", lpKeyState);
 526     if (lpKeyState != NULL) {
 527         QueueKeyStateTable[VK_LBUTTON] = MouseButtonsStates[0] ? 0x80 : 0;
 528         QueueKeyStateTable[VK_MBUTTON] = MouseButtonsStates[1] ? 0x80 : 0;
 529         QueueKeyStateTable[VK_RBUTTON] = MouseButtonsStates[2] ? 0x80 : 0;
 530         memcpy(lpKeyState, QueueKeyStateTable, 256);
 531     }
 532
 533     return TRUE;
 534 }
 535
 536 /**********************************************************************
 537  *          SetKeyboardState      (USER.223)(USER32.484)
 538  */
 539 BOOL WINAPI SetKeyboardState(LPBYTE lpKeyState)
 540 {
 541     TRACE_(key)("(%p)\n", lpKeyState);
 542     if (lpKeyState != NULL) {
 543         memcpy(QueueKeyStateTable, lpKeyState, 256);
 544         MouseButtonsStates[0] = (QueueKeyStateTable[VK_LBUTTON] != 0);
 545         MouseButtonsStates[1] = (QueueKeyStateTable[VK_MBUTTON] != 0);
 546         MouseButtonsStates[2] = (QueueKeyStateTable[VK_RBUTTON] != 0);
 547     }
 548
 549     return TRUE;
 550 }
 551
 552 /**********************************************************************
 553  *           GetAsyncKeyState      (USER32.207)
 554  *
 555  *      Determine if a key is or was pressed.  retval has high-order
 556  * bit set to 1 if currently pressed, low-order bit set to 1 if key has
 557  * been pressed.
 558  *
 559  *      This uses the variable AsyncMouseButtonsStates and
 560  * AsyncKeyStateTable (set in event.c) which have the mouse button
 561  * number or key number (whichever is applicable) set to true if the
 562  * mouse or key had been depressed since the last call to
 563  * GetAsyncKeyState.
 564  */
 565 WORD WINAPI GetAsyncKeyState(INT nKey)
 566 {
 567     short retval;
 568
 569     switch (nKey) {
 570      case VK_LBUTTON:
 571         retval = (AsyncMouseButtonsStates[0] ? 0x0001 : 0) |
 572                  (MouseButtonsStates[0] ? 0x8000 : 0);
 573         break;
 574      case VK_MBUTTON:
 575         retval = (AsyncMouseButtonsStates[1] ? 0x0001 : 0) |
 576                  (MouseButtonsStates[1] ? 0x8000 : 0);
 577         break;
 578      case VK_RBUTTON:
 579         retval = (AsyncMouseButtonsStates[2] ? 0x0001 : 0) |
 580                  (MouseButtonsStates[2] ? 0x8000 : 0);
 581         break;
 582      default:
 583         retval = AsyncKeyStateTable[nKey] |
 584                 ((InputKeyStateTable[nKey] & 0x80) ? 0x8000 : 0);
 585         break;
 586     }
 587
 588     /* all states to false */
 589     memset( AsyncMouseButtonsStates, 0, sizeof(AsyncMouseButtonsStates) );
 590     memset( AsyncKeyStateTable, 0, sizeof(AsyncKeyStateTable) );
 591
 592     TRACE_(key)("(%x) -> %x\n", nKey, retval);
 593     return retval;
 594 }
 595
 596 /**********************************************************************
 597  *            GetAsyncKeyState16        (USER.249)
 598  */
 599 WORD WINAPI GetAsyncKeyState16(INT16 nKey)
 600 {
 601     return GetAsyncKeyState(nKey);
 602 }
 603
 604 /***********************************************************************
 605  *              IsUserIdle      (USER.333)
 606  */
 607 BOOL16 WINAPI IsUserIdle16(void)
 608 {
 609     if ( GetAsyncKeyState( VK_LBUTTON ) & 0x8000 )
 610         return FALSE;
 611
 612     if ( GetAsyncKeyState( VK_RBUTTON ) & 0x8000 )
 613         return FALSE;
 614
 615     if ( GetAsyncKeyState( VK_MBUTTON ) & 0x8000 )
 616         return FALSE;
 617
 618     /* Should check for screen saver activation here ... */
 619
 620     return TRUE;
 621 }
 622
 623 /**********************************************************************
 624  *           VkKeyScanA      (USER32.573)
 625  */
 626 WORD WINAPI VkKeyScanA(CHAR cChar)
 627 {
 628         return VkKeyScan16(cChar);
 629 }
 630
 631 /******************************************************************************
 632  *      VkKeyScanW      (USER32.576)
 633  */
 634 WORD WINAPI VkKeyScanW(WCHAR cChar)
 635 {
 636         return VkKeyScanA((CHAR)cChar); /* FIXME: check unicode */
 637 }
 638
 639 /**********************************************************************
 640  *           VkKeyScanExA      (USER32.574)
 641  */
 642 WORD WINAPI VkKeyScanExA(CHAR cChar, HKL dwhkl)
 643 {
 644                                 /* FIXME: complete workaround this is */
 645                                 return VkKeyScan16(cChar);
 646 }
 647
 648 /******************************************************************************
 649  *      VkKeyScanExW      (USER32.575)
 650  */
 651 WORD WINAPI VkKeyScanExW(WCHAR cChar, HKL dwhkl)
 652 {
 653                                 /* FIXME: complete workaround this is */
 654                                 return VkKeyScanA((CHAR)cChar); /* FIXME: check unicode */
 655 }
 656
 657 /******************************************************************************
 658  *      GetKeyboardType      (USER32.255)
 659  */
 660 INT WINAPI GetKeyboardType(INT nTypeFlag)
 661 {
 662   return GetKeyboardType16(nTypeFlag);
 663 }
 664
 665 /******************************************************************************
 666  *      MapVirtualKeyA      (USER32.383)
 667  */
 668 UINT WINAPI MapVirtualKeyA(UINT code, UINT maptype)
 669 {
 670     return MapVirtualKey16(code,maptype);
 671 }
 672
 673 /******************************************************************************
 674  *      MapVirtualKeyW      (USER32.385)
 675  */
 676 UINT WINAPI MapVirtualKeyW(UINT code, UINT maptype)
 677 {
 678     return MapVirtualKey16(code,maptype);
 679 }
 680
 681 /******************************************************************************
 682  *      MapVirtualKeyExA      (USER32.384)
 683  */
 684 UINT WINAPI MapVirtualKeyExA(UINT code, UINT maptype, HKL hkl)
 685 {
 686     if (hkl)
 687         FIXME_(keyboard)("(%d,%d,0x%08lx), hkl unhandled!\n",code,maptype,(DWORD)hkl);
 688     return MapVirtualKey16(code,maptype);
 689 }
 690
 691 /****************************************************************************
 692  *      GetKBCodePage   (USER32.246)
 693  */
 694 UINT WINAPI GetKBCodePage(void)
 695 {
 696     return GetKBCodePage16();
 697 }
 698
 699 /****************************************************************************
 700  *      GetKeyboardLayoutName16   (USER.477)
 701  */
 702 INT16 WINAPI GetKeyboardLayoutName16(LPSTR pwszKLID)
 703 {
 704         return GetKeyboardLayoutNameA(pwszKLID);
 705 }
 706
 707 /***********************************************************************
 708  *           GetKeyboardLayout                  (USER32.250)
 709  *
 710  * FIXME: - device handle for keyboard layout defaulted to
 711  *          the language id. This is the way Windows default works.
 712  *        - the thread identifier (dwLayout) is also ignored.
 713  */
 714 HKL WINAPI GetKeyboardLayout(DWORD dwLayout)
 715 {
 716         HKL layout;
 717         layout = GetSystemDefaultLCID(); /* FIXME */
 718         layout |= (layout<<16);          /* FIXME */
 719         TRACE_(keyboard)("returning %08x\n",layout);
 720         return layout;
 721 }
 722
 723 /****************************************************************************
 724  *      GetKeyboardLayoutNameA   (USER32.252)
 725  */
 726 INT WINAPI GetKeyboardLayoutNameA(LPSTR pwszKLID)
 727 {
 728         sprintf(pwszKLID, "%08x",GetKeyboardLayout(0));
 729         return 1;
 730 }
 731
 732 /****************************************************************************
 733  *      GetKeyboardLayoutNameW   (USER32.253)
 734  */
 735 INT WINAPI GetKeyboardLayoutNameW(LPWSTR pwszKLID)
 736 {
 737         char buf[9];
 738         int res = GetKeyboardLayoutNameA(buf);
 739         lstrcpyAtoW(pwszKLID,buf);
 740         return res;
 741 }
 742
 743 /****************************************************************************
 744  *      GetKeyNameTextA   (USER32.247)
 745  */
 746 INT WINAPI GetKeyNameTextA(LONG lParam, LPSTR lpBuffer, INT nSize)
 747 {
 748         return GetKeyNameText16(lParam,lpBuffer,nSize);
 749 }
 750
 751 /****************************************************************************
 752  *      GetKeyNameTextW   (USER32.248)
 753  */
 754 INT WINAPI GetKeyNameTextW(LONG lParam, LPWSTR lpBuffer, INT nSize)
 755 {
 756         int res;
 757         LPSTR buf = HeapAlloc( GetProcessHeap(), 0, nSize );
 758         if(buf == NULL) return 0; /* FIXME: is this the correct failure value?*/
 759         res = GetKeyNameTextA(lParam,buf,nSize);
 760
 761         lstrcpynAtoW(lpBuffer,buf,nSize);
 762         HeapFree( GetProcessHeap(), 0, buf );
 763         return res;
 764 }
 765
 766 /****************************************************************************
 767  *      ToUnicode      (USER32.@)
 768  */
 769 INT WINAPI ToUnicode(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 770                      LPWSTR lpwStr, int size, UINT flags)
 771 {
 772     return USER_Driver.pToUnicode(virtKey, scanCode, lpKeyState, lpwStr, size, flags);
 773 }
 774
 775 /****************************************************************************
 776  *      ToUnicodeEx      (USER32.@)
 777  */
 778 INT WINAPI ToUnicodeEx(UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 779                        LPWSTR lpwStr, int size, UINT flags, HKL hkl)
 780 {
 781     /* FIXME: need true implementation */
 782     return ToUnicode(virtKey, scanCode, lpKeyState, lpwStr, size, flags);
 783 }
 784
 785 /****************************************************************************
 786  *      ToAscii      (USER32.546)
 787  */
 788 INT WINAPI ToAscii( UINT virtKey,UINT scanCode,LPBYTE lpKeyState,
 789                         LPWORD lpChar,UINT flags )
 790 {
 791     WCHAR uni_chars[2];
 792     INT ret, n_ret;
 793
 794     ret = ToUnicode(virtKey, scanCode, lpKeyState, uni_chars, 2, flags);
 795     if(ret < 0) n_ret = 1; /* FIXME: make ToUnicode return 2 for dead chars */
 796     else n_ret = ret;
 797     WideCharToMultiByte(CP_ACP, 0, uni_chars, n_ret, (LPSTR)lpChar, 2, NULL, NULL);
 798     return ret;
 799 }
 800
 801 /****************************************************************************
 802  *      ToAsciiEx      (USER32.547)
 803  */
 804 INT WINAPI ToAsciiEx( UINT virtKey, UINT scanCode, LPBYTE lpKeyState,
 805                       LPWORD lpChar, UINT flags, HKL dwhkl )
 806 {
 807     /* FIXME: need true implementation */
 808     return ToAscii(virtKey, scanCode, lpKeyState, lpChar, flags);
 809 }
 810
 811 /**********************************************************************
 812  *           ActivateKeyboardLayout      (USER32.1)
 813  *
 814  * Call ignored. WINE supports only system default keyboard layout.
 815  */
 816 HKL WINAPI ActivateKeyboardLayout(HKL hLayout, UINT flags)
 817 {
 818     TRACE_(keyboard)("(%d, %d)\n", hLayout, flags);
 819     ERR_(keyboard)("Only default system keyboard layout supported. Call ignored.\n");
 820     return 0;
 821 }
 822
 823
 824 /***********************************************************************
 825  *           GetKeyboardLayoutList              (USER32.251)
 826  *
 827  * FIXME: Supports only the system default language and layout and
 828  *          returns only 1 value.
 829  *
 830  * Return number of values available if either input parm is
 831  *  0, per MS documentation.
 832  *
 833  */
 834 INT WINAPI GetKeyboardLayoutList(INT nBuff,HKL *layouts)
 835 {
 836         TRACE_(keyboard)("(%d,%p)\n",nBuff,layouts);
 837         if (!nBuff || !layouts)
 838             return 1;
 839         if (layouts)
 840                 layouts[0] = GetKeyboardLayout(0);
 841         return 1;
 842 }
 843
 844
 845 /***********************************************************************
 846  *           RegisterHotKey                     (USER32.433)
 847  */
 848 BOOL WINAPI RegisterHotKey(HWND hwnd,INT id,UINT modifiers,UINT vk) {
 849         FIXME_(keyboard)("(0x%08x,%d,0x%08x,%d): stub\n",hwnd,id,modifiers,vk);
 850         return TRUE;
 851 }
 852
 853 /***********************************************************************
 854  *           UnregisterHotKey                   (USER32.565)
 855  */
 856 BOOL WINAPI UnregisterHotKey(HWND hwnd,INT id) {
 857         FIXME_(keyboard)("(0x%08x,%d): stub\n",hwnd,id);
 858         return TRUE;
 859 }
 860
 861 /***********************************************************************
 862  *           LoadKeyboardLayoutA                (USER32.367)
 863  * Call ignored. WINE supports only system default keyboard layout.
 864  */
 865 HKL WINAPI LoadKeyboardLayoutA(LPCSTR pwszKLID, UINT Flags)
 866 {
 867     TRACE_(keyboard)("(%s, %d)\n", pwszKLID, Flags);
 868     ERR_(keyboard)("Only default system keyboard layout supported. Call ignored.\n");
 869   return 0;
 870 }
 871
 872 /***********************************************************************
 873  *           LoadKeyboardLayoutW                (USER32.368)
 874  */
 875 HKL WINAPI LoadKeyboardLayoutW(LPCWSTR pwszKLID, UINT Flags)
 876 {
 877     char buf[9];
 878
 879     lstrcpynWtoA(buf,pwszKLID,8);
 880     buf[8] = 0;
 881     return LoadKeyboardLayoutA(buf, Flags);
 882 }