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