dlls/user32/message.c

   1 /*
   2  * Window messaging support
   3  *
   4  * Copyright 2001 Alexandre Julliard
   5  * Copyright 2008 Maarten Lankhorst
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include "ntstatus.h"
  23 #define WIN32_NO_STATUS
  24 #include "user_private.h"
  25 #include "controls.h"
  26 #include "dde.h"
  27 #include "wine/server.h"
  28 #include "wine/debug.h"
  29 #include "wine/exception.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(msg);
  32
  33
  34 /* pack a pointer into a 32/64 portable format */
  35 static inline ULONGLONG pack_ptr( const void *ptr )
  36 {
  37     return (ULONG_PTR)ptr;
  38 }
  39
  40 /* unpack a potentially 64-bit pointer, returning 0 when truncated */
  41 static inline void *unpack_ptr( ULONGLONG ptr64 )
  42 {
  43     if ((ULONG_PTR)ptr64 != ptr64) return 0;
  44     return (void *)(ULONG_PTR)ptr64;
  45 }
  46
  47 static struct wm_char_mapping_data *get_wmchar_data(void)
  48 {
  49     return (struct wm_char_mapping_data *)(UINT_PTR)NtUserGetThreadInfo()->wmchar_data;
  50 }
  51
  52 /* check for pending WM_CHAR message with DBCS trailing byte */
  53 static inline BOOL get_pending_wmchar( MSG *msg, UINT first, UINT last, BOOL remove )
  54 {
  55     struct wm_char_mapping_data *data = get_wmchar_data();
  56
  57     if (!data || !data->get_msg.message) return FALSE;
  58     if ((first || last) && (first > WM_CHAR || last < WM_CHAR)) return FALSE;
  59     if (!msg) return FALSE;
  60     *msg = data->get_msg;
  61     if (remove) data->get_msg.message = 0;
  62     return TRUE;
  63 }
  64
  65
  66 /***********************************************************************
  67  *           MessageWndProc
  68  *
  69  * Window procedure for "Message" windows (HWND_MESSAGE parent).
  70  */
  71 LRESULT WINAPI MessageWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
  72 {
  73     if (message == WM_NCCREATE) return TRUE;
  74     return 0;  /* all other messages are ignored */
  75 }
  76
  77
  78 DWORD get_input_codepage( void )
  79 {
  80     DWORD cp;
  81     int ret;
  82     HKL hkl = NtUserGetKeyboardLayout( 0 );
  83
  84     ret = GetLocaleInfoW( LOWORD(hkl), LOCALE_IDEFAULTANSICODEPAGE | LOCALE_RETURN_NUMBER,
  85                           (WCHAR *)&cp, sizeof(cp) / sizeof(WCHAR) );
  86     if (!ret) cp = CP_ACP;
  87     return cp;
  88 }
  89
  90 /***********************************************************************
  91  *              map_wparam_AtoW
  92  *
  93  * Convert the wparam of an ASCII message to Unicode.
  94  */
  95 BOOL map_wparam_AtoW( UINT message, WPARAM *wparam, enum wm_char_mapping mapping )
  96 {
  97     char ch[2];
  98     WCHAR wch[2];
  99     DWORD cp;
 100
 101     wch[0] = wch[1] = 0;
 102     switch(message)
 103     {
 104     case WM_CHAR:
 105         /* WM_CHAR is magic: a DBCS char can be sent/posted as two consecutive WM_CHAR
 106          * messages, in which case the first char is stored, and the conversion
 107          * to Unicode only takes place once the second char is sent/posted.
 108          */
 109         if (mapping != WMCHAR_MAP_NOMAPPING)
 110         {
 111             struct wm_char_mapping_data *data = get_wmchar_data();
 112             BYTE low = LOBYTE(*wparam);
 113             cp = get_input_codepage();
 114
 115             if (HIBYTE(*wparam))
 116             {
 117                 ch[0] = low;
 118                 ch[1] = HIBYTE(*wparam);
 119                 MultiByteToWideChar( cp, 0, ch, 2, wch, 2 );
 120                 TRACE( "map %02x,%02x -> %04x mapping %u\n", (BYTE)ch[0], (BYTE)ch[1], wch[0], mapping );
 121                 if (data) data->lead_byte[mapping] = 0;
 122             }
 123             else if (data && data->lead_byte[mapping])
 124             {
 125                 ch[0] = data->lead_byte[mapping];
 126                 ch[1] = low;
 127                 MultiByteToWideChar( cp, 0, ch, 2, wch, 2 );
 128                 TRACE( "map stored %02x,%02x -> %04x mapping %u\n", (BYTE)ch[0], (BYTE)ch[1], wch[0], mapping );
 129                 data->lead_byte[mapping] = 0;
 130             }
 131             else if (!IsDBCSLeadByte( low ))
 132             {
 133                 ch[0] = low;
 134                 MultiByteToWideChar( cp, 0, ch, 1, wch, 2 );
 135                 TRACE( "map %02x -> %04x\n", (BYTE)ch[0], wch[0] );
 136                 if (data) data->lead_byte[mapping] = 0;
 137             }
 138             else  /* store it and wait for trail byte */
 139             {
 140                 if (!data)
 141                 {
 142                     if (!(data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) )))
 143                         return FALSE;
 144                     NtUserGetThreadInfo()->wmchar_data = (UINT_PTR)data;
 145                 }
 146                 TRACE( "storing lead byte %02x mapping %u\n", low, mapping );
 147                 data->lead_byte[mapping] = low;
 148                 return FALSE;
 149             }
 150             *wparam = MAKEWPARAM(wch[0], wch[1]);
 151             break;
 152         }
 153         /* else fall through */
 154     case WM_CHARTOITEM:
 155     case EM_SETPASSWORDCHAR:
 156     case WM_DEADCHAR:
 157     case WM_SYSCHAR:
 158     case WM_SYSDEADCHAR:
 159     case WM_MENUCHAR:
 160         cp = get_input_codepage();
 161         ch[0] = LOBYTE(*wparam);
 162         ch[1] = HIBYTE(*wparam);
 163         MultiByteToWideChar( cp, 0, ch, 2, wch, 2 );
 164         *wparam = MAKEWPARAM(wch[0], wch[1]);
 165         break;
 166     case WM_IME_CHAR:
 167         cp = get_input_codepage();
 168         ch[0] = HIBYTE(*wparam);
 169         ch[1] = LOBYTE(*wparam);
 170         if (ch[0]) MultiByteToWideChar( cp, 0, ch, 2, wch, 2 );
 171         else MultiByteToWideChar( cp, 0, ch + 1, 1, wch, 1 );
 172         *wparam = MAKEWPARAM(wch[0], HIWORD(*wparam));
 173         break;
 174     }
 175     return TRUE;
 176 }
 177
 178
 179 /***********************************************************************
 180  *              map_wparam_WtoA
 181  *
 182  * Convert the wparam of a Unicode message to ASCII.
 183  */
 184 static void map_wparam_WtoA( MSG *msg, BOOL remove )
 185 {
 186     BYTE ch[4];
 187     WCHAR wch[2];
 188     DWORD len;
 189     DWORD cp;
 190
 191     switch(msg->message)
 192     {
 193     case WM_CHAR:
 194         if (!HIWORD(msg->wParam))
 195         {
 196             cp = get_input_codepage();
 197             wch[0] = LOWORD(msg->wParam);
 198             ch[0] = ch[1] = 0;
 199             len = WideCharToMultiByte( cp, 0, wch, 1, (LPSTR)ch, 2, NULL, NULL );
 200             if (len == 2)  /* DBCS char */
 201             {
 202                 struct wm_char_mapping_data *data = get_wmchar_data();
 203                 if (!data)
 204                 {
 205                     if (!(data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) ))) return;
 206                     NtUserGetThreadInfo()->wmchar_data = (UINT_PTR)data;
 207                 }
 208                 if (remove)
 209                 {
 210                     data->get_msg = *msg;
 211                     data->get_msg.wParam = ch[1];
 212                 }
 213                 msg->wParam = ch[0];
 214                 return;
 215             }
 216         }
 217         /* else fall through */
 218     case WM_CHARTOITEM:
 219     case EM_SETPASSWORDCHAR:
 220     case WM_DEADCHAR:
 221     case WM_SYSCHAR:
 222     case WM_SYSDEADCHAR:
 223     case WM_MENUCHAR:
 224         cp = get_input_codepage();
 225         wch[0] = LOWORD(msg->wParam);
 226         wch[1] = HIWORD(msg->wParam);
 227         ch[0] = ch[1] = 0;
 228         WideCharToMultiByte( cp, 0, wch, 2, (LPSTR)ch, 4, NULL, NULL );
 229         msg->wParam = MAKEWPARAM( ch[0] | (ch[1] << 8), 0 );
 230         break;
 231     case WM_IME_CHAR:
 232         cp = get_input_codepage();
 233         wch[0] = LOWORD(msg->wParam);
 234         ch[0] = ch[1] = 0;
 235         len = WideCharToMultiByte( cp, 0, wch, 1, (LPSTR)ch, 2, NULL, NULL );
 236         if (len == 2)
 237             msg->wParam = MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(msg->wParam) );
 238         else
 239             msg->wParam = MAKEWPARAM( ch[0], HIWORD(msg->wParam) );
 240         break;
 241     }
 242 }
 243
 244
 245 /* since the WM_DDE_ACK response to a WM_DDE_EXECUTE message should contain the handle
 246  * to the memory handle, we keep track (in the server side) of all pairs of handle
 247  * used (the client passes its value and the content of the memory handle), and
 248  * the server stored both values (the client, and the local one, created after the
 249  * content). When a ACK message is generated, the list of pair is searched for a
 250  * matching pair, so that the client memory handle can be returned.
 251  */
 252 struct DDE_pair {
 253     HGLOBAL     client_hMem;
 254     HGLOBAL     server_hMem;
 255 };
 256
 257 static      struct DDE_pair*    dde_pairs;
 258 static      int                 dde_num_alloc;
 259 static      int                 dde_num_used;
 260
 261 static CRITICAL_SECTION dde_crst;
 262 static CRITICAL_SECTION_DEBUG critsect_debug =
 263 {
 264     0, 0, &dde_crst,
 265     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
 266       0, 0, { (DWORD_PTR)(__FILE__ ": dde_crst") }
 267 };
 268 static CRITICAL_SECTION dde_crst = { &critsect_debug, -1, 0, 0, 0, 0 };
 269
 270 static BOOL dde_add_pair(HGLOBAL chm, HGLOBAL shm)
 271 {
 272     int  i;
 273 #define GROWBY  4
 274
 275     EnterCriticalSection(&dde_crst);
 276
 277     /* now remember the pair of hMem on both sides */
 278     if (dde_num_used == dde_num_alloc)
 279     {
 280         struct DDE_pair* tmp;
 281         if (dde_pairs)
 282             tmp  = HeapReAlloc( GetProcessHeap(), 0, dde_pairs,
 283                                             (dde_num_alloc + GROWBY) * sizeof(struct DDE_pair));
 284         else
 285             tmp  = HeapAlloc( GetProcessHeap(), 0,
 286                                             (dde_num_alloc + GROWBY) * sizeof(struct DDE_pair));
 287
 288         if (!tmp)
 289         {
 290             LeaveCriticalSection(&dde_crst);
 291             return FALSE;
 292         }
 293         dde_pairs = tmp;
 294         /* zero out newly allocated part */
 295         memset(&dde_pairs[dde_num_alloc], 0, GROWBY * sizeof(struct DDE_pair));
 296         dde_num_alloc += GROWBY;
 297     }
 298 #undef GROWBY
 299     for (i = 0; i < dde_num_alloc; i++)
 300     {
 301         if (dde_pairs[i].server_hMem == 0)
 302         {
 303             dde_pairs[i].client_hMem = chm;
 304             dde_pairs[i].server_hMem = shm;
 305             dde_num_used++;
 306             break;
 307         }
 308     }
 309     LeaveCriticalSection(&dde_crst);
 310     return TRUE;
 311 }
 312
 313 static HGLOBAL dde_get_pair(HGLOBAL shm)
 314 {
 315     int  i;
 316     HGLOBAL     ret = 0;
 317
 318     EnterCriticalSection(&dde_crst);
 319     for (i = 0; i < dde_num_alloc; i++)
 320     {
 321         if (dde_pairs[i].server_hMem == shm)
 322         {
 323             /* free this pair */
 324             dde_pairs[i].server_hMem = 0;
 325             dde_num_used--;
 326             ret = dde_pairs[i].client_hMem;
 327             break;
 328         }
 329     }
 330     LeaveCriticalSection(&dde_crst);
 331     return ret;
 332 }
 333
 334 /***********************************************************************
 335  *              post_dde_message
 336  *
 337  * Post a DDE message
 338  */
 339 BOOL post_dde_message( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam, DWORD dest_tid, DWORD type )
 340 {
 341     void*       ptr = NULL;
 342     int         size = 0;
 343     UINT_PTR    uiLo, uiHi;
 344     LPARAM      lp;
 345     HGLOBAL     hunlock = 0;
 346     DWORD       res;
 347     ULONGLONG   hpack;
 348
 349     if (!UnpackDDElParam( msg, lparam, &uiLo, &uiHi ))
 350         return FALSE;
 351
 352     lp = lparam;
 353     switch (msg)
 354     {
 355         /* DDE messages which don't require packing are:
 356          * WM_DDE_INITIATE
 357          * WM_DDE_TERMINATE
 358          * WM_DDE_REQUEST
 359          * WM_DDE_UNADVISE
 360          */
 361     case WM_DDE_ACK:
 362         if (HIWORD(uiHi))
 363         {
 364             /* uiHi should contain a hMem from WM_DDE_EXECUTE */
 365             HGLOBAL h = dde_get_pair( (HANDLE)uiHi );
 366             if (h)
 367             {
 368                 hpack = pack_ptr( h );
 369                 /* send back the value of h on the other side */
 370                 ptr = &hpack;
 371                 size = sizeof(hpack);
 372                 lp = uiLo;
 373                 TRACE( "send dde-ack %Ix %08Ix => %p\n", uiLo, uiHi, h );
 374             }
 375         }
 376         else
 377         {
 378             /* uiHi should contain either an atom or 0 */
 379             TRACE( "send dde-ack %Ix atom=%Ix\n", uiLo, uiHi );
 380             lp = MAKELONG( uiLo, uiHi );
 381         }
 382         break;
 383     case WM_DDE_ADVISE:
 384     case WM_DDE_DATA:
 385     case WM_DDE_POKE:
 386         if (uiLo)
 387         {
 388             size = GlobalSize( (HGLOBAL)uiLo ) ;
 389             if ((msg == WM_DDE_ADVISE && size < sizeof(DDEADVISE)) ||
 390                 (msg == WM_DDE_DATA   && size < FIELD_OFFSET(DDEDATA, Value)) ||
 391                 (msg == WM_DDE_POKE   && size < FIELD_OFFSET(DDEPOKE, Value)))
 392                 return FALSE;
 393         }
 394         else if (msg != WM_DDE_DATA) return FALSE;
 395
 396         lp = uiHi;
 397         if (uiLo)
 398         {
 399             if ((ptr = GlobalLock( (HGLOBAL)uiLo) ))
 400             {
 401                 DDEDATA *dde_data = ptr;
 402                 TRACE("unused %d, fResponse %d, fRelease %d, fDeferUpd %d, fAckReq %d, cfFormat %d\n",
 403                        dde_data->unused, dde_data->fResponse, dde_data->fRelease,
 404                        dde_data->reserved, dde_data->fAckReq, dde_data->cfFormat);
 405                 hunlock = (HGLOBAL)uiLo;
 406             }
 407         }
 408         TRACE( "send ddepack %u %Ix\n", size, uiHi );
 409         break;
 410     case WM_DDE_EXECUTE:
 411         if (lparam)
 412         {
 413             if ((ptr = GlobalLock( (HGLOBAL)lparam) ))
 414             {
 415                 size = GlobalSize( (HGLOBAL)lparam );
 416                 /* so that the other side can send it back on ACK */
 417                 lp = lparam;
 418                 hunlock = (HGLOBAL)lparam;
 419             }
 420         }
 421         break;
 422     }
 423     SERVER_START_REQ( send_message )
 424     {
 425         req->id      = dest_tid;
 426         req->type    = type;
 427         req->flags   = 0;
 428         req->win     = wine_server_user_handle( hwnd );
 429         req->msg     = msg;
 430         req->wparam  = wparam;
 431         req->lparam  = lp;
 432         req->timeout = TIMEOUT_INFINITE;
 433         if (size) wine_server_add_data( req, ptr, size );
 434         if ((res = wine_server_call( req )))
 435         {
 436             if (res == STATUS_INVALID_PARAMETER)
 437                 /* FIXME: find a STATUS_ value for this one */
 438                 SetLastError( ERROR_INVALID_THREAD_ID );
 439             else
 440                 SetLastError( RtlNtStatusToDosError(res) );
 441         }
 442         else
 443             FreeDDElParam( msg, lparam );
 444     }
 445     SERVER_END_REQ;
 446     if (hunlock) GlobalUnlock(hunlock);
 447
 448     return !res;
 449 }
 450
 451 /***********************************************************************
 452  *              unpack_dde_message
 453  *
 454  * Unpack a posted DDE message received from another process.
 455  */
 456 BOOL unpack_dde_message( HWND hwnd, UINT message, WPARAM *wparam, LPARAM *lparam,
 457                          const void *buffer, size_t size )
 458 {
 459     UINT_PTR    uiLo, uiHi;
 460     HGLOBAL     hMem = 0;
 461     void*       ptr;
 462
 463     switch (message)
 464     {
 465     case WM_DDE_ACK:
 466         if (size)
 467         {
 468             ULONGLONG hpack;
 469             /* hMem is being passed */
 470             if (size != sizeof(hpack)) return FALSE;
 471             uiLo = *lparam;
 472             memcpy( &hpack, buffer, size );
 473             hMem = unpack_ptr( hpack );
 474             uiHi = (UINT_PTR)hMem;
 475             TRACE("recv dde-ack %Ix mem=%Ix[%Ix]\n", uiLo, uiHi, GlobalSize( hMem ));
 476         }
 477         else
 478         {
 479             uiLo = LOWORD( *lparam );
 480             uiHi = HIWORD( *lparam );
 481             TRACE("recv dde-ack %Ix atom=%Ix\n", uiLo, uiHi);
 482         }
 483         *lparam = PackDDElParam( WM_DDE_ACK, uiLo, uiHi );
 484         break;
 485     case WM_DDE_ADVISE:
 486     case WM_DDE_DATA:
 487     case WM_DDE_POKE:
 488         if (!size && message != WM_DDE_DATA) return FALSE;
 489         uiHi = *lparam;
 490         if (size)
 491         {
 492             if (!(hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size )))
 493                 return FALSE;
 494             if ((ptr = GlobalLock( hMem )))
 495             {
 496                 memcpy( ptr, buffer, size );
 497                 GlobalUnlock( hMem );
 498             }
 499             else
 500             {
 501                 GlobalFree( hMem );
 502                 return FALSE;
 503             }
 504         }
 505         uiLo = (UINT_PTR)hMem;
 506
 507         *lparam = PackDDElParam( message, uiLo, uiHi );
 508         break;
 509     case WM_DDE_EXECUTE:
 510         if (size)
 511         {
 512             if (!(hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size ))) return FALSE;
 513             if ((ptr = GlobalLock( hMem )))
 514             {
 515                 memcpy( ptr, buffer, size );
 516                 GlobalUnlock( hMem );
 517                 TRACE( "exec: pairing c=%08Ix s=%p\n", *lparam, hMem );
 518                 if (!dde_add_pair( (HGLOBAL)*lparam, hMem ))
 519                 {
 520                     GlobalFree( hMem );
 521                     return FALSE;
 522                 }
 523             }
 524             else
 525             {
 526                 GlobalFree( hMem );
 527                 return FALSE;
 528             }
 529         } else return FALSE;
 530         *lparam = (LPARAM)hMem;
 531         break;
 532     }
 533     return TRUE;
 534 }
 535
 536 /***********************************************************************
 537  *              SendMessageTimeoutW  (USER32.@)
 538  */
 539 LRESULT WINAPI SendMessageTimeoutW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
 540                                     UINT flags, UINT timeout, PDWORD_PTR res_ptr )
 541 {
 542     struct send_message_timeout_params params = { .flags = flags, .timeout = timeout };
 543     LRESULT res;
 544
 545     res = NtUserMessageCall( hwnd, msg, wparam, lparam, &params, NtUserSendMessageTimeout, FALSE );
 546     if (res_ptr) *res_ptr = res;
 547     return params.result;
 548 }
 549
 550 /***********************************************************************
 551  *              SendMessageTimeoutA  (USER32.@)
 552  */
 553 LRESULT WINAPI SendMessageTimeoutA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
 554                                     UINT flags, UINT timeout, PDWORD_PTR res_ptr )
 555 {
 556     struct send_message_timeout_params params = { .flags = flags, .timeout = timeout };
 557     LRESULT res = 0;
 558
 559     if (msg != WM_CHAR || WIN_IsCurrentThread( hwnd ))
 560     {
 561         res = NtUserMessageCall( hwnd, msg, wparam, lparam, &params,
 562                                  NtUserSendMessageTimeout, TRUE );
 563     }
 564     else if (map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_SENDMESSAGE ))
 565     {
 566         res = NtUserMessageCall( hwnd, msg, wparam, lparam, &params,
 567                                  NtUserSendMessageTimeout, FALSE );
 568     }
 569
 570     if (res_ptr) *res_ptr = res;
 571     return params.result;
 572 }
 573
 574
 575 static LRESULT dispatch_send_message( struct win_proc_params *params, WPARAM wparam, LPARAM lparam )
 576 {
 577     struct ntuser_thread_info *thread_info = NtUserGetThreadInfo();
 578     INPUT_MESSAGE_SOURCE prev_source = thread_info->msg_source;
 579     LRESULT retval = 0;
 580
 581     static const INPUT_MESSAGE_SOURCE msg_source_unavailable = { IMDT_UNAVAILABLE, IMO_UNAVAILABLE };
 582
 583     /* params may contain arguments modified by wow, use original parameters instead */
 584     params->wparam = wparam;
 585     params->lparam = lparam;
 586
 587     thread_info->recursion_count++;
 588
 589     params->result = &retval;
 590     thread_info->msg_source = msg_source_unavailable;
 591     SPY_EnterMessage( SPY_SENDMESSAGE, params->hwnd, params->msg, params->wparam, params->lparam );
 592
 593     dispatch_win_proc_params( params );
 594
 595     SPY_ExitMessage( SPY_RESULT_OK, params->hwnd, params->msg, retval, params->wparam, params->lparam );
 596     thread_info->msg_source = prev_source;
 597     thread_info->recursion_count--;
 598     return retval;
 599 }
 600
 601
 602 /***********************************************************************
 603  *              SendMessageW  (USER32.@)
 604  */
 605 LRESULT WINAPI SendMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 606 {
 607     struct win_proc_params params;
 608     LRESULT retval;
 609
 610     params.hwnd = 0;
 611     retval = NtUserMessageCall( hwnd, msg, wparam, lparam, &params, NtUserSendMessage, FALSE );
 612     if (params.hwnd) retval = dispatch_send_message( &params, wparam, lparam );
 613     return retval;
 614 }
 615
 616
 617 /***********************************************************************
 618  *              SendMessageA  (USER32.@)
 619  */
 620 LRESULT WINAPI SendMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 621 {
 622     struct win_proc_params params;
 623     LRESULT retval;
 624
 625     if (msg == WM_CHAR && !WIN_IsCurrentThread( hwnd ))
 626     {
 627         if (!map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_SENDMESSAGE ))
 628             return 0;
 629         return NtUserMessageCall( hwnd, msg, wparam, lparam, NULL, NtUserSendMessage, FALSE );
 630     }
 631
 632     params.hwnd = 0;
 633     retval = NtUserMessageCall( hwnd, msg, wparam, lparam, &params, NtUserSendMessage, TRUE );
 634     if (params.hwnd) retval = dispatch_send_message( &params, wparam, lparam );
 635     return retval;
 636 }
 637
 638
 639 /***********************************************************************
 640  *              SendNotifyMessageA  (USER32.@)
 641  */
 642 BOOL WINAPI SendNotifyMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 643 {
 644     if (!WIN_IsCurrentThread( hwnd ) && !map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_SENDMESSAGE ))
 645         return FALSE;
 646
 647     return NtUserMessageCall( hwnd, msg, wparam, lparam, 0, NtUserSendNotifyMessage, TRUE );
 648 }
 649
 650
 651 /***********************************************************************
 652  *              SendNotifyMessageW  (USER32.@)
 653  */
 654 BOOL WINAPI SendNotifyMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 655 {
 656     return NtUserMessageCall( hwnd, msg, wparam, lparam, 0, NtUserSendNotifyMessage, FALSE );
 657 }
 658
 659
 660 /***********************************************************************
 661  *              SendMessageCallbackA  (USER32.@)
 662  */
 663 BOOL WINAPI SendMessageCallbackA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
 664                                   SENDASYNCPROC callback, ULONG_PTR data )
 665 {
 666     struct send_message_callback_params params = { .callback = callback, .data = data };
 667
 668     if (!WIN_IsCurrentThread( hwnd ) && !map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_SENDMESSAGE ))
 669         return FALSE;
 670
 671     return NtUserMessageCall( hwnd, msg, wparam, lparam, &params, NtUserSendMessageCallback, TRUE );
 672 }
 673
 674
 675 /***********************************************************************
 676  *              SendMessageCallbackW  (USER32.@)
 677  */
 678 BOOL WINAPI SendMessageCallbackW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
 679                                   SENDASYNCPROC callback, ULONG_PTR data )
 680 {
 681     struct send_message_callback_params params = { .callback = callback, .data = data };
 682     return NtUserMessageCall( hwnd, msg, wparam, lparam, &params, NtUserSendMessageCallback, FALSE );
 683 }
 684
 685
 686 /***********************************************************************
 687  *              ReplyMessage  (USER32.@)
 688  */
 689 BOOL WINAPI ReplyMessage( LRESULT result )
 690 {
 691     return NtUserReplyMessage( result );
 692 }
 693
 694
 695 /***********************************************************************
 696  *              InSendMessage  (USER32.@)
 697  */
 698 BOOL WINAPI InSendMessage(void)
 699 {
 700     return (InSendMessageEx( NULL ) & (ISMEX_SEND | ISMEX_NOTIFY | ISMEX_CALLBACK)) != 0;
 701 }
 702
 703
 704 /***********************************************************************
 705  *              InSendMessageEx  (USER32.@)
 706  */
 707 DWORD WINAPI InSendMessageEx( LPVOID reserved )
 708 {
 709     return NtUserGetThreadInfo()->receive_flags;
 710 }
 711
 712
 713 /***********************************************************************
 714  *              PostMessageA  (USER32.@)
 715  */
 716 BOOL WINAPI PostMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 717 {
 718     if (!map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_POSTMESSAGE )) return TRUE;
 719     return PostMessageW( hwnd, msg, wparam, lparam );
 720 }
 721
 722
 723 /***********************************************************************
 724  *              PostMessageW  (USER32.@)
 725  */
 726 BOOL WINAPI PostMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
 727 {
 728     return NtUserPostMessage( hwnd, msg, wparam, lparam );
 729 }
 730
 731
 732 /**********************************************************************
 733  *              PostThreadMessageA  (USER32.@)
 734  */
 735 BOOL WINAPI PostThreadMessageA( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam )
 736 {
 737     if (!map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_POSTMESSAGE )) return TRUE;
 738     return NtUserPostThreadMessage( thread, msg, wparam, lparam );
 739 }
 740
 741
 742 /***********************************************************************
 743  *              PostQuitMessage  (USER32.@)
 744  *
 745  * Posts a quit message to the current thread's message queue.
 746  *
 747  * PARAMS
 748  *  exit_code [I] Exit code to return from message loop.
 749  *
 750  * RETURNS
 751  *  Nothing.
 752  *
 753  * NOTES
 754  *  This function is not the same as calling:
 755  *|PostThreadMessage(GetCurrentThreadId(), WM_QUIT, exit_code, 0);
 756  *  It instead sets a flag in the message queue that signals it to generate
 757  *  a WM_QUIT message when there are no other pending sent or posted messages
 758  *  in the queue.
 759  */
 760 void WINAPI PostQuitMessage( INT exit_code )
 761 {
 762     SERVER_START_REQ( post_quit_message )
 763     {
 764         req->exit_code = exit_code;
 765         wine_server_call( req );
 766     }
 767     SERVER_END_REQ;
 768 }
 769
 770 /***********************************************************************
 771  *              PeekMessageW  (USER32.@)
 772  */
 773 BOOL WINAPI DECLSPEC_HOTPATCH PeekMessageW( MSG *msg_out, HWND hwnd, UINT first, UINT last, UINT flags )
 774 {
 775     return NtUserPeekMessage( msg_out, hwnd, first, last, flags );
 776 }
 777
 778
 779 /***********************************************************************
 780  *              PeekMessageA  (USER32.@)
 781  */
 782 BOOL WINAPI DECLSPEC_HOTPATCH PeekMessageA( MSG *msg, HWND hwnd, UINT first, UINT last, UINT flags )
 783 {
 784     if (get_pending_wmchar( msg, first, last, (flags & PM_REMOVE) )) return TRUE;
 785     if (!PeekMessageW( msg, hwnd, first, last, flags )) return FALSE;
 786     map_wparam_WtoA( msg, (flags & PM_REMOVE) );
 787     return TRUE;
 788 }
 789
 790
 791 /***********************************************************************
 792  *              GetMessageW  (USER32.@)
 793  */
 794 BOOL WINAPI DECLSPEC_HOTPATCH GetMessageW( MSG *msg, HWND hwnd, UINT first, UINT last )
 795 {
 796     return NtUserGetMessage( msg, hwnd, first, last );
 797 }
 798
 799
 800 /***********************************************************************
 801  *              GetMessageA  (USER32.@)
 802  */
 803 BOOL WINAPI DECLSPEC_HOTPATCH GetMessageA( MSG *msg, HWND hwnd, UINT first, UINT last )
 804 {
 805     if (get_pending_wmchar( msg, first, last, TRUE )) return TRUE;
 806     if (GetMessageW( msg, hwnd, first, last ) < 0) return -1;
 807     map_wparam_WtoA( msg, TRUE );
 808     return (msg->message != WM_QUIT);
 809 }
 810
 811
 812 /***********************************************************************
 813  *              IsDialogMessageA (USER32.@)
 814  *              IsDialogMessage  (USER32.@)
 815  */
 816 BOOL WINAPI IsDialogMessageA( HWND hwndDlg, LPMSG pmsg )
 817 {
 818     MSG msg = *pmsg;
 819     map_wparam_AtoW( msg.message, &msg.wParam, WMCHAR_MAP_NOMAPPING );
 820     return IsDialogMessageW( hwndDlg, &msg );
 821 }
 822
 823
 824 /***********************************************************************
 825  *              TranslateMessage (USER32.@)
 826  *
 827  * Implementation of TranslateMessage.
 828  *
 829  * TranslateMessage translates virtual-key messages into character-messages,
 830  * as follows :
 831  * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
 832  * ditto replacing WM_* with WM_SYS*
 833  * This produces WM_CHAR messages only for keys mapped to ASCII characters
 834  * by the keyboard driver.
 835  *
 836  * If the message is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP, the
 837  * return value is nonzero, regardless of the translation.
 838  *
 839  */
 840 BOOL WINAPI TranslateMessage( const MSG *msg )
 841 {
 842     return NtUserTranslateMessage( msg, 0 );
 843 }
 844
 845
 846 static LRESULT dispatch_message( const MSG *msg, BOOL ansi )
 847 {
 848     struct win_proc_params params;
 849     LRESULT retval = 0;
 850
 851     if (!NtUserMessageCall( msg->hwnd, msg->message, msg->wParam, msg->lParam,
 852                             &params, NtUserGetDispatchParams, ansi )) return 0;
 853     params.result = &retval;
 854
 855     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message, msg->wParam, msg->lParam );
 856     dispatch_win_proc_params( &params );
 857     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval, msg->wParam, msg->lParam );
 858     return retval;
 859 }
 860
 861
 862 /***********************************************************************
 863  *              DispatchMessageA (USER32.@)
 864  *
 865  * See DispatchMessageW.
 866  */
 867 LRESULT WINAPI DECLSPEC_HOTPATCH DispatchMessageA( const MSG* msg )
 868 {
 869     LRESULT retval;
 870
 871       /* Process timer messages */
 872     if (msg->lParam && msg->message == WM_TIMER)
 873     {
 874         __TRY
 875         {
 876             retval = CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
 877                                       msg->message, msg->wParam, GetTickCount() );
 878         }
 879         __EXCEPT_ALL
 880         {
 881             retval = 0;
 882         }
 883         __ENDTRY
 884         return retval;
 885     }
 886
 887     /* whenever possible, avoid using NtUserDispatchMessage to make the call unwindable */
 888     if (msg->message != WM_SYSTIMER && msg->message != WM_PAINT)
 889         return dispatch_message( msg, TRUE );
 890
 891     return NtUserDispatchMessage( msg );
 892 }
 893
 894
 895 /***********************************************************************
 896  *              DispatchMessageW (USER32.@) Process a message
 897  *
 898  * Process the message specified in the structure *_msg_.
 899  *
 900  * If the lpMsg parameter points to a WM_TIMER message and the
 901  * parameter of the WM_TIMER message is not NULL, the lParam parameter
 902  * points to the function that is called instead of the window
 903  * procedure. The function stored in lParam (timer callback) is protected
 904  * from causing page-faults.
 905  *
 906  * The message must be valid.
 907  *
 908  * RETURNS
 909  *
 910  *   DispatchMessage() returns the result of the window procedure invoked.
 911  *
 912  * CONFORMANCE
 913  *
 914  *   ECMA-234, Win32
 915  *
 916  */
 917 LRESULT WINAPI DECLSPEC_HOTPATCH DispatchMessageW( const MSG* msg )
 918 {
 919     LRESULT retval;
 920
 921       /* Process timer messages */
 922     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
 923     {
 924         if (msg->lParam)
 925         {
 926             __TRY
 927             {
 928                 retval = CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
 929                                           msg->message, msg->wParam, GetTickCount() );
 930             }
 931             __EXCEPT_ALL
 932             {
 933                 retval = 0;
 934             }
 935             __ENDTRY
 936             return retval;
 937         }
 938     }
 939
 940     /* whenever possible, avoid using NtUserDispatchMessage to make the call unwindable */
 941     if (msg->message != WM_SYSTIMER && msg->message != WM_PAINT)
 942         return dispatch_message( msg, FALSE );
 943
 944     return NtUserDispatchMessage( msg );
 945 }
 946
 947
 948 /***********************************************************************
 949  *              GetMessagePos (USER.119)
 950  *              GetMessagePos (USER32.@)
 951  *
 952  * The GetMessagePos() function returns a long value representing a
 953  * cursor position, in screen coordinates, when the last message
 954  * retrieved by the GetMessage() function occurs. The x-coordinate is
 955  * in the low-order word of the return value, the y-coordinate is in
 956  * the high-order word. The application can use the MAKEPOINT()
 957  * macro to obtain a POINT structure from the return value.
 958  *
 959  * For the current cursor position, use GetCursorPos().
 960  *
 961  * RETURNS
 962  *
 963  * Cursor position of last message on success, zero on failure.
 964  *
 965  * CONFORMANCE
 966  *
 967  * ECMA-234, Win32
 968  *
 969  */
 970 DWORD WINAPI GetMessagePos(void)
 971 {
 972     return NtUserGetThreadInfo()->message_pos;
 973 }
 974
 975
 976 /***********************************************************************
 977  *              GetMessageTime (USER.120)
 978  *              GetMessageTime (USER32.@)
 979  *
 980  * GetMessageTime() returns the message time for the last message
 981  * retrieved by the function. The time is measured in milliseconds with
 982  * the same offset as GetTickCount().
 983  *
 984  * Since the tick count wraps, this is only useful for moderately short
 985  * relative time comparisons.
 986  *
 987  * RETURNS
 988  *
 989  * Time of last message on success, zero on failure.
 990  */
 991 LONG WINAPI GetMessageTime(void)
 992 {
 993     return NtUserGetThreadInfo()->message_time;
 994 }
 995
 996
 997 /***********************************************************************
 998  *              GetMessageExtraInfo (USER.288)
 999  *              GetMessageExtraInfo (USER32.@)
1000  */
1001 LPARAM WINAPI GetMessageExtraInfo(void)
1002 {
1003     return NtUserGetThreadInfo()->message_extra;
1004 }
1005
1006
1007 /***********************************************************************
1008  *              SetMessageExtraInfo (USER32.@)
1009  */
1010 LPARAM WINAPI SetMessageExtraInfo(LPARAM lParam)
1011 {
1012     struct ntuser_thread_info *thread_info = NtUserGetThreadInfo();
1013     LONG old_value = thread_info->message_extra;
1014     thread_info->message_extra = lParam;
1015     return old_value;
1016 }
1017
1018
1019 /***********************************************************************
1020  *              GetCurrentInputMessageSource (USER32.@)
1021  */
1022 BOOL WINAPI GetCurrentInputMessageSource( INPUT_MESSAGE_SOURCE *source )
1023 {
1024     *source = NtUserGetThreadInfo()->msg_source;
1025     return TRUE;
1026 }
1027
1028
1029 /***********************************************************************
1030  *              WaitMessage (USER.112) Suspend thread pending messages
1031  *              WaitMessage (USER32.@) Suspend thread pending messages
1032  *
1033  * WaitMessage() suspends a thread until events appear in the thread's
1034  * queue.
1035  */
1036 BOOL WINAPI WaitMessage(void)
1037 {
1038     return NtUserMsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, 0 ) != WAIT_FAILED;
1039 }
1040
1041
1042 /***********************************************************************
1043  *              MsgWaitForMultipleObjects (USER32.@)
1044  */
1045 DWORD WINAPI MsgWaitForMultipleObjects( DWORD count, const HANDLE *handles,
1046                                         BOOL wait_all, DWORD timeout, DWORD mask )
1047 {
1048     return NtUserMsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
1049                                               wait_all ? MWMO_WAITALL : 0 );
1050 }
1051
1052
1053 /***********************************************************************
1054  *              WaitForInputIdle (USER32.@)
1055  */
1056 DWORD WINAPI WaitForInputIdle( HANDLE process, DWORD timeout )
1057 {
1058     return NtUserWaitForInputIdle( process, timeout, FALSE );
1059 }
1060
1061
1062 /***********************************************************************
1063  *              RegisterWindowMessageA (USER32.@)
1064  *              RegisterWindowMessage (USER.118)
1065  */
1066 UINT WINAPI RegisterWindowMessageA( LPCSTR str )
1067 {
1068     UINT ret = GlobalAddAtomA(str);
1069     TRACE("%s, ret=%x\n", str, ret);
1070     return ret;
1071 }
1072
1073
1074 /***********************************************************************
1075  *              RegisterWindowMessageW (USER32.@)
1076  */
1077 UINT WINAPI RegisterWindowMessageW( LPCWSTR str )
1078 {
1079     UINT ret = GlobalAddAtomW(str);
1080     TRACE("%s ret=%x\n", debugstr_w(str), ret);
1081     return ret;
1082 }
1083
1084 typedef struct BroadcastParm
1085 {
1086     DWORD flags;
1087     LPDWORD recipients;
1088     UINT msg;
1089     WPARAM wp;
1090     LPARAM lp;
1091     BOOL success;
1092     HWINSTA winsta;
1093 } BroadcastParm;
1094
1095 static BOOL CALLBACK bcast_childwindow( HWND hw, LPARAM lp )
1096 {
1097     BroadcastParm *parm = (BroadcastParm*)lp;
1098     DWORD_PTR retval = 0;
1099     LRESULT lresult;
1100
1101     if (parm->flags & BSF_IGNORECURRENTTASK && WIN_IsCurrentProcess(hw))
1102     {
1103         TRACE("Not telling myself %p\n", hw);
1104         return TRUE;
1105     }
1106
1107     /* I don't know 100% for sure if this is what Windows does, but it fits the tests */
1108     if (parm->flags & BSF_QUERY)
1109     {
1110         TRACE("Telling window %p using SendMessageTimeout\n", hw);
1111
1112         /* Not tested for conflicting flags */
1113         if (parm->flags & BSF_FORCEIFHUNG || parm->flags & BSF_NOHANG)
1114             lresult = SendMessageTimeoutW( hw, parm->msg, parm->wp, parm->lp, SMTO_ABORTIFHUNG, 2000, &retval );
1115         else if (parm->flags & BSF_NOTIMEOUTIFNOTHUNG)
1116             lresult = SendMessageTimeoutW( hw, parm->msg, parm->wp, parm->lp, SMTO_NOTIMEOUTIFNOTHUNG, 2000, &retval );
1117         else
1118             lresult = SendMessageTimeoutW( hw, parm->msg, parm->wp, parm->lp, SMTO_NORMAL, 2000, &retval );
1119
1120         if (!lresult && GetLastError() == ERROR_TIMEOUT)
1121         {
1122             WARN("Timed out!\n");
1123             if (!(parm->flags & BSF_FORCEIFHUNG))
1124                 goto fail;
1125         }
1126         if (retval == BROADCAST_QUERY_DENY)
1127             goto fail;
1128
1129         return TRUE;
1130
1131 fail:
1132         parm->success = FALSE;
1133         return FALSE;
1134     }
1135     else if (parm->flags & BSF_POSTMESSAGE)
1136     {
1137         TRACE("Telling window %p using PostMessage\n", hw);
1138         PostMessageW( hw, parm->msg, parm->wp, parm->lp );
1139     }
1140     else
1141     {
1142         TRACE("Telling window %p using SendNotifyMessage\n", hw);
1143         SendNotifyMessageW( hw, parm->msg, parm->wp, parm->lp );
1144     }
1145
1146     return TRUE;
1147 }
1148
1149 static BOOL CALLBACK bcast_desktop( LPWSTR desktop, LPARAM lp )
1150 {
1151     BOOL ret;
1152     HDESK hdesktop;
1153     BroadcastParm *parm = (BroadcastParm*)lp;
1154
1155     TRACE("desktop: %s\n", debugstr_w( desktop ));
1156
1157     hdesktop = open_winstation_desktop( parm->winsta, desktop, 0, FALSE, DESKTOP_ENUMERATE|DESKTOP_WRITEOBJECTS|STANDARD_RIGHTS_WRITE );
1158     if (!hdesktop)
1159     {
1160         FIXME("Could not open desktop %s\n", debugstr_w(desktop));
1161         return TRUE;
1162     }
1163
1164     ret = EnumDesktopWindows( hdesktop, bcast_childwindow, lp );
1165     NtUserCloseDesktop( hdesktop );
1166     TRACE("-->%d\n", ret);
1167     return parm->success;
1168 }
1169
1170 static BOOL CALLBACK bcast_winsta( LPWSTR winsta, LPARAM lp )
1171 {
1172     BOOL ret;
1173     HWINSTA hwinsta = OpenWindowStationW( winsta, FALSE, WINSTA_ENUMDESKTOPS );
1174     TRACE("hwinsta: %p/%s/%08lx\n", hwinsta, debugstr_w( winsta ), GetLastError());
1175     if (!hwinsta)
1176         return TRUE;
1177     ((BroadcastParm *)lp)->winsta = hwinsta;
1178     ret = EnumDesktopsW( hwinsta, bcast_desktop, lp );
1179     NtUserCloseWindowStation( hwinsta );
1180     TRACE("-->%d\n", ret);
1181     return ret;
1182 }
1183
1184 /***********************************************************************
1185  *              BroadcastSystemMessageA (USER32.@)
1186  *              BroadcastSystemMessage  (USER32.@)
1187  */
1188 LONG WINAPI BroadcastSystemMessageA( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp )
1189 {
1190     return BroadcastSystemMessageExA( flags, recipients, msg, wp, lp, NULL );
1191 }
1192
1193
1194 /***********************************************************************
1195  *              BroadcastSystemMessageW (USER32.@)
1196  */
1197 LONG WINAPI BroadcastSystemMessageW( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp )
1198 {
1199     return BroadcastSystemMessageExW( flags, recipients, msg, wp, lp, NULL );
1200 }
1201
1202 /***********************************************************************
1203  *              BroadcastSystemMessageExA (USER32.@)
1204  */
1205 LONG WINAPI BroadcastSystemMessageExA( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp, PBSMINFO pinfo )
1206 {
1207     map_wparam_AtoW( msg, &wp, WMCHAR_MAP_NOMAPPING );
1208     return BroadcastSystemMessageExW( flags, recipients, msg, wp, lp, NULL );
1209 }
1210
1211
1212 /***********************************************************************
1213  *              BroadcastSystemMessageExW (USER32.@)
1214  */
1215 LONG WINAPI BroadcastSystemMessageExW( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp, PBSMINFO pinfo )
1216 {
1217     BroadcastParm parm;
1218     DWORD recips = BSM_ALLCOMPONENTS;
1219     BOOL ret = TRUE;
1220     static const DWORD all_flags = ( BSF_QUERY | BSF_IGNORECURRENTTASK | BSF_FLUSHDISK | BSF_NOHANG
1221                                    | BSF_POSTMESSAGE | BSF_FORCEIFHUNG | BSF_NOTIMEOUTIFNOTHUNG
1222                                    | BSF_ALLOWSFW | BSF_SENDNOTIFYMESSAGE | BSF_RETURNHDESK | BSF_LUID );
1223
1224     TRACE("Flags: %08lx, recipients: %p(0x%lx), msg: %04x, wparam: %08Ix, lparam: %08Ix\n", flags, recipients,
1225          (recipients ? *recipients : recips), msg, wp, lp);
1226
1227     if (flags & ~all_flags)
1228     {
1229         SetLastError(ERROR_INVALID_PARAMETER);
1230         return 0;
1231     }
1232
1233     if (!recipients)
1234         recipients = &recips;
1235
1236     if ( pinfo && flags & BSF_QUERY )
1237         FIXME("Not returning PBSMINFO information yet\n");
1238
1239     parm.flags = flags;
1240     parm.recipients = recipients;
1241     parm.msg = msg;
1242     parm.wp = wp;
1243     parm.lp = lp;
1244     parm.success = TRUE;
1245
1246     if (*recipients & BSM_ALLDESKTOPS || *recipients == BSM_ALLCOMPONENTS)
1247         ret = EnumWindowStationsW(bcast_winsta, (LONG_PTR)&parm);
1248     else if (*recipients & BSM_APPLICATIONS)
1249     {
1250         EnumWindows(bcast_childwindow, (LONG_PTR)&parm);
1251         ret = parm.success;
1252     }
1253     else
1254         FIXME("Recipients %08lx not supported!\n", *recipients);
1255
1256     return ret;
1257 }
1258
1259 /***********************************************************************
1260  *              SetMessageQueue (USER32.@)
1261  */
1262 BOOL WINAPI SetMessageQueue( INT size )
1263 {
1264     /* now obsolete the message queue will be expanded dynamically as necessary */
1265     return TRUE;
1266 }
1267
1268
1269 /***********************************************************************
1270  *              MessageBeep (USER32.@)
1271  */
1272 BOOL WINAPI MessageBeep( UINT i )
1273 {
1274     return NtUserMessageBeep( i );
1275 }
1276
1277
1278 /******************************************************************
1279  *      SetTimer (USER32.@)
1280  */
1281 UINT_PTR WINAPI SetTimer( HWND hwnd, UINT_PTR id, UINT timeout, TIMERPROC proc )
1282 {
1283     return NtUserSetTimer( hwnd, id, timeout, proc, TIMERV_DEFAULT_COALESCING );
1284 }
1285
1286
1287 /******************************************************************
1288  *      SetSystemTimer (USER32.@)
1289  */
1290 UINT_PTR WINAPI SetSystemTimer( HWND hwnd, UINT_PTR id, UINT timeout, void *unknown )
1291 {
1292     if (unknown) FIXME( "ignoring unknown parameter %p\n", unknown );
1293
1294     return NtUserSetSystemTimer( hwnd, id, timeout );
1295 }
1296
1297
1298 /***********************************************************************
1299  *              KillSystemTimer (USER32.@)
1300  */
1301 BOOL WINAPI KillSystemTimer( HWND hwnd, UINT_PTR id )
1302 {
1303     return NtUserKillSystemTimer( hwnd, id );
1304 }
1305
1306
1307 /**********************************************************************
1308  *              IsGUIThread  (USER32.@)
1309  */
1310 BOOL WINAPI IsGUIThread( BOOL convert )
1311 {
1312     FIXME( "%u: stub\n", convert );
1313     return TRUE;
1314 }
1315
1316
1317 /******************************************************************
1318  *              IsHungAppWindow (USER32.@)
1319  *
1320  */
1321 BOOL WINAPI IsHungAppWindow( HWND hWnd )
1322 {
1323     BOOL ret;
1324
1325     SERVER_START_REQ( is_window_hung )
1326     {
1327         req->win = wine_server_user_handle( hWnd );
1328         ret = !wine_server_call_err( req ) && reply->is_hung;
1329     }
1330     SERVER_END_REQ;
1331     return ret;
1332 }
1333
1334 /******************************************************************
1335  *      ChangeWindowMessageFilter (USER32.@)
1336  */
1337 BOOL WINAPI ChangeWindowMessageFilter( UINT message, DWORD flag )
1338 {
1339     FIXME( "%x %08lx\n", message, flag );
1340     return TRUE;
1341 }
1342
1343 /******************************************************************
1344  *      ChangeWindowMessageFilterEx (USER32.@)
1345  */
1346 BOOL WINAPI ChangeWindowMessageFilterEx( HWND hwnd, UINT message, DWORD action, CHANGEFILTERSTRUCT *changefilter )
1347 {
1348     FIXME( "%p %x %ld %p\n", hwnd, message, action, changefilter );
1349     return TRUE;
1350 }