2 * Window messaging support
4 * Copyright 2001 Alexandre Julliard
13 #include "wine/unicode.h"
14 #include "wine/server.h"
22 #include "debugtools.h"
24 DEFAULT_DEBUG_CHANNEL(msg);
26 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
27 #define WM_NCMOUSELAST WM_NCMBUTTONDBLCLK
29 #define MAX_PACK_COUNT 4
31 /* description of the data fields that need to be packed along with a sent message */
35 const void *data[MAX_PACK_COUNT];
36 size_t size[MAX_PACK_COUNT];
39 /* info about the message currently being received by the current thread */
40 struct received_message_info
42 enum message_type type;
44 UINT flags; /* InSendMessageEx return flags */
47 /* structure to group all parameters for sent messages of the various kinds */
48 struct send_message_info
50 enum message_type type;
55 UINT flags; /* flags for SendMessageTimeout */
56 UINT timeout; /* timeout for SendMessageTimeout */
57 SENDASYNCPROC callback; /* callback function for SendMessageCallback */
58 ULONG_PTR data; /* callback data */
62 /* flag for messages that contain pointers */
63 /* 32 messages per entry, messages 0..31 map to bits 0..31 */
65 #define SET(msg) (1 << ((msg) & 31))
67 static const unsigned int message_pointer_flags[] =
70 SET(WM_CREATE) | SET(WM_SETTEXT) | SET(WM_GETTEXT) |
71 SET(WM_WININICHANGE) | SET(WM_DEVMODECHANGE),
73 SET(WM_GETMINMAXINFO) | SET(WM_DRAWITEM) | SET(WM_MEASUREITEM) | SET(WM_DELETEITEM) |
76 SET(WM_WINDOWPOSCHANGING) | SET(WM_WINDOWPOSCHANGED) | SET(WM_COPYDATA) |
77 SET(WM_NOTIFY) | SET(WM_HELP),
79 SET(WM_STYLECHANGING) | SET(WM_STYLECHANGED),
81 SET(WM_NCCREATE) | SET(WM_NCCALCSIZE) | SET(WM_GETDLGCODE),
83 SET(EM_GETSEL) | SET(EM_GETRECT) | SET(EM_SETRECT) | SET(EM_SETRECTNP),
85 SET(EM_REPLACESEL) | SET(EM_GETLINE) | SET(EM_SETTABSTOPS),
87 SET(SBM_GETRANGE) | SET(SBM_SETSCROLLINFO) | SET(SBM_GETSCROLLINFO),
93 SET(CB_GETEDITSEL) | SET(CB_ADDSTRING) | SET(CB_DIR) | SET(CB_GETLBTEXT) |
94 SET(CB_INSERTSTRING) | SET(CB_FINDSTRING) | SET(CB_SELECTSTRING) |
95 SET(CB_GETDROPPEDCONTROLRECT) | SET(CB_FINDSTRINGEXACT),
99 SET(LB_ADDSTRING) | SET(LB_INSERTSTRING) | SET(LB_GETTEXT) | SET(LB_SELECTSTRING) |
100 SET(LB_DIR) | SET(LB_FINDSTRING) |
101 SET(LB_GETSELITEMS) | SET(LB_SETTABSTOPS) | SET(LB_ADDFILE) | SET(LB_GETITEMRECT),
103 SET(LB_FINDSTRINGEXACT),
109 SET(WM_NEXTMENU) | SET(WM_SIZING) | SET(WM_MOVING) | SET(WM_DEVICECHANGE),
111 SET(WM_MDICREATE) | SET(WM_MDIGETACTIVE) | SET(WM_DROPOBJECT) |
112 SET(WM_QUERYDROPOBJECT) | SET(WM_DRAGLOOP) | SET(WM_DRAGSELECT) | SET(WM_DRAGMOVE),
126 SET(WM_ASKCBFORMATNAME)
129 /* flags for messages that contain Unicode strings */
130 static const unsigned int message_unicode_flags[] =
133 SET(WM_CREATE) | SET(WM_SETTEXT) | SET(WM_GETTEXT) | SET(WM_GETTEXTLENGTH) |
134 SET(WM_WININICHANGE) | SET(WM_DEVMODECHANGE),
146 SET(EM_REPLACESEL) | SET(EM_GETLINE) | SET(EM_SETPASSWORDCHAR),
150 SET(WM_CHAR) | SET(WM_DEADCHAR) | SET(WM_SYSCHAR) | SET(WM_SYSDEADCHAR),
154 SET(CB_ADDSTRING) | SET(CB_DIR) | SET(CB_GETLBTEXT) | SET(CB_GETLBTEXTLEN) |
155 SET(CB_INSERTSTRING) | SET(CB_FINDSTRING) | SET(CB_SELECTSTRING) | SET(CB_FINDSTRINGEXACT),
159 SET(LB_ADDSTRING) | SET(LB_INSERTSTRING) | SET(LB_GETTEXT) | SET(LB_GETTEXTLEN) |
160 SET(LB_SELECTSTRING) | SET(LB_DIR) | SET(LB_FINDSTRING) | SET(LB_ADDFILE),
162 SET(LB_FINDSTRINGEXACT),
184 SET(WM_PAINTCLIPBOARD) | SET(WM_SIZECLIPBOARD) | SET(WM_ASKCBFORMATNAME)
187 /* check whether a given message type includes pointers */
188 inline static int is_pointer_message( UINT message )
190 if (message >= 8*sizeof(message_pointer_flags)) return FALSE;
191 return (message_pointer_flags[message / 32] & SET(message)) != 0;
194 /* check whether a given message type contains Unicode (or ASCII) chars */
195 inline static int is_unicode_message( UINT message )
197 if (message >= 8*sizeof(message_unicode_flags)) return FALSE;
198 return (message_unicode_flags[message / 32] & SET(message)) != 0;
203 /* add a data field to a packed message */
204 inline static void push_data( struct packed_message *data, const void *ptr, size_t size )
206 data->data[data->count] = ptr;
207 data->size[data->count] = size;
211 /* add a string to a packed message */
212 inline static void push_string( struct packed_message *data, LPCWSTR str )
214 push_data( data, str, (strlenW(str) + 1) * sizeof(WCHAR) );
217 /* retrieve a pointer to data from a packed message and increment the buffer pointer */
218 inline static void *get_data( void **buffer, size_t size )
221 *buffer = (char *)*buffer + size;
225 /* make sure that the buffer contains a valid null-terminated Unicode string */
226 inline static BOOL check_string( LPCWSTR str, size_t size )
228 for (size /= sizeof(WCHAR); size; size--, str++)
229 if (!*str) return TRUE;
233 /* make sure that there is space for 'size' bytes in buffer, growing it if needed */
234 inline static void *get_buffer_space( void **buffer, size_t size )
237 if (!(ret = HeapReAlloc( GetProcessHeap(), 0, *buffer, size )))
238 HeapFree( GetProcessHeap(), 0, *buffer );
243 /* retrieve a string pointer from packed data */
244 inline static LPWSTR get_string( void **buffer )
246 return get_data( buffer, (strlenW( (LPWSTR)*buffer ) + 1) * sizeof(WCHAR) );
249 /* check whether a combobox expects strings or ids in CB_ADDSTRING/CB_INSERTSTRING */
250 inline static BOOL combobox_has_strings( HWND hwnd )
252 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
253 return (!(style & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) || (style & CBS_HASSTRINGS));
256 /* check whether a listbox expects strings or ids in LB_ADDSTRING/LB_INSERTSTRING */
257 inline static BOOL listbox_has_strings( HWND hwnd )
259 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
260 return (!(style & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) || (style & LBS_HASSTRINGS));
263 /* check if hwnd is a broadcast magic handle */
264 inline static BOOL is_broadcast( HWND hwnd )
266 return (hwnd == HWND_BROADCAST || hwnd == HWND_TOPMOST);
270 /***********************************************************************
271 * broadcast_message_callback
273 * Helper callback for broadcasting messages.
275 static BOOL CALLBACK broadcast_message_callback( HWND hwnd, LPARAM lparam )
277 struct send_message_info *info = (struct send_message_info *)lparam;
278 if (!(GetWindowLongW( hwnd, GWL_STYLE ) & (WS_POPUP|WS_CAPTION))) return TRUE;
282 SendMessageTimeoutW( hwnd, info->msg, info->wparam, info->lparam,
283 info->flags, info->timeout, NULL );
286 SendMessageTimeoutA( hwnd, info->msg, info->wparam, info->lparam,
287 info->flags, info->timeout, NULL );
290 SendNotifyMessageW( hwnd, info->msg, info->wparam, info->lparam );
293 SendMessageCallbackW( hwnd, info->msg, info->wparam, info->lparam,
294 info->callback, info->data );
297 PostMessageW( hwnd, info->msg, info->wparam, info->lparam );
300 ERR( "bad type %d\n", info->type );
307 /***********************************************************************
310 * Convert the wparam of an ASCII message to Unicode.
312 static WPARAM map_wparam_AtoW( UINT message, WPARAM wparam )
314 if (message == WM_CHARTOITEM ||
315 message == EM_SETPASSWORDCHAR ||
316 message == WM_CHAR ||
317 message == WM_DEADCHAR ||
318 message == WM_SYSCHAR ||
319 message == WM_SYSDEADCHAR ||
320 message == WM_MENUCHAR)
322 char ch = LOWORD(wparam);
324 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
325 wparam = MAKEWPARAM( wch, HIWORD(wparam) );
331 /***********************************************************************
334 * Convert the wparam of a Unicode message to ASCII.
336 static WPARAM map_wparam_WtoA( UINT message, WPARAM wparam )
338 if (message == WM_CHARTOITEM ||
339 message == EM_SETPASSWORDCHAR ||
340 message == WM_CHAR ||
341 message == WM_DEADCHAR ||
342 message == WM_SYSCHAR ||
343 message == WM_SYSDEADCHAR ||
344 message == WM_MENUCHAR)
346 WCHAR wch = LOWORD(wparam);
348 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL );
349 wparam = MAKEWPARAM( (unsigned char)ch, HIWORD(wparam) );
355 /***********************************************************************
358 * Pack a message for sending to another process.
359 * Return the size of the data we expect in the message reply.
360 * Set data->count to -1 if there is an error.
362 static size_t pack_message( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam,
363 struct packed_message *data )
371 CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
372 push_data( data, cs, sizeof(*cs) );
373 if (HIWORD(cs->lpszName)) push_string( data, cs->lpszName );
374 if (HIWORD(cs->lpszClass)) push_string( data, cs->lpszClass );
378 case WM_ASKCBFORMATNAME:
379 return wparam * sizeof(WCHAR);
381 case WM_WININICHANGE:
382 case WM_DEVMODECHANGE:
385 case CB_FINDSTRINGEXACT:
386 case CB_SELECTSTRING:
390 case LB_FINDSTRINGEXACT:
391 case LB_SELECTSTRING:
393 push_string( data, (LPWSTR)lparam );
395 case WM_GETMINMAXINFO:
396 push_data( data, (MINMAXINFO *)lparam, sizeof(MINMAXINFO) );
397 return sizeof(MINMAXINFO);
399 push_data( data, (DRAWITEMSTRUCT *)lparam, sizeof(DRAWITEMSTRUCT) );
402 push_data( data, (MEASUREITEMSTRUCT *)lparam, sizeof(MEASUREITEMSTRUCT) );
403 return sizeof(MEASUREITEMSTRUCT);
405 push_data( data, (DELETEITEMSTRUCT *)lparam, sizeof(DELETEITEMSTRUCT) );
408 push_data( data, (COMPAREITEMSTRUCT *)lparam, sizeof(COMPAREITEMSTRUCT) );
410 case WM_WINDOWPOSCHANGING:
411 case WM_WINDOWPOSCHANGED:
412 push_data( data, (WINDOWPOS *)lparam, sizeof(WINDOWPOS) );
413 return sizeof(WINDOWPOS);
416 COPYDATASTRUCT *cp = (COPYDATASTRUCT *)lparam;
417 push_data( data, cp, sizeof(*cp) );
418 if (cp->lpData) push_data( data, cp->lpData, cp->cbData );
422 /* WM_NOTIFY cannot be sent across processes (MSDN) */
426 push_data( data, (HELPINFO *)lparam, sizeof(HELPINFO) );
428 case WM_STYLECHANGING:
429 case WM_STYLECHANGED:
430 push_data( data, (STYLESTRUCT *)lparam, sizeof(STYLESTRUCT) );
435 push_data( data, (RECT *)lparam, sizeof(RECT) );
440 NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lparam;
441 push_data( data, nc, sizeof(*nc) );
442 push_data( data, nc->lppos, sizeof(*nc->lppos) );
443 return sizeof(*nc) + sizeof(*nc->lppos);
446 if (lparam) push_data( data, (MSG *)lparam, sizeof(MSG) );
448 case SBM_SETSCROLLINFO:
449 push_data( data, (SCROLLINFO *)lparam, sizeof(SCROLLINFO) );
451 case SBM_GETSCROLLINFO:
452 push_data( data, (SCROLLINFO *)lparam, sizeof(SCROLLINFO) );
453 return sizeof(SCROLLINFO);
459 if (wparam) size += sizeof(DWORD);
460 if (lparam) size += sizeof(DWORD);
465 case CB_GETDROPPEDCONTROLRECT:
469 push_data( data, (RECT *)lparam, sizeof(RECT) );
473 WORD *pw = (WORD *)lparam;
474 push_data( data, pw, sizeof(*pw) );
475 return *pw * sizeof(WCHAR);
479 if (wparam) push_data( data, (UINT *)lparam, sizeof(UINT) * wparam );
482 case CB_INSERTSTRING:
483 if (combobox_has_strings( hwnd )) push_string( data, (LPWSTR)lparam );
486 if (!combobox_has_strings( hwnd )) return sizeof(ULONG_PTR);
487 return (SendMessageW( hwnd, CB_GETLBTEXTLEN, wparam, 0 ) + 1) * sizeof(WCHAR);
489 case LB_INSERTSTRING:
490 if (listbox_has_strings( hwnd )) push_string( data, (LPWSTR)lparam );
493 if (!listbox_has_strings( hwnd )) return sizeof(ULONG_PTR);
494 return (SendMessageW( hwnd, LB_GETTEXTLEN, wparam, 0 ) + 1) * sizeof(WCHAR);
496 return wparam * sizeof(UINT);
498 push_data( data, (MDINEXTMENU *)lparam, sizeof(MDINEXTMENU) );
499 return sizeof(MDINEXTMENU);
502 push_data( data, (RECT *)lparam, sizeof(RECT) );
506 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lparam;
507 push_data( data, cs, sizeof(*cs) );
508 if (HIWORD(cs->szTitle)) push_string( data, cs->szTitle );
509 if (HIWORD(cs->szClass)) push_string( data, cs->szClass );
512 case WM_MDIGETACTIVE:
513 if (lparam) return sizeof(BOOL);
515 case WM_WINE_SETWINDOWPOS:
516 push_data( data, (WINDOWPOS *)lparam, sizeof(WINDOWPOS) );
519 /* these contain an HFONT */
522 /* these contain an HDC */
525 case WM_ICONERASEBKGND:
527 case WM_CTLCOLORMSGBOX:
528 case WM_CTLCOLOREDIT:
529 case WM_CTLCOLORLISTBOX:
532 case WM_CTLCOLORSCROLLBAR:
533 case WM_CTLCOLORSTATIC:
536 /* these contain an HGLOBAL */
537 case WM_PAINTCLIPBOARD:
538 case WM_SIZECLIPBOARD:
539 /* these contain pointers */
541 case WM_QUERYDROPOBJECT:
545 case WM_DEVICECHANGE:
546 FIXME( "msg %x (%s) not supported yet\n", message, SPY_GetMsgName(message, hwnd) );
554 /***********************************************************************
557 * Unpack a message received from another process.
559 static BOOL unpack_message( HWND hwnd, UINT message, WPARAM *wparam, LPARAM *lparam,
560 void **buffer, size_t size )
569 CREATESTRUCTW *cs = *buffer;
570 WCHAR *str = (WCHAR *)(cs + 1);
571 if (size < sizeof(*cs)) return FALSE;
573 if (HIWORD(cs->lpszName))
575 if (!check_string( str, size )) return FALSE;
577 size -= (strlenW(str) + 1) * sizeof(WCHAR);
578 str += strlenW(str) + 1;
580 if (HIWORD(cs->lpszClass))
582 if (!check_string( str, size )) return FALSE;
588 case WM_ASKCBFORMATNAME:
589 if (!get_buffer_space( buffer, (*wparam * sizeof(WCHAR)) )) return FALSE;
592 case WM_WININICHANGE:
593 case WM_DEVMODECHANGE:
596 case CB_FINDSTRINGEXACT:
597 case CB_SELECTSTRING:
601 case LB_FINDSTRINGEXACT:
602 case LB_SELECTSTRING:
604 if (!check_string( *buffer, size )) return FALSE;
606 case WM_GETMINMAXINFO:
607 minsize = sizeof(MINMAXINFO);
610 minsize = sizeof(DRAWITEMSTRUCT);
613 minsize = sizeof(MEASUREITEMSTRUCT);
616 minsize = sizeof(DELETEITEMSTRUCT);
619 minsize = sizeof(COMPAREITEMSTRUCT);
621 case WM_WINDOWPOSCHANGING:
622 case WM_WINDOWPOSCHANGED:
623 case WM_WINE_SETWINDOWPOS:
624 minsize = sizeof(WINDOWPOS);
628 COPYDATASTRUCT *cp = *buffer;
629 if (size < sizeof(*cp)) return FALSE;
632 minsize = sizeof(*cp) + cp->cbData;
638 /* WM_NOTIFY cannot be sent across processes (MSDN) */
641 minsize = sizeof(HELPINFO);
643 case WM_STYLECHANGING:
644 case WM_STYLECHANGED:
645 minsize = sizeof(STYLESTRUCT);
648 if (!*wparam) minsize = sizeof(RECT);
651 NCCALCSIZE_PARAMS *nc = *buffer;
652 if (size < sizeof(*nc) + sizeof(*nc->lppos)) return FALSE;
653 nc->lppos = (WINDOWPOS *)(nc + 1);
657 if (!*lparam) return TRUE;
658 minsize = sizeof(MSG);
660 case SBM_SETSCROLLINFO:
661 minsize = sizeof(SCROLLINFO);
663 case SBM_GETSCROLLINFO:
664 if (!get_buffer_space( buffer, sizeof(SCROLLINFO ))) return FALSE;
669 if (*wparam || *lparam)
671 if (!get_buffer_space( buffer, 2*sizeof(DWORD) )) return FALSE;
672 if (*wparam) *wparam = (WPARAM)*buffer;
673 if (*lparam) *lparam = (LPARAM)((DWORD *)*buffer + 1);
678 case CB_GETDROPPEDCONTROLRECT:
679 if (!get_buffer_space( buffer, sizeof(RECT) )) return FALSE;
683 minsize = sizeof(RECT);
688 if (size < sizeof(WORD)) return FALSE;
689 len = *(WORD *)*buffer;
690 if (!get_buffer_space( buffer, (len + 1) * sizeof(WCHAR) )) return FALSE;
691 *lparam = (LPARAM)*buffer + sizeof(WORD); /* don't erase WORD at start of buffer */
696 if (!*wparam) return TRUE;
697 minsize = *wparam * sizeof(UINT);
700 case CB_INSERTSTRING:
702 case LB_INSERTSTRING:
703 if (!*buffer) return TRUE;
704 if (!check_string( *buffer, size )) return FALSE;
708 size = sizeof(ULONG_PTR);
709 if (combobox_has_strings( hwnd ))
710 size = (SendMessageW( hwnd, CB_GETLBTEXTLEN, *wparam, 0 ) + 1) * sizeof(WCHAR);
711 if (!get_buffer_space( buffer, size )) return FALSE;
716 size = sizeof(ULONG_PTR);
717 if (listbox_has_strings( hwnd ))
718 size = (SendMessageW( hwnd, LB_GETTEXTLEN, *wparam, 0 ) + 1) * sizeof(WCHAR);
719 if (!get_buffer_space( buffer, size )) return FALSE;
723 if (!get_buffer_space( buffer, *wparam * sizeof(UINT) )) return FALSE;
726 minsize = sizeof(MDINEXTMENU);
727 if (!get_buffer_space( buffer, sizeof(MDINEXTMENU) )) return FALSE;
731 minsize = sizeof(RECT);
732 if (!get_buffer_space( buffer, sizeof(RECT) )) return FALSE;
736 MDICREATESTRUCTW *cs = *buffer;
737 WCHAR *str = (WCHAR *)(cs + 1);
738 if (size < sizeof(*cs)) return FALSE;
740 if (HIWORD(cs->szTitle))
742 if (!check_string( str, size )) return FALSE;
744 size -= (strlenW(str) + 1) * sizeof(WCHAR);
745 str += strlenW(str) + 1;
747 if (HIWORD(cs->szClass))
749 if (!check_string( str, size )) return FALSE;
754 case WM_MDIGETACTIVE:
755 if (!*lparam) return TRUE;
756 if (!get_buffer_space( buffer, sizeof(BOOL) )) return FALSE;
758 /* these contain an HFONT */
761 /* these contain an HDC */
764 case WM_ICONERASEBKGND:
766 case WM_CTLCOLORMSGBOX:
767 case WM_CTLCOLOREDIT:
768 case WM_CTLCOLORLISTBOX:
771 case WM_CTLCOLORSCROLLBAR:
772 case WM_CTLCOLORSTATIC:
775 /* these contain an HGLOBAL */
776 case WM_PAINTCLIPBOARD:
777 case WM_SIZECLIPBOARD:
778 /* these contain pointers */
780 case WM_QUERYDROPOBJECT:
784 case WM_DEVICECHANGE:
785 FIXME( "msg %x (%s) not supported yet\n", message, SPY_GetMsgName(message, hwnd) );
789 return TRUE; /* message doesn't need any unpacking */
792 /* default exit for most messages: check minsize and store buffer in lparam */
793 if (size < minsize) return FALSE;
794 *lparam = (LPARAM)*buffer;
799 /***********************************************************************
802 * Pack a reply to a message for sending to another process.
804 static void pack_reply( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam,
805 LRESULT res, struct packed_message *data )
812 push_data( data, (CREATESTRUCTW *)lparam, sizeof(CREATESTRUCTW) );
817 push_data( data, (WCHAR *)lparam, (res + 1) * sizeof(WCHAR) );
819 case WM_GETMINMAXINFO:
820 push_data( data, (MINMAXINFO *)lparam, sizeof(MINMAXINFO) );
823 push_data( data, (MEASUREITEMSTRUCT *)lparam, sizeof(MEASUREITEMSTRUCT) );
825 case WM_WINDOWPOSCHANGING:
826 case WM_WINDOWPOSCHANGED:
827 push_data( data, (WINDOWPOS *)lparam, sizeof(WINDOWPOS) );
830 if (lparam) push_data( data, (MSG *)lparam, sizeof(MSG) );
832 case SBM_GETSCROLLINFO:
833 push_data( data, (SCROLLINFO *)lparam, sizeof(SCROLLINFO) );
837 case CB_GETDROPPEDCONTROLRECT:
840 push_data( data, (RECT *)lparam, sizeof(RECT) );
844 WORD *ptr = (WORD *)lparam;
845 push_data( data, ptr, ptr[-1] * sizeof(WCHAR) );
849 push_data( data, (UINT *)lparam, wparam * sizeof(UINT) );
851 case WM_MDIGETACTIVE:
852 if (lparam) push_data( data, (BOOL *)lparam, sizeof(BOOL) );
856 push_data( data, (RECT *)lparam, sizeof(RECT) );
859 NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lparam;
860 push_data( data, nc, sizeof(*nc) );
861 push_data( data, nc->lppos, sizeof(*nc->lppos) );
867 if (wparam) push_data( data, (DWORD *)wparam, sizeof(DWORD) );
868 if (lparam) push_data( data, (DWORD *)lparam, sizeof(DWORD) );
871 push_data( data, (MDINEXTMENU *)lparam, sizeof(MDINEXTMENU) );
874 push_data( data, (MDICREATESTRUCTW *)lparam, sizeof(MDICREATESTRUCTW) );
876 case WM_ASKCBFORMATNAME:
877 push_data( data, (WCHAR *)lparam, (strlenW((WCHAR *)lparam) + 1) * sizeof(WCHAR) );
883 /***********************************************************************
886 * Unpack a message reply received from another process.
888 static void unpack_reply( HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam,
889 void *buffer, size_t size )
896 CREATESTRUCTW *cs = (CREATESTRUCTW *)lparam;
897 LPCWSTR name = cs->lpszName, class = cs->lpszClass;
898 memcpy( cs, buffer, min( sizeof(*cs), size ));
899 cs->lpszName = name; /* restore the original pointers */
900 cs->lpszClass = class;
904 case WM_ASKCBFORMATNAME:
905 memcpy( (WCHAR *)lparam, buffer, min( wparam*sizeof(WCHAR), size ));
907 case WM_GETMINMAXINFO:
908 memcpy( (MINMAXINFO *)lparam, buffer, min( sizeof(MINMAXINFO), size ));
911 memcpy( (MEASUREITEMSTRUCT *)lparam, buffer, min( sizeof(MEASUREITEMSTRUCT), size ));
913 case WM_WINDOWPOSCHANGING:
914 case WM_WINDOWPOSCHANGED:
915 memcpy( (WINDOWPOS *)lparam, buffer, min( sizeof(WINDOWPOS), size ));
918 if (lparam) memcpy( (MSG *)lparam, buffer, min( sizeof(MSG), size ));
920 case SBM_GETSCROLLINFO:
921 memcpy( (SCROLLINFO *)lparam, buffer, min( sizeof(SCROLLINFO), size ));
924 case CB_GETDROPPEDCONTROLRECT:
928 memcpy( (RECT *)lparam, buffer, min( sizeof(RECT), size ));
931 size = min( size, (size_t)*(WORD *)lparam );
932 memcpy( (WCHAR *)lparam, buffer, size );
935 memcpy( (UINT *)lparam, buffer, min( wparam*sizeof(UINT), size ));
939 memcpy( (WCHAR *)lparam, buffer, size );
942 memcpy( (MDINEXTMENU *)lparam, buffer, min( sizeof(MDINEXTMENU), size ));
944 case WM_MDIGETACTIVE:
945 if (lparam) memcpy( (BOOL *)lparam, buffer, min( sizeof(BOOL), size ));
949 memcpy( (RECT *)lparam, buffer, min( sizeof(RECT), size ));
952 NCCALCSIZE_PARAMS *nc = (NCCALCSIZE_PARAMS *)lparam;
953 WINDOWPOS *wp = nc->lppos;
954 memcpy( nc, buffer, min( sizeof(*nc), size ));
955 if (size > sizeof(*nc))
958 memcpy( wp, (NCCALCSIZE_PARAMS*)buffer + 1, min( sizeof(*wp), size ));
960 nc->lppos = wp; /* restore the original pointer */
968 memcpy( (DWORD *)wparam, buffer, min( sizeof(DWORD), size ));
969 if (size <= sizeof(DWORD)) break;
970 size -= sizeof(DWORD);
971 buffer = (DWORD *)buffer + 1;
973 if (lparam) memcpy( (DWORD *)lparam, buffer, min( sizeof(DWORD), size ));
977 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lparam;
978 LPCWSTR title = cs->szTitle, class = cs->szClass;
979 memcpy( cs, buffer, min( sizeof(*cs), size ));
980 cs->szTitle = title; /* restore the original pointers */
985 ERR( "should not happen: unexpected message %x\n", message );
991 /***********************************************************************
994 * Send a reply to a sent message.
996 static void reply_message( struct received_message_info *info, LRESULT result, BOOL remove )
998 struct packed_message data;
999 int i, replied = info->flags & ISMEX_REPLIED;
1001 if (info->flags & ISMEX_NOTIFY) return; /* notify messages don't get replies */
1002 if (!remove && replied) return; /* replied already */
1005 info->flags |= ISMEX_REPLIED;
1007 if (info->type == MSG_OTHER_PROCESS && !replied)
1009 pack_reply( info->msg.hwnd, info->msg.message, info->msg.wParam,
1010 info->msg.lParam, result, &data );
1013 SERVER_START_REQ( reply_message )
1015 req->result = result;
1016 req->remove = remove;
1017 for (i = 0; i < data.count; i++) wine_server_add_data( req, data.data[i], data.size[i] );
1018 wine_server_call( req );
1024 /***********************************************************************
1025 * handle_internal_message
1027 * Handle an internal Wine message instead of calling the window proc.
1029 static LRESULT handle_internal_message( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1031 if (hwnd == GetDesktopWindow()) return 0;
1034 case WM_WINE_DESTROYWINDOW:
1035 return WIN_DestroyWindow( hwnd );
1036 case WM_WINE_SETWINDOWPOS:
1037 return USER_Driver.pSetWindowPos( (WINDOWPOS *)lparam );
1038 case WM_WINE_SHOWWINDOW:
1039 return ShowWindow( hwnd, wparam );
1040 case WM_WINE_SETPARENT:
1041 return (LRESULT)SetParent( hwnd, (HWND)wparam );
1042 case WM_WINE_SETWINDOWLONG:
1043 return (LRESULT)SetWindowLongW( hwnd, wparam, lparam );
1044 case WM_WINE_ENABLEWINDOW:
1045 return EnableWindow( hwnd, wparam );
1047 FIXME( "unknown internal message %x\n", msg );
1052 /* since the WM_DDE_ACK response to a WM_DDE_EXECUTE message should contain the handle
1053 * to the memory handle, we keep track (in the server side) of all pairs of handle
1054 * used (the client passes its value and the content of the memory handle), and
1055 * the server stored both values (the client, and the local one, created after the
1056 * content). When a ACK message is generated, the list of pair is searched for a
1057 * matching pair, so that the client memory handle can be returned.
1060 HGLOBAL client_hMem;
1061 HGLOBAL server_hMem;
1064 static struct DDE_pair* dde_pairs;
1065 static int dde_num_alloc;
1066 static int dde_num_used;
1067 static CRITICAL_SECTION dde_crst = CRITICAL_SECTION_INIT("Raw_DDE_CritSect");
1069 static BOOL dde_add_pair(HGLOBAL chm, HGLOBAL shm)
1074 EnterCriticalSection(&dde_crst);
1076 /* now remember the pair of hMem on both sides */
1077 if (dde_num_used == dde_num_alloc)
1079 struct DDE_pair* tmp = HeapReAlloc( GetProcessHeap(), 0, dde_pairs,
1080 (dde_num_alloc + GROWBY) * sizeof(struct DDE_pair));
1083 LeaveCriticalSection(&dde_crst);
1087 /* zero out newly allocated part */
1088 memset(&dde_pairs[dde_num_alloc], 0, GROWBY * sizeof(struct DDE_pair));
1089 dde_num_alloc += GROWBY;
1092 for (i = 0; i < dde_num_alloc; i++)
1094 if (dde_pairs[i].server_hMem == 0)
1096 dde_pairs[i].client_hMem = chm;
1097 dde_pairs[i].server_hMem = shm;
1102 LeaveCriticalSection(&dde_crst);
1106 static HGLOBAL dde_get_pair(HGLOBAL shm)
1111 EnterCriticalSection(&dde_crst);
1112 for (i = 0; i < dde_num_alloc; i++)
1114 if (dde_pairs[i].server_hMem == shm)
1116 /* free this pair */
1117 dde_pairs[i].server_hMem = 0;
1119 ret = dde_pairs[i].client_hMem;
1123 LeaveCriticalSection(&dde_crst);
1127 /***********************************************************************
1132 static BOOL post_dde_message( DWORD dest_tid, struct packed_message *data, const struct send_message_info *info )
1138 HGLOBAL hunlock = 0;
1142 if (!UnpackDDElParam( info->msg, info->lparam, &uiLo, &uiHi ))
1148 /* DDE messages which don't require packing are:
1157 /* uiHi should contain a hMem from WM_DDE_EXECUTE */
1158 HGLOBAL h = dde_get_pair( uiHi );
1161 /* send back the value of h on the other side */
1162 push_data( data, &h, sizeof(HGLOBAL) );
1164 TRACE( "send dde-ack %x %08x => %08lx\n", uiLo, uiHi, (DWORD)h );
1169 /* uiHi should contain either an atom or 0 */
1170 TRACE( "send dde-ack %x atom=%x\n", uiLo, uiHi );
1171 lp = MAKELONG( uiLo, uiHi );
1180 size = GlobalSize( (HGLOBAL)uiLo ) ;
1181 if ((info->msg == WM_DDE_ADVISE && size < sizeof(DDEADVISE)) ||
1182 (info->msg == WM_DDE_DATA && size < sizeof(DDEDATA)) ||
1183 (info->msg == WM_DDE_POKE && size < sizeof(DDEPOKE))
1187 else if (info->msg != WM_DDE_DATA) return FALSE;
1192 if ((ptr = GlobalLock( (HGLOBAL)uiLo) ))
1194 push_data( data, ptr, size );
1195 hunlock = (HGLOBAL)uiLo;
1198 TRACE( "send ddepack %u %x\n", size, uiHi );
1200 case WM_DDE_EXECUTE:
1203 if ((ptr = GlobalLock( (HGLOBAL)info->lparam) ))
1205 push_data(data, ptr, GlobalSize( (HGLOBAL)info->lparam ));
1206 /* so that the other side can send it back on ACK */
1208 hunlock = (HGLOBAL)info->lparam;
1213 SERVER_START_REQ( send_message )
1215 req->id = (void *)dest_tid;
1216 req->type = info->type;
1217 req->win = info->hwnd;
1218 req->msg = info->msg;
1219 req->wparam = info->wparam;
1221 req->time = GetCurrentTime();
1223 for (i = 0; i < data->count; i++)
1224 wine_server_add_data( req, data->data[i], data->size[i] );
1225 if ((res = wine_server_call( req )))
1227 if (res == STATUS_INVALID_PARAMETER)
1228 /* FIXME: find a STATUS_ value for this one */
1229 SetLastError( ERROR_INVALID_THREAD_ID );
1231 SetLastError( RtlNtStatusToDosError(res) );
1234 FreeDDElParam(info->msg, info->lparam);
1237 if (hunlock) GlobalUnlock(hunlock);
1242 /***********************************************************************
1243 * unpack_dde_message
1245 * Unpack a posted DDE message received from another process.
1247 static BOOL unpack_dde_message( HWND hwnd, UINT message, WPARAM *wparam, LPARAM *lparam,
1248 void **buffer, size_t size )
1259 /* hMem is being passed */
1260 if (size != sizeof(HGLOBAL)) return FALSE;
1261 if (!buffer || !*buffer) return FALSE;
1263 memcpy( &hMem, *buffer, size );
1265 TRACE("recv dde-ack %u mem=%x[%lx]\n", uiLo, uiHi, GlobalSize( uiHi ));
1269 uiLo = LOWORD( *lparam );
1270 uiHi = HIWORD( *lparam );
1271 TRACE("recv dde-ack %x atom=%x\n", uiLo, uiHi);
1273 *lparam = PackDDElParam( WM_DDE_ACK, uiLo, uiHi );
1278 if ((!buffer || !*buffer) && message != WM_DDE_DATA) return FALSE;
1280 TRACE( "recv ddepack %u %x\n", size, uiHi );
1283 hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size );
1284 if (hMem && (ptr = GlobalLock( hMem )))
1286 memcpy( ptr, *buffer, size );
1287 GlobalUnlock( hMem );
1293 *lparam = PackDDElParam( message, uiLo, uiHi );
1295 case WM_DDE_EXECUTE:
1298 if (!buffer || !*buffer) return FALSE;
1299 hMem = GlobalAlloc( GMEM_MOVEABLE|GMEM_DDESHARE, size );
1300 if (hMem && (ptr = GlobalLock( hMem )))
1302 memcpy( ptr, *buffer, size );
1303 GlobalUnlock( hMem );
1304 TRACE( "exec: pairing c=%08lx s=%08lx\n", *lparam, (DWORD)hMem );
1305 if (!dde_add_pair( *lparam, hMem ))
1311 } else return FALSE;
1318 /***********************************************************************
1321 * Call a window procedure and the corresponding hooks.
1323 static LRESULT call_window_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam, BOOL unicode )
1328 if (msg & 0x80000000) return handle_internal_message( hwnd, msg, wparam, lparam );
1330 /* first the WH_CALLWNDPROC hook */
1331 if (HOOK_IsHooked( WH_CALLWNDPROC ))
1334 cwp.lParam = lparam;
1335 cwp.wParam = wparam;
1337 cwp.hwnd = WIN_GetFullHandle( hwnd );
1338 if (unicode) HOOK_CallHooksW( WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp );
1339 else HOOK_CallHooksA( WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp );
1340 lparam = cwp.lParam;
1341 wparam = cwp.wParam;
1346 /* now call the window procedure */
1349 if (!(winproc = (WNDPROC)GetWindowLongW( hwnd, GWL_WNDPROC ))) return 0;
1350 result = CallWindowProcW( winproc, hwnd, msg, wparam, lparam );
1354 if (!(winproc = (WNDPROC)GetWindowLongA( hwnd, GWL_WNDPROC ))) return 0;
1355 result = CallWindowProcA( winproc, hwnd, msg, wparam, lparam );
1358 /* and finally the WH_CALLWNDPROCRET hook */
1359 if (HOOK_IsHooked( WH_CALLWNDPROCRET ))
1362 cwp.lResult = result;
1363 cwp.lParam = lparam;
1364 cwp.wParam = wparam;
1366 cwp.hwnd = WIN_GetFullHandle( hwnd );
1367 if (unicode) HOOK_CallHooksW( WH_CALLWNDPROCRET, HC_ACTION, 1, (LPARAM)&cwp );
1368 else HOOK_CallHooksA( WH_CALLWNDPROCRET, HC_ACTION, 1, (LPARAM)&cwp );
1374 /***********************************************************************
1377 * Peek for a message matching the given parameters. Return FALSE if none available.
1378 * All pending sent messages are processed before returning.
1380 BOOL MSG_peek_message( MSG *msg, HWND hwnd, UINT first, UINT last, int flags )
1383 ULONG_PTR extra_info = 0;
1384 MESSAGEQUEUE *queue = QUEUE_Current();
1385 struct received_message_info info, *old_info;
1387 if (!first && !last) last = ~0;
1392 void *buffer = NULL;
1393 size_t size = 0, buffer_size = 0;
1395 do /* loop while buffer is too small */
1397 if (buffer_size && !(buffer = HeapAlloc( GetProcessHeap(), 0, buffer_size )))
1399 SERVER_START_REQ( get_message )
1402 req->get_win = hwnd;
1403 req->get_first = first;
1404 req->get_last = last;
1405 if (buffer_size) wine_server_set_reply( req, buffer, buffer_size );
1406 if (!(res = wine_server_call( req )))
1408 size = wine_server_reply_size( reply );
1409 info.type = reply->type;
1410 info.msg.hwnd = reply->win;
1411 info.msg.message = reply->msg;
1412 info.msg.wParam = reply->wparam;
1413 info.msg.lParam = reply->lparam;
1414 info.msg.time = reply->time;
1415 info.msg.pt.x = reply->x;
1416 info.msg.pt.y = reply->y;
1417 extra_info = reply->info;
1421 if (buffer) HeapFree( GetProcessHeap(), 0, buffer );
1422 buffer_size = reply->total;
1426 } while (res == STATUS_BUFFER_OVERFLOW);
1428 if (res) return FALSE;
1430 TRACE( "got type %d msg %x hwnd %x wp %x lp %lx\n",
1431 info.type, info.msg.message, info.msg.hwnd, info.msg.wParam, info.msg.lParam );
1437 info.flags = ISMEX_SEND;
1440 info.flags = ISMEX_NOTIFY;
1443 info.flags = ISMEX_CALLBACK;
1445 case MSG_OTHER_PROCESS:
1446 info.flags = ISMEX_SEND;
1447 if (!unpack_message( info.msg.hwnd, info.msg.message, &info.msg.wParam,
1448 &info.msg.lParam, &buffer, size ))
1450 ERR( "invalid packed message %x (%s) hwnd %x wp %x lp %lx size %d\n",
1451 info.msg.message, SPY_GetMsgName(info.msg.message, info.msg.hwnd), info.msg.hwnd,
1452 info.msg.wParam, info.msg.lParam, size );
1454 reply_message( &info, 0, TRUE );
1458 case MSG_HARDWARE_RAW:
1459 if (!MSG_process_raw_hardware_message( &info.msg, extra_info,
1460 hwnd, first, last, flags & GET_MSG_REMOVE ))
1463 case MSG_HARDWARE_COOKED:
1464 if (!MSG_process_cooked_hardware_message( &info.msg, extra_info,
1465 flags & GET_MSG_REMOVE ))
1467 flags |= GET_MSG_REMOVE_LAST;
1470 queue->GetMessagePosVal = MAKELONG( info.msg.pt.x, info.msg.pt.y );
1473 queue->GetMessageExtraInfoVal = extra_info;
1474 if (info.msg.message >= WM_DDE_FIRST && info.msg.message <= WM_DDE_LAST)
1476 if (!unpack_dde_message( info.msg.hwnd, info.msg.message, &info.msg.wParam,
1477 &info.msg.lParam, &buffer, size ))
1479 ERR( "invalid packed dde-message %x (%s) hwnd %x wp %x lp %lx size %d\n",
1480 info.msg.message, SPY_GetMsgName(info.msg.message, info.msg.hwnd),
1481 info.msg.hwnd, info.msg.wParam, info.msg.lParam, size );
1487 if (buffer) HeapFree( GetProcessHeap(), 0, buffer );
1491 /* if we get here, we have a sent message; call the window procedure */
1492 old_info = queue->receive_info;
1493 queue->receive_info = &info;
1494 result = call_window_proc( info.msg.hwnd, info.msg.message, info.msg.wParam,
1495 info.msg.lParam, (info.type != MSG_ASCII) );
1496 reply_message( &info, result, TRUE );
1497 queue->receive_info = old_info;
1499 if (buffer) HeapFree( GetProcessHeap(), 0, buffer );
1504 /***********************************************************************
1505 * wait_message_reply
1507 * Wait until a sent message gets replied to.
1509 static void wait_message_reply( UINT flags )
1511 MESSAGEQUEUE *queue;
1513 if (!(queue = QUEUE_Current())) return;
1517 unsigned int wake_bits = 0, changed_bits = 0;
1520 SERVER_START_REQ( set_queue_mask )
1522 req->wake_mask = (flags & SMTO_BLOCK) ? 0 : QS_SENDMESSAGE;
1523 req->changed_mask = QS_SMRESULT | req->wake_mask;
1525 if (!wine_server_call( req ))
1527 wake_bits = reply->wake_bits;
1528 changed_bits = reply->changed_bits;
1533 if (changed_bits & QS_SMRESULT) return; /* got a result */
1534 if (wake_bits & QS_SENDMESSAGE)
1536 /* Process the sent message immediately */
1538 MSG_peek_message( &msg, 0, 0, 0, GET_MSG_REMOVE | GET_MSG_SENT_ONLY );
1542 /* now wait for it */
1544 ReleaseThunkLock( &dwlc );
1546 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
1547 res = USER_Driver.pMsgWaitForMultipleObjectsEx( 1, &queue->server_queue,
1550 res = WaitForSingleObject( queue->server_queue, INFINITE );
1552 if (dwlc) RestoreThunkLock( dwlc );
1556 /***********************************************************************
1557 * put_message_in_queue
1559 * Put a sent message into the destination queue.
1560 * For inter-process message, reply_size is set to expected size of reply data.
1562 static BOOL put_message_in_queue( DWORD dest_tid, const struct send_message_info *info,
1563 size_t *reply_size )
1565 struct packed_message data;
1567 int i, timeout = -1;
1569 if (info->type != MSG_NOTIFY &&
1570 info->type != MSG_CALLBACK &&
1571 info->type != MSG_POSTED &&
1572 info->timeout != INFINITE)
1573 timeout = info->timeout;
1576 if (info->type == MSG_OTHER_PROCESS)
1578 *reply_size = pack_message( info->hwnd, info->msg, info->wparam, info->lparam, &data );
1579 if (data.count == -1)
1581 WARN( "cannot pack message %x\n", info->msg );
1585 else if (info->type == MSG_POSTED && info->msg >= WM_DDE_FIRST && info->msg <= WM_DDE_LAST)
1587 return post_dde_message( dest_tid, &data, info );
1590 SERVER_START_REQ( send_message )
1592 req->id = (void *)dest_tid;
1593 req->type = info->type;
1594 req->win = info->hwnd;
1595 req->msg = info->msg;
1596 req->wparam = info->wparam;
1597 req->lparam = info->lparam;
1598 req->time = GetCurrentTime();
1599 req->timeout = timeout;
1600 for (i = 0; i < data.count; i++) wine_server_add_data( req, data.data[i], data.size[i] );
1601 if ((res = wine_server_call( req )))
1603 if (res == STATUS_INVALID_PARAMETER)
1604 /* FIXME: find a STATUS_ value for this one */
1605 SetLastError( ERROR_INVALID_THREAD_ID );
1607 SetLastError( RtlNtStatusToDosError(res) );
1615 /***********************************************************************
1618 * Retrieve a message reply from the server.
1620 static LRESULT retrieve_reply( const struct send_message_info *info,
1621 size_t reply_size, LRESULT *result )
1624 void *reply_data = NULL;
1628 if (!(reply_data = HeapAlloc( GetProcessHeap(), 0, reply_size )))
1630 WARN( "no memory for reply %d bytes, will be truncated\n", reply_size );
1634 SERVER_START_REQ( get_message_reply )
1637 if (reply_size) wine_server_set_reply( req, reply_data, reply_size );
1638 if (!(status = wine_server_call( req ))) *result = reply->result;
1639 reply_size = wine_server_reply_size( reply );
1642 if (!status && reply_size)
1643 unpack_reply( info->hwnd, info->msg, info->wparam, info->lparam, reply_data, reply_size );
1645 if (reply_data) HeapFree( GetProcessHeap(), 0, reply_data );
1647 TRACE( "hwnd %x msg %x (%s) wp %x lp %lx got reply %lx (err=%ld)\n",
1648 info->hwnd, info->msg, SPY_GetMsgName(info->msg, info->hwnd), info->wparam,
1649 info->lparam, *result, status );
1651 if (!status) return 1;
1652 if (status == STATUS_TIMEOUT) SetLastError(0); /* timeout */
1653 else SetLastError( RtlNtStatusToDosError(status) );
1658 /***********************************************************************
1659 * send_inter_thread_message
1661 static LRESULT send_inter_thread_message( DWORD dest_tid, const struct send_message_info *info,
1666 size_t reply_size = 0;
1668 TRACE( "hwnd %x msg %x (%s) wp %x lp %lx\n",
1669 info->hwnd, info->msg, SPY_GetMsgName(info->msg, info->hwnd), info->wparam, info->lparam );
1671 if (!put_message_in_queue( dest_tid, info, &reply_size )) return 0;
1673 /* there's no reply to wait for on notify/callback messages */
1674 if (info->type == MSG_NOTIFY || info->type == MSG_CALLBACK) return 1;
1676 locks = WIN_SuspendWndsLock();
1678 wait_message_reply( info->flags );
1679 ret = retrieve_reply( info, reply_size, res_ptr );
1681 WIN_RestoreWndsLock( locks );
1686 /***********************************************************************
1687 * SendMessageTimeoutW (USER32.@)
1689 LRESULT WINAPI SendMessageTimeoutW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
1690 UINT flags, UINT timeout, LPDWORD res_ptr )
1692 struct send_message_info info;
1693 DWORD dest_tid, dest_pid;
1694 LRESULT ret, result;
1696 info.type = MSG_UNICODE;
1699 info.wparam = wparam;
1700 info.lparam = lparam;
1702 info.timeout = timeout;
1704 if (is_broadcast(hwnd))
1706 EnumWindows( broadcast_message_callback, (LPARAM)&info );
1707 if (res_ptr) *res_ptr = 1;
1711 if (!(dest_tid = GetWindowThreadProcessId( hwnd, &dest_pid ))) return 0;
1713 if (USER_IsExitingThread( dest_tid )) return 0;
1715 SPY_EnterMessage( SPY_SENDMESSAGE, hwnd, msg, wparam, lparam );
1717 if (dest_tid == GetCurrentThreadId())
1719 result = call_window_proc( hwnd, msg, wparam, lparam, TRUE );
1724 if (dest_pid != GetCurrentProcessId()) info.type = MSG_OTHER_PROCESS;
1725 ret = send_inter_thread_message( dest_tid, &info, &result );
1728 SPY_ExitMessage( SPY_RESULT_OK, hwnd, msg, result, wparam, lparam );
1729 if (ret && res_ptr) *res_ptr = result;
1734 /***********************************************************************
1735 * SendMessageTimeoutA (USER32.@)
1737 LRESULT WINAPI SendMessageTimeoutA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
1738 UINT flags, UINT timeout, LPDWORD res_ptr )
1740 struct send_message_info info;
1741 DWORD dest_tid, dest_pid;
1742 LRESULT ret, result;
1744 info.type = MSG_ASCII;
1747 info.wparam = wparam;
1748 info.lparam = lparam;
1750 info.timeout = timeout;
1752 if (is_broadcast(hwnd))
1754 EnumWindows( broadcast_message_callback, (LPARAM)&info );
1755 if (res_ptr) *res_ptr = 1;
1759 if (!(dest_tid = GetWindowThreadProcessId( hwnd, &dest_pid ))) return 0;
1761 if (USER_IsExitingThread( dest_tid )) return 0;
1763 SPY_EnterMessage( SPY_SENDMESSAGE, hwnd, msg, wparam, lparam );
1765 if (dest_tid == GetCurrentThreadId())
1767 result = call_window_proc( hwnd, msg, wparam, lparam, FALSE );
1770 else if (dest_pid == GetCurrentProcessId())
1772 ret = send_inter_thread_message( dest_tid, &info, &result );
1776 /* inter-process message: need to map to Unicode */
1777 info.type = MSG_OTHER_PROCESS;
1778 if (is_unicode_message( info.msg ))
1780 if (WINPROC_MapMsg32ATo32W( info.hwnd, info.msg, &info.wparam, &info.lparam ) == -1)
1782 ret = send_inter_thread_message( dest_tid, &info, &result );
1783 result = WINPROC_UnmapMsg32ATo32W( info.hwnd, info.msg, info.wparam,
1784 info.lparam, result );
1786 else ret = send_inter_thread_message( dest_tid, &info, &result );
1788 SPY_ExitMessage( SPY_RESULT_OK, hwnd, msg, result, wparam, lparam );
1789 if (ret && res_ptr) *res_ptr = result;
1794 /***********************************************************************
1795 * SendMessageW (USER32.@)
1797 LRESULT WINAPI SendMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1800 SendMessageTimeoutW( hwnd, msg, wparam, lparam, SMTO_NORMAL, INFINITE, &res );
1805 /***********************************************************************
1806 * SendMessageA (USER32.@)
1808 LRESULT WINAPI SendMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1811 SendMessageTimeoutA( hwnd, msg, wparam, lparam, SMTO_NORMAL, INFINITE, &res );
1816 /***********************************************************************
1817 * SendNotifyMessageA (USER32.@)
1819 BOOL WINAPI SendNotifyMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1821 return SendNotifyMessageW( hwnd, msg, map_wparam_AtoW( msg, wparam ), lparam );
1825 /***********************************************************************
1826 * SendNotifyMessageW (USER32.@)
1828 BOOL WINAPI SendNotifyMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1830 struct send_message_info info;
1834 if (is_pointer_message(msg))
1836 SetLastError(ERROR_INVALID_PARAMETER);
1840 info.type = MSG_NOTIFY;
1843 info.wparam = wparam;
1844 info.lparam = lparam;
1846 if (is_broadcast(hwnd))
1848 EnumWindows( broadcast_message_callback, (LPARAM)&info );
1852 if (!(dest_tid = GetWindowThreadProcessId( hwnd, NULL ))) return FALSE;
1854 if (USER_IsExitingThread( dest_tid )) return TRUE;
1856 if (dest_tid == GetCurrentThreadId())
1858 call_window_proc( hwnd, msg, wparam, lparam, TRUE );
1861 return send_inter_thread_message( dest_tid, &info, &result );
1865 /***********************************************************************
1866 * SendMessageCallbackA (USER32.@)
1868 BOOL WINAPI SendMessageCallbackA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
1869 SENDASYNCPROC callback, ULONG_PTR data )
1871 return SendMessageCallbackW( hwnd, msg, map_wparam_AtoW( msg, wparam ),
1872 lparam, callback, data );
1876 /***********************************************************************
1877 * SendMessageCallbackW (USER32.@)
1879 BOOL WINAPI SendMessageCallbackW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam,
1880 SENDASYNCPROC callback, ULONG_PTR data )
1882 struct send_message_info info;
1886 if (is_pointer_message(msg))
1888 SetLastError(ERROR_INVALID_PARAMETER);
1892 info.type = MSG_CALLBACK;
1895 info.wparam = wparam;
1896 info.lparam = lparam;
1897 info.callback = callback;
1900 if (is_broadcast(hwnd))
1902 EnumWindows( broadcast_message_callback, (LPARAM)&info );
1906 if (!(dest_tid = GetWindowThreadProcessId( hwnd, NULL ))) return FALSE;
1908 if (USER_IsExitingThread( dest_tid )) return TRUE;
1910 if (dest_tid == GetCurrentThreadId())
1912 result = call_window_proc( hwnd, msg, wparam, lparam, TRUE );
1913 callback( hwnd, msg, data, result );
1916 FIXME( "callback will not be called\n" );
1917 return send_inter_thread_message( dest_tid, &info, &result );
1921 /***********************************************************************
1922 * ReplyMessage (USER32.@)
1924 BOOL WINAPI ReplyMessage( LRESULT result )
1926 MESSAGEQUEUE *queue = QUEUE_Current();
1927 struct received_message_info *info = queue->receive_info;
1929 if (!info) return FALSE;
1930 reply_message( info, result, FALSE );
1935 /***********************************************************************
1936 * InSendMessage (USER32.@)
1938 BOOL WINAPI InSendMessage(void)
1940 return (InSendMessageEx(NULL) & (ISMEX_SEND|ISMEX_REPLIED)) == ISMEX_SEND;
1944 /***********************************************************************
1945 * InSendMessageEx (USER32.@)
1947 DWORD WINAPI InSendMessageEx( LPVOID reserved )
1949 MESSAGEQUEUE *queue = QUEUE_Current();
1950 struct received_message_info *info = queue->receive_info;
1952 if (info) return info->flags;
1953 return ISMEX_NOSEND;
1957 /***********************************************************************
1958 * PostMessageA (USER32.@)
1960 BOOL WINAPI PostMessageA( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1962 return PostMessageW( hwnd, msg, map_wparam_AtoW( msg, wparam ), lparam );
1966 /***********************************************************************
1967 * PostMessageW (USER32.@)
1969 BOOL WINAPI PostMessageW( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )
1971 struct send_message_info info;
1974 if (is_pointer_message( msg ))
1976 SetLastError( ERROR_INVALID_PARAMETER );
1980 info.type = MSG_POSTED;
1983 info.wparam = wparam;
1984 info.lparam = lparam;
1986 if (is_broadcast(hwnd))
1988 EnumWindows( broadcast_message_callback, (LPARAM)&info );
1991 if (!(dest_tid = GetWindowThreadProcessId( hwnd, NULL ))) return FALSE;
1993 if (USER_IsExitingThread( dest_tid )) return TRUE;
1995 return put_message_in_queue( dest_tid, &info, NULL );
1999 /**********************************************************************
2000 * PostThreadMessageA (USER32.@)
2002 BOOL WINAPI PostThreadMessageA( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam )
2004 return PostThreadMessageW( thread, msg, map_wparam_AtoW( msg, wparam ), lparam );
2008 /**********************************************************************
2009 * PostThreadMessageW (USER32.@)
2011 BOOL WINAPI PostThreadMessageW( DWORD thread, UINT msg, WPARAM wparam, LPARAM lparam )
2013 struct send_message_info info;
2015 if (is_pointer_message( msg ))
2017 SetLastError( ERROR_INVALID_PARAMETER );
2020 if (USER_IsExitingThread( thread )) return TRUE;
2022 info.type = MSG_POSTED;
2025 info.wparam = wparam;
2026 info.lparam = lparam;
2027 return put_message_in_queue( thread, &info, NULL );
2031 /***********************************************************************
2032 * PostQuitMessage (USER32.@)
2034 void WINAPI PostQuitMessage( INT exitCode )
2036 PostThreadMessageW( GetCurrentThreadId(), WM_QUIT, exitCode, 0 );
2040 /***********************************************************************
2041 * PeekMessageW (USER32.@)
2043 BOOL WINAPI PeekMessageW( MSG *msg_out, HWND hwnd, UINT first, UINT last, UINT flags )
2045 MESSAGEQUEUE *queue;
2049 /* check for graphics events */
2050 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
2051 USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
2053 hwnd = WIN_GetFullHandle( hwnd );
2054 locks = WIN_SuspendWndsLock();
2056 if (!MSG_peek_message( &msg, hwnd, first, last,
2057 (flags & PM_REMOVE) ? GET_MSG_REMOVE : 0 ))
2059 /* FIXME: should be done before checking for hw events */
2060 MSG_JournalPlayBackMsg();
2062 if (!(flags & PM_NOYIELD))
2065 ReleaseThunkLock(&count);
2066 if (count) RestoreThunkLock(count);
2068 WIN_RestoreWndsLock( locks );
2072 WIN_RestoreWndsLock( locks );
2074 /* need to fill the window handle for WM_PAINT message */
2075 if (msg.message == WM_PAINT)
2077 if (IsIconic( msg.hwnd ) && GetClassLongA( msg.hwnd, GCL_HICON ))
2079 msg.message = WM_PAINTICON;
2082 /* clear internal paint flag */
2083 RedrawWindow( msg.hwnd, NULL, 0, RDW_NOINTERNALPAINT | RDW_NOCHILDREN );
2086 if ((queue = QUEUE_Current()))
2088 queue->GetMessageTimeVal = msg.time;
2089 msg.pt.x = LOWORD( queue->GetMessagePosVal );
2090 msg.pt.y = HIWORD( queue->GetMessagePosVal );
2093 HOOK_CallHooksW( WH_GETMESSAGE, HC_ACTION, flags & PM_REMOVE, (LPARAM)&msg );
2095 /* copy back our internal safe copy of message data to msg_out.
2096 * msg_out is a variable from the *program*, so it can't be used
2097 * internally as it can get "corrupted" by our use of SendMessage()
2098 * (back to the program) inside the message handling itself. */
2104 /***********************************************************************
2105 * PeekMessageA (USER32.@)
2107 BOOL WINAPI PeekMessageA( MSG *msg, HWND hwnd, UINT first, UINT last, UINT flags )
2109 BOOL ret = PeekMessageW( msg, hwnd, first, last, flags );
2110 if (ret) msg->wParam = map_wparam_WtoA( msg->message, msg->wParam );
2115 /***********************************************************************
2116 * GetMessageW (USER32.@)
2118 BOOL WINAPI GetMessageW( MSG *msg, HWND hwnd, UINT first, UINT last )
2120 MESSAGEQUEUE *queue = QUEUE_Current();
2123 mask = QS_POSTMESSAGE | QS_SENDMESSAGE; /* Always selected */
2126 if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
2127 if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
2128 ((first <= WM_NCMOUSELAST) && (last >= WM_NCMOUSEFIRST)) ) mask |= QS_MOUSE;
2129 if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
2130 if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
2131 if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
2133 else mask |= QS_MOUSE | QS_KEY | QS_TIMER | QS_PAINT;
2135 locks = WIN_SuspendWndsLock();
2137 while (!PeekMessageW( msg, hwnd, first, last, PM_REMOVE ))
2139 /* wait until one of the bits is set */
2140 unsigned int wake_bits = 0, changed_bits = 0;
2143 SERVER_START_REQ( set_queue_mask )
2145 req->wake_mask = QS_SENDMESSAGE;
2146 req->changed_mask = mask;
2148 if (!wine_server_call( req ))
2150 wake_bits = reply->wake_bits;
2151 changed_bits = reply->changed_bits;
2156 if (changed_bits & mask) continue;
2157 if (wake_bits & QS_SENDMESSAGE) continue;
2159 TRACE( "(%04x) mask=%08x, bits=%08x, changed=%08x, waiting\n",
2160 queue->self, mask, wake_bits, changed_bits );
2162 ReleaseThunkLock( &dwlc );
2163 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
2164 USER_Driver.pMsgWaitForMultipleObjectsEx( 1, &queue->server_queue, INFINITE, 0, 0 );
2166 WaitForSingleObject( queue->server_queue, INFINITE );
2167 if (dwlc) RestoreThunkLock( dwlc );
2170 WIN_RestoreWndsLock( locks );
2172 return (msg->message != WM_QUIT);
2176 /***********************************************************************
2177 * GetMessageA (USER32.@)
2179 BOOL WINAPI GetMessageA( MSG *msg, HWND hwnd, UINT first, UINT last )
2181 GetMessageW( msg, hwnd, first, last );
2182 msg->wParam = map_wparam_WtoA( msg->message, msg->wParam );
2183 return (msg->message != WM_QUIT);
2187 /***********************************************************************
2188 * SetMessageQueue (USER32.@)
2190 BOOL WINAPI SetMessageQueue( INT size )
2192 /* now obsolete the message queue will be expanded dynamically as necessary */