git.oblomov.eu Git - wine/blob - 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 "config.h"
  23 #include "wine/port.h"
  24
  25 #include <assert.h>
  26 #include <stdarg.h>
  27
  28 #include "ntstatus.h"
  29 #define WIN32_NO_STATUS
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "winuser.h"
  34 #include "winerror.h"
  35 #include "winnls.h"
  36 #include "dbt.h"
  37 #include "dde.h"
  38 #include "imm.h"
  39 #include "ddk/imm.h"
  40 #include "wine/unicode.h"
  41 #include "wine/server.h"
  42 #include "user_private.h"
  43 #include "win.h"
  44 #include "controls.h"
  45 #include "wine/debug.h"
  46 #include "wine/exception.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(msg);
  49 WINE_DECLARE_DEBUG_CHANNEL(relay);
  50 WINE_DECLARE_DEBUG_CHANNEL(key);
  51
  52 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
  53 #define WM_NCMOUSELAST  (WM_NCMOUSEFIRST+(WM_MOUSELAST-WM_MOUSEFIRST))
  54
  55 #define MAX_PACK_COUNT 4
  56
  57 #define SYS_TIMER_RATE  55   /* min. timer rate in ms (actually 54.925)*/
  58
  59 /* the various structures that can be sent in messages, in platform-independent layout */
  60 struct packed_CREATESTRUCTW
  61 {
  62     ULONGLONG     lpCreateParams;
  63     ULONGLONG     hInstance;
  64     user_handle_t hMenu;
  65     DWORD         __pad1;
  66     user_handle_t hwndParent;
  67     DWORD         __pad2;
  68     INT           cy;
  69     INT           cx;
  70     INT           y;
  71     INT           x;
  72     LONG          style;
  73     ULONGLONG     lpszName;
  74     ULONGLONG     lpszClass;
  75     DWORD         dwExStyle;
  76     DWORD         __pad3;
  77 };
  78
  79 /* the structures are unpacked on top of the packed ones, so make sure they fit */
  80 C_ASSERT( sizeof(struct packed_CREATESTRUCTW) >= sizeof(CREATESTRUCTW) );
  81
  82 union packed_structs
  83 {
  84     struct packed_CREATESTRUCTW cs;
  85 };
  86
  87 /* description of the data fields that need to be packed along with a sent message */
  88 struct packed_message
  89 {
  90     union packed_structs ps;
  91     int                  count;
  92     const void          *data[MAX_PACK_COUNT];
  93     size_t               size[MAX_PACK_COUNT];
  94 };
  95
  96 /* info about the message currently being received by the current thread */
  97 struct received_message_info
  98 {
  99     enum message_type type;
 100     MSG               msg;
 101     UINT              flags;  /* InSendMessageEx return flags */
 102 };
 103
 104 /* structure to group all parameters for sent messages of the various kinds */
 105 struct send_message_info
 106 {
 107     enum message_type type;
 108     DWORD             dest_tid;
 109     HWND              hwnd;
 110     UINT              msg;
 111     WPARAM            wparam;
 112     LPARAM            lparam;
 113     UINT              flags;      /* flags for SendMessageTimeout */
 114     UINT              timeout;    /* timeout for SendMessageTimeout */
 115     SENDASYNCPROC     callback;   /* callback function for SendMessageCallback */
 116     ULONG_PTR         data;       /* callback data */
 117     enum wm_char_mapping wm_char;
 118 };
 119
 120
 121 /* Message class descriptor */
 122 static const WCHAR messageW[] = {'M','e','s','s','a','g','e',0};
 123
 124 const struct builtin_class_descr MESSAGE_builtin_class =
 125 {
 126     messageW,             /* name */
 127     0,                    /* style */
 128     WINPROC_MESSAGE,      /* proc */
 129     0,                    /* extra */
 130     IDC_ARROW,            /* cursor */
 131     0                     /* brush */
 132 };
 133
 134
 135
 136 /* flag for messages that contain pointers */
 137 /* 32 messages per entry, messages 0..31 map to bits 0..31 */
 138
 139 #define SET(msg) (1 << ((msg) & 31))
 140
 141 static const unsigned int message_pointer_flags[] =
 142 {
 143     /* 0x00 - 0x1f */
 144     SET(WM_CREATE) | SET(WM_SETTEXT) | SET(WM_GETTEXT) |
 145     SET(WM_WININICHANGE) | SET(WM_DEVMODECHANGE),
 146     /* 0x20 - 0x3f */
 147     SET(WM_GETMINMAXINFO) | SET(WM_DRAWITEM) | SET(WM_MEASUREITEM) | SET(WM_DELETEITEM) |
 148     SET(WM_COMPAREITEM),
 149     /* 0x40 - 0x5f */
 150     SET(WM_WINDOWPOSCHANGING) | SET(WM_WINDOWPOSCHANGED) | SET(WM_COPYDATA) |
 151     SET(WM_NOTIFY) | SET(WM_HELP),
 152     /* 0x60 - 0x7f */
 153     SET(WM_STYLECHANGING) | SET(WM_STYLECHANGED),
 154     /* 0x80 - 0x9f */
 155     SET(WM_NCCREATE) | SET(WM_NCCALCSIZE) | SET(WM_GETDLGCODE),
 156     /* 0xa0 - 0xbf */
 157     SET(EM_GETSEL) | SET(EM_GETRECT) | SET(EM_SETRECT) | SET(EM_SETRECTNP),
 158     /* 0xc0 - 0xdf */
 159     SET(EM_REPLACESEL) | SET(EM_GETLINE) | SET(EM_SETTABSTOPS),
 160     /* 0xe0 - 0xff */
 161     SET(SBM_GETRANGE) | SET(SBM_SETSCROLLINFO) | SET(SBM_GETSCROLLINFO) | SET(SBM_GETSCROLLBARINFO),
 162     /* 0x100 - 0x11f */
 163     0,
 164     /* 0x120 - 0x13f */
 165     0,
 166     /* 0x140 - 0x15f */
 167     SET(CB_GETEDITSEL) | SET(CB_ADDSTRING) | SET(CB_DIR) | SET(CB_GETLBTEXT) |
 168     SET(CB_INSERTSTRING) | SET(CB_FINDSTRING) | SET(CB_SELECTSTRING) |
 169     SET(CB_GETDROPPEDCONTROLRECT) | SET(CB_FINDSTRINGEXACT),
 170     /* 0x160 - 0x17f */
 171     0,
 172     /* 0x180 - 0x19f */
 173     SET(LB_ADDSTRING) | SET(LB_INSERTSTRING) | SET(LB_GETTEXT) | SET(LB_SELECTSTRING) |
 174     SET(LB_DIR) | SET(LB_FINDSTRING) |
 175     SET(LB_GETSELITEMS) | SET(LB_SETTABSTOPS) | SET(LB_ADDFILE) | SET(LB_GETITEMRECT),
 176     /* 0x1a0 - 0x1bf */
 177     SET(LB_FINDSTRINGEXACT),
 178     /* 0x1c0 - 0x1df */
 179     0,
 180     /* 0x1e0 - 0x1ff */
 181     0,
 182     /* 0x200 - 0x21f */
 183     SET(WM_NEXTMENU) | SET(WM_SIZING) | SET(WM_MOVING) | SET(WM_DEVICECHANGE),
 184     /* 0x220 - 0x23f */
 185     SET(WM_MDICREATE) | SET(WM_MDIGETACTIVE) | SET(WM_DROPOBJECT) |
 186     SET(WM_QUERYDROPOBJECT) | SET(WM_DRAGLOOP) | SET(WM_DRAGSELECT) | SET(WM_DRAGMOVE),
 187     /* 0x240 - 0x25f */
 188     0,
 189     /* 0x260 - 0x27f */
 190     0,
 191     /* 0x280 - 0x29f */
 192     0,
 193     /* 0x2a0 - 0x2bf */
 194     0,
 195     /* 0x2c0 - 0x2df */
 196     0,
 197     /* 0x2e0 - 0x2ff */
 198     0,
 199     /* 0x300 - 0x31f */
 200     SET(WM_ASKCBFORMATNAME)
 201 };
 202
 203 /* flags for messages that contain Unicode strings */
 204 static const unsigned int message_unicode_flags[] =
 205 {
 206     /* 0x00 - 0x1f */
 207     SET(WM_CREATE) | SET(WM_SETTEXT) | SET(WM_GETTEXT) | SET(WM_GETTEXTLENGTH) |
 208     SET(WM_WININICHANGE) | SET(WM_DEVMODECHANGE),
 209     /* 0x20 - 0x3f */
 210     SET(WM_CHARTOITEM),
 211     /* 0x40 - 0x5f */
 212     0,
 213     /* 0x60 - 0x7f */
 214     0,
 215     /* 0x80 - 0x9f */
 216     SET(WM_NCCREATE),
 217     /* 0xa0 - 0xbf */
 218     0,
 219     /* 0xc0 - 0xdf */
 220     SET(EM_REPLACESEL) | SET(EM_GETLINE) | SET(EM_SETPASSWORDCHAR),
 221     /* 0xe0 - 0xff */
 222     0,
 223     /* 0x100 - 0x11f */
 224     SET(WM_CHAR) | SET(WM_DEADCHAR) | SET(WM_SYSCHAR) | SET(WM_SYSDEADCHAR),
 225     /* 0x120 - 0x13f */
 226     SET(WM_MENUCHAR),
 227     /* 0x140 - 0x15f */
 228     SET(CB_ADDSTRING) | SET(CB_DIR) | SET(CB_GETLBTEXT) | SET(CB_GETLBTEXTLEN) |
 229     SET(CB_INSERTSTRING) | SET(CB_FINDSTRING) | SET(CB_SELECTSTRING) | SET(CB_FINDSTRINGEXACT),
 230     /* 0x160 - 0x17f */
 231     0,
 232     /* 0x180 - 0x19f */
 233     SET(LB_ADDSTRING) | SET(LB_INSERTSTRING) | SET(LB_GETTEXT) | SET(LB_GETTEXTLEN) |
 234     SET(LB_SELECTSTRING) | SET(LB_DIR) | SET(LB_FINDSTRING) | SET(LB_ADDFILE),
 235     /* 0x1a0 - 0x1bf */
 236     SET(LB_FINDSTRINGEXACT),
 237     /* 0x1c0 - 0x1df */
 238     0,
 239     /* 0x1e0 - 0x1ff */
 240     0,
 241     /* 0x200 - 0x21f */
 242     0,
 243     /* 0x220 - 0x23f */
 244     SET(WM_MDICREATE),
 245     /* 0x240 - 0x25f */
 246     0,
 247     /* 0x260 - 0x27f */
 248     0,
 249     /* 0x280 - 0x29f */
 250     SET(WM_IME_CHAR),
 251     /* 0x2a0 - 0x2bf */
 252     0,
 253     /* 0x2c0 - 0x2df */
 254     0,
 255     /* 0x2e0 - 0x2ff */
 256     0,
 257     /* 0x300 - 0x31f */
 258     SET(WM_PAINTCLIPBOARD) | SET(WM_SIZECLIPBOARD) | SET(WM_ASKCBFORMATNAME)
 259 };
 260
 261 /* check whether a given message type includes pointers */
 262 static inline int is_pointer_message( UINT message )
 263 {
 264     if (message >= 8*sizeof(message_pointer_flags)) return FALSE;
 265     return (message_pointer_flags[message / 32] & SET(message)) != 0;
 266 }
 267
 268 /* check whether a given message type contains Unicode (or ASCII) chars */
 269 static inline int is_unicode_message( UINT message )
 270 {
 271     if (message >= 8*sizeof(message_unicode_flags)) return FALSE;
 272     return (message_unicode_flags[message / 32] & SET(message)) != 0;
 273 }
 274
 275 #undef SET
 276
 277 /* add a data field to a packed message */
 278 static inline void push_data( struct packed_message *data, const void *ptr, size_t size )
 279 {
 280     data->data[data->count] = ptr;
 281     data->size[data->count] = size;
 282     data->count++;
 283 }
 284
 285 /* add a string to a packed message */
 286 static inline void push_string( struct packed_message *data, LPCWSTR str )
 287 {
 288     push_data( data, str, (strlenW(str) + 1) * sizeof(WCHAR) );
 289 }
 290
 291 /* make sure that the buffer contains a valid null-terminated Unicode string */
 292 static inline BOOL check_string( LPCWSTR str, size_t size )
 293 {
 294     for (size /= sizeof(WCHAR); size; size--, str++)
 295         if (!*str) return TRUE;
 296     return FALSE;
 297 }
 298
 299 /* pack a pointer into a 32/64 portable format */
 300 static inline ULONGLONG pack_ptr( const void *ptr )
 301 {
 302     return (ULONG_PTR)ptr;
 303 }
 304
 305 /* unpack a potentially 64-bit pointer, returning 0 when truncated */
 306 static inline void *unpack_ptr( ULONGLONG ptr64 )
 307 {
 308     if ((ULONG_PTR)ptr64 != ptr64) return 0;
 309     return (void *)(ULONG_PTR)ptr64;
 310 }
 311
 312 /* make sure that there is space for 'size' bytes in buffer, growing it if needed */
 313 static inline void *get_buffer_space( void **buffer, size_t size )
 314 {
 315     void *ret;
 316
 317     if (*buffer)
 318     {
 319         if (!(ret = HeapReAlloc( GetProcessHeap(), 0, *buffer, size )))
 320             HeapFree( GetProcessHeap(), 0, *buffer );
 321     }
 322     else ret = HeapAlloc( GetProcessHeap(), 0, size );
 323
 324     *buffer = ret;
 325     return ret;
 326 }
 327
 328 /* check whether a combobox expects strings or ids in CB_ADDSTRING/CB_INSERTSTRING */
 329 static inline BOOL combobox_has_strings( HWND hwnd )
 330 {
 331     DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
 332     return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
 333 }
 334
 335 /* check whether a listbox expects strings or ids in LB_ADDSTRING/LB_INSERTSTRING */
 336 static inline BOOL listbox_has_strings( HWND hwnd )
 337 {
 338     DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
 339     return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
 340 }
 341
 342 /* check whether message is in the range of keyboard messages */
 343 static inline BOOL is_keyboard_message( UINT message )
 344 {
 345     return (message >= WM_KEYFIRST && message <= WM_KEYLAST);
 346 }
 347
 348 /* check whether message is in the range of mouse messages */
 349 static inline BOOL is_mouse_message( UINT message )
 350 {
 351     return ((message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST) ||
 352             (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST));
 353 }
 354
 355 /* check whether message matches the specified hwnd filter */
 356 static inline BOOL check_hwnd_filter( const MSG *msg, HWND hwnd_filter )
 357 {
 358     if (!hwnd_filter || hwnd_filter == GetDesktopWindow()) return TRUE;
 359     return (msg->hwnd == hwnd_filter || IsChild( hwnd_filter, msg->hwnd ));
 360 }
 361
 362 /* check for pending WM_CHAR message with DBCS trailing byte */
 363 static inline BOOL get_pending_wmchar( MSG *msg, UINT first, UINT last, BOOL remove )
 364 {
 365     struct wm_char_mapping_data *data = get_user_thread_info()->wmchar_data;
 366
 367     if (!data || !data->get_msg.message) return FALSE;
 368     if ((first || last) && (first > WM_CHAR || last < WM_CHAR)) return FALSE;
 369     if (!msg) return FALSE;
 370     *msg = data->get_msg;
 371     if (remove) data->get_msg.message = 0;
 372     return TRUE;
 373 }
 374
 375
 376 /***********************************************************************
 377  *           MessageWndProc
 378  *
 379  * Window procedure for "Message" windows (HWND_MESSAGE parent).
 380  */
 381 LRESULT WINAPI MessageWndProc( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
 382 {
 383     if (message == WM_NCCREATE) return TRUE;
 384     return 0;  /* all other messages are ignored */
 385 }
 386
 387
 388 /***********************************************************************
 389  *              broadcast_message_callback
 390  *
 391  * Helper callback for broadcasting messages.
 392  */
 393 static BOOL CALLBACK broadcast_message_callback( HWND hwnd, LPARAM lparam )
 394 {
 395     struct send_message_info *info = (struct send_message_info *)lparam;
 396     if (!(GetWindowLongW( hwnd, GWL_STYLE ) & (WS_POPUP|WS_CAPTION))) return TRUE;
 397     switch(info->type)
 398     {
 399     case MSG_UNICODE:
 400         SendMessageTimeoutW( hwnd, info->msg, info->wparam, info->lparam,
 401                              info->flags, info->timeout, NULL );
 402         break;
 403     case MSG_ASCII:
 404         SendMessageTimeoutA( hwnd, info->msg, info->wparam, info->lparam,
 405                              info->flags, info->timeout, NULL );
 406         break;
 407     case MSG_NOTIFY:
 408         SendNotifyMessageW( hwnd, info->msg, info->wparam, info->lparam );
 409         break;
 410     case MSG_CALLBACK:
 411         SendMessageCallbackW( hwnd, info->msg, info->wparam, info->lparam,
 412                               info->callback, info->data );
 413         break;
 414     case MSG_POSTED:
 415         PostMessageW( hwnd, info->msg, info->wparam, info->lparam );
 416         break;
 417     default:
 418         ERR( "bad type %d\n", info->type );
 419         break;
 420     }
 421     return TRUE;
 422 }
 423
 424
 425 /***********************************************************************
 426  *              map_wparam_AtoW
 427  *
 428  * Convert the wparam of an ASCII message to Unicode.
 429  */
 430 BOOL map_wparam_AtoW( UINT message, WPARAM *wparam, enum wm_char_mapping mapping )
 431 {
 432     char ch[2];
 433     WCHAR wch[2];
 434
 435     wch[0] = wch[1] = 0;
 436     switch(message)
 437     {
 438     case WM_CHAR:
 439         /* WM_CHAR is magic: a DBCS char can be sent/posted as two consecutive WM_CHAR
 440          * messages, in which case the first char is stored, and the conversion
 441          * to Unicode only takes place once the second char is sent/posted.
 442          */
 443         if (mapping != WMCHAR_MAP_NOMAPPING)
 444         {
 445             struct wm_char_mapping_data *data = get_user_thread_info()->wmchar_data;
 446             BYTE low = LOBYTE(*wparam);
 447
 448             if (HIBYTE(*wparam))
 449             {
 450                 ch[0] = low;
 451                 ch[1] = HIBYTE(*wparam);
 452                 RtlMultiByteToUnicodeN( wch, sizeof(wch), NULL, ch, 2 );
 453                 TRACE( "map %02x,%02x -> %04x mapping %u\n", (BYTE)ch[0], (BYTE)ch[1], wch[0], mapping );
 454                 if (data) data->lead_byte[mapping] = 0;
 455             }
 456             else if (data && data->lead_byte[mapping])
 457             {
 458                 ch[0] = data->lead_byte[mapping];
 459                 ch[1] = low;
 460                 RtlMultiByteToUnicodeN( wch, sizeof(wch), NULL, ch, 2 );
 461                 TRACE( "map stored %02x,%02x -> %04x mapping %u\n", (BYTE)ch[0], (BYTE)ch[1], wch[0], mapping );
 462                 data->lead_byte[mapping] = 0;
 463             }
 464             else if (!IsDBCSLeadByte( low ))
 465             {
 466                 ch[0] = low;
 467                 RtlMultiByteToUnicodeN( wch, sizeof(wch), NULL, ch, 1 );
 468                 TRACE( "map %02x -> %04x\n", (BYTE)ch[0], wch[0] );
 469                 if (data) data->lead_byte[mapping] = 0;
 470             }
 471             else  /* store it and wait for trail byte */
 472             {
 473                 if (!data)
 474                 {
 475                     if (!(data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) )))
 476                         return FALSE;
 477                     get_user_thread_info()->wmchar_data = data;
 478                 }
 479                 TRACE( "storing lead byte %02x mapping %u\n", low, mapping );
 480                 data->lead_byte[mapping] = low;
 481                 return FALSE;
 482             }
 483             *wparam = MAKEWPARAM(wch[0], wch[1]);
 484             break;
 485         }
 486         /* else fall through */
 487     case WM_CHARTOITEM:
 488     case EM_SETPASSWORDCHAR:
 489     case WM_DEADCHAR:
 490     case WM_SYSCHAR:
 491     case WM_SYSDEADCHAR:
 492     case WM_MENUCHAR:
 493         ch[0] = LOBYTE(*wparam);
 494         ch[1] = HIBYTE(*wparam);
 495         RtlMultiByteToUnicodeN( wch, sizeof(wch), NULL, ch, 2 );
 496         *wparam = MAKEWPARAM(wch[0], wch[1]);
 497         break;
 498     case WM_IME_CHAR:
 499         ch[0] = HIBYTE(*wparam);
 500         ch[1] = LOBYTE(*wparam);
 501         if (ch[0]) RtlMultiByteToUnicodeN( wch, sizeof(wch[0]), NULL, ch, 2 );
 502         else RtlMultiByteToUnicodeN( wch, sizeof(wch[0]), NULL, ch + 1, 1 );
 503         *wparam = MAKEWPARAM(wch[0], HIWORD(*wparam));
 504         break;
 505     }
 506     return TRUE;
 507 }
 508
 509
 510 /***********************************************************************
 511  *              map_wparam_WtoA
 512  *
 513  * Convert the wparam of a Unicode message to ASCII.
 514  */
 515 static void map_wparam_WtoA( MSG *msg, BOOL remove )
 516 {
 517     BYTE ch[2];
 518     WCHAR wch[2];
 519     DWORD len;
 520
 521     switch(msg->message)
 522     {
 523     case WM_CHAR:
 524         if (!HIWORD(msg->wParam))
 525         {
 526             wch[0] = LOWORD(msg->wParam);
 527             ch[0] = ch[1] = 0;
 528             RtlUnicodeToMultiByteN( (LPSTR)ch, 2, &len, wch, sizeof(wch[0]) );
 529             if (len == 2)  /* DBCS char */
 530             {
 531                 struct wm_char_mapping_data *data = get_user_thread_info()->wmchar_data;
 532                 if (!data)
 533                 {
 534                     if (!(data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data) ))) return;
 535                     get_user_thread_info()->wmchar_data = data;
 536                 }
 537                 if (remove)
 538                 {
 539                     data->get_msg = *msg;
 540                     data->get_msg.wParam = ch[1];
 541                 }
 542                 msg->wParam = ch[0];
 543                 return;
 544             }
 545         }
 546         /* else fall through */
 547     case WM_CHARTOITEM:
 548     case EM_SETPASSWORDCHAR:
 549     case WM_DEADCHAR:
 550     case WM_SYSCHAR:
 551     case WM_SYSDEADCHAR:
 552     case WM_MENUCHAR:
 553         wch[0] = LOWORD(msg->wParam);
 554         wch[1] = HIWORD(msg->wParam);
 555         ch[0] = ch[1] = 0;
 556         RtlUnicodeToMultiByteN( (LPSTR)ch, 2, NULL, wch, sizeof(wch) );
 557         msg->wParam = MAKEWPARAM( ch[0] | (ch[1] << 8), 0 );
 558         break;
 559     case WM_IME_CHAR:
 560         wch[0] = LOWORD(msg->wParam);
 561         ch[0] = ch[1] = 0;
 562         RtlUnicodeToMultiByteN( (LPSTR)ch, 2, &len, wch, sizeof(wch[0]) );
 563         if (len == 2)
 564             msg->wParam = MAKEWPARAM( (ch[0] << 8) | ch[1], HIWORD(msg->wParam) );
 565         else
 566             msg->wParam = MAKEWPARAM( ch[0], HIWORD(msg->wParam) );
 567         break;
 568     }
 569 }
 570
 571
 572 /***********************************************************************
 573  *              pack_message
 574  *
 575  * Pack a message for sending to another process.
 576  * Return the size of the data we expect in the message reply.
 577  * Set data->count to -1 if there is an error.
 578  */
 579 static size_t pack_message( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam,
 580                             struct packed_message *data )
 581 {
 582     data->count = 0;
 583     switch(message)
 584     {
 585     case WM_NCCREATE:
 586     case WM_CREATE:
 587     {
 588         CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
 589         data->ps.cs.lpCreateParams = pack_ptr( cs->lpCreateParams );
 590         data->ps.cs.hInstance      = pack_ptr( cs->hInstance );
 591         data->ps.cs.hMenu          = wine_server_user_handle( cs->hMenu );
 592         data->ps.cs.hwndParent     = wine_server_user_handle( cs->hwndParent );
 593         data->ps.cs.cy             = cs->cy;
 594         data->ps.cs.cx             = cs->cx;
 595         data->ps.cs.y              = cs->y;
 596         data->ps.cs.x              = cs->x;
 597         data->ps.cs.style          = cs->style;
 598         data->ps.cs.dwExStyle      = cs->dwExStyle;
 599         data->ps.cs.lpszName       = pack_ptr( cs->lpszName );
 600         data->ps.cs.lpszClass      = pack_ptr( cs->lpszClass );
 601         push_data( data, &data->ps.cs, sizeof(data->ps.cs) );
 602         if (!IS_INTRESOURCE(cs->lpszName)) push_string( data, cs->lpszName );
 603         if (!IS_INTRESOURCE(cs->lpszClass)) push_string( data, cs->lpszClass );
 604         return sizeof(data->ps.cs);
 605     }
 606     case WM_GETTEXT:
 607     case WM_ASKCBFORMATNAME:
 608         return wparam * sizeof(WCHAR);
 609     case WM_WININICHANGE:
 610         if (lparam) push_string(data, (LPWSTR)lparam );
 611         return 0;
 612     case WM_SETTEXT:
 613     case WM_DEVMODECHANGE:
 614     case CB_DIR:
 615     case LB_DIR:
 616     case LB_ADDFILE:
 617     case EM_REPLACESEL:
 618         push_string( data, (LPWSTR)lparam );
 619         return 0;
 620     case WM_GETMINMAXINFO:
 621         push_data( data, (MINMAXINFO *)lparam, sizeof(MINMAXINFO) );
 622         return sizeof(MINMAXINFO);
 623     case WM_DRAWITEM:
 624         push_data( data, (DRAWITEMSTRUCT *)lparam, sizeof(DRAWITEMSTRUCT) );
 625         return 0;
 626     case WM_MEASUREITEM:
 627         push_data( data, (MEASUREITEMSTRUCT *)lparam, sizeof(MEASUREITEMSTRUCT) );
 628         return sizeof(MEASUREITEMSTRUCT);
 629     case WM_DELETEITEM:
 630         push_data( data, (DELETEITEMSTRUCT *)lparam, sizeof(DELETEITEMSTRUCT) );
 631         return 0;
 632     case WM_COMPAREITEM:
 633         push_data( data, (COMPAREITEMSTRUCT *)lparam, sizeof(COMPAREITEMSTRUCT) );
 634         return 0;
 635     case WM_WINDOWPOSCHANGING:
 636     case WM_WINDOWPOSCHANGED:
 637         push_data( data, (WINDOWPOS *)lparam, sizeof(WINDOWPOS) );
 638         return sizeof(WINDOWPOS);
 639     case WM_COPYDATA:
 640     {
 641         COPYDATASTRUCT *cp = (COPYDATASTRUCT *)lparam;
 642         push_data( data, cp, sizeof(*cp) );
 643         if (cp->lpData) push_data( data, cp->lpData, cp->cbData );
 644         return 0;
 645     }
 646     case WM_NOTIFY:
 647         /* WM_NOTIFY cannot be sent across processes (MSDN) */
 648         data->count = -1;
 649         return 0;
 650     case WM_HELP:
 651         push_data( data, (HELPINFO *)lparam, sizeof(HELPINFO) );
 652         return 0;
 653     case WM_STYLECHANGING:
 654     case WM_STYLECHANGED:
 655         push_data( data, (STYLESTRUCT *)lparam, sizeof(STYLESTRUCT) );
 656         return 0;
 657     case WM_NCCALCSIZE:
 658         if (!wparam)
 659         {
 660             push_data( data, (RECT *)lparam, sizeof(RECT) );
 661             return sizeof(RECT);
 662         }
 663         else
 664         {
 665             NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lparam;
 666             push_data( data, nc, sizeof(*nc) );
 667             push_data( data, nc->lppos, sizeof(*nc->lppos) );
 668             return sizeof(*nc) + sizeof(*nc->lppos);
 669         }
 670     case WM_GETDLGCODE:
 671         if (lparam) push_data( data, (MSG *)lparam, sizeof(MSG) );
 672         return sizeof(MSG);
 673     case SBM_SETSCROLLINFO:
 674         push_data( data, (SCROLLINFO *)lparam, sizeof(SCROLLINFO) );
 675         return 0;
 676     case SBM_GETSCROLLINFO:
 677         push_data( data, (SCROLLINFO *)lparam, sizeof(SCROLLINFO) );
 678         return sizeof(SCROLLINFO);
 679     case SBM_GETSCROLLBARINFO:
 680     {
 681         const SCROLLBARINFO *info = (const SCROLLBARINFO *)lparam;
 682         size_t size = min( info->cbSize, sizeof(SCROLLBARINFO) );
 683         push_data( data, info, size );
 684         return size;
 685     }
 686     case EM_GETSEL:
 687     case SBM_GETRANGE:
 688     case CB_GETEDITSEL:
 689     {
 690         size_t size = 0;
 691         if (wparam) size += sizeof(DWORD);
 692         if (lparam) size += sizeof(DWORD);
 693         return size;
 694     }
 695     case EM_GETRECT:
 696     case LB_GETITEMRECT:
 697     case CB_GETDROPPEDCONTROLRECT:
 698         return sizeof(RECT);
 699     case EM_SETRECT:
 700     case EM_SETRECTNP:
 701         push_data( data, (RECT *)lparam, sizeof(RECT) );
 702         return 0;
 703     case EM_GETLINE:
 704     {
 705         WORD *pw = (WORD *)lparam;
 706         push_data( data, pw, sizeof(*pw) );
 707         return *pw * sizeof(WCHAR);
 708     }
 709     case EM_SETTABSTOPS:
 710     case LB_SETTABSTOPS:
 711         if (wparam) push_data( data, (UINT *)lparam, sizeof(UINT) * wparam );
 712         return 0;
 713     case CB_ADDSTRING:
 714     case CB_INSERTSTRING:
 715     case CB_FINDSTRING:
 716     case CB_FINDSTRINGEXACT:
 717     case CB_SELECTSTRING:
 718         if (combobox_has_strings( hwnd )) push_string( data, (LPWSTR)lparam );
 719         return 0;
 720     case CB_GETLBTEXT:
 721         if (!combobox_has_strings( hwnd )) return sizeof(ULONG_PTR);
 722         return (SendMessageW( hwnd, CB_GETLBTEXTLEN, wparam, 0 ) + 1) * sizeof(WCHAR);
 723     case LB_ADDSTRING:
 724     case LB_INSERTSTRING:
 725     case LB_FINDSTRING:
 726     case LB_FINDSTRINGEXACT:
 727     case LB_SELECTSTRING:
 728         if (listbox_has_strings( hwnd )) push_string( data, (LPWSTR)lparam );
 729         return 0;
 730     case LB_GETTEXT:
 731         if (!listbox_has_strings( hwnd )) return sizeof(ULONG_PTR);
 732         return (SendMessageW( hwnd, LB_GETTEXTLEN, wparam, 0 ) + 1) * sizeof(WCHAR);
 733     case LB_GETSELITEMS:
 734         return wparam * sizeof(UINT);
 735     case WM_NEXTMENU:
 736         push_data( data, (MDINEXTMENU *)lparam, sizeof(MDINEXTMENU) );
 737         return sizeof(MDINEXTMENU);
 738     case WM_SIZING:
 739     case WM_MOVING:
 740         push_data( data, (RECT *)lparam, sizeof(RECT) );
 741         return sizeof(RECT);
 742     case WM_MDICREATE:
 743     {
 744         MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lparam;
 745         push_data( data, cs, sizeof(*cs) );
 746         if (!IS_INTRESOURCE(cs->szTitle)) push_string( data, cs->szTitle );
 747         if (!IS_INTRESOURCE(cs->szClass)) push_string( data, cs->szClass );
 748         return sizeof(*cs);
 749     }
 750     case WM_MDIGETACTIVE:
 751         if (lparam) return sizeof(BOOL);
 752         return 0;
 753     case WM_DEVICECHANGE:
 754     {
 755         DEV_BROADCAST_HDR *header = (DEV_BROADCAST_HDR *)lparam;
 756         push_data( data, header, header->dbch_size );
 757         return 0;
 758     }
 759     case WM_WINE_SETWINDOWPOS:
 760         push_data( data, (WINDOWPOS *)lparam, sizeof(WINDOWPOS) );
 761         return 0;
 762     case WM_WINE_KEYBOARD_LL_HOOK:
 763     {
 764         struct hook_extra_info *h_extra = (struct hook_extra_info *)lparam;
 765         push_data( data, h_extra, sizeof(*h_extra) );
 766         push_data( data, (LPVOID)h_extra->lparam, sizeof(KBDLLHOOKSTRUCT) );
 767         return 0;
 768     }
 769     case WM_WINE_MOUSE_LL_HOOK:
 770     {
 771         struct hook_extra_info *h_extra = (struct hook_extra_info *)lparam;
 772         push_data( data, h_extra, sizeof(*h_extra) );
 773         push_data( data, (LPVOID)h_extra->lparam, sizeof(MSLLHOOKSTRUCT) );
 774         return 0;
 775     }
 776     case WM_NCPAINT:
 777         if (wparam <= 1) return 0;
 778         FIXME( "WM_NCPAINT hdc packing not supported yet\n" );
 779         data->count = -1;
 780         return 0;
 781     case WM_PAINT:
 782         if (!wparam) return 0;
 783         /* fall through */
 784
 785     /* these contain an HFONT */
 786     case WM_SETFONT:
 787     case WM_GETFONT:
 788     /* these contain an HDC */
 789     case WM_ERASEBKGND:
 790     case WM_ICONERASEBKGND:
 791     case WM_CTLCOLORMSGBOX:
 792     case WM_CTLCOLOREDIT:
 793     case WM_CTLCOLORLISTBOX:
 794     case WM_CTLCOLORBTN:
 795     case WM_CTLCOLORDLG:
 796     case WM_CTLCOLORSCROLLBAR:
 797     case WM_CTLCOLORSTATIC:
 798     case WM_PRINT:
 799     case WM_PRINTCLIENT:
 800     /* these contain an HGLOBAL */
 801     case WM_PAINTCLIPBOARD:
 802     case WM_SIZECLIPBOARD:
 803     /* these contain HICON */
 804     case WM_GETICON:
 805     case WM_SETICON:
 806     case WM_QUERYDRAGICON:
 807     case WM_QUERYPARKICON:
 808     /* these contain pointers */
 809     case WM_DROPOBJECT:
 810     case WM_QUERYDROPOBJECT:
 811     case WM_DRAGLOOP:
 812     case WM_DRAGSELECT:
 813     case WM_DRAGMOVE:
 814         FIXME( "msg %x (%s) not supported yet\n", message, SPY_GetMsgName(message, hwnd) );
 815         data->count = -1;
 816         return 0;
 817     }
 818     return 0;
 819 }
 820
 821
 822 /***********************************************************************
 823  *              unpack_message
 824  *
 825  * Unpack a message received from another process.
 826  */
 827 static BOOL unpack_message( HWND hwnd, UINT message, WPARAM *wparam, LPARAM *lparam,
 828                             void **buffer, size_t size )
 829 {
 830     size_t minsize = 0;
 831     union packed_structs *ps = *buffer;
 832
 833     switch(message)
 834     {
 835     case WM_NCCREATE:
 836     case WM_CREATE:
 837     {
 838         CREATESTRUCTW cs;
 839         WCHAR *str = (WCHAR *)(&ps->cs + 1);
 840         if (size < sizeof(ps->cs)) return FALSE;
 841         size -= sizeof(ps->cs);
 842         cs.lpCreateParams = unpack_ptr( ps->cs.lpCreateParams );
 843         cs.hInstance      = unpack_ptr( ps->cs.hInstance );
 844         cs.hMenu          = wine_server_ptr_handle( ps->cs.hMenu );
 845         cs.hwndParent     = wine_server_ptr_handle( ps->cs.hwndParent );
 846         cs.cy             = ps->cs.cy;
 847         cs.cx             = ps->cs.cx;
 848         cs.y              = ps->cs.y;
 849         cs.x              = ps->cs.x;
 850         cs.style          = ps->cs.style;
 851         cs.dwExStyle      = ps->cs.dwExStyle;
 852         cs.lpszName       = unpack_ptr( ps->cs.lpszName );
 853         cs.lpszClass      = unpack_ptr( ps->cs.lpszClass );
 854         if (ps->cs.lpszName >> 16)
 855         {
 856             if (!check_string( str, size )) return FALSE;
 857             cs.lpszName = str;
 858             size -= (strlenW(str) + 1) * sizeof(WCHAR);
 859             str += strlenW(str) + 1;
 860         }
 861         if (ps->cs.lpszClass >> 16)
 862         {
 863             if (!check_string( str, size )) return FALSE;
 864             cs.lpszClass = str;
 865         }
 866         memcpy( &ps->cs, &cs, sizeof(cs) );
 867         break;
 868     }
 869     case WM_GETTEXT:
 870     case WM_ASKCBFORMATNAME:
 871         if (!get_buffer_space( buffer, (*wparam * sizeof(WCHAR)) )) return FALSE;
 872         break;
 873     case WM_WININICHANGE:
 874         if (!*lparam) return TRUE;
 875         /* fall through */
 876     case WM_SETTEXT:
 877     case WM_DEVMODECHANGE:
 878     case CB_DIR:
 879     case LB_DIR:
 880     case LB_ADDFILE:
 881     case EM_REPLACESEL:
 882         if (!check_string( *buffer, size )) return FALSE;
 883         break;
 884     case WM_GETMINMAXINFO:
 885         minsize = sizeof(MINMAXINFO);
 886         break;
 887     case WM_DRAWITEM:
 888         minsize = sizeof(DRAWITEMSTRUCT);
 889         break;
 890     case WM_MEASUREITEM:
 891         minsize = sizeof(MEASUREITEMSTRUCT);
 892         break;
 893     case WM_DELETEITEM:
 894         minsize = sizeof(DELETEITEMSTRUCT);
 895         break;
 896     case WM_COMPAREITEM:
 897         minsize = sizeof(COMPAREITEMSTRUCT);
 898         break;
 899     case WM_WINDOWPOSCHANGING:
 900     case WM_WINDOWPOSCHANGED:
 901     case WM_WINE_SETWINDOWPOS:
 902         minsize = sizeof(WINDOWPOS);
 903         break;
 904     case WM_COPYDATA:
 905     {
 906         COPYDATASTRUCT *cp = *buffer;
 907         if (size < sizeof(*cp)) return FALSE;
 908         if (cp->lpData)
 909         {
 910             minsize = sizeof(*cp) + cp->cbData;
 911             cp->lpData = cp + 1;
 912         }
 913         break;
 914     }
 915     case WM_NOTIFY:
 916         /* WM_NOTIFY cannot be sent across processes (MSDN) */
 917         return FALSE;
 918     case WM_HELP:
 919         minsize = sizeof(HELPINFO);
 920         break;
 921     case WM_STYLECHANGING:
 922     case WM_STYLECHANGED:
 923         minsize = sizeof(STYLESTRUCT);
 924         break;
 925     case WM_NCCALCSIZE:
 926         if (!*wparam) minsize = sizeof(RECT);
 927         else
 928         {
 929             NCCALCSIZE_PARAMS *nc = *buffer;
 930             if (size < sizeof(*nc) + sizeof(*nc->lppos)) return FALSE;
 931             nc->lppos = (WINDOWPOS *)(nc + 1);
 932         }
 933         break;
 934     case WM_GETDLGCODE:
 935         if (!*lparam) return TRUE;
 936         minsize = sizeof(MSG);
 937         break;
 938     case SBM_SETSCROLLINFO:
 939         minsize = sizeof(SCROLLINFO);
 940         break;
 941     case SBM_GETSCROLLINFO:
 942         if (!get_buffer_space( buffer, sizeof(SCROLLINFO ))) return FALSE;
 943         break;
 944     case SBM_GETSCROLLBARINFO:
 945         if (!get_buffer_space( buffer, sizeof(SCROLLBARINFO ))) return FALSE;
 946         break;
 947     case EM_GETSEL:
 948     case SBM_GETRANGE:
 949     case CB_GETEDITSEL:
 950         if (*wparam || *lparam)
 951         {
 952             if (!get_buffer_space( buffer, 2*sizeof(DWORD) )) return FALSE;
 953             if (*wparam) *wparam = (WPARAM)*buffer;
 954             if (*lparam) *lparam = (LPARAM)((DWORD *)*buffer + 1);
 955         }
 956         return TRUE;
 957     case EM_GETRECT:
 958     case LB_GETITEMRECT:
 959     case CB_GETDROPPEDCONTROLRECT:
 960         if (!get_buffer_space( buffer, sizeof(RECT) )) return FALSE;
 961         break;
 962     case EM_SETRECT:
 963     case EM_SETRECTNP:
 964         minsize = sizeof(RECT);
 965         break;
 966     case EM_GETLINE:
 967     {
 968         WORD len;
 969         if (size < sizeof(WORD)) return FALSE;
 970         len = *(WORD *)*buffer;
 971         if (!get_buffer_space( buffer, (len + 1) * sizeof(WCHAR) )) return FALSE;
 972         *lparam = (LPARAM)*buffer + sizeof(WORD);  /* don't erase WORD at start of buffer */
 973         return TRUE;
 974     }
 975     case EM_SETTABSTOPS:
 976     case LB_SETTABSTOPS:
 977         if (!*wparam) return TRUE;
 978         minsize = *wparam * sizeof(UINT);
 979         break;
 980     case CB_ADDSTRING:
 981     case CB_INSERTSTRING:
 982     case CB_FINDSTRING:
 983     case CB_FINDSTRINGEXACT:
 984     case CB_SELECTSTRING:
 985     case LB_ADDSTRING:
 986     case LB_INSERTSTRING:
 987     case LB_FINDSTRING:
 988     case LB_FINDSTRINGEXACT:
 989     case LB_SELECTSTRING:
 990         if (!*buffer) return TRUE;
 991         if (!check_string( *buffer, size )) return FALSE;
 992         break;
 993     case CB_GETLBTEXT:
 994     {
 995         size = sizeof(ULONG_PTR);
 996         if (combobox_has_strings( hwnd ))
 997             size = (SendMessageW( hwnd, CB_GETLBTEXTLEN, *wparam, 0 ) + 1) * sizeof(WCHAR);
 998         if (!get_buffer_space( buffer, size )) return FALSE;
 999         break;
1000     }
1001     case LB_GETTEXT:
1002     {
1003         size = sizeof(ULONG_PTR);
1004         if (listbox_has_strings( hwnd ))
1005             size = (SendMessageW( hwnd, LB_GETTEXTLEN, *wparam, 0 ) + 1) * sizeof(WCHAR);
1006         if (!get_buffer_space( buffer, size )) return FALSE;
1007         break;
1008     }
1009     case LB_GETSELITEMS:
1010         if (!get_buffer_space( buffer, *wparam * sizeof(UINT) )) return FALSE;
1011         break;
1012     case WM_NEXTMENU:
1013         minsize = sizeof(MDINEXTMENU);
1014         if (!get_buffer_space( buffer, sizeof(MDINEXTMENU) )) return FALSE;
1015         break;
1016     case WM_SIZING:
1017     case WM_MOVING:
1018         minsize = sizeof(RECT);
1019         if (!get_buffer_space( buffer, sizeof(RECT) )) return FALSE;
1020         break;
1021     case WM_MDICREATE:
1022     {
1023         MDICREATESTRUCTW *cs = *buffer;
1024         WCHAR *str = (WCHAR *)(cs + 1);
1025         if (size < sizeof(*cs)) return FALSE;
1026         size -= sizeof(*cs);
1027         if (!IS_INTRESOURCE(cs->szTitle))
1028         {
1029             if (!check_string( str, size )) return FALSE;
1030             cs->szTitle = str;
1031             size -= (strlenW(str) + 1) * sizeof(WCHAR);
1032             str += strlenW(str) + 1;
1033         }
1034         if (!IS_INTRESOURCE(cs->szClass))
1035         {
1036             if (!check_string( str, size )) return FALSE;
1037             cs->szClass = str;
1038         }
1039         break;
1040     }
1041     case WM_MDIGETACTIVE:
1042         if (!*lparam) return TRUE;
1043         if (!get_buffer_space( buffer, sizeof(BOOL) )) return FALSE;
1044         break;
1045     case WM_DEVICECHANGE:
1046         minsize = sizeof(DEV_BROADCAST_HDR);
1047         break;
1048     case WM_WINE_KEYBOARD_LL_HOOK:
1049     case WM_WINE_MOUSE_LL_HOOK:
1050     {
1051         struct hook_extra_info *h_extra = *buffer;
1052
1053         minsize = sizeof(struct hook_extra_info) +
1054                   (message == WM_WINE_KEYBOARD_LL_HOOK ? sizeof(KBDLLHOOKSTRUCT)
1055                                                        : sizeof(MSLLHOOKSTRUCT));
1056         if (size < minsize) return FALSE;
1057         h_extra->lparam = (LPARAM)(h_extra + 1);
1058         break;
1059     }
1060     case WM_NCPAINT:
1061         if (*wparam <= 1) return TRUE;
1062         FIXME( "WM_NCPAINT hdc unpacking not supported\n" );
1063         return FALSE;
1064     case WM_PAINT:
1065         if (!*wparam) return TRUE;
1066         /* fall through */
1067
1068     /* these contain an HFONT */
1069     case WM_SETFONT:
1070     case WM_GETFONT:
1071     /* these contain an HDC */
1072     case WM_ERASEBKGND:
1073     case WM_ICONERASEBKGND:
1074     case WM_CTLCOLORMSGBOX:
1075     case WM_CTLCOLOREDIT:
1076     case WM_CTLCOLORLISTBOX:
1077     case WM_CTLCOLORBTN:
1078     case WM_CTLCOLORDLG:
1079     case WM_CTLCOLORSCROLLBAR:
1080     case WM_CTLCOLORSTATIC:
1081     case WM_PRINT:
1082     case WM_PRINTCLIENT:
1083     /* these contain an HGLOBAL */
1084     case WM_PAINTCLIPBOARD:
1085     case WM_SIZECLIPBOARD:
1086     /* these contain HICON */
1087     case WM_GETICON:
1088     case WM_SETICON:
1089     case WM_QUERYDRAGICON:
1090     case WM_QUERYPARKICON:
1091     /* these contain pointers */
1092     case WM_DROPOBJECT:
1093     case WM_QUERYDROPOBJECT:
1094     case WM_DRAGLOOP:
1095     case WM_DRAGSELECT:
1096     case WM_DRAGMOVE:
1097         FIXME( "msg %x (%s) not supported yet\n", message, SPY_GetMsgName(message, hwnd) );
1098         return FALSE;
1099
1100     default:
1101         return TRUE; /* message doesn't need any unpacking */
1102     }
1103
1104     /* default exit for most messages: check minsize and store buffer in lparam */
1105     if (size < minsize) return FALSE;
1106     *lparam = (LPARAM)*buffer;
1107     return TRUE;
1108 }
1109
1110
1111 /***********************************************************************
1112  *              pack_reply
1113  *
1114  * Pack a reply to a message for sending to another process.
1115  */
1116 static void pack_reply( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam,
1117                         LRESULT res, struct packed_message *data )
1118 {
1119     data->count = 0;
1120     switch(message)
1121     {
1122     case WM_NCCREATE:
1123     case WM_CREATE:
1124     {
1125         CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
1126         data->ps.cs.lpCreateParams = (ULONG_PTR)cs->lpCreateParams;
1127         data->ps.cs.hInstance      = (ULONG_PTR)cs->hInstance;
1128         data->ps.cs.hMenu          = wine_server_user_handle( cs->hMenu );
1129         data->ps.cs.hwndParent     = wine_server_user_handle( cs->hwndParent );
1130         data->ps.cs.cy             = cs->cy;
1131         data->ps.cs.cx             = cs->cx;
1132         data->ps.cs.y              = cs->y;
1133         data->ps.cs.x              = cs->x;
1134         data->ps.cs.style          = cs->style;
1135         data->ps.cs.dwExStyle      = cs->dwExStyle;
1136         data->ps.cs.lpszName       = (ULONG_PTR)cs->lpszName;
1137         data->ps.cs.lpszClass      = (ULONG_PTR)cs->lpszClass;
1138         push_data( data, &data->ps.cs, sizeof(data->ps.cs) );
1139         break;
1140     }
1141     case WM_GETTEXT:
1142     case CB_GETLBTEXT:
1143     case LB_GETTEXT:
1144         push_data( data, (WCHAR *)lparam, (res + 1) * sizeof(WCHAR) );
1145         break;
1146     case WM_GETMINMAXINFO:
1147         push_data( data, (MINMAXINFO *)lparam, sizeof(MINMAXINFO) );
1148         break;
1149     case WM_MEASUREITEM:
1150         push_data( data, (MEASUREITEMSTRUCT *)lparam, sizeof(MEASUREITEMSTRUCT) );
1151         break;
1152     case WM_WINDOWPOSCHANGING:
1153     case WM_WINDOWPOSCHANGED:
1154         push_data( data, (WINDOWPOS *)lparam, sizeof(WINDOWPOS) );
1155         break;
1156     case WM_GETDLGCODE:
1157         if (lparam) push_data( data, (MSG *)lparam, sizeof(MSG) );
1158         break;
1159     case SBM_GETSCROLLINFO:
1160         push_data( data, (SCROLLINFO *)lparam, sizeof(SCROLLINFO) );
1161         break;
1162     case EM_GETRECT:
1163     case LB_GETITEMRECT:
1164     case CB_GETDROPPEDCONTROLRECT:
1165     case WM_SIZING:
1166     case WM_MOVING:
1167         push_data( data, (RECT *)lparam, sizeof(RECT) );
1168         break;
1169     case EM_GETLINE:
1170     {
1171         WORD *ptr = (WORD *)lparam;
1172         push_data( data, ptr, ptr[-1] * sizeof(WCHAR) );
1173         break;
1174     }
1175     case LB_GETSELITEMS:
1176         push_data( data, (UINT *)lparam, wparam * sizeof(UINT) );
1177         break;
1178     case WM_MDIGETACTIVE:
1179         if (lparam) push_data( data, (BOOL *)lparam, sizeof(BOOL) );
1180         break;
1181     case WM_NCCALCSIZE:
1182         if (!wparam)
1183             push_data( data, (RECT *)lparam, sizeof(RECT) );
1184         else
1185         {
1186             NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lparam;
1187             push_data( data, nc, sizeof(*nc) );
1188             push_data( data, nc->lppos, sizeof(*nc->lppos) );
1189         }
1190         break;
1191     case EM_GETSEL:
1192     case SBM_GETRANGE:
1193     case CB_GETEDITSEL:
1194         if (wparam) push_data( data, (DWORD *)wparam, sizeof(DWORD) );
1195         if (lparam) push_data( data, (DWORD *)lparam, sizeof(DWORD) );
1196         break;
1197     case WM_NEXTMENU:
1198         push_data( data, (MDINEXTMENU *)lparam, sizeof(MDINEXTMENU) );
1199         break;
1200     case WM_MDICREATE:
1201         push_data( data, (MDICREATESTRUCTW *)lparam, sizeof(MDICREATESTRUCTW) );
1202         break;
1203     case WM_ASKCBFORMATNAME:
1204         push_data( data, (WCHAR *)lparam, (strlenW((WCHAR *)lparam) + 1) * sizeof(WCHAR) );
1205         break;
1206     }
1207 }
1208
1209
1210 /***********************************************************************
1211  *              unpack_reply
1212  *
1213  * Unpack a message reply received from another process.
1214  */
1215 static void unpack_reply( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam,
1216                           void *buffer, size_t size )
1217 {
1218     union packed_structs *ps = buffer;
1219
1220     switch(message)
1221     {
1222     case WM_NCCREATE:
1223     case WM_CREATE:
1224         if (size >= sizeof(ps->cs))
1225         {
1226             CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
1227             cs->lpCreateParams = unpack_ptr( ps->cs.lpCreateParams );
1228             cs->hInstance      = unpack_ptr( ps->cs.hInstance );
1229             cs->hMenu          = wine_server_ptr_handle( ps->cs.hMenu );
1230             cs->hwndParent     = wine_server_ptr_handle( ps->cs.hwndParent );
1231             cs->cy             = ps->cs.cy;
1232             cs->cx             = ps->cs.cx;
1233             cs->y              = ps->cs.y;
1234             cs->x              = ps->cs.x;
1235             cs->style          = ps->cs.style;
1236             cs->dwExStyle      = ps->cs.dwExStyle;
1237             /* don't allow changing name and class pointers */
1238         }
1239         break;
1240     case WM_GETTEXT:
1241     case WM_ASKCBFORMATNAME:
1242         memcpy( (WCHAR *)lparam, buffer, min( wparam*sizeof(WCHAR), size ));
1243         break;
1244     case WM_GETMINMAXINFO:
1245         memcpy( (MINMAXINFO *)lparam, buffer, min( sizeof(MINMAXINFO), size ));
1246         break;
1247     case WM_MEASUREITEM:
1248         memcpy( (MEASUREITEMSTRUCT *)lparam, buffer, min( sizeof(MEASUREITEMSTRUCT), size ));
1249         break;
1250     case WM_WINDOWPOSCHANGING:
1251     case WM_WINDOWPOSCHANGED:
1252         memcpy( (WINDOWPOS *)lparam, buffer, min( sizeof(WINDOWPOS), size ));
1253         break;
1254     case WM_GETDLGCODE:
1255         if (lparam) memcpy( (MSG *)lparam, buffer, min( sizeof(MSG), size ));
1256         break;
1257     case SBM_GETSCROLLINFO:
1258         memcpy( (SCROLLINFO *)lparam, buffer, min( sizeof(SCROLLINFO), size ));
1259         break;
1260     case SBM_GETSCROLLBARINFO:
1261         memcpy( (SCROLLBARINFO *)lparam, buffer, min( sizeof(SCROLLBARINFO), size ));
1262         break;
1263     case EM_GETRECT:
1264     case CB_GETDROPPEDCONTROLRECT:
1265     case LB_GETITEMRECT:
1266     case WM_SIZING:
1267     case WM_MOVING:
1268         memcpy( (RECT *)lparam, buffer, min( sizeof(RECT), size ));
1269         break;
1270     case EM_GETLINE:
1271         size = min( size, (size_t)*(WORD *)lparam );
1272         memcpy( (WCHAR *)lparam, buffer, size );
1273         break;
1274     case LB_GETSELITEMS:
1275         memcpy( (UINT *)lparam, buffer, min( wparam*sizeof(UINT), size ));
1276         break;
1277     case LB_GETTEXT:
1278     case CB_GETLBTEXT:
1279         memcpy( (WCHAR *)lparam, buffer, size );
1280         break;
1281     case WM_NEXTMENU:
1282         memcpy( (MDINEXTMENU *)lparam, buffer, min( sizeof(MDINEXTMENU), size ));
1283         break;
1284     case WM_MDIGETACTIVE:
1285         if (lparam) memcpy( (BOOL *)lparam, buffer, min( sizeof(BOOL), size ));
1286         break;
1287     case WM_NCCALCSIZE:
1288         if (!wparam)
1289             memcpy( (RECT *)lparam, buffer, min( sizeof(RECT), size ));
1290         else
1291         {
1292             NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lparam;
1293             WINDOWPOS *wp = nc->lppos;
1294             memcpy( nc, buffer, min( sizeof(*nc), size ));
1295             if (size > sizeof(*nc))
1296             {
1297                 size -= sizeof(*nc);
1298                 memcpy( wp, (NCCALCSIZE_PARAMS*)buffer + 1, min( sizeof(*wp), size ));
1299             }
1300             nc->lppos = wp;  /* restore the original pointer */
1301         }
1302         break;
1303     case EM_GETSEL:
1304     case SBM_GETRANGE:
1305     case CB_GETEDITSEL:
1306         if (wparam)
1307         {
1308             memcpy( (DWORD *)wparam, buffer, min( sizeof(DWORD), size ));
1309             if (size <= sizeof(DWORD)) break;
1310             size -= sizeof(DWORD);
1311             buffer = (DWORD *)buffer + 1;
1312         }
1313         if (lparam) memcpy( (DWORD *)lparam, buffer, min( sizeof(DWORD), size ));
1314         break;
1315     case WM_MDICREATE:
1316     {
1317         MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lparam;
1318         LPCWSTR title = cs->szTitle, class = cs->szClass;
1319         memcpy( cs, buffer, min( sizeof(*cs), size ));
1320         cs->szTitle = title;  /* restore the original pointers */
1321         cs->szClass = class;
1322         break;
1323     }
1324     default:
1325         ERR( "should not happen: unexpected message %x\n", message );
1326         break;
1327     }
1328 }
1329
1330
1331 /***********************************************************************
1332  *           reply_message
1333  *
1334  * Send a reply to a sent message.
1335  */
1336 static void reply_message( struct received_message_info *info, LRESULT result, BOOL remove )
1337 {
1338     struct packed_message data;
1339     int i, replied = info->flags & ISMEX_REPLIED;
1340
1341     if (info->flags & ISMEX_NOTIFY) return;  /* notify messages don't get replies */
1342     if (!remove && replied) return;  /* replied already */
1343
1344     memset( &data, 0, sizeof(data) );
1345     info->flags |= ISMEX_REPLIED;
1346
1347     if (info->type == MSG_OTHER_PROCESS && !replied)
1348     {
1349         pack_reply( info->msg.hwnd, info->msg.message, info->msg.wParam,
1350                     info->msg.lParam, result, &data );
1351     }
1352
1353     SERVER_START_REQ( reply_message )
1354     {
1355         req->result = result;
1356         req->remove = remove;
1357         for (i = 0; i < data.count; i++) wine_server_add_data( req, data.data[i], data.size[i] );
1358         wine_server_call( req );
1359     }
1360     SERVER_END_REQ;
1361 }
1362
1363
1364 /***********************************************************************
1365  *           handle_internal_message
1366  *
1367  * Handle an internal Wine message instead of calling the window proc.
1368  */
1369 static LRESULT handle_internal_message( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1370 {
1371     switch(msg)
1372     {
1373     case WM_WINE_DESTROYWINDOW:
1374         return WIN_DestroyWindow( hwnd );
1375     case WM_WINE_SETWINDOWPOS:
1376         if (is_desktop_window( hwnd )) return 0;
1377         return USER_SetWindowPos( (WINDOWPOS *)lparam );
1378     case WM_WINE_SHOWWINDOW:
1379         if (is_desktop_window( hwnd )) return 0;
1380         return ShowWindow( hwnd, wparam );
1381     case WM_WINE_SETPARENT:
1382         if (is_desktop_window( hwnd )) return 0;
1383         return (LRESULT)SetParent( hwnd, (HWND)wparam );
1384     case WM_WINE_SETWINDOWLONG:
1385         return WIN_SetWindowLong( hwnd, (short)LOWORD(wparam), HIWORD(wparam), lparam, TRUE );
1386     case WM_WINE_ENABLEWINDOW:
1387         if (is_desktop_window( hwnd )) return 0;
1388         return EnableWindow( hwnd, wparam );
1389     case WM_WINE_SETACTIVEWINDOW:
1390         if (is_desktop_window( hwnd )) return 0;
1391         return (LRESULT)SetActiveWindow( (HWND)wparam );
1392     case WM_WINE_KEYBOARD_LL_HOOK:
1393     case WM_WINE_MOUSE_LL_HOOK:
1394     {
1395         struct hook_extra_info *h_extra = (struct hook_extra_info *)lparam;
1396
1397         return call_current_hook( h_extra->handle, HC_ACTION, wparam, h_extra->lparam );
1398     }
1399     default:
1400         if (msg >= WM_WINE_FIRST_DRIVER_MSG && msg <= WM_WINE_LAST_DRIVER_MSG)
1401             return USER_Driver->pWindowMessage( hwnd, msg, wparam, lparam );
1402         FIXME( "unknown internal message %x\n", msg );
1403         return 0;
1404     }
1405 }
1406
1407 /* since the WM_DDE_ACK response to a WM_DDE_EXECUTE message should contain the handle
1408  * to the memory handle, we keep track (in the server side) of all pairs of handle
1409  * used (the client passes its value and the content of the memory handle), and
1410  * the server stored both values (the client, and the local one, created after the
1411  * content). When a ACK message is generated, the list of pair is searched for a
1412  * matching pair, so that the client memory handle can be returned.
1413  */
1414 struct DDE_pair {
1415     HGLOBAL     client_hMem;
1416     HGLOBAL     server_hMem;
1417 };
1418
1419 static      struct DDE_pair*    dde_pairs;
1420 static      int                 dde_num_alloc;
1421 static      int                 dde_num_used;
1422
1423 static CRITICAL_SECTION dde_crst;
1424 static CRITICAL_SECTION_DEBUG critsect_debug =
1425 {
1426     0, 0, &dde_crst,
1427     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
1428       0, 0, { (DWORD_PTR)(__FILE__ ": dde_crst") }
1429 };
1430 static CRITICAL_SECTION dde_crst = { &critsect_debug, -1, 0, 0, 0, 0 };
1431
1432 static BOOL dde_add_pair(HGLOBAL chm, HGLOBAL shm)
1433 {
1434     int  i;
1435 #define GROWBY  4
1436
1437     EnterCriticalSection(&dde_crst);
1438
1439     /* now remember the pair of hMem on both sides */
1440     if (dde_num_used == dde_num_alloc)
1441     {
1442         struct DDE_pair* tmp;
1443         if (dde_pairs)
1444             tmp  = HeapReAlloc( GetProcessHeap(), 0, dde_pairs,
1445                                             (dde_num_alloc + GROWBY) * sizeof(struct DDE_pair));
1446         else
1447             tmp  = HeapAlloc( GetProcessHeap(), 0,
1448                                             (dde_num_alloc + GROWBY) * sizeof(struct DDE_pair));
1449
1450         if (!tmp)
1451         {
1452             LeaveCriticalSection(&dde_crst);
1453             return FALSE;
1454         }
1455         dde_pairs = tmp;
1456         /* zero out newly allocated part */
1457         memset(&dde_pairs[dde_num_alloc], 0, GROWBY * sizeof(struct DDE_pair));
1458         dde_num_alloc += GROWBY;
1459     }
1460 #undef GROWBY
1461     for (i = 0; i < dde_num_alloc; i++)
1462     {
1463         if (dde_pairs[i].server_hMem == 0)
1464         {
1465             dde_pairs[i].client_hMem = chm;
1466             dde_pairs[i].server_hMem = shm;
1467             dde_num_used++;
1468             break;
1469         }
1470     }
1471     LeaveCriticalSection(&dde_crst);
1472     return TRUE;
1473 }
1474
1475 static HGLOBAL dde_get_pair(HGLOBAL shm)
1476 {
1477     int  i;
1478     HGLOBAL     ret = 0;
1479
1480     EnterCriticalSection(&dde_crst);
1481     for (i = 0; i < dde_num_alloc; i++)
1482     {
1483         if (dde_pairs[i].server_hMem == shm)
1484         {
1485             /* free this pair */
1486             dde_pairs[i].server_hMem = 0;
1487             dde_num_used--;
1488             ret = dde_pairs[i].client_hMem;
1489             break;
1490         }
1491     }
1492     LeaveCriticalSection(&dde_crst);
1493     return ret;
1494 }
1495
1496 /***********************************************************************
1497  *              post_dde_message
1498  *
1499  * Post a DDE message
1500  */
1501 static BOOL post_dde_message( struct packed_message *data, const struct send_message_info *info )
1502 {
1503     void*       ptr = NULL;
1504     int         size = 0;
1505     UINT_PTR    uiLo, uiHi;
1506     LPARAM      lp = 0;
1507     HGLOBAL     hunlock = 0;
1508     int         i;
1509     DWORD       res;
1510
1511     if (!UnpackDDElParam( info->msg, info->lparam, &uiLo, &uiHi ))
1512         return FALSE;
1513
1514     lp = info->lparam;
1515     switch (info->msg)
1516     {
1517         /* DDE messages which don't require packing are:
1518          * WM_DDE_INITIATE
1519          * WM_DDE_TERMINATE
1520          * WM_DDE_REQUEST
1521          * WM_DDE_UNADVISE
1522          */
1523     case WM_DDE_ACK:
1524         if (HIWORD(uiHi))
1525         {
1526             /* uiHi should contain a hMem from WM_DDE_EXECUTE */
1527             HGLOBAL h = dde_get_pair( (HANDLE)uiHi );
1528             if (h)
1529             {
1530                 /* send back the value of h on the other side */
1531                 push_data( data, &h, sizeof(HGLOBAL) );
1532                 lp = uiLo;
1533                 TRACE( "send dde-ack %lx %08lx => %p\n", uiLo, uiHi, h );
1534             }
1535         }
1536         else
1537         {
1538             /* uiHi should contain either an atom or 0 */
1539             TRACE( "send dde-ack %lx atom=%lx\n", uiLo, uiHi );
1540             lp = MAKELONG( uiLo, uiHi );
1541         }
1542         break;
1543     case WM_DDE_ADVISE:
1544     case WM_DDE_DATA:
1545     case WM_DDE_POKE:
1546         size = 0;
1547         if (uiLo)
1548         {
1549             size = GlobalSize( (HGLOBAL)uiLo ) ;
1550             if ((info->msg == WM_DDE_ADVISE && size < sizeof(DDEADVISE)) ||
1551                 (info->msg == WM_DDE_DATA   && size < FIELD_OFFSET(DDEDATA, Value)) ||
1552                 (info->msg == WM_DDE_POKE   && size < FIELD_OFFSET(DDEPOKE, Value))
1553                 )
1554             return FALSE;
1555         }
1556         else if (info->msg != WM_DDE_DATA) return FALSE;
1557
1558         lp = uiHi;
1559         if (uiLo)
1560         {
1561             if ((ptr = GlobalLock( (HGLOBAL)uiLo) ))
1562             {
1563                 DDEDATA *dde_data = ptr;
1564                 TRACE("unused %d, fResponse %d, fRelease %d, fDeferUpd %d, fAckReq %d, cfFormat %d\n",
1565                        dde_data->unused, dde_data->fResponse, dde_data->fRelease,
1566                        dde_data->reserved, dde_data->fAckReq, dde_data->cfFormat);
1567                 push_data( data, ptr, size );
1568                 hunlock = (HGLOBAL)uiLo;
1569             }
1570         }
1571         TRACE( "send ddepack %u %lx\n", size, uiHi );
1572         break;
1573     case WM_DDE_EXECUTE:
1574         if (info->lparam)
1575         {
1576             if ((ptr = GlobalLock( (HGLOBAL)info->lparam) ))
1577             {
1578                 push_data(data, ptr, GlobalSize( (HGLOBAL)info->lparam ));
1579                 /* so that the other side can send it back on ACK */
1580                 lp = info->lparam;
1581                 hunlock = (HGLOBAL)info->lparam;
1582             }
1583         }
1584         break;
1585     }
1586     SERVER_START_REQ( send_message )
1587     {
1588         req->id      = info->dest_tid;
1589         req->type    = info->type;
1590         req->flags   = 0;
1591         req->win     = wine_server_user_handle( info->hwnd );
1592         req->msg     = info->msg;
1593         req->wparam  = info->wparam;
1594         req->lparam  = lp;
1595         req->timeout = TIMEOUT_INFINITE;
1596         for (i = 0; i < data->count; i++)
1597             wine_server_add_data( req, data->data[i], data->size[i] );
1598         if ((res = wine_server_call( req )))
1599         {
1600             if (res == STATUS_INVALID_PARAMETER)
1601                 /* FIXME: find a STATUS_ value for this one */
1602                 SetLastError( ERROR_INVALID_THREAD_ID );
1603             else
1604                 SetLastError( RtlNtStatusToDosError(res) );
1605         }
1606         else
1607             FreeDDElParam(info->msg, info->lparam);
1608     }
1609     SERVER_END_REQ;
1610     if (hunlock) GlobalUnlock(hunlock);
1611
1612     return !res;
1613 }
1614
1615 /***********************************************************************
1616  *              unpack_dde_message
1617  *
1618  * Unpack a posted DDE message received from another process.
1619  */
1620 static BOOL unpack_dde_message( HWND hwnd, UINT message, WPARAM *wparam, LPARAM *lparam,
1621                                 void **buffer, size_t size )
1622 {
1623     UINT_PTR    uiLo, uiHi;
1624     HGLOBAL     hMem = 0;
1625     void*       ptr;
1626
1627     switch (message)
1628     {
1629     case WM_DDE_ACK:
1630         if (size)
1631         {
1632             /* hMem is being passed */
1633             if (size != sizeof(HGLOBAL)) return FALSE;
1634             if (!buffer || !*buffer) return FALSE;
1635             uiLo = *lparam;
1636             memcpy( &hMem, *buffer, size );
1637             uiHi = (UINT_PTR)hMem;
1638             TRACE("recv dde-ack %lx mem=%lx[%lx]\n", uiLo, uiHi, GlobalSize( hMem ));
1639         }
1640         else
1641         {
1642             uiLo = LOWORD( *lparam );
1643             uiHi = HIWORD( *lparam );
1644             TRACE("recv dde-ack %lx atom=%lx\n", uiLo, uiHi);
1645         }
1646         *lparam = PackDDElParam( WM_DDE_ACK, uiLo, uiHi );
1647         break;
1648     case WM_DDE_ADVISE:
1649     case WM_DDE_DATA:
1650     case WM_DDE_POKE:
1651         if ((!buffer || !*buffer) && message != WM_DDE_DATA) return FALSE;
1652         uiHi = *lparam;
1653         if (size)
1654         {
1655             if (!(hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size )))
1656                 return FALSE;
1657             if ((ptr = GlobalLock( hMem )))
1658             {
1659                 memcpy( ptr, *buffer, size );
1660                 GlobalUnlock( hMem );
1661             }
1662             else
1663             {
1664                 GlobalFree( hMem );
1665                 return FALSE;
1666             }
1667         }
1668         uiLo = (UINT_PTR)hMem;
1669
1670         *lparam = PackDDElParam( message, uiLo, uiHi );
1671         break;
1672     case WM_DDE_EXECUTE:
1673         if (size)
1674         {
1675             if (!buffer || !*buffer) return FALSE;
1676             if (!(hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size ))) return FALSE;
1677             if ((ptr = GlobalLock( hMem )))
1678             {
1679                 memcpy( ptr, *buffer, size );
1680                 GlobalUnlock( hMem );
1681                 TRACE( "exec: pairing c=%08lx s=%p\n", *lparam, hMem );
1682                 if (!dde_add_pair( (HGLOBAL)*lparam, hMem ))
1683                 {
1684                     GlobalFree( hMem );
1685                     return FALSE;
1686                 }
1687             }
1688             else
1689             {
1690                 GlobalFree( hMem );
1691                 return FALSE;
1692             }
1693         } else return FALSE;
1694         *lparam = (LPARAM)hMem;
1695         break;
1696     }
1697     return TRUE;
1698 }
1699
1700 /***********************************************************************
1701  *           call_window_proc
1702  *
1703  * Call a window procedure and the corresponding hooks.
1704  */
1705 static LRESULT call_window_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
1706                                  BOOL unicode, BOOL same_thread, enum wm_char_mapping mapping )
1707 {
1708     LRESULT result = 0;
1709     CWPSTRUCT cwp;
1710     CWPRETSTRUCT cwpret;
1711
1712     if (msg & 0x80000000)
1713     {
1714         result = handle_internal_message( hwnd, msg, wparam, lparam );
1715         goto done;
1716     }
1717
1718     /* first the WH_CALLWNDPROC hook */
1719     hwnd = WIN_GetFullHandle( hwnd );
1720     cwp.lParam  = lparam;
1721     cwp.wParam  = wparam;
1722     cwp.message = msg;
1723     cwp.hwnd    = hwnd;
1724     HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, same_thread, (LPARAM)&cwp, unicode );
1725
1726     /* now call the window procedure */
1727     if (!WINPROC_call_window( hwnd, msg, wparam, lparam, &result, unicode, mapping )) goto done;
1728
1729     /* and finally the WH_CALLWNDPROCRET hook */
1730     cwpret.lResult = result;
1731     cwpret.lParam  = lparam;
1732     cwpret.wParam  = wparam;
1733     cwpret.message = msg;
1734     cwpret.hwnd    = hwnd;
1735     HOOK_CallHooks( WH_CALLWNDPROCRET, HC_ACTION, same_thread, (LPARAM)&cwpret, unicode );
1736  done:
1737     return result;
1738 }
1739
1740
1741 /***********************************************************************
1742  *           send_parent_notify
1743  *
1744  * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
1745  * the window has the WS_EX_NOPARENTNOTIFY style.
1746  */
1747 static void send_parent_notify( HWND hwnd, WORD event, WORD idChild, POINT pt )
1748 {
1749     /* pt has to be in the client coordinates of the parent window */
1750     MapWindowPoints( 0, hwnd, &pt, 1 );
1751     for (;;)
1752     {
1753         HWND parent;
1754
1755         if (!(GetWindowLongW( hwnd, GWL_STYLE ) & WS_CHILD)) break;
1756         if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) break;
1757         if (!(parent = GetParent(hwnd))) break;
1758         if (parent == GetDesktopWindow()) break;
1759         MapWindowPoints( hwnd, parent, &pt, 1 );
1760         hwnd = parent;
1761         SendMessageW( hwnd, WM_PARENTNOTIFY,
1762                       MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
1763     }
1764 }
1765
1766
1767 /***********************************************************************
1768  *          accept_hardware_message
1769  *
1770  * Tell the server we have passed the message to the app
1771  * (even though we may end up dropping it later on)
1772  */
1773 static void accept_hardware_message( UINT hw_id, BOOL remove, HWND new_hwnd )
1774 {
1775     SERVER_START_REQ( accept_hardware_message )
1776     {
1777         req->hw_id   = hw_id;
1778         req->remove  = remove;
1779         req->new_win = wine_server_user_handle( new_hwnd );
1780         if (wine_server_call( req ))
1781             FIXME("Failed to reply to MSG_HARDWARE message. Message may not be removed from queue.\n");
1782     }
1783     SERVER_END_REQ;
1784 }
1785
1786
1787 /***********************************************************************
1788  *          process_keyboard_message
1789  *
1790  * returns TRUE if the contents of 'msg' should be passed to the application
1791  */
1792 static BOOL process_keyboard_message( MSG *msg, UINT hw_id, HWND hwnd_filter,
1793                                       UINT first, UINT last, BOOL remove )
1794 {
1795     EVENTMSG event;
1796
1797     if (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN ||
1798         msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
1799         switch (msg->wParam)
1800         {
1801             case VK_LSHIFT: case VK_RSHIFT:
1802                 msg->wParam = VK_SHIFT;
1803                 break;
1804             case VK_LCONTROL: case VK_RCONTROL:
1805                 msg->wParam = VK_CONTROL;
1806                 break;
1807             case VK_LMENU: case VK_RMENU:
1808                 msg->wParam = VK_MENU;
1809                 break;
1810         }
1811
1812     /* FIXME: is this really the right place for this hook? */
1813     event.message = msg->message;
1814     event.hwnd    = msg->hwnd;
1815     event.time    = msg->time;
1816     event.paramL  = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
1817     event.paramH  = msg->lParam & 0x7FFF;
1818     if (HIWORD(msg->lParam) & 0x0100) event.paramH |= 0x8000; /* special_key - bit */
1819     HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event, TRUE );
1820
1821     /* check message filters */
1822     if (msg->message < first || msg->message > last) return FALSE;
1823     if (!check_hwnd_filter( msg, hwnd_filter )) return FALSE;
1824
1825     if (remove)
1826     {
1827         if((msg->message == WM_KEYDOWN) &&
1828            (msg->hwnd != GetDesktopWindow()))
1829         {
1830             /* Handle F1 key by sending out WM_HELP message */
1831             if (msg->wParam == VK_F1)
1832             {
1833                 PostMessageW( msg->hwnd, WM_KEYF1, 0, 0 );
1834             }
1835             else if(msg->wParam >= VK_BROWSER_BACK &&
1836                     msg->wParam <= VK_LAUNCH_APP2)
1837             {
1838                 /* FIXME: Process keystate */
1839                 SendMessageW(msg->hwnd, WM_APPCOMMAND, (WPARAM)msg->hwnd, MAKELPARAM(0, (FAPPCOMMAND_KEY | (msg->wParam - VK_BROWSER_BACK + 1))));
1840             }
1841         }
1842         else if (msg->message == WM_KEYUP)
1843         {
1844             /* Handle VK_APPS key by posting a WM_CONTEXTMENU message */
1845             if (msg->wParam == VK_APPS && !MENU_IsMenuActive())
1846                 PostMessageW(msg->hwnd, WM_CONTEXTMENU, (WPARAM)msg->hwnd, -1);
1847         }
1848     }
1849
1850     if (HOOK_CallHooks( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
1851                         LOWORD(msg->wParam), msg->lParam, TRUE ))
1852     {
1853         /* skip this message */
1854         HOOK_CallHooks( WH_CBT, HCBT_KEYSKIPPED, LOWORD(msg->wParam), msg->lParam, TRUE );
1855         accept_hardware_message( hw_id, TRUE, 0 );
1856         return FALSE;
1857     }
1858     accept_hardware_message( hw_id, remove, 0 );
1859
1860     if ( msg->message == WM_KEYDOWN || msg->message == WM_KEYUP )
1861         if ( ImmProcessKey(msg->hwnd, GetKeyboardLayout(0), msg->wParam, msg->lParam, 0) )
1862             msg->wParam = VK_PROCESSKEY;
1863
1864     return TRUE;
1865 }
1866
1867
1868 /***********************************************************************
1869  *          process_mouse_message
1870  *
1871  * returns TRUE if the contents of 'msg' should be passed to the application
1872  */
1873 static BOOL process_mouse_message( MSG *msg, UINT hw_id, ULONG_PTR extra_info, HWND hwnd_filter,
1874                                    UINT first, UINT last, BOOL remove )
1875 {
1876     static MSG clk_msg;
1877
1878     POINT pt;
1879     UINT message;
1880     INT hittest;
1881     EVENTMSG event;
1882     GUITHREADINFO info;
1883     MOUSEHOOKSTRUCT hook;
1884     BOOL eatMsg;
1885
1886     /* find the window to dispatch this mouse message to */
1887
1888     GetGUIThreadInfo( GetCurrentThreadId(), &info );
1889     if (info.hwndCapture)
1890     {
1891         hittest = HTCLIENT;
1892         msg->hwnd = info.hwndCapture;
1893     }
1894     else
1895     {
1896         msg->hwnd = WINPOS_WindowFromPoint( msg->hwnd, msg->pt, &hittest );
1897     }
1898
1899     if (!msg->hwnd || !WIN_IsCurrentThread( msg->hwnd ))
1900     {
1901         accept_hardware_message( hw_id, TRUE, msg->hwnd );
1902         return FALSE;
1903     }
1904
1905     /* FIXME: is this really the right place for this hook? */
1906     event.message = msg->message;
1907     event.time    = msg->time;
1908     event.hwnd    = msg->hwnd;
1909     event.paramL  = msg->pt.x;
1910     event.paramH  = msg->pt.y;
1911     HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event, TRUE );
1912
1913     if (!check_hwnd_filter( msg, hwnd_filter )) return FALSE;
1914
1915     pt = msg->pt;
1916     message = msg->message;
1917     /* Note: windows has no concept of a non-client wheel message */
1918     if (message != WM_MOUSEWHEEL)
1919     {
1920         if (hittest != HTCLIENT)
1921         {
1922             message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
1923             msg->wParam = hittest;
1924         }
1925         else
1926         {
1927             /* coordinates don't get translated while tracking a menu */
1928             /* FIXME: should differentiate popups and top-level menus */
1929             if (!(info.flags & GUI_INMENUMODE))
1930                 ScreenToClient( msg->hwnd, &pt );
1931         }
1932     }
1933     msg->lParam = MAKELONG( pt.x, pt.y );
1934
1935     /* translate double clicks */
1936
1937     if ((msg->message == WM_LBUTTONDOWN) ||
1938         (msg->message == WM_RBUTTONDOWN) ||
1939         (msg->message == WM_MBUTTONDOWN) ||
1940         (msg->message == WM_XBUTTONDOWN))
1941     {
1942         BOOL update = remove;
1943
1944         /* translate double clicks -
1945          * note that ...MOUSEMOVEs can slip in between
1946          * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
1947
1948         if ((info.flags & (GUI_INMENUMODE|GUI_INMOVESIZE)) ||
1949             hittest != HTCLIENT ||
1950             (GetClassLongA( msg->hwnd, GCL_STYLE ) & CS_DBLCLKS))
1951         {
1952            if ((msg->message == clk_msg.message) &&
1953                (msg->hwnd == clk_msg.hwnd) &&
1954                (msg->wParam == clk_msg.wParam) &&
1955                (msg->time - clk_msg.time < GetDoubleClickTime()) &&
1956                (abs(msg->pt.x - clk_msg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK)/2) &&
1957                (abs(msg->pt.y - clk_msg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK)/2))
1958            {
1959                message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
1960                if (update)
1961                {
1962                    clk_msg.message = 0;  /* clear the double click conditions */
1963                    update = FALSE;
1964                }
1965            }
1966         }
1967         if (message < first || message > last) return FALSE;
1968         /* update static double click conditions */
1969         if (update) clk_msg = *msg;
1970     }
1971     else
1972     {
1973         if (message < first || message > last) return FALSE;
1974     }
1975
1976     /* message is accepted now (but may still get dropped) */
1977
1978     hook.pt           = msg->pt;
1979     hook.hwnd         = msg->hwnd;
1980     hook.wHitTestCode = hittest;
1981     hook.dwExtraInfo  = extra_info;
1982     if (HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
1983                         message, (LPARAM)&hook, TRUE ))
1984     {
1985         hook.pt           = msg->pt;
1986         hook.hwnd         = msg->hwnd;
1987         hook.wHitTestCode = hittest;
1988         hook.dwExtraInfo  = extra_info;
1989         HOOK_CallHooks( WH_CBT, HCBT_CLICKSKIPPED, message, (LPARAM)&hook, TRUE );
1990         accept_hardware_message( hw_id, TRUE, 0 );
1991         return FALSE;
1992     }
1993
1994     if ((hittest == HTERROR) || (hittest == HTNOWHERE))
1995     {
1996         SendMessageW( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
1997                       MAKELONG( hittest, msg->message ));
1998         accept_hardware_message( hw_id, TRUE, 0 );
1999         return FALSE;
2000     }
2001
2002     accept_hardware_message( hw_id, remove, 0 );
2003
2004     if (!remove || info.hwndCapture)
2005     {
2006         msg->message = message;
2007         return TRUE;
2008     }
2009
2010     eatMsg = FALSE;
2011
2012     if ((msg->message == WM_LBUTTONDOWN) ||
2013         (msg->message == WM_RBUTTONDOWN) ||
2014         (msg->message == WM_MBUTTONDOWN) ||
2015         (msg->message == WM_XBUTTONDOWN))
2016     {
2017         /* Send the WM_PARENTNOTIFY,
2018          * note that even for double/nonclient clicks
2019          * notification message is still WM_L/M/RBUTTONDOWN.
2020          */
2021         send_parent_notify( msg->hwnd, msg->message, 0, msg->pt );
2022
2023         /* Activate the window if needed */
2024
2025         if (msg->hwnd != info.hwndActive)
2026         {
2027             HWND hwndTop = msg->hwnd;
2028             while (hwndTop)
2029             {
2030                 if ((GetWindowLongW( hwndTop, GWL_STYLE ) & (WS_POPUP|WS_CHILD)) != WS_CHILD) break;
2031                 hwndTop = GetParent( hwndTop );
2032             }
2033
2034             if (hwndTop && hwndTop != GetDesktopWindow())
2035             {
2036                 LONG ret = SendMessageW( msg->hwnd, WM_MOUSEACTIVATE, (WPARAM)hwndTop,
2037                                          MAKELONG( hittest, msg->message ) );
2038                 switch(ret)
2039                 {
2040                 case MA_NOACTIVATEANDEAT:
2041                     eatMsg = TRUE;
2042                     /* fall through */
2043                 case MA_NOACTIVATE:
2044                     break;
2045                 case MA_ACTIVATEANDEAT:
2046                     eatMsg = TRUE;
2047                     /* fall through */
2048                 case MA_ACTIVATE:
2049                 case 0:
2050                     if (!FOCUS_MouseActivate( hwndTop )) eatMsg = TRUE;
2051                     break;
2052                 default:
2053                     WARN( "unknown WM_MOUSEACTIVATE code %d\n", ret );
2054                     break;
2055                 }
2056             }
2057         }
2058     }
2059
2060     /* send the WM_SETCURSOR message */
2061
2062     /* Windows sends the normal mouse message as the message parameter
2063        in the WM_SETCURSOR message even if it's non-client mouse message */
2064     SendMessageW( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd, MAKELONG( hittest, msg->message ));
2065
2066     msg->message = message;
2067     return !eatMsg;
2068 }
2069
2070
2071 /***********************************************************************
2072  *           process_hardware_message
2073  *
2074  * Process a hardware message; return TRUE if message should be passed on to the app
2075  */
2076 static BOOL process_hardware_message( MSG *msg, UINT hw_id, ULONG_PTR extra_info, HWND hwnd_filter,
2077                                       UINT first, UINT last, BOOL remove )
2078 {
2079     if (is_keyboard_message( msg->message ))
2080         return process_keyboard_message( msg, hw_id, hwnd_filter, first, last, remove );
2081
2082     if (is_mouse_message( msg->message ))
2083         return process_mouse_message( msg, hw_id, extra_info, hwnd_filter, first, last, remove );
2084
2085     ERR( "unknown message type %x\n", msg->message );
2086     return FALSE;
2087 }
2088
2089
2090 /***********************************************************************
2091  *           call_sendmsg_callback
2092  *
2093  * Call the callback function of SendMessageCallback.
2094  */
2095 static inline void call_sendmsg_callback( SENDASYNCPROC callback, HWND hwnd, UINT msg,
2096                                           ULONG_PTR data, LRESULT result )
2097 {
2098     if (!callback) return;
2099
2100     if (TRACE_ON(relay))
2101         DPRINTF( "%04x:Call message callback %p (hwnd=%p,msg=%s,data=%08lx,result=%08lx)\n",
2102                  GetCurrentThreadId(), callback, hwnd, SPY_GetMsgName( msg, hwnd ),
2103                  data, result );
2104     callback( hwnd, msg, data, result );
2105     if (TRACE_ON(relay))
2106         DPRINTF( "%04x:Ret  message callback %p (hwnd=%p,msg=%s,data=%08lx,result=%08lx)\n",
2107                  GetCurrentThreadId(), callback, hwnd, SPY_GetMsgName( msg, hwnd ),
2108                  data, result );
2109 }
2110
2111
2112 /***********************************************************************
2113  *           peek_message
2114  *
2115  * Peek for a message matching the given parameters. Return FALSE if none available.
2116  * All pending sent messages are processed before returning.
2117  */
2118 static BOOL peek_message( MSG *msg, HWND hwnd, UINT first, UINT last, UINT flags, UINT changed_mask )
2119 {
2120     LRESULT result;
2121     struct user_thread_info *thread_info = get_user_thread_info();
2122     struct received_message_info info, *old_info;
2123     unsigned int hw_id = 0;  /* id of previous hardware message */
2124     void *buffer;
2125     size_t buffer_size = 256;
2126
2127     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, buffer_size ))) return FALSE;
2128
2129     if (!first && !last) last = ~0;
2130     if (hwnd == HWND_BROADCAST) hwnd = HWND_TOPMOST;
2131
2132     for (;;)
2133     {
2134         NTSTATUS res;
2135         size_t size = 0;
2136         const message_data_t *msg_data = buffer;
2137
2138         SERVER_START_REQ( get_message )
2139         {
2140             req->flags     = flags;
2141             req->get_win   = wine_server_user_handle( hwnd );
2142             req->get_first = first;
2143             req->get_last  = last;
2144             req->hw_id     = hw_id;
2145             req->wake_mask = changed_mask & (QS_SENDMESSAGE | QS_SMRESULT);
2146             req->changed_mask = changed_mask;
2147             wine_server_set_reply( req, buffer, buffer_size );
2148             if (!(res = wine_server_call( req )))
2149             {
2150                 size = wine_server_reply_size( reply );
2151                 info.type        = reply->type;
2152                 info.msg.hwnd    = wine_server_ptr_handle( reply->win );
2153                 info.msg.message = reply->msg;
2154                 info.msg.wParam  = reply->wparam;
2155                 info.msg.lParam  = reply->lparam;
2156                 info.msg.time    = reply->time;
2157                 info.msg.pt.x    = 0;
2158                 info.msg.pt.y    = 0;
2159                 hw_id            = 0;
2160                 thread_info->active_hooks = reply->active_hooks;
2161             }
2162             else buffer_size = reply->total;
2163         }
2164         SERVER_END_REQ;
2165
2166         if (res)
2167         {
2168             HeapFree( GetProcessHeap(), 0, buffer );
2169             if (res != STATUS_BUFFER_OVERFLOW) return FALSE;
2170             if (!(buffer = HeapAlloc( GetProcessHeap(), 0, buffer_size ))) return FALSE;
2171             continue;
2172         }
2173
2174         TRACE( "got type %d msg %x (%s) hwnd %p wp %lx lp %lx\n",
2175                info.type, info.msg.message,
2176                (info.type == MSG_WINEVENT) ? "MSG_WINEVENT" : SPY_GetMsgName(info.msg.message, info.msg.hwnd),
2177                info.msg.hwnd, info.msg.wParam, info.msg.lParam );
2178
2179         switch(info.type)
2180         {
2181         case MSG_ASCII:
2182         case MSG_UNICODE:
2183             info.flags = ISMEX_SEND;
2184             break;
2185         case MSG_NOTIFY:
2186             info.flags = ISMEX_NOTIFY;
2187             break;
2188         case MSG_CALLBACK:
2189             info.flags = ISMEX_CALLBACK;
2190             break;
2191         case MSG_CALLBACK_RESULT:
2192             if (size >= sizeof(msg_data->callback))
2193                 call_sendmsg_callback( wine_server_get_ptr(msg_data->callback.callback),
2194                                        info.msg.hwnd, info.msg.message,
2195                                        msg_data->callback.data, msg_data->callback.result );
2196             continue;
2197         case MSG_WINEVENT:
2198             if (size >= sizeof(msg_data->winevent))
2199             {
2200                 WINEVENTPROC hook_proc;
2201
2202                 hook_proc = wine_server_get_ptr( msg_data->winevent.hook_proc );
2203                 size -= sizeof(msg_data->winevent);
2204                 if (size)
2205                 {
2206                     WCHAR module[MAX_PATH];
2207
2208                     size = min( size, (MAX_PATH - 1) * sizeof(WCHAR) );
2209                     memcpy( module, &msg_data->winevent + 1, size );
2210                     module[size / sizeof(WCHAR)] = 0;
2211                     if (!(hook_proc = get_hook_proc( hook_proc, module )))
2212                     {
2213                         ERR( "invalid winevent hook module name %s\n", debugstr_w(module) );
2214                         continue;
2215                     }
2216                 }
2217
2218                 if (TRACE_ON(relay))
2219                     DPRINTF( "%04x:Call winevent proc %p (hook=%04x,event=%x,hwnd=%p,object_id=%lx,child_id=%lx,tid=%04x,time=%x)\n",
2220                              GetCurrentThreadId(), hook_proc,
2221                              msg_data->winevent.hook, info.msg.message, info.msg.hwnd, info.msg.wParam,
2222                              info.msg.lParam, msg_data->winevent.tid, info.msg.time);
2223
2224                 hook_proc( wine_server_ptr_handle( msg_data->winevent.hook ), info.msg.message,
2225                            info.msg.hwnd, info.msg.wParam, info.msg.lParam,
2226                            msg_data->winevent.tid, info.msg.time );
2227
2228                 if (TRACE_ON(relay))
2229                     DPRINTF( "%04x:Ret  winevent proc %p (hook=%04x,event=%x,hwnd=%p,object_id=%lx,child_id=%lx,tid=%04x,time=%x)\n",
2230                              GetCurrentThreadId(), hook_proc,
2231                              msg_data->winevent.hook, info.msg.message, info.msg.hwnd, info.msg.wParam,
2232                              info.msg.lParam, msg_data->winevent.tid, info.msg.time);
2233             }
2234             continue;
2235         case MSG_OTHER_PROCESS:
2236             info.flags = ISMEX_SEND;
2237             if (!unpack_message( info.msg.hwnd, info.msg.message, &info.msg.wParam,
2238                                  &info.msg.lParam, &buffer, size ))
2239             {
2240                 /* ignore it */
2241                 reply_message( &info, 0, TRUE );
2242                 continue;
2243             }
2244             break;
2245         case MSG_HARDWARE:
2246             if (size >= sizeof(msg_data->hardware))
2247             {
2248                 info.msg.pt.x = msg_data->hardware.x;
2249                 info.msg.pt.y = msg_data->hardware.y;
2250                 hw_id         = msg_data->hardware.hw_id;
2251                 if (!process_hardware_message( &info.msg, hw_id, msg_data->hardware.info,
2252                                                hwnd, first, last, flags & PM_REMOVE ))
2253                 {
2254                     TRACE("dropping msg %x\n", info.msg.message );
2255                     continue;  /* ignore it */
2256                 }
2257                 *msg = info.msg;
2258                 thread_info->GetMessagePosVal = MAKELONG( info.msg.pt.x, info.msg.pt.y );
2259                 thread_info->GetMessageTimeVal = info.msg.time;
2260                 thread_info->GetMessageExtraInfoVal = msg_data->hardware.info;
2261                 HeapFree( GetProcessHeap(), 0, buffer );
2262                 HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, flags & PM_REMOVE, (LPARAM)msg, TRUE );
2263                 return TRUE;
2264             }
2265             continue;
2266         case MSG_POSTED:
2267             if (info.msg.message & 0x80000000)  /* internal message */
2268             {
2269                 if (flags & PM_REMOVE)
2270                 {
2271                     handle_internal_message( info.msg.hwnd, info.msg.message,
2272                                              info.msg.wParam, info.msg.lParam );
2273                     /* if this is a nested call return right away */
2274                     if (first == info.msg.message && last == info.msg.message) return FALSE;
2275                 }
2276                 else
2277                     peek_message( msg, info.msg.hwnd, info.msg.message,
2278                                   info.msg.message, flags | PM_REMOVE, changed_mask );
2279                 continue;
2280             }
2281             if (info.msg.message >= WM_DDE_FIRST && info.msg.message <= WM_DDE_LAST)
2282             {
2283                 if (!unpack_dde_message( info.msg.hwnd, info.msg.message, &info.msg.wParam,
2284                                          &info.msg.lParam, &buffer, size ))
2285                     continue;  /* ignore it */
2286             }
2287             *msg = info.msg;
2288             msg->pt.x = (short)LOWORD( thread_info->GetMessagePosVal );
2289             msg->pt.y = (short)HIWORD( thread_info->GetMessagePosVal );
2290             thread_info->GetMessageTimeVal = info.msg.time;
2291             thread_info->GetMessageExtraInfoVal = 0;
2292             HeapFree( GetProcessHeap(), 0, buffer );
2293             HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, flags & PM_REMOVE, (LPARAM)msg, TRUE );
2294             return TRUE;
2295         }
2296
2297         /* if we get here, we have a sent message; call the window procedure */
2298         old_info = thread_info->receive_info;
2299         thread_info->receive_info = &info;
2300         result = call_window_proc( info.msg.hwnd, info.msg.message, info.msg.wParam,
2301                                    info.msg.lParam, (info.type != MSG_ASCII), FALSE,
2302                                    WMCHAR_MAP_RECVMESSAGE );
2303         reply_message( &info, result, TRUE );
2304         thread_info->receive_info = old_info;
2305
2306         /* if some PM_QS* flags were specified, only handle sent messages from now on */
2307         if (HIWORD(flags) && !changed_mask) flags = PM_QS_SENDMESSAGE | LOWORD(flags);
2308     }
2309 }
2310
2311
2312 /***********************************************************************
2313  *           process_sent_messages
2314  *
2315  * Process all pending sent messages.
2316  */
2317 static inline void process_sent_messages(void)
2318 {
2319     MSG msg;
2320     peek_message( &msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE, 0 );
2321 }
2322
2323
2324 /***********************************************************************
2325  *           get_server_queue_handle
2326  *
2327  * Get a handle to the server message queue for the current thread.
2328  */
2329 static HANDLE get_server_queue_handle(void)
2330 {
2331     struct user_thread_info *thread_info = get_user_thread_info();
2332     HANDLE ret;
2333
2334     if (!(ret = thread_info->server_queue))
2335     {
2336         SERVER_START_REQ( get_msg_queue )
2337         {
2338             wine_server_call( req );
2339             ret = wine_server_ptr_handle( reply->handle );
2340         }
2341         SERVER_END_REQ;
2342         thread_info->server_queue = ret;
2343         if (!ret) ERR( "Cannot get server thread queue\n" );
2344     }
2345     return ret;
2346 }
2347
2348
2349 /***********************************************************************
2350  *           wait_message_reply
2351  *
2352  * Wait until a sent message gets replied to.
2353  */
2354 static void wait_message_reply( UINT flags )
2355 {
2356     HANDLE server_queue = get_server_queue_handle();
2357
2358     for (;;)
2359     {
2360         unsigned int wake_bits = 0;
2361
2362         SERVER_START_REQ( set_queue_mask )
2363         {
2364             req->wake_mask    = QS_SMRESULT | ((flags & SMTO_BLOCK) ? 0 : QS_SENDMESSAGE);
2365             req->changed_mask = req->wake_mask;
2366             req->skip_wait    = 1;
2367             if (!wine_server_call( req ))
2368                 wake_bits = reply->wake_bits;
2369         }
2370         SERVER_END_REQ;
2371
2372         if (wake_bits & QS_SMRESULT) return;  /* got a result */
2373         if (wake_bits & QS_SENDMESSAGE)
2374         {
2375             /* Process the sent message immediately */
2376             process_sent_messages();
2377             continue;
2378         }
2379
2380         wow_handlers.wait_message( 1, &server_queue, INFINITE, QS_SENDMESSAGE, 0 );
2381     }
2382 }
2383
2384 /***********************************************************************
2385  *              put_message_in_queue
2386  *
2387  * Put a sent message into the destination queue.
2388  * For inter-process message, reply_size is set to expected size of reply data.
2389  */
2390 static BOOL put_message_in_queue( const struct send_message_info *info, size_t *reply_size )
2391 {
2392     struct packed_message data;
2393     message_data_t msg_data;
2394     unsigned int res;
2395     int i;
2396     timeout_t timeout = TIMEOUT_INFINITE;
2397
2398     /* Check for INFINITE timeout for compatibility with Win9x,
2399      * although Windows >= NT does not do so
2400      */
2401     if (info->type != MSG_NOTIFY &&
2402         info->type != MSG_CALLBACK &&
2403         info->type != MSG_POSTED &&
2404         info->timeout &&
2405         info->timeout != INFINITE)
2406     {
2407         /* timeout is signed despite the prototype */
2408         timeout = (timeout_t)max( 0, (int)info->timeout ) * -10000;
2409     }
2410
2411     memset( &data, 0, sizeof(data) );
2412     if (info->type == MSG_OTHER_PROCESS)
2413     {
2414         *reply_size = pack_message( info->hwnd, info->msg, info->wparam, info->lparam, &data );
2415         if (data.count == -1)
2416         {
2417             WARN( "cannot pack message %x\n", info->msg );
2418             return FALSE;
2419         }
2420     }
2421     else if (info->type == MSG_CALLBACK)
2422     {
2423         msg_data.callback.callback = wine_server_client_ptr( info->callback );
2424         msg_data.callback.data     = info->data;
2425         msg_data.callback.result   = 0;
2426         data.data[0] = &msg_data;
2427         data.size[0] = sizeof(msg_data.callback);
2428         data.count = 1;
2429     }
2430     else if (info->type == MSG_POSTED && info->msg >= WM_DDE_FIRST && info->msg <= WM_DDE_LAST)
2431     {
2432         return post_dde_message( &data, info );
2433     }
2434
2435     SERVER_START_REQ( send_message )
2436     {
2437         req->id      = info->dest_tid;
2438         req->type    = info->type;
2439         req->flags   = 0;
2440         req->win     = wine_server_user_handle( info->hwnd );
2441         req->msg     = info->msg;
2442         req->wparam  = info->wparam;
2443         req->lparam  = info->lparam;
2444         req->timeout = timeout;
2445
2446         if (info->flags & SMTO_ABORTIFHUNG) req->flags |= SEND_MSG_ABORT_IF_HUNG;
2447         for (i = 0; i < data.count; i++) wine_server_add_data( req, data.data[i], data.size[i] );
2448         if ((res = wine_server_call( req )))
2449         {
2450             if (res == STATUS_INVALID_PARAMETER)
2451                 /* FIXME: find a STATUS_ value for this one */
2452                 SetLastError( ERROR_INVALID_THREAD_ID );
2453             else
2454                 SetLastError( RtlNtStatusToDosError(res) );
2455         }
2456     }
2457     SERVER_END_REQ;
2458     return !res;
2459 }
2460
2461
2462 /***********************************************************************
2463  *              retrieve_reply
2464  *
2465  * Retrieve a message reply from the server.
2466  */
2467 static LRESULT retrieve_reply( const struct send_message_info *info,
2468                                size_t reply_size, LRESULT *result )
2469 {
2470     NTSTATUS status;
2471     void *reply_data = NULL;
2472
2473     if (reply_size)
2474     {
2475         if (!(reply_data = HeapAlloc( GetProcessHeap(), 0, reply_size )))
2476         {
2477             WARN( "no memory for reply, will be truncated\n" );
2478             reply_size = 0;
2479         }
2480     }
2481     SERVER_START_REQ( get_message_reply )
2482     {
2483         req->cancel = 1;
2484         if (reply_size) wine_server_set_reply( req, reply_data, reply_size );
2485         if (!(status = wine_server_call( req ))) *result = reply->result;
2486         reply_size = wine_server_reply_size( reply );
2487     }
2488     SERVER_END_REQ;
2489     if (!status && reply_size)
2490         unpack_reply( info->hwnd, info->msg, info->wparam, info->lparam, reply_data, reply_size );
2491
2492     HeapFree( GetProcessHeap(), 0, reply_data );
2493
2494     TRACE( "hwnd %p msg %x (%s) wp %lx lp %lx got reply %lx (err=%d)\n",
2495            info->hwnd, info->msg, SPY_GetMsgName(info->msg, info->hwnd), info->wparam,
2496            info->lparam, *result, status );
2497
2498     /* MSDN states that last error is 0 on timeout, but at least NT4 returns ERROR_TIMEOUT */
2499     if (status) SetLastError( RtlNtStatusToDosError(status) );
2500     return !status;
2501 }
2502
2503
2504 /***********************************************************************
2505  *              send_inter_thread_message
2506  */
2507 static LRESULT send_inter_thread_message( const struct send_message_info *info, LRESULT *res_ptr )
2508 {
2509     size_t reply_size = 0;
2510
2511     TRACE( "hwnd %p msg %x (%s) wp %lx lp %lx\n",
2512            info->hwnd, info->msg, SPY_GetMsgName(info->msg, info->hwnd), info->wparam, info->lparam );
2513
2514     USER_CheckNotLock();
2515
2516     if (!put_message_in_queue( info, &reply_size )) return 0;
2517
2518     /* there's no reply to wait for on notify/callback messages */
2519     if (info->type == MSG_NOTIFY || info->type == MSG_CALLBACK) return 1;
2520
2521     wait_message_reply( info->flags );
2522     return retrieve_reply( info, reply_size, res_ptr );
2523 }
2524
2525
2526 /***********************************************************************
2527  *              send_inter_thread_callback
2528  */
2529 static LRESULT send_inter_thread_callback( HWND hwnd, UINT msg, WPARAM wp, LPARAM lp,
2530                                            LRESULT *result, void *arg )
2531 {
2532     struct send_message_info *info = arg;
2533     info->hwnd   = hwnd;
2534     info->msg    = msg;
2535     info->wparam = wp;
2536     info->lparam = lp;
2537     return send_inter_thread_message( info, result );
2538 }
2539
2540
2541 /***********************************************************************
2542  *              send_message
2543  *
2544  * Backend implementation of the various SendMessage functions.
2545  */
2546 static BOOL send_message( struct send_message_info *info, DWORD_PTR *res_ptr, BOOL unicode )
2547 {
2548     DWORD dest_pid;
2549     BOOL ret;
2550     LRESULT result;
2551
2552     if (is_broadcast(info->hwnd))
2553     {
2554         EnumWindows( broadcast_message_callback, (LPARAM)info );
2555         if (res_ptr) *res_ptr = 1;
2556         return TRUE;
2557     }
2558
2559     if (!(info->dest_tid = GetWindowThreadProcessId( info->hwnd, &dest_pid ))) return FALSE;
2560
2561     if (USER_IsExitingThread( info->dest_tid )) return FALSE;
2562
2563     SPY_EnterMessage( SPY_SENDMESSAGE, info->hwnd, info->msg, info->wparam, info->lparam );
2564
2565     if (info->dest_tid == GetCurrentThreadId())
2566     {
2567         result = call_window_proc( info->hwnd, info->msg, info->wparam, info->lparam,
2568                                    unicode, TRUE, info->wm_char );
2569         if (info->type == MSG_CALLBACK)
2570             call_sendmsg_callback( info->callback, info->hwnd, info->msg, info->data, result );
2571         ret = TRUE;
2572     }
2573     else
2574     {
2575         if (dest_pid != GetCurrentProcessId() && (info->type == MSG_ASCII || info->type == MSG_UNICODE))
2576             info->type = MSG_OTHER_PROCESS;
2577
2578         /* MSG_ASCII can be sent unconverted except for WM_CHAR; everything else needs to be Unicode */
2579         if (!unicode && is_unicode_message( info->msg ) &&
2580             (info->type != MSG_ASCII || info->msg == WM_CHAR))
2581             ret = WINPROC_CallProcAtoW( send_inter_thread_callback, info->hwnd, info->msg,
2582                                         info->wparam, info->lparam, &result, info, info->wm_char );
2583         else
2584             ret = send_inter_thread_message( info, &result );
2585     }
2586
2587     SPY_ExitMessage( SPY_RESULT_OK, info->hwnd, info->msg, result, info->wparam, info->lparam );
2588     if (ret && res_ptr) *res_ptr = result;
2589     return ret;
2590 }
2591
2592
2593 /***********************************************************************
2594  *              MSG_SendInternalMessageTimeout
2595  *
2596  * Same as SendMessageTimeoutW but sends the message to a specific thread
2597  * without requiring a window handle. Only works for internal Wine messages.
2598  */
2599 LRESULT MSG_SendInternalMessageTimeout( DWORD dest_pid, DWORD dest_tid,
2600                                         UINT msg, WPARAM wparam, LPARAM lparam,
2601                                         UINT flags, UINT timeout, PDWORD_PTR res_ptr )
2602 {
2603     struct send_message_info info;
2604     LRESULT ret, result;
2605
2606     assert( msg & 0x80000000 );  /* must be an internal Wine message */
2607
2608     info.type     = MSG_UNICODE;
2609     info.dest_tid = dest_tid;
2610     info.hwnd     = 0;
2611     info.msg      = msg;
2612     info.wparam   = wparam;
2613     info.lparam   = lparam;
2614     info.flags    = flags;
2615     info.timeout  = timeout;
2616
2617     if (USER_IsExitingThread( dest_tid )) return 0;
2618
2619     if (dest_tid == GetCurrentThreadId())
2620     {
2621         result = handle_internal_message( 0, msg, wparam, lparam );
2622         ret = 1;
2623     }
2624     else
2625     {
2626         if (dest_pid != GetCurrentProcessId()) info.type = MSG_OTHER_PROCESS;
2627         ret = send_inter_thread_message( &info, &result );
2628     }
2629     if (ret && res_ptr) *res_ptr = result;
2630     return ret;
2631 }
2632
2633
2634 /***********************************************************************
2635  *              SendMessageTimeoutW  (USER32.@)
2636  */
2637 LRESULT WINAPI SendMessageTimeoutW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
2638                                     UINT flags, UINT timeout, PDWORD_PTR res_ptr )
2639 {
2640     struct send_message_info info;
2641
2642     info.type    = MSG_UNICODE;
2643     info.hwnd    = hwnd;
2644     info.msg     = msg;
2645     info.wparam  = wparam;
2646     info.lparam  = lparam;
2647     info.flags   = flags;
2648     info.timeout = timeout;
2649
2650     return send_message( &info, res_ptr, TRUE );
2651 }
2652
2653 /***********************************************************************
2654  *              SendMessageTimeoutA  (USER32.@)
2655  */
2656 LRESULT WINAPI SendMessageTimeoutA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
2657                                     UINT flags, UINT timeout, PDWORD_PTR res_ptr )
2658 {
2659     struct send_message_info info;
2660
2661     info.type    = MSG_ASCII;
2662     info.hwnd    = hwnd;
2663     info.msg     = msg;
2664     info.wparam  = wparam;
2665     info.lparam  = lparam;
2666     info.flags   = flags;
2667     info.timeout = timeout;
2668     info.wm_char  = WMCHAR_MAP_SENDMESSAGETIMEOUT;
2669
2670     return send_message( &info, res_ptr, FALSE );
2671 }
2672
2673
2674 /***********************************************************************
2675  *              SendMessageW  (USER32.@)
2676  */
2677 LRESULT WINAPI SendMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
2678 {
2679     DWORD_PTR res = 0;
2680     struct send_message_info info;
2681
2682     info.type    = MSG_UNICODE;
2683     info.hwnd    = hwnd;
2684     info.msg     = msg;
2685     info.wparam  = wparam;
2686     info.lparam  = lparam;
2687     info.flags   = SMTO_NORMAL;
2688     info.timeout = 0;
2689
2690     send_message( &info, &res, TRUE );
2691     return res;
2692 }
2693
2694
2695 /***********************************************************************
2696  *              SendMessageA  (USER32.@)
2697  */
2698 LRESULT WINAPI SendMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
2699 {
2700     DWORD_PTR res = 0;
2701     struct send_message_info info;
2702
2703     info.type    = MSG_ASCII;
2704     info.hwnd    = hwnd;
2705     info.msg     = msg;
2706     info.wparam  = wparam;
2707     info.lparam  = lparam;
2708     info.flags   = SMTO_NORMAL;
2709     info.timeout = 0;
2710     info.wm_char  = WMCHAR_MAP_SENDMESSAGE;
2711
2712     send_message( &info, &res, FALSE );
2713     return res;
2714 }
2715
2716
2717 /***********************************************************************
2718  *              SendNotifyMessageA  (USER32.@)
2719  */
2720 BOOL WINAPI SendNotifyMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
2721 {
2722     struct send_message_info info;
2723
2724     if (is_pointer_message(msg))
2725     {
2726         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
2727         return FALSE;
2728     }
2729
2730     info.type    = MSG_NOTIFY;
2731     info.hwnd    = hwnd;
2732     info.msg     = msg;
2733     info.wparam  = wparam;
2734     info.lparam  = lparam;
2735     info.flags   = 0;
2736     info.wm_char = WMCHAR_MAP_SENDMESSAGETIMEOUT;
2737
2738     return send_message( &info, NULL, FALSE );
2739 }
2740
2741
2742 /***********************************************************************
2743  *              SendNotifyMessageW  (USER32.@)
2744  */
2745 BOOL WINAPI SendNotifyMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
2746 {
2747     struct send_message_info info;
2748
2749     if (is_pointer_message(msg))
2750     {
2751         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
2752         return FALSE;
2753     }
2754
2755     info.type    = MSG_NOTIFY;
2756     info.hwnd    = hwnd;
2757     info.msg     = msg;
2758     info.wparam  = wparam;
2759     info.lparam  = lparam;
2760     info.flags   = 0;
2761
2762     return send_message( &info, NULL, TRUE );
2763 }
2764
2765
2766 /***********************************************************************
2767  *              SendMessageCallbackA  (USER32.@)
2768  */
2769 BOOL WINAPI SendMessageCallbackA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
2770                                   SENDASYNCPROC callback, ULONG_PTR data )
2771 {
2772     struct send_message_info info;
2773
2774     if (is_pointer_message(msg))
2775     {
2776         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
2777         return FALSE;
2778     }
2779
2780     info.type     = MSG_CALLBACK;
2781     info.hwnd     = hwnd;
2782     info.msg      = msg;
2783     info.wparam   = wparam;
2784     info.lparam   = lparam;
2785     info.callback = callback;
2786     info.data     = data;
2787     info.flags    = 0;
2788     info.wm_char  = WMCHAR_MAP_SENDMESSAGETIMEOUT;
2789
2790     return send_message( &info, NULL, FALSE );
2791 }
2792
2793
2794 /***********************************************************************
2795  *              SendMessageCallbackW  (USER32.@)
2796  */
2797 BOOL WINAPI SendMessageCallbackW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
2798                                   SENDASYNCPROC callback, ULONG_PTR data )
2799 {
2800     struct send_message_info info;
2801
2802     if (is_pointer_message(msg))
2803     {
2804         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
2805         return FALSE;
2806     }
2807
2808     info.type     = MSG_CALLBACK;
2809     info.hwnd     = hwnd;
2810     info.msg      = msg;
2811     info.wparam   = wparam;
2812     info.lparam   = lparam;
2813     info.callback = callback;
2814     info.data     = data;
2815     info.flags    = 0;
2816
2817     return send_message( &info, NULL, TRUE );
2818 }
2819
2820
2821 /***********************************************************************
2822  *              ReplyMessage  (USER32.@)
2823  */
2824 BOOL WINAPI ReplyMessage( LRESULT result )
2825 {
2826     struct received_message_info *info = get_user_thread_info()->receive_info;
2827
2828     if (!info) return FALSE;
2829     reply_message( info, result, FALSE );
2830     return TRUE;
2831 }
2832
2833
2834 /***********************************************************************
2835  *              InSendMessage  (USER32.@)
2836  */
2837 BOOL WINAPI InSendMessage(void)
2838 {
2839     return (InSendMessageEx(NULL) & (ISMEX_SEND|ISMEX_REPLIED)) == ISMEX_SEND;
2840 }
2841
2842
2843 /***********************************************************************
2844  *              InSendMessageEx  (USER32.@)
2845  */
2846 DWORD WINAPI InSendMessageEx( LPVOID reserved )
2847 {
2848     struct received_message_info *info = get_user_thread_info()->receive_info;
2849
2850     if (info) return info->flags;
2851     return ISMEX_NOSEND;
2852 }
2853
2854
2855 /***********************************************************************
2856  *              PostMessageA  (USER32.@)
2857  */
2858 BOOL WINAPI PostMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
2859 {
2860     if (!map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_POSTMESSAGE )) return TRUE;
2861     return PostMessageW( hwnd, msg, wparam, lparam );
2862 }
2863
2864
2865 /***********************************************************************
2866  *              PostMessageW  (USER32.@)
2867  */
2868 BOOL WINAPI PostMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
2869 {
2870     struct send_message_info info;
2871
2872     if (is_pointer_message( msg ))
2873     {
2874         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
2875         return FALSE;
2876     }
2877
2878     TRACE( "hwnd %p msg %x (%s) wp %lx lp %lx\n",
2879            hwnd, msg, SPY_GetMsgName(msg, hwnd), wparam, lparam );
2880
2881     info.type   = MSG_POSTED;
2882     info.hwnd   = hwnd;
2883     info.msg    = msg;
2884     info.wparam = wparam;
2885     info.lparam = lparam;
2886     info.flags  = 0;
2887
2888     if (is_broadcast(hwnd))
2889     {
2890         EnumWindows( broadcast_message_callback, (LPARAM)&info );
2891         return TRUE;
2892     }
2893
2894     if (!hwnd) return PostThreadMessageW( GetCurrentThreadId(), msg, wparam, lparam );
2895
2896     if (!(info.dest_tid = GetWindowThreadProcessId( hwnd, NULL ))) return FALSE;
2897
2898     if (USER_IsExitingThread( info.dest_tid )) return TRUE;
2899
2900     return put_message_in_queue( &info, NULL );
2901 }
2902
2903
2904 /**********************************************************************
2905  *              PostThreadMessageA  (USER32.@)
2906  */
2907 BOOL WINAPI PostThreadMessageA( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam )
2908 {
2909     if (!map_wparam_AtoW( msg, &wparam, WMCHAR_MAP_POSTMESSAGE )) return TRUE;
2910     return PostThreadMessageW( thread, msg, wparam, lparam );
2911 }
2912
2913
2914 /**********************************************************************
2915  *              PostThreadMessageW  (USER32.@)
2916  */
2917 BOOL WINAPI PostThreadMessageW( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam )
2918 {
2919     struct send_message_info info;
2920
2921     if (is_pointer_message( msg ))
2922     {
2923         SetLastError( ERROR_MESSAGE_SYNC_ONLY );
2924         return FALSE;
2925     }
2926     if (USER_IsExitingThread( thread )) return TRUE;
2927
2928     info.type     = MSG_POSTED;
2929     info.dest_tid = thread;
2930     info.hwnd     = 0;
2931     info.msg      = msg;
2932     info.wparam   = wparam;
2933     info.lparam   = lparam;
2934     info.flags    = 0;
2935     return put_message_in_queue( &info, NULL );
2936 }
2937
2938
2939 /***********************************************************************
2940  *              PostQuitMessage  (USER32.@)
2941  *
2942  * Posts a quit message to the current thread's message queue.
2943  *
2944  * PARAMS
2945  *  exit_code [I] Exit code to return from message loop.
2946  *
2947  * RETURNS
2948  *  Nothing.
2949  *
2950  * NOTES
2951  *  This function is not the same as calling:
2952  *|PostThreadMessage(GetCurrentThreadId(), WM_QUIT, exit_code, 0);
2953  *  It instead sets a flag in the message queue that signals it to generate
2954  *  a WM_QUIT message when there are no other pending sent or posted messages
2955  *  in the queue.
2956  */
2957 void WINAPI PostQuitMessage( INT exit_code )
2958 {
2959     SERVER_START_REQ( post_quit_message )
2960     {
2961         req->exit_code = exit_code;
2962         wine_server_call( req );
2963     }
2964     SERVER_END_REQ;
2965 }
2966
2967
2968 /***********************************************************************
2969  *              PeekMessageW  (USER32.@)
2970  */
2971 BOOL WINAPI PeekMessageW( MSG *msg_out, HWND hwnd, UINT first, UINT last, UINT flags )
2972 {
2973     MSG msg;
2974
2975     USER_CheckNotLock();
2976
2977     /* check for graphics events */
2978     USER_Driver->pMsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_ALLINPUT, 0 );
2979
2980     if (!peek_message( &msg, hwnd, first, last, flags, 0 ))
2981     {
2982         if (!(flags & PM_NOYIELD)) wow_handlers.wait_message( 0, NULL, 0, 0, 0 );
2983         return FALSE;
2984     }
2985
2986     /* copy back our internal safe copy of message data to msg_out.
2987      * msg_out is a variable from the *program*, so it can't be used
2988      * internally as it can get "corrupted" by our use of SendMessage()
2989      * (back to the program) inside the message handling itself. */
2990     if (!msg_out)
2991     {
2992         SetLastError( ERROR_NOACCESS );
2993         return FALSE;
2994     }
2995     *msg_out = msg;
2996     return TRUE;
2997 }
2998
2999
3000 /***********************************************************************
3001  *              PeekMessageA  (USER32.@)
3002  */
3003 BOOL WINAPI PeekMessageA( MSG *msg, HWND hwnd, UINT first, UINT last, UINT flags )
3004 {
3005     if (get_pending_wmchar( msg, first, last, (flags & PM_REMOVE) )) return TRUE;
3006     if (!PeekMessageW( msg, hwnd, first, last, flags )) return FALSE;
3007     map_wparam_WtoA( msg, (flags & PM_REMOVE) );
3008     return TRUE;
3009 }
3010
3011
3012 /***********************************************************************
3013  *              GetMessageW  (USER32.@)
3014  */
3015 BOOL WINAPI GetMessageW( MSG *msg, HWND hwnd, UINT first, UINT last )
3016 {
3017     HANDLE server_queue = get_server_queue_handle();
3018     unsigned int mask = QS_POSTMESSAGE | QS_SENDMESSAGE;  /* Always selected */
3019
3020     USER_CheckNotLock();
3021
3022     /* check for graphics events */
3023     USER_Driver->pMsgWaitForMultipleObjectsEx( 0, NULL, 0, QS_ALLINPUT, 0 );
3024
3025     if (first || last)
3026     {
3027         if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
3028         if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
3029              ((first <= WM_NCMOUSELAST) && (last >= WM_NCMOUSEFIRST)) ) mask |= QS_MOUSE;
3030         if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
3031         if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
3032         if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
3033     }
3034     else mask = QS_ALLINPUT;
3035
3036     while (!peek_message( msg, hwnd, first, last, PM_REMOVE | (mask << 16), mask ))
3037     {
3038         wow_handlers.wait_message( 1, &server_queue, INFINITE, mask, 0 );
3039     }
3040
3041     return (msg->message != WM_QUIT);
3042 }
3043
3044
3045 /***********************************************************************
3046  *              GetMessageA  (USER32.@)
3047  */
3048 BOOL WINAPI GetMessageA( MSG *msg, HWND hwnd, UINT first, UINT last )
3049 {
3050     if (get_pending_wmchar( msg, first, last, TRUE )) return TRUE;
3051     GetMessageW( msg, hwnd, first, last );
3052     map_wparam_WtoA( msg, TRUE );
3053     return (msg->message != WM_QUIT);
3054 }
3055
3056
3057 /***********************************************************************
3058  *              IsDialogMessageA (USER32.@)
3059  *              IsDialogMessage  (USER32.@)
3060  */
3061 BOOL WINAPI IsDialogMessageA( HWND hwndDlg, LPMSG pmsg )
3062 {
3063     MSG msg = *pmsg;
3064     map_wparam_AtoW( msg.message, &msg.wParam, WMCHAR_MAP_NOMAPPING );
3065     return IsDialogMessageW( hwndDlg, &msg );
3066 }
3067
3068
3069 /***********************************************************************
3070  *              TranslateMessage (USER32.@)
3071  *
3072  * Implementation of TranslateMessage.
3073  *
3074  * TranslateMessage translates virtual-key messages into character-messages,
3075  * as follows :
3076  * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
3077  * ditto replacing WM_* with WM_SYS*
3078  * This produces WM_CHAR messages only for keys mapped to ASCII characters
3079  * by the keyboard driver.
3080  *
3081  * If the message is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP, the
3082  * return value is nonzero, regardless of the translation.
3083  *
3084  */
3085 BOOL WINAPI TranslateMessage( const MSG *msg )
3086 {
3087     UINT message;
3088     WCHAR wp[2];
3089     BYTE state[256];
3090
3091     if (msg->message < WM_KEYFIRST || msg->message > WM_KEYLAST) return FALSE;
3092     if (msg->message != WM_KEYDOWN && msg->message != WM_SYSKEYDOWN) return TRUE;
3093
3094     TRACE_(key)("Translating key %s (%04lX), scancode %04x\n",
3095                 SPY_GetVKeyName(msg->wParam), msg->wParam, HIWORD(msg->lParam));
3096
3097     switch (msg->wParam)
3098     {
3099     case VK_PACKET:
3100         message = (msg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
3101         TRACE_(key)("PostMessageW(%p,%s,%04x,%08x)\n",
3102                     msg->hwnd, SPY_GetMsgName(message, msg->hwnd), HIWORD(msg->lParam), LOWORD(msg->lParam));
3103         PostMessageW( msg->hwnd, message, HIWORD(msg->lParam), LOWORD(msg->lParam));
3104         return TRUE;
3105
3106     case VK_PROCESSKEY:
3107         return ImmTranslateMessage(msg->hwnd, msg->message, msg->wParam, msg->lParam);
3108     }
3109
3110     GetKeyboardState( state );
3111     /* FIXME : should handle ToUnicode yielding 2 */
3112     switch (ToUnicode(msg->wParam, HIWORD(msg->lParam), state, wp, 2, 0))
3113     {
3114     case 1:
3115         message = (msg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
3116         TRACE_(key)("1 -> PostMessageW(%p,%s,%04x,%08lx)\n",
3117             msg->hwnd, SPY_GetMsgName(message, msg->hwnd), wp[0], msg->lParam);
3118         PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
3119         break;
3120
3121     case -1:
3122         message = (msg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
3123         TRACE_(key)("-1 -> PostMessageW(%p,%s,%04x,%08lx)\n",
3124             msg->hwnd, SPY_GetMsgName(message, msg->hwnd), wp[0], msg->lParam);
3125         PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
3126         break;
3127     }
3128     return TRUE;
3129 }
3130
3131
3132 /***********************************************************************
3133  *              DispatchMessageA (USER32.@)
3134  *
3135  * See DispatchMessageW.
3136  */
3137 LRESULT WINAPI DECLSPEC_HOTPATCH DispatchMessageA( const MSG* msg )
3138 {
3139     LRESULT retval;
3140
3141       /* Process timer messages */
3142     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
3143     {
3144         if (msg->lParam)
3145         {
3146             __TRY
3147             {
3148                 retval = CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
3149                                           msg->message, msg->wParam, GetTickCount() );
3150             }
3151             __EXCEPT_PAGE_FAULT
3152             {
3153                 retval = 0;
3154             }
3155             __ENDTRY
3156             return retval;
3157         }
3158     }
3159     if (!msg->hwnd) return 0;
3160
3161     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
3162                       msg->wParam, msg->lParam );
3163
3164     if (!WINPROC_call_window( msg->hwnd, msg->message, msg->wParam, msg->lParam,
3165                               &retval, FALSE, WMCHAR_MAP_DISPATCHMESSAGE ))
3166     {
3167         if (!IsWindow( msg->hwnd )) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
3168         else SetLastError( ERROR_MESSAGE_SYNC_ONLY );
3169         retval = 0;
3170     }
3171
3172     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
3173                      msg->wParam, msg->lParam );
3174
3175     if (msg->message == WM_PAINT)
3176     {
3177         /* send a WM_NCPAINT and WM_ERASEBKGND if the non-client area is still invalid */
3178         HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
3179         GetUpdateRgn( msg->hwnd, hrgn, TRUE );
3180         DeleteObject( hrgn );
3181     }
3182     return retval;
3183 }
3184
3185
3186 /***********************************************************************
3187  *              DispatchMessageW (USER32.@) Process a message
3188  *
3189  * Process the message specified in the structure *_msg_.
3190  *
3191  * If the lpMsg parameter points to a WM_TIMER message and the
3192  * parameter of the WM_TIMER message is not NULL, the lParam parameter
3193  * points to the function that is called instead of the window
3194  * procedure. The function stored in lParam (timer callback) is protected
3195  * from causing page-faults.
3196  *
3197  * The message must be valid.
3198  *
3199  * RETURNS
3200  *
3201  *   DispatchMessage() returns the result of the window procedure invoked.
3202  *
3203  * CONFORMANCE
3204  *
3205  *   ECMA-234, Win32
3206  *
3207  */
3208 LRESULT WINAPI DECLSPEC_HOTPATCH DispatchMessageW( const MSG* msg )
3209 {
3210     LRESULT retval;
3211
3212       /* Process timer messages */
3213     if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
3214     {
3215         if (msg->lParam)
3216         {
3217             __TRY
3218             {
3219                 retval = CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
3220                                           msg->message, msg->wParam, GetTickCount() );
3221             }
3222             __EXCEPT_PAGE_FAULT
3223             {
3224                 retval = 0;
3225             }
3226             __ENDTRY
3227             return retval;
3228         }
3229     }
3230     if (!msg->hwnd) return 0;
3231
3232     SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
3233                       msg->wParam, msg->lParam );
3234
3235     if (!WINPROC_call_window( msg->hwnd, msg->message, msg->wParam, msg->lParam,
3236                               &retval, TRUE, WMCHAR_MAP_DISPATCHMESSAGE ))
3237     {
3238         if (!IsWindow( msg->hwnd )) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
3239         else SetLastError( ERROR_MESSAGE_SYNC_ONLY );
3240         retval = 0;
3241     }
3242
3243     SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
3244                      msg->wParam, msg->lParam );
3245
3246     if (msg->message == WM_PAINT)
3247     {
3248         /* send a WM_NCPAINT and WM_ERASEBKGND if the non-client area is still invalid */
3249         HRGN hrgn = CreateRectRgn( 0, 0, 0, 0 );
3250         GetUpdateRgn( msg->hwnd, hrgn, TRUE );
3251         DeleteObject( hrgn );
3252     }
3253     return retval;
3254 }
3255
3256
3257 /***********************************************************************
3258  *              GetMessagePos (USER.119)
3259  *              GetMessagePos (USER32.@)
3260  *
3261  * The GetMessagePos() function returns a long value representing a
3262  * cursor position, in screen coordinates, when the last message
3263  * retrieved by the GetMessage() function occurs. The x-coordinate is
3264  * in the low-order word of the return value, the y-coordinate is in
3265  * the high-order word. The application can use the MAKEPOINT()
3266  * macro to obtain a POINT structure from the return value.
3267  *
3268  * For the current cursor position, use GetCursorPos().
3269  *
3270  * RETURNS
3271  *
3272  * Cursor position of last message on success, zero on failure.
3273  *
3274  * CONFORMANCE
3275  *
3276  * ECMA-234, Win32
3277  *
3278  */
3279 DWORD WINAPI GetMessagePos(void)
3280 {
3281     return get_user_thread_info()->GetMessagePosVal;
3282 }
3283
3284
3285 /***********************************************************************
3286  *              GetMessageTime (USER.120)
3287  *              GetMessageTime (USER32.@)
3288  *
3289  * GetMessageTime() returns the message time for the last message
3290  * retrieved by the function. The time is measured in milliseconds with
3291  * the same offset as GetTickCount().
3292  *
3293  * Since the tick count wraps, this is only useful for moderately short
3294  * relative time comparisons.
3295  *
3296  * RETURNS
3297  *
3298  * Time of last message on success, zero on failure.
3299  */
3300 LONG WINAPI GetMessageTime(void)
3301 {
3302     return get_user_thread_info()->GetMessageTimeVal;
3303 }
3304
3305
3306 /***********************************************************************
3307  *              GetMessageExtraInfo (USER.288)
3308  *              GetMessageExtraInfo (USER32.@)
3309  */
3310 LPARAM WINAPI GetMessageExtraInfo(void)
3311 {
3312     return get_user_thread_info()->GetMessageExtraInfoVal;
3313 }
3314
3315
3316 /***********************************************************************
3317  *              SetMessageExtraInfo (USER32.@)
3318  */
3319 LPARAM WINAPI SetMessageExtraInfo(LPARAM lParam)
3320 {
3321     struct user_thread_info *thread_info = get_user_thread_info();
3322     LONG old_value = thread_info->GetMessageExtraInfoVal;
3323     thread_info->GetMessageExtraInfoVal = lParam;
3324     return old_value;
3325 }
3326
3327
3328 /***********************************************************************
3329  *              WaitMessage (USER.112) Suspend thread pending messages
3330  *              WaitMessage (USER32.@) Suspend thread pending messages
3331  *
3332  * WaitMessage() suspends a thread until events appear in the thread's
3333  * queue.
3334  */
3335 BOOL WINAPI WaitMessage(void)
3336 {
3337     return (MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, 0 ) != WAIT_FAILED);
3338 }
3339
3340
3341 /***********************************************************************
3342  *              MsgWaitForMultipleObjectsEx   (USER32.@)
3343  */
3344 DWORD WINAPI MsgWaitForMultipleObjectsEx( DWORD count, CONST HANDLE *pHandles,
3345                                           DWORD timeout, DWORD mask, DWORD flags )
3346 {
3347     HANDLE handles[MAXIMUM_WAIT_OBJECTS];
3348     DWORD i;
3349
3350     if (count > MAXIMUM_WAIT_OBJECTS-1)
3351     {
3352         SetLastError( ERROR_INVALID_PARAMETER );
3353         return WAIT_FAILED;
3354     }
3355
3356     /* set the queue mask */
3357     SERVER_START_REQ( set_queue_mask )
3358     {
3359         req->wake_mask    = (flags & MWMO_INPUTAVAILABLE) ? mask : 0;
3360         req->changed_mask = mask;
3361         req->skip_wait    = 0;
3362         wine_server_call( req );
3363     }
3364     SERVER_END_REQ;
3365
3366     /* add the queue to the handle list */
3367     for (i = 0; i < count; i++) handles[i] = pHandles[i];
3368     handles[count] = get_server_queue_handle();
3369
3370     return wow_handlers.wait_message( count+1, handles, timeout, mask, flags );
3371 }
3372
3373
3374 /***********************************************************************
3375  *              MsgWaitForMultipleObjects (USER32.@)
3376  */
3377 DWORD WINAPI MsgWaitForMultipleObjects( DWORD count, CONST HANDLE *handles,
3378                                         BOOL wait_all, DWORD timeout, DWORD mask )
3379 {
3380     return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
3381                                         wait_all ? MWMO_WAITALL : 0 );
3382 }
3383
3384
3385 /***********************************************************************
3386  *              WaitForInputIdle (USER32.@)
3387  */
3388 DWORD WINAPI WaitForInputIdle( HANDLE hProcess, DWORD dwTimeOut )
3389 {
3390     DWORD start_time, elapsed, ret;
3391     HANDLE handles[2];
3392
3393     handles[0] = hProcess;
3394     SERVER_START_REQ( get_process_idle_event )
3395     {
3396         req->handle = wine_server_obj_handle( hProcess );
3397         wine_server_call_err( req );
3398         handles[1] = wine_server_ptr_handle( reply->event );
3399     }
3400     SERVER_END_REQ;
3401     if (!handles[1]) return WAIT_FAILED;  /* no event to wait on */
3402
3403     start_time = GetTickCount();
3404     elapsed = 0;
3405
3406     TRACE("waiting for %p\n", handles[1] );
3407     do
3408     {
3409         ret = MsgWaitForMultipleObjects ( 2, handles, FALSE, dwTimeOut - elapsed, QS_SENDMESSAGE );
3410         switch (ret)
3411         {
3412         case WAIT_OBJECT_0:
3413             return 0;
3414         case WAIT_OBJECT_0+2:
3415             process_sent_messages();
3416             break;
3417         case WAIT_TIMEOUT:
3418         case WAIT_FAILED:
3419             TRACE("timeout or error\n");
3420             return ret;
3421         default:
3422             TRACE("finished\n");
3423             return 0;
3424         }
3425         if (dwTimeOut != INFINITE)
3426         {
3427             elapsed = GetTickCount() - start_time;
3428             if (elapsed > dwTimeOut)
3429                 break;
3430         }
3431     }
3432     while (1);
3433
3434     return WAIT_TIMEOUT;
3435 }
3436
3437
3438 /***********************************************************************
3439  *              RegisterWindowMessageA (USER32.@)
3440  *              RegisterWindowMessage (USER.118)
3441  */
3442 UINT WINAPI RegisterWindowMessageA( LPCSTR str )
3443 {
3444     UINT ret = GlobalAddAtomA(str);
3445     TRACE("%s, ret=%x\n", str, ret);
3446     return ret;
3447 }
3448
3449
3450 /***********************************************************************
3451  *              RegisterWindowMessageW (USER32.@)
3452  */
3453 UINT WINAPI RegisterWindowMessageW( LPCWSTR str )
3454 {
3455     UINT ret = GlobalAddAtomW(str);
3456     TRACE("%s ret=%x\n", debugstr_w(str), ret);
3457     return ret;
3458 }
3459
3460 typedef struct BroadcastParm
3461 {
3462     DWORD flags;
3463     LPDWORD recipients;
3464     UINT msg;
3465     WPARAM wp;
3466     LPARAM lp;
3467     DWORD success;
3468     HWINSTA winsta;
3469 } BroadcastParm;
3470
3471 static BOOL CALLBACK bcast_childwindow( HWND hw, LPARAM lp )
3472 {
3473     BroadcastParm *parm = (BroadcastParm*)lp;
3474     DWORD_PTR retval = 0;
3475     LRESULT lresult;
3476
3477     if (parm->flags & BSF_IGNORECURRENTTASK && WIN_IsCurrentProcess(hw))
3478     {
3479         TRACE("Not telling myself %p\n", hw);
3480         return TRUE;
3481     }
3482
3483     /* I don't know 100% for sure if this is what Windows does, but it fits the tests */
3484     if (parm->flags & BSF_QUERY)
3485     {
3486         TRACE("Telling window %p using SendMessageTimeout\n", hw);
3487
3488         /* Not tested for conflicting flags */
3489         if (parm->flags & BSF_FORCEIFHUNG || parm->flags & BSF_NOHANG)
3490             lresult = SendMessageTimeoutW( hw, parm->msg, parm->wp, parm->lp, SMTO_ABORTIFHUNG, 2000, &retval );
3491         else if (parm->flags & BSF_NOTIMEOUTIFNOTHUNG)
3492             lresult = SendMessageTimeoutW( hw, parm->msg, parm->wp, parm->lp, SMTO_NOTIMEOUTIFNOTHUNG, 2000, &retval );
3493         else
3494             lresult = SendMessageTimeoutW( hw, parm->msg, parm->wp, parm->lp, SMTO_NORMAL, 2000, &retval );
3495
3496         if (!lresult && GetLastError() == ERROR_TIMEOUT)
3497         {
3498             WARN("Timed out!\n");
3499             if (!(parm->flags & BSF_FORCEIFHUNG))
3500                 goto fail;
3501         }
3502         if (retval == BROADCAST_QUERY_DENY)
3503             goto fail;
3504
3505         return TRUE;
3506
3507 fail:
3508         parm->success = 0;
3509         return FALSE;
3510     }
3511     else if (parm->flags & BSF_POSTMESSAGE)
3512     {
3513         TRACE("Telling window %p using PostMessage\n", hw);
3514         PostMessageW( hw, parm->msg, parm->wp, parm->lp );
3515     }
3516     else
3517     {
3518         TRACE("Telling window %p using SendNotifyMessage\n", hw);
3519         SendNotifyMessageW( hw, parm->msg, parm->wp, parm->lp );
3520     }
3521
3522     return TRUE;
3523 }
3524
3525 static BOOL CALLBACK bcast_desktop( LPWSTR desktop, LPARAM lp )
3526 {
3527     BOOL ret;
3528     HDESK hdesktop;
3529     BroadcastParm *parm = (BroadcastParm*)lp;
3530
3531     TRACE("desktop: %s\n", debugstr_w( desktop ));
3532
3533     hdesktop = open_winstation_desktop( parm->winsta, desktop, 0, FALSE, DESKTOP_ENUMERATE|DESKTOP_WRITEOBJECTS|STANDARD_RIGHTS_WRITE );
3534     if (!hdesktop)
3535     {
3536         FIXME("Could not open desktop %s\n", debugstr_w(desktop));
3537         return TRUE;
3538     }
3539
3540     ret = EnumDesktopWindows( hdesktop, bcast_childwindow, lp );
3541     CloseDesktop(hdesktop);
3542     TRACE("-->%d\n", ret);
3543     return parm->success;
3544 }
3545
3546 static BOOL CALLBACK bcast_winsta( LPWSTR winsta, LPARAM lp )
3547 {
3548     BOOL ret;
3549     HWINSTA hwinsta = OpenWindowStationW( winsta, FALSE, WINSTA_ENUMDESKTOPS );
3550     TRACE("hwinsta: %p/%s/%08x\n", hwinsta, debugstr_w( winsta ), GetLastError());
3551     if (!hwinsta)
3552         return TRUE;
3553     ((BroadcastParm *)lp)->winsta = hwinsta;
3554     ret = EnumDesktopsW( hwinsta, bcast_desktop, lp );
3555     CloseWindowStation( hwinsta );
3556     TRACE("-->%d\n", ret);
3557     return ret;
3558 }
3559
3560 /***********************************************************************
3561  *              BroadcastSystemMessageA (USER32.@)
3562  *              BroadcastSystemMessage  (USER32.@)
3563  */
3564 LONG WINAPI BroadcastSystemMessageA( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp )
3565 {
3566     return BroadcastSystemMessageExA( flags, recipients, msg, wp, lp, NULL );
3567 }
3568
3569
3570 /***********************************************************************
3571  *              BroadcastSystemMessageW (USER32.@)
3572  */
3573 LONG WINAPI BroadcastSystemMessageW( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp )
3574 {
3575     return BroadcastSystemMessageExW( flags, recipients, msg, wp, lp, NULL );
3576 }
3577
3578 /***********************************************************************
3579  *              BroadcastSystemMessageExA (USER32.@)
3580  */
3581 LONG WINAPI BroadcastSystemMessageExA( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp, PBSMINFO pinfo )
3582 {
3583     map_wparam_AtoW( msg, &wp, WMCHAR_MAP_NOMAPPING );
3584     return BroadcastSystemMessageExW( flags, recipients, msg, wp, lp, NULL );
3585 }
3586
3587
3588 /***********************************************************************
3589  *              BroadcastSystemMessageExW (USER32.@)
3590  */
3591 LONG WINAPI BroadcastSystemMessageExW( DWORD flags, LPDWORD recipients, UINT msg, WPARAM wp, LPARAM lp, PBSMINFO pinfo )
3592 {
3593     BroadcastParm parm;
3594     DWORD recips = BSM_ALLCOMPONENTS;
3595     BOOL ret = TRUE;
3596     static const DWORD all_flags = ( BSF_QUERY | BSF_IGNORECURRENTTASK | BSF_FLUSHDISK | BSF_NOHANG
3597                                    | BSF_POSTMESSAGE | BSF_FORCEIFHUNG | BSF_NOTIMEOUTIFNOTHUNG
3598                                    | BSF_ALLOWSFW | BSF_SENDNOTIFYMESSAGE | BSF_RETURNHDESK | BSF_LUID );
3599
3600     TRACE("Flags: %08x, recipients: %p(0x%x), msg: %04x, wparam: %08lx, lparam: %08lx\n", flags, recipients,
3601          (recipients ? *recipients : recips), msg, wp, lp);
3602
3603     if (flags & ~all_flags)
3604     {
3605         SetLastError(ERROR_INVALID_PARAMETER);
3606         return 0;
3607     }
3608
3609     if (!recipients)
3610         recipients = &recips;
3611
3612     if ( pinfo && flags & BSF_QUERY )
3613         FIXME("Not returning PBSMINFO information yet\n");
3614
3615     parm.flags = flags;
3616     parm.recipients = recipients;
3617     parm.msg = msg;
3618     parm.wp = wp;
3619     parm.lp = lp;
3620     parm.success = TRUE;
3621
3622     if (*recipients & BSM_ALLDESKTOPS || *recipients == BSM_ALLCOMPONENTS)
3623         ret = EnumWindowStationsW(bcast_winsta, (LONG_PTR)&parm);
3624     else if (*recipients & BSM_APPLICATIONS)
3625     {
3626         EnumWindows(bcast_childwindow, (LONG_PTR)&parm);
3627         ret = parm.success;
3628     }
3629     else
3630         FIXME("Recipients %08x not supported!\n", *recipients);
3631
3632     return ret;
3633 }
3634
3635 /***********************************************************************
3636  *              SetMessageQueue (USER32.@)
3637  */
3638 BOOL WINAPI SetMessageQueue( INT size )
3639 {
3640     /* now obsolete the message queue will be expanded dynamically as necessary */
3641     return TRUE;
3642 }
3643
3644
3645 /***********************************************************************
3646  *              MessageBeep (USER32.@)
3647  */
3648 BOOL WINAPI MessageBeep( UINT i )
3649 {
3650     BOOL active = TRUE;
3651     SystemParametersInfoA( SPI_GETBEEP, 0, &active, FALSE );
3652     if (active) USER_Driver->pBeep();
3653     return TRUE;
3654 }
3655
3656
3657 /***********************************************************************
3658  *              SetTimer (USER32.@)
3659  */
3660 UINT_PTR WINAPI SetTimer( HWND hwnd, UINT_PTR id, UINT timeout, TIMERPROC proc )
3661 {
3662     UINT_PTR ret;
3663     WNDPROC winproc = 0;
3664
3665     if (proc) winproc = WINPROC_AllocProc( (WNDPROC)proc, FALSE );
3666
3667     SERVER_START_REQ( set_win_timer )
3668     {
3669         req->win    = wine_server_user_handle( hwnd );
3670         req->msg    = WM_TIMER;
3671         req->id     = id;
3672         req->rate   = max( timeout, SYS_TIMER_RATE );
3673         req->lparam = (ULONG_PTR)winproc;
3674         if (!wine_server_call_err( req ))
3675         {
3676             ret = reply->id;
3677             if (!ret) ret = TRUE;
3678         }
3679         else ret = 0;
3680     }
3681     SERVER_END_REQ;
3682
3683     TRACE("Added %p %lx %p timeout %d\n", hwnd, id, winproc, timeout );
3684     return ret;
3685 }
3686
3687
3688 /***********************************************************************
3689  *              SetSystemTimer (USER32.@)
3690  */
3691 UINT_PTR WINAPI SetSystemTimer( HWND hwnd, UINT_PTR id, UINT timeout, TIMERPROC proc )
3692 {
3693     UINT_PTR ret;
3694     WNDPROC winproc = 0;
3695
3696     if (proc) winproc = WINPROC_AllocProc( (WNDPROC)proc, FALSE );
3697
3698     SERVER_START_REQ( set_win_timer )
3699     {
3700         req->win    = wine_server_user_handle( hwnd );
3701         req->msg    = WM_SYSTIMER;
3702         req->id     = id;
3703         req->rate   = max( timeout, SYS_TIMER_RATE );
3704         req->lparam = (ULONG_PTR)winproc;
3705         if (!wine_server_call_err( req ))
3706         {
3707             ret = reply->id;
3708             if (!ret) ret = TRUE;
3709         }
3710         else ret = 0;
3711     }
3712     SERVER_END_REQ;
3713
3714     TRACE("Added %p %lx %p timeout %d\n", hwnd, id, winproc, timeout );
3715     return ret;
3716 }
3717
3718
3719 /***********************************************************************
3720  *              KillTimer (USER32.@)
3721  */
3722 BOOL WINAPI KillTimer( HWND hwnd, UINT_PTR id )
3723 {
3724     BOOL ret;
3725
3726     SERVER_START_REQ( kill_win_timer )
3727     {
3728         req->win = wine_server_user_handle( hwnd );
3729         req->msg = WM_TIMER;
3730         req->id  = id;
3731         ret = !wine_server_call_err( req );
3732     }
3733     SERVER_END_REQ;
3734     return ret;
3735 }
3736
3737
3738 /***********************************************************************
3739  *              KillSystemTimer (USER32.@)
3740  */
3741 BOOL WINAPI KillSystemTimer( HWND hwnd, UINT_PTR id )
3742 {
3743     BOOL ret;
3744
3745     SERVER_START_REQ( kill_win_timer )
3746     {
3747         req->win = wine_server_user_handle( hwnd );
3748         req->msg = WM_SYSTIMER;
3749         req->id  = id;
3750         ret = !wine_server_call_err( req );
3751     }
3752     SERVER_END_REQ;
3753     return ret;
3754 }
3755
3756
3757 /**********************************************************************
3758  *              GetGUIThreadInfo  (USER32.@)
3759  */
3760 BOOL WINAPI GetGUIThreadInfo( DWORD id, GUITHREADINFO *info )
3761 {
3762     BOOL ret;
3763
3764     SERVER_START_REQ( get_thread_input )
3765     {
3766         req->tid = id;
3767         if ((ret = !wine_server_call_err( req )))
3768         {
3769             info->flags          = 0;
3770             info->hwndActive     = wine_server_ptr_handle( reply->active );
3771             info->hwndFocus      = wine_server_ptr_handle( reply->focus );
3772             info->hwndCapture    = wine_server_ptr_handle( reply->capture );
3773             info->hwndMenuOwner  = wine_server_ptr_handle( reply->menu_owner );
3774             info->hwndMoveSize   = wine_server_ptr_handle( reply->move_size );
3775             info->hwndCaret      = wine_server_ptr_handle( reply->caret );
3776             info->rcCaret.left   = reply->rect.left;
3777             info->rcCaret.top    = reply->rect.top;
3778             info->rcCaret.right  = reply->rect.right;
3779             info->rcCaret.bottom = reply->rect.bottom;
3780             if (reply->menu_owner) info->flags |= GUI_INMENUMODE;
3781             if (reply->move_size) info->flags |= GUI_INMOVESIZE;
3782             if (reply->caret) info->flags |= GUI_CARETBLINKING;
3783         }
3784     }
3785     SERVER_END_REQ;
3786     return ret;
3787 }
3788
3789
3790 /******************************************************************
3791  *              IsHungAppWindow (USER32.@)
3792  *
3793  */
3794 BOOL WINAPI IsHungAppWindow( HWND hWnd )
3795 {
3796     BOOL ret;
3797
3798     SERVER_START_REQ( is_window_hung )
3799     {
3800         req->win = wine_server_user_handle( hWnd );
3801         ret = !wine_server_call_err( req ) && reply->is_hung;
3802     }
3803     SERVER_END_REQ;
3804     return ret;
3805 }
3806
3807 /******************************************************************
3808  *      ChangeWindowMessageFilter (USER32.@)
3809  */
3810 BOOL WINAPI ChangeWindowMessageFilter( UINT message, DWORD flag )
3811 {
3812     FIXME( "%x %08x\n", message, flag );
3813     return TRUE;
3814 }