windows/message.c

   1 /*
   2  * Message queues related functions
   3  *
   4  * Copyright 1993, 1994 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <stdarg.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #ifdef HAVE_SYS_TIME_H
  29 # include <sys/time.h>
  30 #endif
  31 #include <sys/types.h>
  32
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "wingdi.h"
  36 #include "winuser.h"
  37 #include "message.h"
  38 #include "winerror.h"
  39 #include "ntstatus.h"
  40 #include "wine/server.h"
  41 #include "controls.h"
  42 #include "dde.h"
  43 #include "message.h"
  44 #include "user.h"
  45 #include "win.h"
  46 #include "winpos.h"
  47 #include "winproc.h"
  48 #include "wine/debug.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(msg);
  51 WINE_DECLARE_DEBUG_CHANNEL(key);
  52
  53 #define WM_NCMOUSEFIRST         WM_NCMOUSEMOVE
  54 #define WM_NCMOUSELAST          WM_NCMBUTTONDBLCLK
  55
  56
  57 /***********************************************************************
  58  *           is_keyboard_message
  59  */
  60 inline static BOOL is_keyboard_message( UINT message )
  61 {
  62     return (message >= WM_KEYFIRST && message <= WM_KEYLAST);
  63 }
  64
  65
  66 /***********************************************************************
  67  *           is_mouse_message
  68  */
  69 inline static BOOL is_mouse_message( UINT message )
  70 {
  71     return ((message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST) ||
  72             (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST));
  73 }
  74
  75
  76 /***********************************************************************
  77  *           check_message_filter
  78  */
  79 inline static BOOL check_message_filter( const MSG *msg, HWND hwnd, UINT first, UINT last )
  80 {
  81     if (hwnd)
  82     {
  83         if (msg->hwnd != hwnd && !IsChild( hwnd, msg->hwnd )) return FALSE;
  84     }
  85     if (first || last)
  86     {
  87        return (msg->message >= first && msg->message <= last);
  88     }
  89     return TRUE;
  90 }
  91
  92
  93 /***********************************************************************
  94  *           process_sent_messages
  95  *
  96  * Process all pending sent messages.
  97  */
  98 inline static void process_sent_messages(void)
  99 {
 100     MSG msg;
 101     MSG_peek_message( &msg, 0, 0, 0, GET_MSG_REMOVE | GET_MSG_SENT_ONLY );
 102 }
 103
 104
 105 /***********************************************************************
 106  *           queue_hardware_message
 107  *
 108  * store a hardware message in the thread queue
 109  */
 110 #if 0
 111 static void queue_hardware_message( MSG *msg, ULONG_PTR extra_info )
 112 {
 113     SERVER_START_REQ( send_message )
 114     {
 115         req->type   = MSG_HARDWARE;
 116         req->id     = GetWindowThreadProcessId( msg->hwnd, NULL );
 117         req->win    = msg->hwnd;
 118         req->msg    = msg->message;
 119         req->wparam = msg->wParam;
 120         req->lparam = msg->lParam;
 121         req->x      = msg->pt.x;
 122         req->y      = msg->pt.y;
 123         req->time   = msg->time;
 124         req->info   = extra_info;
 125         req->timeout = 0;
 126         wine_server_call( req );
 127     }
 128     SERVER_END_REQ;
 129 }
 130 #endif
 131
 132
 133 /***********************************************************************
 134  *           MSG_SendParentNotify
 135  *
 136  * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
 137  * the window has the WS_EX_NOPARENTNOTIFY style.
 138  */
 139 static void MSG_SendParentNotify( HWND hwnd, WORD event, WORD idChild, POINT pt )
 140 {
 141     /* pt has to be in the client coordinates of the parent window */
 142     MapWindowPoints( 0, hwnd, &pt, 1 );
 143     for (;;)
 144     {
 145         HWND parent;
 146
 147         if (!(GetWindowLongA( hwnd, GWL_STYLE ) & WS_CHILD)) break;
 148         if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) break;
 149         if (!(parent = GetParent(hwnd))) break;
 150         MapWindowPoints( hwnd, parent, &pt, 1 );
 151         hwnd = parent;
 152         SendMessageA( hwnd, WM_PARENTNOTIFY,
 153                       MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
 154     }
 155 }
 156
 157
 158 #if 0  /* this is broken for now, will require proper support in the server */
 159
 160 /***********************************************************************
 161  *          MSG_JournalPlayBackMsg
 162  *
 163  * Get an EVENTMSG struct via call JOURNALPLAYBACK hook function
 164  */
 165 void MSG_JournalPlayBackMsg(void)
 166 {
 167     EVENTMSG tmpMsg;
 168     MSG msg;
 169     LRESULT wtime;
 170     int keyDown,i;
 171
 172     wtime=HOOK_CallHooks( WH_JOURNALPLAYBACK, HC_GETNEXT, 0, (LPARAM)&tmpMsg, TRUE );
 173     /*  TRACE(msg,"Playback wait time =%ld\n",wtime); */
 174     if (wtime<=0)
 175     {
 176         wtime=0;
 177         msg.message = tmpMsg.message;
 178         msg.hwnd    = tmpMsg.hwnd;
 179         msg.time    = tmpMsg.time;
 180         if ((tmpMsg.message >= WM_KEYFIRST) && (tmpMsg.message <= WM_KEYLAST))
 181         {
 182             msg.wParam  = tmpMsg.paramL & 0xFF;
 183             msg.lParam  = MAKELONG(tmpMsg.paramH&0x7ffff,tmpMsg.paramL>>8);
 184             if (tmpMsg.message == WM_KEYDOWN || tmpMsg.message == WM_SYSKEYDOWN)
 185             {
 186                 for (keyDown=i=0; i<256 && !keyDown; i++)
 187                     if (InputKeyStateTable[i] & 0x80)
 188                         keyDown++;
 189                 if (!keyDown)
 190                     msg.lParam |= 0x40000000;
 191                 InputKeyStateTable[msg.wParam] |= 0x80;
 192                 AsyncKeyStateTable[msg.wParam] |= 0x80;
 193             }
 194             else                                       /* WM_KEYUP, WM_SYSKEYUP */
 195             {
 196                 msg.lParam |= 0xC0000000;
 197                 InputKeyStateTable[msg.wParam] &= ~0x80;
 198             }
 199             if (InputKeyStateTable[VK_MENU] & 0x80)
 200                 msg.lParam |= 0x20000000;
 201             if (tmpMsg.paramH & 0x8000)              /*special_key bit*/
 202                 msg.lParam |= 0x01000000;
 203
 204             msg.pt.x = msg.pt.y = 0;
 205             queue_hardware_message( &msg, 0 );
 206         }
 207         else if ((tmpMsg.message>= WM_MOUSEFIRST) && (tmpMsg.message <= WM_MOUSELAST))
 208         {
 209             switch (tmpMsg.message)
 210             {
 211             case WM_LBUTTONDOWN:
 212                 InputKeyStateTable[VK_LBUTTON] |= 0x80;
 213                 AsyncKeyStateTable[VK_LBUTTON] |= 0x80;
 214                 break;
 215             case WM_LBUTTONUP:
 216                 InputKeyStateTable[VK_LBUTTON] &= ~0x80;
 217                 break;
 218             case WM_MBUTTONDOWN:
 219                 InputKeyStateTable[VK_MBUTTON] |= 0x80;
 220                 AsyncKeyStateTable[VK_MBUTTON] |= 0x80;
 221                 break;
 222             case WM_MBUTTONUP:
 223                 InputKeyStateTable[VK_MBUTTON] &= ~0x80;
 224                 break;
 225             case WM_RBUTTONDOWN:
 226                 InputKeyStateTable[VK_RBUTTON] |= 0x80;
 227                 AsyncKeyStateTable[VK_RBUTTON] |= 0x80;
 228                 break;
 229             case WM_RBUTTONUP:
 230                 InputKeyStateTable[VK_RBUTTON] &= ~0x80;
 231                 break;
 232             }
 233             SetCursorPos(tmpMsg.paramL,tmpMsg.paramH);
 234             msg.lParam=MAKELONG(tmpMsg.paramL,tmpMsg.paramH);
 235             msg.wParam=0;
 236             if (InputKeyStateTable[VK_LBUTTON] & 0x80) msg.wParam |= MK_LBUTTON;
 237             if (InputKeyStateTable[VK_MBUTTON] & 0x80) msg.wParam |= MK_MBUTTON;
 238             if (InputKeyStateTable[VK_RBUTTON] & 0x80) msg.wParam |= MK_RBUTTON;
 239
 240             msg.pt.x = tmpMsg.paramL;
 241             msg.pt.y = tmpMsg.paramH;
 242             queue_hardware_message( &msg, 0 );
 243         }
 244         HOOK_CallHooks( WH_JOURNALPLAYBACK, HC_SKIP, 0, (LPARAM)&tmpMsg, TRUE );
 245     }
 246     else
 247     {
 248         if( tmpMsg.message == WM_QUEUESYNC ) HOOK_CallHooks( WH_CBT, HCBT_QS, 0, 0, TRUE );
 249     }
 250 }
 251 #endif
 252
 253
 254 /***********************************************************************
 255  *          process_raw_keyboard_message
 256  *
 257  * returns TRUE if the contents of 'msg' should be passed to the application
 258  */
 259 static void process_raw_keyboard_message( MSG *msg )
 260 {
 261     EVENTMSG event;
 262
 263     event.message = msg->message;
 264     event.hwnd    = msg->hwnd;
 265     event.time    = msg->time;
 266     event.paramL  = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
 267     event.paramH  = msg->lParam & 0x7FFF;
 268     if (HIWORD(msg->lParam) & 0x0100) event.paramH |= 0x8000; /* special_key - bit */
 269     HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event, TRUE );
 270 }
 271
 272
 273 /***********************************************************************
 274  *          process_cooked_keyboard_message
 275  *
 276  * returns TRUE if the contents of 'msg' should be passed to the application
 277  */
 278 static BOOL process_cooked_keyboard_message( MSG *msg, BOOL remove )
 279 {
 280     if (remove)
 281     {
 282         /* Handle F1 key by sending out WM_HELP message */
 283         if ((msg->message == WM_KEYUP) &&
 284             (msg->wParam == VK_F1) &&
 285             (msg->hwnd != GetDesktopWindow()) &&
 286             !MENU_IsMenuActive())
 287         {
 288             HELPINFO hi;
 289             hi.cbSize = sizeof(HELPINFO);
 290             hi.iContextType = HELPINFO_WINDOW;
 291             hi.iCtrlId = GetWindowLongPtrA( msg->hwnd, GWLP_ID );
 292             hi.hItemHandle = msg->hwnd;
 293             hi.dwContextId = GetWindowContextHelpId( msg->hwnd );
 294             hi.MousePos = msg->pt;
 295             SendMessageA(msg->hwnd, WM_HELP, 0, (LPARAM)&hi);
 296         }
 297     }
 298
 299     if (HOOK_CallHooks( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
 300                         LOWORD(msg->wParam), msg->lParam, TRUE ))
 301     {
 302         /* skip this message */
 303         HOOK_CallHooks( WH_CBT, HCBT_KEYSKIPPED, LOWORD(msg->wParam), msg->lParam, TRUE );
 304         return FALSE;
 305     }
 306     return TRUE;
 307 }
 308
 309
 310 /***********************************************************************
 311  *          process_raw_mouse_message
 312  */
 313 static void process_raw_mouse_message( MSG *msg, BOOL remove )
 314 {
 315     static MSG clk_msg;
 316
 317     POINT pt;
 318     INT hittest;
 319     EVENTMSG event;
 320     GUITHREADINFO info;
 321     HWND hWndScope = msg->hwnd;
 322
 323     /* find the window to dispatch this mouse message to */
 324
 325     hittest = HTCLIENT;
 326     GetGUIThreadInfo( GetCurrentThreadId(), &info );
 327     if (!(msg->hwnd = info.hwndCapture))
 328     {
 329         /* If no capture HWND, find window which contains the mouse position.
 330          * Also find the position of the cursor hot spot (hittest) */
 331         if (!IsWindow(hWndScope)) hWndScope = 0;
 332         if (!(msg->hwnd = WINPOS_WindowFromPoint( hWndScope, msg->pt, &hittest )))
 333             msg->hwnd = GetDesktopWindow();
 334     }
 335
 336     event.message = msg->message;
 337     event.time    = msg->time;
 338     event.hwnd    = msg->hwnd;
 339     event.paramL  = msg->pt.x;
 340     event.paramH  = msg->pt.y;
 341     HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event, TRUE );
 342
 343     /* translate double clicks */
 344
 345     if ((msg->message == WM_LBUTTONDOWN) ||
 346         (msg->message == WM_RBUTTONDOWN) ||
 347         (msg->message == WM_MBUTTONDOWN))
 348     {
 349         BOOL update = remove;
 350         /* translate double clicks -
 351          * note that ...MOUSEMOVEs can slip in between
 352          * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
 353
 354         if ((info.flags & (GUI_INMENUMODE|GUI_INMOVESIZE)) ||
 355             hittest != HTCLIENT ||
 356             (GetClassLongA( msg->hwnd, GCL_STYLE ) & CS_DBLCLKS))
 357         {
 358            if ((msg->message == clk_msg.message) &&
 359                (msg->hwnd == clk_msg.hwnd) &&
 360                (msg->time - clk_msg.time < GetDoubleClickTime()) &&
 361                (abs(msg->pt.x - clk_msg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK)/2) &&
 362                (abs(msg->pt.y - clk_msg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK)/2))
 363            {
 364                msg->message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
 365                if (remove)
 366                {
 367                    clk_msg.message = 0;
 368                    update = FALSE;
 369                }
 370            }
 371         }
 372         /* update static double click conditions */
 373         if (update) clk_msg = *msg;
 374     }
 375
 376     pt = msg->pt;
 377     /* Note: windows has no concept of a non-client wheel message */
 378     if (hittest != HTCLIENT && msg->message != WM_MOUSEWHEEL)
 379     {
 380         msg->message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
 381         msg->wParam = hittest;
 382     }
 383     else
 384     {
 385         /* coordinates don't get translated while tracking a menu */
 386         /* FIXME: should differentiate popups and top-level menus */
 387         if (!(info.flags & GUI_INMENUMODE)) ScreenToClient( msg->hwnd, &pt );
 388     }
 389     msg->lParam = MAKELONG( pt.x, pt.y );
 390 }
 391
 392
 393 /***********************************************************************
 394  *          process_cooked_mouse_message
 395  *
 396  * returns TRUE if the contents of 'msg' should be passed to the application
 397  */
 398 static BOOL process_cooked_mouse_message( MSG *msg, ULONG_PTR extra_info, BOOL remove )
 399 {
 400     MOUSEHOOKSTRUCT hook;
 401     INT hittest = HTCLIENT;
 402     UINT raw_message = msg->message;
 403     BOOL eatMsg;
 404
 405     if (msg->message >= WM_NCMOUSEFIRST && msg->message <= WM_NCMOUSELAST)
 406     {
 407         raw_message += WM_MOUSEFIRST - WM_NCMOUSEFIRST;
 408         hittest = msg->wParam;
 409     }
 410     if (raw_message == WM_LBUTTONDBLCLK ||
 411         raw_message == WM_RBUTTONDBLCLK ||
 412         raw_message == WM_MBUTTONDBLCLK)
 413     {
 414         raw_message += WM_LBUTTONDOWN - WM_LBUTTONDBLCLK;
 415     }
 416
 417     hook.pt           = msg->pt;
 418     hook.hwnd         = msg->hwnd;
 419     hook.wHitTestCode = hittest;
 420     hook.dwExtraInfo  = extra_info;
 421     if (HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
 422                         msg->message, (LPARAM)&hook, TRUE ))
 423     {
 424         hook.pt           = msg->pt;
 425         hook.hwnd         = msg->hwnd;
 426         hook.wHitTestCode = hittest;
 427         hook.dwExtraInfo  = extra_info;
 428         HOOK_CallHooks( WH_CBT, HCBT_CLICKSKIPPED, msg->message, (LPARAM)&hook, TRUE );
 429         return FALSE;
 430     }
 431
 432     if ((hittest == HTERROR) || (hittest == HTNOWHERE))
 433     {
 434         SendMessageA( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
 435                       MAKELONG( hittest, raw_message ));
 436         return FALSE;
 437     }
 438
 439     if (!remove || GetCapture()) return TRUE;
 440
 441     eatMsg = FALSE;
 442
 443     if ((raw_message == WM_LBUTTONDOWN) ||
 444         (raw_message == WM_RBUTTONDOWN) ||
 445         (raw_message == WM_MBUTTONDOWN))
 446     {
 447         /* Send the WM_PARENTNOTIFY,
 448          * note that even for double/nonclient clicks
 449          * notification message is still WM_L/M/RBUTTONDOWN.
 450          */
 451         MSG_SendParentNotify( msg->hwnd, raw_message, 0, msg->pt );
 452
 453         /* Activate the window if needed */
 454
 455         if (msg->hwnd != GetActiveWindow())
 456         {
 457             HWND hwndTop = msg->hwnd;
 458             while (hwndTop)
 459             {
 460                 if ((GetWindowLongW( hwndTop, GWL_STYLE ) & (WS_POPUP|WS_CHILD)) != WS_CHILD) break;
 461                 hwndTop = GetParent( hwndTop );
 462             }
 463
 464             if (hwndTop && hwndTop != GetDesktopWindow())
 465             {
 466                 LONG ret = SendMessageA( msg->hwnd, WM_MOUSEACTIVATE, (WPARAM)hwndTop,
 467                                          MAKELONG( hittest, raw_message ) );
 468                 switch(ret)
 469                 {
 470                 case MA_NOACTIVATEANDEAT:
 471                     eatMsg = TRUE;
 472                     /* fall through */
 473                 case MA_NOACTIVATE:
 474                     break;
 475                 case MA_ACTIVATEANDEAT:
 476                     eatMsg = TRUE;
 477                     /* fall through */
 478                 case MA_ACTIVATE:
 479                 case 0:
 480                     if (!FOCUS_MouseActivate( hwndTop )) eatMsg = TRUE;
 481                     break;
 482                 default:
 483                     WARN( "unknown WM_MOUSEACTIVATE code %ld\n", ret );
 484                     break;
 485                 }
 486             }
 487         }
 488     }
 489
 490     /* send the WM_SETCURSOR message */
 491
 492     /* Windows sends the normal mouse message as the message parameter
 493        in the WM_SETCURSOR message even if it's non-client mouse message */
 494     SendMessageA( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
 495                   MAKELONG( hittest, raw_message ));
 496
 497     return !eatMsg;
 498 }
 499
 500
 501 /***********************************************************************
 502  *          MSG_process_raw_hardware_message
 503  *
 504  * returns TRUE if the contents of 'msg' should be passed to the application
 505  */
 506 BOOL MSG_process_raw_hardware_message( MSG *msg, ULONG_PTR extra_info, HWND hwnd_filter,
 507                                        UINT first, UINT last, BOOL remove )
 508 {
 509     if (is_keyboard_message( msg->message ))
 510     {
 511         process_raw_keyboard_message( msg );
 512     }
 513     else if (is_mouse_message( msg->message ))
 514     {
 515         process_raw_mouse_message( msg, remove );
 516     }
 517     else
 518     {
 519         ERR( "unknown message type %x\n", msg->message );
 520         return FALSE;
 521     }
 522     return check_message_filter( msg, hwnd_filter, first, last );
 523 }
 524
 525
 526 /***********************************************************************
 527  *          MSG_process_cooked_hardware_message
 528  *
 529  * returns TRUE if the contents of 'msg' should be passed to the application
 530  */
 531 BOOL MSG_process_cooked_hardware_message( MSG *msg, ULONG_PTR extra_info, BOOL remove )
 532 {
 533     if (is_keyboard_message( msg->message ))
 534         return process_cooked_keyboard_message( msg, remove );
 535
 536     if (is_mouse_message( msg->message ))
 537         return process_cooked_mouse_message( msg, extra_info, remove );
 538
 539     ERR( "unknown message type %x\n", msg->message );
 540     return FALSE;
 541 }
 542
 543
 544 /***********************************************************************
 545  *              WaitMessage (USER.112) Suspend thread pending messages
 546  *              WaitMessage (USER32.@) Suspend thread pending messages
 547  *
 548  * WaitMessage() suspends a thread until events appear in the thread's
 549  * queue.
 550  */
 551 BOOL WINAPI WaitMessage(void)
 552 {
 553     return (MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, 0 ) != WAIT_FAILED);
 554 }
 555
 556
 557 /***********************************************************************
 558  *              MsgWaitForMultipleObjectsEx   (USER32.@)
 559  */
 560 DWORD WINAPI MsgWaitForMultipleObjectsEx( DWORD count, CONST HANDLE *pHandles,
 561                                           DWORD timeout, DWORD mask, DWORD flags )
 562 {
 563     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
 564     DWORD i, ret, lock;
 565     MESSAGEQUEUE *msgQueue;
 566
 567     if (count > MAXIMUM_WAIT_OBJECTS-1)
 568     {
 569         SetLastError( ERROR_INVALID_PARAMETER );
 570         return WAIT_FAILED;
 571     }
 572
 573     if (!(msgQueue = QUEUE_Current())) return WAIT_FAILED;
 574
 575     /* set the queue mask */
 576     SERVER_START_REQ( set_queue_mask )
 577     {
 578         req->wake_mask    = (flags & MWMO_INPUTAVAILABLE) ? mask : 0;
 579         req->changed_mask = mask;
 580         req->skip_wait    = 0;
 581         wine_server_call( req );
 582     }
 583     SERVER_END_REQ;
 584
 585     /* Add the thread event to the handle list */
 586     for (i = 0; i < count; i++) handles[i] = pHandles[i];
 587     handles[count] = msgQueue->server_queue;
 588
 589     ReleaseThunkLock( &lock );
 590     if (USER_Driver.pMsgWaitForMultipleObjectsEx)
 591     {
 592         ret = USER_Driver.pMsgWaitForMultipleObjectsEx( count+1, handles, timeout, mask, flags );
 593         if (ret == count+1) ret = count; /* pretend the msg queue is ready */
 594     }
 595     else
 596         ret = WaitForMultipleObjectsEx( count+1, handles, flags & MWMO_WAITALL,
 597                                         timeout, flags & MWMO_ALERTABLE );
 598     if (lock) RestoreThunkLock( lock );
 599     return ret;
 600 }
 601
 602
 603 /***********************************************************************
 604  *              MsgWaitForMultipleObjects (USER32.@)
 605  */
 606 DWORD WINAPI MsgWaitForMultipleObjects( DWORD count, CONST HANDLE *handles,
 607                                         BOOL wait_all, DWORD timeout, DWORD mask )
 608 {
 609     return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
 610                                         wait_all ? MWMO_WAITALL : 0 );
 611 }
 612
 613
 614 /***********************************************************************
 615  *              WaitForInputIdle (USER32.@)
 616  */
 617 DWORD WINAPI WaitForInputIdle( HANDLE hProcess, DWORD dwTimeOut )
 618 {
 619     DWORD start_time, elapsed, ret;
 620     HANDLE idle_event = (HANDLE)-1;
 621
 622     SERVER_START_REQ( wait_input_idle )
 623     {
 624         req->handle = hProcess;
 625         req->timeout = dwTimeOut;
 626         if (!(ret = wine_server_call_err( req ))) idle_event = reply->event;
 627     }
 628     SERVER_END_REQ;
 629     if (ret) return WAIT_FAILED;  /* error */
 630     if (!idle_event) return 0;  /* no event to wait on */
 631
 632     start_time = GetTickCount();
 633     elapsed = 0;
 634
 635     TRACE("waiting for %p\n", idle_event );
 636     do
 637     {
 638         ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut - elapsed, QS_SENDMESSAGE );
 639         switch (ret)
 640         {
 641         case WAIT_OBJECT_0+1:
 642             process_sent_messages();
 643             break;
 644         case WAIT_TIMEOUT:
 645         case WAIT_FAILED:
 646             TRACE("timeout or error\n");
 647             return ret;
 648         default:
 649             TRACE("finished\n");
 650             return 0;
 651         }
 652         if (dwTimeOut != INFINITE)
 653         {
 654             elapsed = GetTickCount() - start_time;
 655             if (elapsed > dwTimeOut)
 656                 break;
 657         }
 658     }
 659     while (1);
 660
 661     return WAIT_TIMEOUT;
 662 }
 663
 664
 665 /***********************************************************************
 666  *              UserYield (USER.332)
 667  */
 668 void WINAPI UserYield16(void)
 669 {
 670    DWORD count;
 671
 672     /* Handle sent messages */
 673     process_sent_messages();
 674
 675     /* Yield */
 676     ReleaseThunkLock(&count);
 677     if (count)
 678     {
 679         RestoreThunkLock(count);
 680         /* Handle sent messages again */
 681         process_sent_messages();
 682     }
 683 }
 684
 685
 686 /***********************************************************************
 687  *              TranslateMessage (USER32.@)
 688  *
 689  * Implementation of TranslateMessage.
 690  *
 691  * TranslateMessage translates virtual-key messages into character-messages,
 692  * as follows :
 693  * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
 694  * ditto replacing WM_* with WM_SYS*
 695  * This produces WM_CHAR messages only for keys mapped to ASCII characters
 696  * by the keyboard driver.
 697  *
 698  * If the message is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP, the
 699  * return value is nonzero, regardless of the translation.
 700  *
 701  */
 702 BOOL WINAPI TranslateMessage( const MSG *msg )
 703 {
 704     UINT message;
 705     WCHAR wp[2];
 706     BOOL rc = FALSE;
 707     BYTE state[256];
 708
 709     if (msg->message >= WM_KEYFIRST && msg->message <= WM_KEYLAST)
 710     {
 711         TRACE_(key)("(%s, %04X, %08lX)\n",
 712                     SPY_GetMsgName(msg->message, msg->hwnd), msg->wParam, msg->lParam );
 713
 714         /* Return code must be TRUE no matter what! */
 715         rc = TRUE;
 716     }
 717
 718     if ((msg->message != WM_KEYDOWN) && (msg->message != WM_SYSKEYDOWN)) return rc;
 719
 720     TRACE_(key)("Translating key %s (%04x), scancode %02x\n",
 721                  SPY_GetVKeyName(msg->wParam), msg->wParam, LOBYTE(HIWORD(msg->lParam)));
 722
 723     GetKeyboardState( state );
 724     /* FIXME : should handle ToUnicode yielding 2 */
 725     switch (ToUnicode(msg->wParam, HIWORD(msg->lParam), state, wp, 2, 0))
 726     {
 727     case 1:
 728         message = (msg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
 729         TRACE_(key)("1 -> PostMessageW(%p,%s,%04x,%08lx)\n",
 730             msg->hwnd, SPY_GetMsgName(message, msg->hwnd), wp[0], msg->lParam);
 731         PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
 732         break;
 733
 734     case -1:
 735         message = (msg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
 736         TRACE_(key)("-1 -> PostMessageW(%p,%s,%04x,%08lx)\n",
 737             msg->hwnd, SPY_GetMsgName(message, msg->hwnd), wp[0], msg->lParam);
 738         PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
 739         return TRUE;
 740     }
 741     return rc;
 742 }
 743
 744
 745 /***********************************************************************
 746  *              DispatchMessageA (USER32.@)
 747  */
 748 LONG WINAPI DispatchMessageA( const MSG* msg )
 749 {
 750     WND * wndPtr;
 751     LONG retval;
 752     int painting;
 753     WNDPROC winproc;
 754
 755       /* Process timer messages */
 756     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
 757     {
 758         if (msg->lParam)
 759         {
 760 /*            HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
 761
 762             /* before calling window proc, verify whether timer is still valid;
 763                there's a slim chance that the application kills the timer
 764                between GetMessage and DispatchMessage API calls */
 765             if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (WNDPROC)msg->lParam))
 766                 return 0; /* invalid winproc */
 767
 768             return CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
 769                                    msg->message, msg->wParam, GetTickCount() );
 770         }
 771     }
 772
 773     if (!(wndPtr = WIN_GetPtr( msg->hwnd )))
 774     {
 775         if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 776         return 0;
 777     }
 778     if (wndPtr == WND_OTHER_PROCESS)
 779     {
 780         if (IsWindow( msg->hwnd )) SetLastError( ERROR_MESSAGE_SYNC_ONLY );
 781         else SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 782         return 0;
 783     }
 784     if (wndPtr->tid != GetCurrentThreadId())
 785     {
 786         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
 787         WIN_ReleasePtr( wndPtr );
 788         return 0;
 789     }
 790     if (!(winproc = wndPtr->winproc))
 791     {
 792         WIN_ReleasePtr( wndPtr );
 793         return 0;
 794     }
 795     painting = (msg->message == WM_PAINT);
 796     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
 797     WIN_ReleasePtr( wndPtr );
 798 /*    hook_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
 799
 800     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
 801                       msg->wParam, msg->lParam );
 802     retval = CallWindowProcA( winproc, msg->hwnd, msg->message,
 803                               msg->wParam, msg->lParam );
 804     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
 805                      msg->wParam, msg->lParam );
 806
 807     if (painting && (wndPtr = WIN_GetPtr( msg->hwnd )) && (wndPtr != WND_OTHER_PROCESS))
 808     {
 809         BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
 810         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
 811         WIN_ReleasePtr( wndPtr );
 812         if (validate)
 813         {
 814             ERR( "BeginPaint not called on WM_PAINT for hwnd %p!\n", msg->hwnd );
 815             /* Validate the update region to avoid infinite WM_PAINT loop */
 816             RedrawWindow( msg->hwnd, NULL, 0,
 817                           RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
 818         }
 819     }
 820     return retval;
 821 }
 822
 823
 824 /***********************************************************************
 825  *              DispatchMessageW (USER32.@) Process Message
 826  *
 827  * Process the message specified in the structure *_msg_.
 828  *
 829  * If the lpMsg parameter points to a WM_TIMER message and the
 830  * parameter of the WM_TIMER message is not NULL, the lParam parameter
 831  * points to the function that is called instead of the window
 832  * procedure.
 833  *
 834  * The message must be valid.
 835  *
 836  * RETURNS
 837  *
 838  *   DispatchMessage() returns the result of the window procedure invoked.
 839  *
 840  * CONFORMANCE
 841  *
 842  *   ECMA-234, Win32
 843  *
 844  */
 845 LONG WINAPI DispatchMessageW( const MSG* msg )
 846 {
 847     WND * wndPtr;
 848     LONG retval;
 849     int painting;
 850     WNDPROC winproc;
 851
 852       /* Process timer messages */
 853     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
 854     {
 855         if (msg->lParam)
 856         {
 857 /*            HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
 858
 859             /* before calling window proc, verify whether timer is still valid;
 860                there's a slim chance that the application kills the timer
 861                between GetMessage and DispatchMessage API calls */
 862             if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (WNDPROC)msg->lParam))
 863                 return 0; /* invalid winproc */
 864
 865             return CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
 866                                    msg->message, msg->wParam, GetTickCount() );
 867         }
 868     }
 869
 870     if (!(wndPtr = WIN_GetPtr( msg->hwnd )))
 871     {
 872         if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 873         return 0;
 874     }
 875     if (wndPtr == WND_OTHER_PROCESS)
 876     {
 877         if (IsWindow( msg->hwnd )) SetLastError( ERROR_MESSAGE_SYNC_ONLY );
 878         else SetLastError( ERROR_INVALID_WINDOW_HANDLE );
 879         return 0;
 880     }
 881     if (wndPtr->tid != GetCurrentThreadId())
 882     {
 883         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
 884         WIN_ReleasePtr( wndPtr );
 885         return 0;
 886     }
 887     if (!(winproc = wndPtr->winproc))
 888     {
 889         WIN_ReleasePtr( wndPtr );
 890         return 0;
 891     }
 892     painting = (msg->message == WM_PAINT);
 893     if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
 894     WIN_ReleasePtr( wndPtr );
 895 /*    HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
 896
 897     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
 898                       msg->wParam, msg->lParam );
 899     retval = CallWindowProcW( winproc, msg->hwnd, msg->message,
 900                               msg->wParam, msg->lParam );
 901     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
 902                      msg->wParam, msg->lParam );
 903
 904     if (painting && (wndPtr = WIN_GetPtr( msg->hwnd )) && (wndPtr != WND_OTHER_PROCESS))
 905     {
 906         BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
 907         wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
 908         WIN_ReleasePtr( wndPtr );
 909         if (validate)
 910         {
 911             ERR( "BeginPaint not called on WM_PAINT for hwnd %p!\n", msg->hwnd );
 912             /* Validate the update region to avoid infinite WM_PAINT loop */
 913             RedrawWindow( msg->hwnd, NULL, 0,
 914                           RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
 915         }
 916     }
 917     return retval;
 918 }
 919
 920
 921 /***********************************************************************
 922  *              RegisterWindowMessage (USER.118)
 923  *              RegisterWindowMessageA (USER32.@)
 924  */
 925 WORD WINAPI RegisterWindowMessageA( LPCSTR str )
 926 {
 927     TRACE("%s\n", str );
 928     return GlobalAddAtomA( str );
 929 }
 930
 931
 932 /***********************************************************************
 933  *              RegisterWindowMessageW (USER32.@)
 934  */
 935 WORD WINAPI RegisterWindowMessageW( LPCWSTR str )
 936 {
 937     TRACE("%p\n", str );
 938     return GlobalAddAtomW( str );
 939 }
 940
 941
 942 /***********************************************************************
 943  *              BroadcastSystemMessage  (USER32.@)
 944  *              BroadcastSystemMessageA (USER32.@)
 945  */
 946 LONG WINAPI BroadcastSystemMessageA(
 947         DWORD dwFlags,LPDWORD recipients,UINT uMessage,WPARAM wParam,
 948         LPARAM lParam )
 949 {
 950     if ((*recipients & BSM_APPLICATIONS)||
 951         (*recipients == BSM_ALLCOMPONENTS))
 952     {
 953         FIXME("(%08lx,%08lx,%08x,%08x,%08lx): semi-stub!\n",
 954               dwFlags,*recipients,uMessage,wParam,lParam);
 955         PostMessageA(HWND_BROADCAST,uMessage,wParam,lParam);
 956         return 1;
 957     }
 958     else
 959     {
 960         FIXME("(%08lx,%08lx,%08x,%08x,%08lx): stub!\n",
 961               dwFlags,*recipients,uMessage,wParam,lParam);
 962         return -1;
 963     }
 964 }
 965
 966 /***********************************************************************
 967  *              BroadcastSystemMessageW (USER32.@)
 968  */
 969 LONG WINAPI BroadcastSystemMessageW(
 970         DWORD dwFlags,LPDWORD recipients,UINT uMessage,WPARAM wParam,
 971         LPARAM lParam )
 972 {
 973     if ((*recipients & BSM_APPLICATIONS)||
 974         (*recipients == BSM_ALLCOMPONENTS))
 975     {
 976         FIXME("(%08lx,%08lx,%08x,%08x,%08lx): semi-stub!\n",
 977               dwFlags,*recipients,uMessage,wParam,lParam);
 978         PostMessageW(HWND_BROADCAST,uMessage,wParam,lParam);
 979         return 1;
 980     }
 981     else
 982     {
 983         FIXME("(%08lx,%08lx,%08x,%08x,%08lx): stub!\n",
 984               dwFlags,*recipients,uMessage,wParam,lParam);
 985         return -1;
 986     }
 987 }