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