2 * Window messaging support
4 * Copyright 2001 Alexandre Julliard
5 * Copyright 2008 Maarten Lankhorst
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.
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.
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
23 #include "wine/port.h"
29 #define WIN32_NO_STATUS
40 #include "wine/unicode.h"
41 #include "wine/server.h"
42 #include "user_private.h"
45 #include "wine/debug.h"
47 WINE_DEFAULT_DEBUG_CHANNEL(msg
);
48 WINE_DECLARE_DEBUG_CHANNEL(relay
);
49 WINE_DECLARE_DEBUG_CHANNEL(key
);
51 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
52 #define WM_NCMOUSELAST (WM_NCMOUSEFIRST+(WM_MOUSELAST-WM_MOUSEFIRST))
54 #define MAX_PACK_COUNT 4
56 #define SYS_TIMER_RATE 55 /* min. timer rate in ms (actually 54.925)*/
58 /* description of the data fields that need to be packed along with a sent message */
62 const void *data
[MAX_PACK_COUNT
];
63 size_t size
[MAX_PACK_COUNT
];
66 /* info about the message currently being received by the current thread */
67 struct received_message_info
69 enum message_type type
;
71 UINT flags
; /* InSendMessageEx return flags */
74 /* structure to group all parameters for sent messages of the various kinds */
75 struct send_message_info
77 enum message_type type
;
83 UINT flags
; /* flags for SendMessageTimeout */
84 UINT timeout
; /* timeout for SendMessageTimeout */
85 SENDASYNCPROC callback
; /* callback function for SendMessageCallback */
86 ULONG_PTR data
; /* callback data */
87 enum wm_char_mapping wm_char
;
91 /* Message class descriptor */
92 static const WCHAR messageW
[] = {'M','e','s','s','a','g','e',0};
93 static LRESULT WINAPI
message_winproc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
);
94 const struct builtin_class_descr MESSAGE_builtin_class
=
98 NULL
, /* procA (winproc is Unicode only) */
99 message_winproc
, /* procW */
101 IDC_ARROW
, /* cursor */
107 /* flag for messages that contain pointers */
108 /* 32 messages per entry, messages 0..31 map to bits 0..31 */
110 #define SET(msg) (1 << ((msg) & 31))
112 static const unsigned int message_pointer_flags
[] =
115 SET(WM_CREATE
) | SET(WM_SETTEXT
) | SET(WM_GETTEXT
) |
116 SET(WM_WININICHANGE
) | SET(WM_DEVMODECHANGE
),
118 SET(WM_GETMINMAXINFO
) | SET(WM_DRAWITEM
) | SET(WM_MEASUREITEM
) | SET(WM_DELETEITEM
) |
121 SET(WM_WINDOWPOSCHANGING
) | SET(WM_WINDOWPOSCHANGED
) | SET(WM_COPYDATA
) |
122 SET(WM_NOTIFY
) | SET(WM_HELP
),
124 SET(WM_STYLECHANGING
) | SET(WM_STYLECHANGED
),
126 SET(WM_NCCREATE
) | SET(WM_NCCALCSIZE
) | SET(WM_GETDLGCODE
),
128 SET(EM_GETSEL
) | SET(EM_GETRECT
) | SET(EM_SETRECT
) | SET(EM_SETRECTNP
),
130 SET(EM_REPLACESEL
) | SET(EM_GETLINE
) | SET(EM_SETTABSTOPS
),
132 SET(SBM_GETRANGE
) | SET(SBM_SETSCROLLINFO
) | SET(SBM_GETSCROLLINFO
) | SET(SBM_GETSCROLLBARINFO
),
138 SET(CB_GETEDITSEL
) | SET(CB_ADDSTRING
) | SET(CB_DIR
) | SET(CB_GETLBTEXT
) |
139 SET(CB_INSERTSTRING
) | SET(CB_FINDSTRING
) | SET(CB_SELECTSTRING
) |
140 SET(CB_GETDROPPEDCONTROLRECT
) | SET(CB_FINDSTRINGEXACT
),
144 SET(LB_ADDSTRING
) | SET(LB_INSERTSTRING
) | SET(LB_GETTEXT
) | SET(LB_SELECTSTRING
) |
145 SET(LB_DIR
) | SET(LB_FINDSTRING
) |
146 SET(LB_GETSELITEMS
) | SET(LB_SETTABSTOPS
) | SET(LB_ADDFILE
) | SET(LB_GETITEMRECT
),
148 SET(LB_FINDSTRINGEXACT
),
154 SET(WM_NEXTMENU
) | SET(WM_SIZING
) | SET(WM_MOVING
) | SET(WM_DEVICECHANGE
),
156 SET(WM_MDICREATE
) | SET(WM_MDIGETACTIVE
) | SET(WM_DROPOBJECT
) |
157 SET(WM_QUERYDROPOBJECT
) | SET(WM_DRAGLOOP
) | SET(WM_DRAGSELECT
) | SET(WM_DRAGMOVE
),
171 SET(WM_ASKCBFORMATNAME
)
174 /* flags for messages that contain Unicode strings */
175 static const unsigned int message_unicode_flags
[] =
178 SET(WM_CREATE
) | SET(WM_SETTEXT
) | SET(WM_GETTEXT
) | SET(WM_GETTEXTLENGTH
) |
179 SET(WM_WININICHANGE
) | SET(WM_DEVMODECHANGE
),
191 SET(EM_REPLACESEL
) | SET(EM_GETLINE
) | SET(EM_SETPASSWORDCHAR
),
195 SET(WM_CHAR
) | SET(WM_DEADCHAR
) | SET(WM_SYSCHAR
) | SET(WM_SYSDEADCHAR
),
199 SET(CB_ADDSTRING
) | SET(CB_DIR
) | SET(CB_GETLBTEXT
) | SET(CB_GETLBTEXTLEN
) |
200 SET(CB_INSERTSTRING
) | SET(CB_FINDSTRING
) | SET(CB_SELECTSTRING
) | SET(CB_FINDSTRINGEXACT
),
204 SET(LB_ADDSTRING
) | SET(LB_INSERTSTRING
) | SET(LB_GETTEXT
) | SET(LB_GETTEXTLEN
) |
205 SET(LB_SELECTSTRING
) | SET(LB_DIR
) | SET(LB_FINDSTRING
) | SET(LB_ADDFILE
),
207 SET(LB_FINDSTRINGEXACT
),
229 SET(WM_PAINTCLIPBOARD
) | SET(WM_SIZECLIPBOARD
) | SET(WM_ASKCBFORMATNAME
)
232 /* check whether a given message type includes pointers */
233 static inline int is_pointer_message( UINT message
)
235 if (message
>= 8*sizeof(message_pointer_flags
)) return FALSE
;
236 return (message_pointer_flags
[message
/ 32] & SET(message
)) != 0;
239 /* check whether a given message type contains Unicode (or ASCII) chars */
240 static inline int is_unicode_message( UINT message
)
242 if (message
>= 8*sizeof(message_unicode_flags
)) return FALSE
;
243 return (message_unicode_flags
[message
/ 32] & SET(message
)) != 0;
248 /* add a data field to a packed message */
249 static inline void push_data( struct packed_message
*data
, const void *ptr
, size_t size
)
251 data
->data
[data
->count
] = ptr
;
252 data
->size
[data
->count
] = size
;
256 /* add a string to a packed message */
257 static inline void push_string( struct packed_message
*data
, LPCWSTR str
)
259 push_data( data
, str
, (strlenW(str
) + 1) * sizeof(WCHAR
) );
262 /* make sure that the buffer contains a valid null-terminated Unicode string */
263 static inline BOOL
check_string( LPCWSTR str
, size_t size
)
265 for (size
/= sizeof(WCHAR
); size
; size
--, str
++)
266 if (!*str
) return TRUE
;
270 /* make sure that there is space for 'size' bytes in buffer, growing it if needed */
271 static inline void *get_buffer_space( void **buffer
, size_t size
)
277 if (!(ret
= HeapReAlloc( GetProcessHeap(), 0, *buffer
, size
)))
278 HeapFree( GetProcessHeap(), 0, *buffer
);
280 else ret
= HeapAlloc( GetProcessHeap(), 0, size
);
286 /* check whether a combobox expects strings or ids in CB_ADDSTRING/CB_INSERTSTRING */
287 static inline BOOL
combobox_has_strings( HWND hwnd
)
289 DWORD style
= GetWindowLongA( hwnd
, GWL_STYLE
);
290 return (!(style
& (CBS_OWNERDRAWFIXED
| CBS_OWNERDRAWVARIABLE
)) || (style
& CBS_HASSTRINGS
));
293 /* check whether a listbox expects strings or ids in LB_ADDSTRING/LB_INSERTSTRING */
294 static inline BOOL
listbox_has_strings( HWND hwnd
)
296 DWORD style
= GetWindowLongA( hwnd
, GWL_STYLE
);
297 return (!(style
& (LBS_OWNERDRAWFIXED
| LBS_OWNERDRAWVARIABLE
)) || (style
& LBS_HASSTRINGS
));
300 /* check whether message is in the range of keyboard messages */
301 static inline BOOL
is_keyboard_message( UINT message
)
303 return (message
>= WM_KEYFIRST
&& message
<= WM_KEYLAST
);
306 /* check whether message is in the range of mouse messages */
307 static inline BOOL
is_mouse_message( UINT message
)
309 return ((message
>= WM_NCMOUSEFIRST
&& message
<= WM_NCMOUSELAST
) ||
310 (message
>= WM_MOUSEFIRST
&& message
<= WM_MOUSELAST
));
313 /* check whether message matches the specified hwnd filter */
314 static inline BOOL
check_hwnd_filter( const MSG
*msg
, HWND hwnd_filter
)
316 if (!hwnd_filter
|| hwnd_filter
== GetDesktopWindow()) return TRUE
;
317 return (msg
->hwnd
== hwnd_filter
|| IsChild( hwnd_filter
, msg
->hwnd
));
320 /* check for pending WM_CHAR message with DBCS trailing byte */
321 static inline BOOL
get_pending_wmchar( MSG
*msg
, UINT first
, UINT last
, BOOL remove
)
323 struct wm_char_mapping_data
*data
= get_user_thread_info()->wmchar_data
;
325 if (!data
|| !data
->get_msg
.message
) return FALSE
;
326 if ((first
|| last
) && (first
> WM_CHAR
|| last
< WM_CHAR
)) return FALSE
;
327 if (!msg
) return FALSE
;
328 *msg
= data
->get_msg
;
329 if (remove
) data
->get_msg
.message
= 0;
334 /***********************************************************************
337 * Window procedure for "Message" windows (HWND_MESSAGE parent).
339 static LRESULT WINAPI
message_winproc( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
341 if (message
== WM_NCCREATE
) return TRUE
;
342 return 0; /* all other messages are ignored */
346 /***********************************************************************
347 * broadcast_message_callback
349 * Helper callback for broadcasting messages.
351 static BOOL CALLBACK
broadcast_message_callback( HWND hwnd
, LPARAM lparam
)
353 struct send_message_info
*info
= (struct send_message_info
*)lparam
;
354 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & (WS_POPUP
|WS_CAPTION
))) return TRUE
;
358 SendMessageTimeoutW( hwnd
, info
->msg
, info
->wparam
, info
->lparam
,
359 info
->flags
, info
->timeout
, NULL
);
362 SendMessageTimeoutA( hwnd
, info
->msg
, info
->wparam
, info
->lparam
,
363 info
->flags
, info
->timeout
, NULL
);
366 SendNotifyMessageW( hwnd
, info
->msg
, info
->wparam
, info
->lparam
);
369 SendMessageCallbackW( hwnd
, info
->msg
, info
->wparam
, info
->lparam
,
370 info
->callback
, info
->data
);
373 PostMessageW( hwnd
, info
->msg
, info
->wparam
, info
->lparam
);
376 ERR( "bad type %d\n", info
->type
);
383 /***********************************************************************
386 * Convert the wparam of an ASCII message to Unicode.
388 BOOL
map_wparam_AtoW( UINT message
, WPARAM
*wparam
, enum wm_char_mapping mapping
)
397 /* WM_CHAR is magic: a DBCS char can be sent/posted as two consecutive WM_CHAR
398 * messages, in which case the first char is stored, and the conversion
399 * to Unicode only takes place once the second char is sent/posted.
401 if (mapping
!= WMCHAR_MAP_NOMAPPING
)
403 struct wm_char_mapping_data
*data
= get_user_thread_info()->wmchar_data
;
404 BYTE low
= LOBYTE(*wparam
);
409 ch
[1] = HIBYTE(*wparam
);
410 RtlMultiByteToUnicodeN( wch
, sizeof(wch
), NULL
, ch
, 2 );
411 TRACE( "map %02x,%02x -> %04x mapping %u\n", (BYTE
)ch
[0], (BYTE
)ch
[1], wch
[0], mapping
);
412 if (data
) data
->lead_byte
[mapping
] = 0;
414 else if (data
&& data
->lead_byte
[mapping
])
416 ch
[0] = data
->lead_byte
[mapping
];
418 RtlMultiByteToUnicodeN( wch
, sizeof(wch
), NULL
, ch
, 2 );
419 TRACE( "map stored %02x,%02x -> %04x mapping %u\n", (BYTE
)ch
[0], (BYTE
)ch
[1], wch
[0], mapping
);
420 data
->lead_byte
[mapping
] = 0;
422 else if (!IsDBCSLeadByte( low
))
425 RtlMultiByteToUnicodeN( wch
, sizeof(wch
), NULL
, ch
, 1 );
426 TRACE( "map %02x -> %04x\n", (BYTE
)ch
[0], wch
[0] );
427 if (data
) data
->lead_byte
[mapping
] = 0;
429 else /* store it and wait for trail byte */
433 if (!(data
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
) )))
435 get_user_thread_info()->wmchar_data
= data
;
437 TRACE( "storing lead byte %02x mapping %u\n", low
, mapping
);
438 data
->lead_byte
[mapping
] = low
;
441 *wparam
= MAKEWPARAM(wch
[0], wch
[1]);
444 /* else fall through */
446 case EM_SETPASSWORDCHAR
:
451 ch
[0] = LOBYTE(*wparam
);
452 ch
[1] = HIBYTE(*wparam
);
453 RtlMultiByteToUnicodeN( wch
, sizeof(wch
), NULL
, ch
, 2 );
454 *wparam
= MAKEWPARAM(wch
[0], wch
[1]);
457 ch
[0] = HIBYTE(*wparam
);
458 ch
[1] = LOBYTE(*wparam
);
459 if (ch
[0]) RtlMultiByteToUnicodeN( wch
, sizeof(wch
[0]), NULL
, ch
, 2 );
460 else RtlMultiByteToUnicodeN( wch
, sizeof(wch
[0]), NULL
, ch
+ 1, 1 );
461 *wparam
= MAKEWPARAM(wch
[0], HIWORD(*wparam
));
468 /***********************************************************************
471 * Convert the wparam of a Unicode message to ASCII.
473 static void map_wparam_WtoA( MSG
*msg
, BOOL remove
)
482 if (!HIWORD(msg
->wParam
))
484 wch
[0] = LOWORD(msg
->wParam
);
486 RtlUnicodeToMultiByteN( (LPSTR
)ch
, 2, &len
, wch
, sizeof(wch
[0]) );
487 if (len
== 2) /* DBCS char */
489 struct wm_char_mapping_data
*data
= get_user_thread_info()->wmchar_data
;
492 if (!(data
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*data
) ))) return;
493 get_user_thread_info()->wmchar_data
= data
;
497 data
->get_msg
= *msg
;
498 data
->get_msg
.wParam
= ch
[1];
504 /* else fall through */
506 case EM_SETPASSWORDCHAR
:
511 wch
[0] = LOWORD(msg
->wParam
);
512 wch
[1] = HIWORD(msg
->wParam
);
514 RtlUnicodeToMultiByteN( (LPSTR
)ch
, 2, NULL
, wch
, sizeof(wch
) );
515 msg
->wParam
= MAKEWPARAM( ch
[0] | (ch
[1] << 8), 0 );
518 wch
[0] = LOWORD(msg
->wParam
);
520 RtlUnicodeToMultiByteN( (LPSTR
)ch
, 2, &len
, wch
, sizeof(wch
[0]) );
522 msg
->wParam
= MAKEWPARAM( (ch
[0] << 8) | ch
[1], HIWORD(msg
->wParam
) );
524 msg
->wParam
= MAKEWPARAM( ch
[0], HIWORD(msg
->wParam
) );
530 /***********************************************************************
533 * Pack a message for sending to another process.
534 * Return the size of the data we expect in the message reply.
535 * Set data->count to -1 if there is an error.
537 static size_t pack_message( HWND hwnd
, UINT message
, WPARAM wparam
, LPARAM lparam
,
538 struct packed_message
*data
)
546 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)lparam
;
547 push_data( data
, cs
, sizeof(*cs
) );
548 if (HIWORD(cs
->lpszName
)) push_string( data
, cs
->lpszName
);
549 if (HIWORD(cs
->lpszClass
)) push_string( data
, cs
->lpszClass
);
553 case WM_ASKCBFORMATNAME
:
554 return wparam
* sizeof(WCHAR
);
555 case WM_WININICHANGE
:
556 if (lparam
) push_string(data
, (LPWSTR
)lparam
);
559 case WM_DEVMODECHANGE
:
564 push_string( data
, (LPWSTR
)lparam
);
566 case WM_GETMINMAXINFO
:
567 push_data( data
, (MINMAXINFO
*)lparam
, sizeof(MINMAXINFO
) );
568 return sizeof(MINMAXINFO
);
570 push_data( data
, (DRAWITEMSTRUCT
*)lparam
, sizeof(DRAWITEMSTRUCT
) );
573 push_data( data
, (MEASUREITEMSTRUCT
*)lparam
, sizeof(MEASUREITEMSTRUCT
) );
574 return sizeof(MEASUREITEMSTRUCT
);
576 push_data( data
, (DELETEITEMSTRUCT
*)lparam
, sizeof(DELETEITEMSTRUCT
) );
579 push_data( data
, (COMPAREITEMSTRUCT
*)lparam
, sizeof(COMPAREITEMSTRUCT
) );
581 case WM_WINDOWPOSCHANGING
:
582 case WM_WINDOWPOSCHANGED
:
583 push_data( data
, (WINDOWPOS
*)lparam
, sizeof(WINDOWPOS
) );
584 return sizeof(WINDOWPOS
);
587 COPYDATASTRUCT
*cp
= (COPYDATASTRUCT
*)lparam
;
588 push_data( data
, cp
, sizeof(*cp
) );
589 if (cp
->lpData
) push_data( data
, cp
->lpData
, cp
->cbData
);
593 /* WM_NOTIFY cannot be sent across processes (MSDN) */
597 push_data( data
, (HELPINFO
*)lparam
, sizeof(HELPINFO
) );
599 case WM_STYLECHANGING
:
600 case WM_STYLECHANGED
:
601 push_data( data
, (STYLESTRUCT
*)lparam
, sizeof(STYLESTRUCT
) );
606 push_data( data
, (RECT
*)lparam
, sizeof(RECT
) );
611 NCCALCSIZE_PARAMS
*nc
= (NCCALCSIZE_PARAMS
*)lparam
;
612 push_data( data
, nc
, sizeof(*nc
) );
613 push_data( data
, nc
->lppos
, sizeof(*nc
->lppos
) );
614 return sizeof(*nc
) + sizeof(*nc
->lppos
);
617 if (lparam
) push_data( data
, (MSG
*)lparam
, sizeof(MSG
) );
619 case SBM_SETSCROLLINFO
:
620 push_data( data
, (SCROLLINFO
*)lparam
, sizeof(SCROLLINFO
) );
622 case SBM_GETSCROLLINFO
:
623 push_data( data
, (SCROLLINFO
*)lparam
, sizeof(SCROLLINFO
) );
624 return sizeof(SCROLLINFO
);
625 case SBM_GETSCROLLBARINFO
:
627 const SCROLLBARINFO
*info
= (const SCROLLBARINFO
*)lparam
;
628 size_t size
= min( info
->cbSize
, sizeof(SCROLLBARINFO
) );
629 push_data( data
, info
, size
);
637 if (wparam
) size
+= sizeof(DWORD
);
638 if (lparam
) size
+= sizeof(DWORD
);
643 case CB_GETDROPPEDCONTROLRECT
:
647 push_data( data
, (RECT
*)lparam
, sizeof(RECT
) );
651 WORD
*pw
= (WORD
*)lparam
;
652 push_data( data
, pw
, sizeof(*pw
) );
653 return *pw
* sizeof(WCHAR
);
657 if (wparam
) push_data( data
, (UINT
*)lparam
, sizeof(UINT
) * wparam
);
660 case CB_INSERTSTRING
:
662 case CB_FINDSTRINGEXACT
:
663 case CB_SELECTSTRING
:
664 if (combobox_has_strings( hwnd
)) push_string( data
, (LPWSTR
)lparam
);
667 if (!combobox_has_strings( hwnd
)) return sizeof(ULONG_PTR
);
668 return (SendMessageW( hwnd
, CB_GETLBTEXTLEN
, wparam
, 0 ) + 1) * sizeof(WCHAR
);
670 case LB_INSERTSTRING
:
672 case LB_FINDSTRINGEXACT
:
673 case LB_SELECTSTRING
:
674 if (listbox_has_strings( hwnd
)) push_string( data
, (LPWSTR
)lparam
);
677 if (!listbox_has_strings( hwnd
)) return sizeof(ULONG_PTR
);
678 return (SendMessageW( hwnd
, LB_GETTEXTLEN
, wparam
, 0 ) + 1) * sizeof(WCHAR
);
680 return wparam
* sizeof(UINT
);
682 push_data( data
, (MDINEXTMENU
*)lparam
, sizeof(MDINEXTMENU
) );
683 return sizeof(MDINEXTMENU
);
686 push_data( data
, (RECT
*)lparam
, sizeof(RECT
) );
690 MDICREATESTRUCTW
*cs
= (MDICREATESTRUCTW
*)lparam
;
691 push_data( data
, cs
, sizeof(*cs
) );
692 if (HIWORD(cs
->szTitle
)) push_string( data
, cs
->szTitle
);
693 if (HIWORD(cs
->szClass
)) push_string( data
, cs
->szClass
);
696 case WM_MDIGETACTIVE
:
697 if (lparam
) return sizeof(BOOL
);
699 case WM_DEVICECHANGE
:
701 DEV_BROADCAST_HDR
*header
= (DEV_BROADCAST_HDR
*)lparam
;
702 push_data( data
, header
, header
->dbch_size
);
705 case WM_WINE_SETWINDOWPOS
:
706 push_data( data
, (WINDOWPOS
*)lparam
, sizeof(WINDOWPOS
) );
708 case WM_WINE_KEYBOARD_LL_HOOK
:
710 struct hook_extra_info
*h_extra
= (struct hook_extra_info
*)lparam
;
711 push_data( data
, h_extra
, sizeof(*h_extra
) );
712 push_data( data
, (LPVOID
)h_extra
->lparam
, sizeof(KBDLLHOOKSTRUCT
) );
715 case WM_WINE_MOUSE_LL_HOOK
:
717 struct hook_extra_info
*h_extra
= (struct hook_extra_info
*)lparam
;
718 push_data( data
, h_extra
, sizeof(*h_extra
) );
719 push_data( data
, (LPVOID
)h_extra
->lparam
, sizeof(MSLLHOOKSTRUCT
) );
723 if (wparam
<= 1) return 0;
724 FIXME( "WM_NCPAINT hdc packing not supported yet\n" );
728 if (!wparam
) return 0;
731 /* these contain an HFONT */
734 /* these contain an HDC */
736 case WM_ICONERASEBKGND
:
737 case WM_CTLCOLORMSGBOX
:
738 case WM_CTLCOLOREDIT
:
739 case WM_CTLCOLORLISTBOX
:
742 case WM_CTLCOLORSCROLLBAR
:
743 case WM_CTLCOLORSTATIC
:
746 /* these contain an HGLOBAL */
747 case WM_PAINTCLIPBOARD
:
748 case WM_SIZECLIPBOARD
:
749 /* these contain HICON */
752 case WM_QUERYDRAGICON
:
753 case WM_QUERYPARKICON
:
754 /* these contain pointers */
756 case WM_QUERYDROPOBJECT
:
760 FIXME( "msg %x (%s) not supported yet\n", message
, SPY_GetMsgName(message
, hwnd
) );
768 /***********************************************************************
771 * Unpack a message received from another process.
773 static BOOL
unpack_message( HWND hwnd
, UINT message
, WPARAM
*wparam
, LPARAM
*lparam
,
774 void **buffer
, size_t size
)
783 CREATESTRUCTW
*cs
= *buffer
;
784 WCHAR
*str
= (WCHAR
*)(cs
+ 1);
785 if (size
< sizeof(*cs
)) return FALSE
;
787 if (HIWORD(cs
->lpszName
))
789 if (!check_string( str
, size
)) return FALSE
;
791 size
-= (strlenW(str
) + 1) * sizeof(WCHAR
);
792 str
+= strlenW(str
) + 1;
794 if (HIWORD(cs
->lpszClass
))
796 if (!check_string( str
, size
)) return FALSE
;
802 case WM_ASKCBFORMATNAME
:
803 if (!get_buffer_space( buffer
, (*wparam
* sizeof(WCHAR
)) )) return FALSE
;
805 case WM_WININICHANGE
:
806 if (!*lparam
) return TRUE
;
809 case WM_DEVMODECHANGE
:
814 if (!check_string( *buffer
, size
)) return FALSE
;
816 case WM_GETMINMAXINFO
:
817 minsize
= sizeof(MINMAXINFO
);
820 minsize
= sizeof(DRAWITEMSTRUCT
);
823 minsize
= sizeof(MEASUREITEMSTRUCT
);
826 minsize
= sizeof(DELETEITEMSTRUCT
);
829 minsize
= sizeof(COMPAREITEMSTRUCT
);
831 case WM_WINDOWPOSCHANGING
:
832 case WM_WINDOWPOSCHANGED
:
833 case WM_WINE_SETWINDOWPOS
:
834 minsize
= sizeof(WINDOWPOS
);
838 COPYDATASTRUCT
*cp
= *buffer
;
839 if (size
< sizeof(*cp
)) return FALSE
;
842 minsize
= sizeof(*cp
) + cp
->cbData
;
848 /* WM_NOTIFY cannot be sent across processes (MSDN) */
851 minsize
= sizeof(HELPINFO
);
853 case WM_STYLECHANGING
:
854 case WM_STYLECHANGED
:
855 minsize
= sizeof(STYLESTRUCT
);
858 if (!*wparam
) minsize
= sizeof(RECT
);
861 NCCALCSIZE_PARAMS
*nc
= *buffer
;
862 if (size
< sizeof(*nc
) + sizeof(*nc
->lppos
)) return FALSE
;
863 nc
->lppos
= (WINDOWPOS
*)(nc
+ 1);
867 if (!*lparam
) return TRUE
;
868 minsize
= sizeof(MSG
);
870 case SBM_SETSCROLLINFO
:
871 minsize
= sizeof(SCROLLINFO
);
873 case SBM_GETSCROLLINFO
:
874 if (!get_buffer_space( buffer
, sizeof(SCROLLINFO
))) return FALSE
;
876 case SBM_GETSCROLLBARINFO
:
877 if (!get_buffer_space( buffer
, sizeof(SCROLLBARINFO
))) return FALSE
;
882 if (*wparam
|| *lparam
)
884 if (!get_buffer_space( buffer
, 2*sizeof(DWORD
) )) return FALSE
;
885 if (*wparam
) *wparam
= (WPARAM
)*buffer
;
886 if (*lparam
) *lparam
= (LPARAM
)((DWORD
*)*buffer
+ 1);
891 case CB_GETDROPPEDCONTROLRECT
:
892 if (!get_buffer_space( buffer
, sizeof(RECT
) )) return FALSE
;
896 minsize
= sizeof(RECT
);
901 if (size
< sizeof(WORD
)) return FALSE
;
902 len
= *(WORD
*)*buffer
;
903 if (!get_buffer_space( buffer
, (len
+ 1) * sizeof(WCHAR
) )) return FALSE
;
904 *lparam
= (LPARAM
)*buffer
+ sizeof(WORD
); /* don't erase WORD at start of buffer */
909 if (!*wparam
) return TRUE
;
910 minsize
= *wparam
* sizeof(UINT
);
913 case CB_INSERTSTRING
:
915 case CB_FINDSTRINGEXACT
:
916 case CB_SELECTSTRING
:
918 case LB_INSERTSTRING
:
920 case LB_FINDSTRINGEXACT
:
921 case LB_SELECTSTRING
:
922 if (!*buffer
) return TRUE
;
923 if (!check_string( *buffer
, size
)) return FALSE
;
927 size
= sizeof(ULONG_PTR
);
928 if (combobox_has_strings( hwnd
))
929 size
= (SendMessageW( hwnd
, CB_GETLBTEXTLEN
, *wparam
, 0 ) + 1) * sizeof(WCHAR
);
930 if (!get_buffer_space( buffer
, size
)) return FALSE
;
935 size
= sizeof(ULONG_PTR
);
936 if (listbox_has_strings( hwnd
))
937 size
= (SendMessageW( hwnd
, LB_GETTEXTLEN
, *wparam
, 0 ) + 1) * sizeof(WCHAR
);
938 if (!get_buffer_space( buffer
, size
)) return FALSE
;
942 if (!get_buffer_space( buffer
, *wparam
* sizeof(UINT
) )) return FALSE
;
945 minsize
= sizeof(MDINEXTMENU
);
946 if (!get_buffer_space( buffer
, sizeof(MDINEXTMENU
) )) return FALSE
;
950 minsize
= sizeof(RECT
);
951 if (!get_buffer_space( buffer
, sizeof(RECT
) )) return FALSE
;
955 MDICREATESTRUCTW
*cs
= *buffer
;
956 WCHAR
*str
= (WCHAR
*)(cs
+ 1);
957 if (size
< sizeof(*cs
)) return FALSE
;
959 if (HIWORD(cs
->szTitle
))
961 if (!check_string( str
, size
)) return FALSE
;
963 size
-= (strlenW(str
) + 1) * sizeof(WCHAR
);
964 str
+= strlenW(str
) + 1;
966 if (HIWORD(cs
->szClass
))
968 if (!check_string( str
, size
)) return FALSE
;
973 case WM_MDIGETACTIVE
:
974 if (!*lparam
) return TRUE
;
975 if (!get_buffer_space( buffer
, sizeof(BOOL
) )) return FALSE
;
977 case WM_DEVICECHANGE
:
978 minsize
= sizeof(DEV_BROADCAST_HDR
);
980 case WM_WINE_KEYBOARD_LL_HOOK
:
981 case WM_WINE_MOUSE_LL_HOOK
:
983 struct hook_extra_info
*h_extra
= (struct hook_extra_info
*)*buffer
;
985 minsize
= sizeof(struct hook_extra_info
) +
986 (message
== WM_WINE_KEYBOARD_LL_HOOK
? sizeof(KBDLLHOOKSTRUCT
)
987 : sizeof(MSLLHOOKSTRUCT
));
988 if (size
< minsize
) return FALSE
;
989 h_extra
->lparam
= (LPARAM
)(h_extra
+ 1);
993 if (*wparam
<= 1) return TRUE
;
994 FIXME( "WM_NCPAINT hdc unpacking not supported\n" );
997 if (!*wparam
) return TRUE
;
1000 /* these contain an HFONT */
1003 /* these contain an HDC */
1005 case WM_ICONERASEBKGND
:
1006 case WM_CTLCOLORMSGBOX
:
1007 case WM_CTLCOLOREDIT
:
1008 case WM_CTLCOLORLISTBOX
:
1009 case WM_CTLCOLORBTN
:
1010 case WM_CTLCOLORDLG
:
1011 case WM_CTLCOLORSCROLLBAR
:
1012 case WM_CTLCOLORSTATIC
:
1014 case WM_PRINTCLIENT
:
1015 /* these contain an HGLOBAL */
1016 case WM_PAINTCLIPBOARD
:
1017 case WM_SIZECLIPBOARD
:
1018 /* these contain HICON */
1021 case WM_QUERYDRAGICON
:
1022 case WM_QUERYPARKICON
:
1023 /* these contain pointers */
1025 case WM_QUERYDROPOBJECT
:
1029 FIXME( "msg %x (%s) not supported yet\n", message
, SPY_GetMsgName(message
, hwnd
) );
1033 return TRUE
; /* message doesn't need any unpacking */
1036 /* default exit for most messages: check minsize and store buffer in lparam */
1037 if (size
< minsize
) return FALSE
;
1038 *lparam
= (LPARAM
)*buffer
;
1043 /***********************************************************************
1046 * Pack a reply to a message for sending to another process.
1048 static void pack_reply( HWND hwnd
, UINT message
, WPARAM wparam
, LPARAM lparam
,
1049 LRESULT res
, struct packed_message
*data
)
1056 push_data( data
, (CREATESTRUCTW
*)lparam
, sizeof(CREATESTRUCTW
) );
1061 push_data( data
, (WCHAR
*)lparam
, (res
+ 1) * sizeof(WCHAR
) );
1063 case WM_GETMINMAXINFO
:
1064 push_data( data
, (MINMAXINFO
*)lparam
, sizeof(MINMAXINFO
) );
1066 case WM_MEASUREITEM
:
1067 push_data( data
, (MEASUREITEMSTRUCT
*)lparam
, sizeof(MEASUREITEMSTRUCT
) );
1069 case WM_WINDOWPOSCHANGING
:
1070 case WM_WINDOWPOSCHANGED
:
1071 push_data( data
, (WINDOWPOS
*)lparam
, sizeof(WINDOWPOS
) );
1074 if (lparam
) push_data( data
, (MSG
*)lparam
, sizeof(MSG
) );
1076 case SBM_GETSCROLLINFO
:
1077 push_data( data
, (SCROLLINFO
*)lparam
, sizeof(SCROLLINFO
) );
1080 case LB_GETITEMRECT
:
1081 case CB_GETDROPPEDCONTROLRECT
:
1084 push_data( data
, (RECT
*)lparam
, sizeof(RECT
) );
1088 WORD
*ptr
= (WORD
*)lparam
;
1089 push_data( data
, ptr
, ptr
[-1] * sizeof(WCHAR
) );
1092 case LB_GETSELITEMS
:
1093 push_data( data
, (UINT
*)lparam
, wparam
* sizeof(UINT
) );
1095 case WM_MDIGETACTIVE
:
1096 if (lparam
) push_data( data
, (BOOL
*)lparam
, sizeof(BOOL
) );
1100 push_data( data
, (RECT
*)lparam
, sizeof(RECT
) );
1103 NCCALCSIZE_PARAMS
*nc
= (NCCALCSIZE_PARAMS
*)lparam
;
1104 push_data( data
, nc
, sizeof(*nc
) );
1105 push_data( data
, nc
->lppos
, sizeof(*nc
->lppos
) );
1111 if (wparam
) push_data( data
, (DWORD
*)wparam
, sizeof(DWORD
) );
1112 if (lparam
) push_data( data
, (DWORD
*)lparam
, sizeof(DWORD
) );
1115 push_data( data
, (MDINEXTMENU
*)lparam
, sizeof(MDINEXTMENU
) );
1118 push_data( data
, (MDICREATESTRUCTW
*)lparam
, sizeof(MDICREATESTRUCTW
) );
1120 case WM_ASKCBFORMATNAME
:
1121 push_data( data
, (WCHAR
*)lparam
, (strlenW((WCHAR
*)lparam
) + 1) * sizeof(WCHAR
) );
1127 /***********************************************************************
1130 * Unpack a message reply received from another process.
1132 static void unpack_reply( HWND hwnd
, UINT message
, WPARAM wparam
, LPARAM lparam
,
1133 void *buffer
, size_t size
)
1140 CREATESTRUCTW
*cs
= (CREATESTRUCTW
*)lparam
;
1141 LPCWSTR name
= cs
->lpszName
, class = cs
->lpszClass
;
1142 memcpy( cs
, buffer
, min( sizeof(*cs
), size
));
1143 cs
->lpszName
= name
; /* restore the original pointers */
1144 cs
->lpszClass
= class;
1148 case WM_ASKCBFORMATNAME
:
1149 memcpy( (WCHAR
*)lparam
, buffer
, min( wparam
*sizeof(WCHAR
), size
));
1151 case WM_GETMINMAXINFO
:
1152 memcpy( (MINMAXINFO
*)lparam
, buffer
, min( sizeof(MINMAXINFO
), size
));
1154 case WM_MEASUREITEM
:
1155 memcpy( (MEASUREITEMSTRUCT
*)lparam
, buffer
, min( sizeof(MEASUREITEMSTRUCT
), size
));
1157 case WM_WINDOWPOSCHANGING
:
1158 case WM_WINDOWPOSCHANGED
:
1159 memcpy( (WINDOWPOS
*)lparam
, buffer
, min( sizeof(WINDOWPOS
), size
));
1162 if (lparam
) memcpy( (MSG
*)lparam
, buffer
, min( sizeof(MSG
), size
));
1164 case SBM_GETSCROLLINFO
:
1165 memcpy( (SCROLLINFO
*)lparam
, buffer
, min( sizeof(SCROLLINFO
), size
));
1167 case SBM_GETSCROLLBARINFO
:
1168 memcpy( (SCROLLBARINFO
*)lparam
, buffer
, min( sizeof(SCROLLBARINFO
), size
));
1171 case CB_GETDROPPEDCONTROLRECT
:
1172 case LB_GETITEMRECT
:
1175 memcpy( (RECT
*)lparam
, buffer
, min( sizeof(RECT
), size
));
1178 size
= min( size
, (size_t)*(WORD
*)lparam
);
1179 memcpy( (WCHAR
*)lparam
, buffer
, size
);
1181 case LB_GETSELITEMS
:
1182 memcpy( (UINT
*)lparam
, buffer
, min( wparam
*sizeof(UINT
), size
));
1186 memcpy( (WCHAR
*)lparam
, buffer
, size
);
1189 memcpy( (MDINEXTMENU
*)lparam
, buffer
, min( sizeof(MDINEXTMENU
), size
));
1191 case WM_MDIGETACTIVE
:
1192 if (lparam
) memcpy( (BOOL
*)lparam
, buffer
, min( sizeof(BOOL
), size
));
1196 memcpy( (RECT
*)lparam
, buffer
, min( sizeof(RECT
), size
));
1199 NCCALCSIZE_PARAMS
*nc
= (NCCALCSIZE_PARAMS
*)lparam
;
1200 WINDOWPOS
*wp
= nc
->lppos
;
1201 memcpy( nc
, buffer
, min( sizeof(*nc
), size
));
1202 if (size
> sizeof(*nc
))
1204 size
-= sizeof(*nc
);
1205 memcpy( wp
, (NCCALCSIZE_PARAMS
*)buffer
+ 1, min( sizeof(*wp
), size
));
1207 nc
->lppos
= wp
; /* restore the original pointer */
1215 memcpy( (DWORD
*)wparam
, buffer
, min( sizeof(DWORD
), size
));
1216 if (size
<= sizeof(DWORD
)) break;
1217 size
-= sizeof(DWORD
);
1218 buffer
= (DWORD
*)buffer
+ 1;
1220 if (lparam
) memcpy( (DWORD
*)lparam
, buffer
, min( sizeof(DWORD
), size
));
1224 MDICREATESTRUCTW
*cs
= (MDICREATESTRUCTW
*)lparam
;
1225 LPCWSTR title
= cs
->szTitle
, class = cs
->szClass
;
1226 memcpy( cs
, buffer
, min( sizeof(*cs
), size
));
1227 cs
->szTitle
= title
; /* restore the original pointers */
1228 cs
->szClass
= class;
1232 ERR( "should not happen: unexpected message %x\n", message
);
1238 /***********************************************************************
1241 * Send a reply to a sent message.
1243 static void reply_message( struct received_message_info
*info
, LRESULT result
, BOOL remove
)
1245 struct packed_message data
;
1246 int i
, replied
= info
->flags
& ISMEX_REPLIED
;
1248 if (info
->flags
& ISMEX_NOTIFY
) return; /* notify messages don't get replies */
1249 if (!remove
&& replied
) return; /* replied already */
1252 info
->flags
|= ISMEX_REPLIED
;
1254 if (info
->type
== MSG_OTHER_PROCESS
&& !replied
)
1256 pack_reply( info
->msg
.hwnd
, info
->msg
.message
, info
->msg
.wParam
,
1257 info
->msg
.lParam
, result
, &data
);
1260 SERVER_START_REQ( reply_message
)
1262 req
->result
= result
;
1263 req
->remove
= remove
;
1264 for (i
= 0; i
< data
.count
; i
++) wine_server_add_data( req
, data
.data
[i
], data
.size
[i
] );
1265 wine_server_call( req
);
1271 /***********************************************************************
1272 * handle_internal_message
1274 * Handle an internal Wine message instead of calling the window proc.
1276 static LRESULT
handle_internal_message( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
1280 case WM_WINE_DESTROYWINDOW
:
1281 return WIN_DestroyWindow( hwnd
);
1282 case WM_WINE_SETWINDOWPOS
:
1283 if (is_desktop_window( hwnd
)) return 0;
1284 return USER_SetWindowPos( (WINDOWPOS
*)lparam
);
1285 case WM_WINE_SHOWWINDOW
:
1286 if (is_desktop_window( hwnd
)) return 0;
1287 return ShowWindow( hwnd
, wparam
);
1288 case WM_WINE_SETPARENT
:
1289 if (is_desktop_window( hwnd
)) return 0;
1290 return (LRESULT
)SetParent( hwnd
, (HWND
)wparam
);
1291 case WM_WINE_SETWINDOWLONG
:
1292 return WIN_SetWindowLong( hwnd
, (short)LOWORD(wparam
), HIWORD(wparam
), lparam
, TRUE
);
1293 case WM_WINE_ENABLEWINDOW
:
1294 if (is_desktop_window( hwnd
)) return 0;
1295 return EnableWindow( hwnd
, wparam
);
1296 case WM_WINE_SETACTIVEWINDOW
:
1297 if (is_desktop_window( hwnd
)) return 0;
1298 return (LRESULT
)SetActiveWindow( (HWND
)wparam
);
1299 case WM_WINE_KEYBOARD_LL_HOOK
:
1300 case WM_WINE_MOUSE_LL_HOOK
:
1302 struct hook_extra_info
*h_extra
= (struct hook_extra_info
*)lparam
;
1304 return call_current_hook( h_extra
->handle
, HC_ACTION
, wparam
, h_extra
->lparam
);
1307 if (msg
>= WM_WINE_FIRST_DRIVER_MSG
&& msg
<= WM_WINE_LAST_DRIVER_MSG
)
1308 return USER_Driver
->pWindowMessage( hwnd
, msg
, wparam
, lparam
);
1309 FIXME( "unknown internal message %x\n", msg
);
1314 /* since the WM_DDE_ACK response to a WM_DDE_EXECUTE message should contain the handle
1315 * to the memory handle, we keep track (in the server side) of all pairs of handle
1316 * used (the client passes its value and the content of the memory handle), and
1317 * the server stored both values (the client, and the local one, created after the
1318 * content). When a ACK message is generated, the list of pair is searched for a
1319 * matching pair, so that the client memory handle can be returned.
1322 HGLOBAL client_hMem
;
1323 HGLOBAL server_hMem
;
1326 static struct DDE_pair
* dde_pairs
;
1327 static int dde_num_alloc
;
1328 static int dde_num_used
;
1330 static CRITICAL_SECTION dde_crst
;
1331 static CRITICAL_SECTION_DEBUG critsect_debug
=
1334 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
1335 0, 0, { (DWORD_PTR
)(__FILE__
": dde_crst") }
1337 static CRITICAL_SECTION dde_crst
= { &critsect_debug
, -1, 0, 0, 0, 0 };
1339 static BOOL
dde_add_pair(HGLOBAL chm
, HGLOBAL shm
)
1344 EnterCriticalSection(&dde_crst
);
1346 /* now remember the pair of hMem on both sides */
1347 if (dde_num_used
== dde_num_alloc
)
1349 struct DDE_pair
* tmp
;
1351 tmp
= HeapReAlloc( GetProcessHeap(), 0, dde_pairs
,
1352 (dde_num_alloc
+ GROWBY
) * sizeof(struct DDE_pair
));
1354 tmp
= HeapAlloc( GetProcessHeap(), 0,
1355 (dde_num_alloc
+ GROWBY
) * sizeof(struct DDE_pair
));
1359 LeaveCriticalSection(&dde_crst
);
1363 /* zero out newly allocated part */
1364 memset(&dde_pairs
[dde_num_alloc
], 0, GROWBY
* sizeof(struct DDE_pair
));
1365 dde_num_alloc
+= GROWBY
;
1368 for (i
= 0; i
< dde_num_alloc
; i
++)
1370 if (dde_pairs
[i
].server_hMem
== 0)
1372 dde_pairs
[i
].client_hMem
= chm
;
1373 dde_pairs
[i
].server_hMem
= shm
;
1378 LeaveCriticalSection(&dde_crst
);
1382 static HGLOBAL
dde_get_pair(HGLOBAL shm
)
1387 EnterCriticalSection(&dde_crst
);
1388 for (i
= 0; i
< dde_num_alloc
; i
++)
1390 if (dde_pairs
[i
].server_hMem
== shm
)
1392 /* free this pair */
1393 dde_pairs
[i
].server_hMem
= 0;
1395 ret
= dde_pairs
[i
].client_hMem
;
1399 LeaveCriticalSection(&dde_crst
);
1403 /***********************************************************************
1406 * Post a DDE message
1408 static BOOL
post_dde_message( struct packed_message
*data
, const struct send_message_info
*info
)
1412 UINT_PTR uiLo
, uiHi
;
1414 HGLOBAL hunlock
= 0;
1418 if (!UnpackDDElParam( info
->msg
, info
->lparam
, &uiLo
, &uiHi
))
1424 /* DDE messages which don't require packing are:
1433 /* uiHi should contain a hMem from WM_DDE_EXECUTE */
1434 HGLOBAL h
= dde_get_pair( (HANDLE
)uiHi
);
1437 /* send back the value of h on the other side */
1438 push_data( data
, &h
, sizeof(HGLOBAL
) );
1440 TRACE( "send dde-ack %lx %08lx => %p\n", uiLo
, uiHi
, h
);
1445 /* uiHi should contain either an atom or 0 */
1446 TRACE( "send dde-ack %lx atom=%lx\n", uiLo
, uiHi
);
1447 lp
= MAKELONG( uiLo
, uiHi
);
1456 size
= GlobalSize( (HGLOBAL
)uiLo
) ;
1457 if ((info
->msg
== WM_DDE_ADVISE
&& size
< sizeof(DDEADVISE
)) ||
1458 (info
->msg
== WM_DDE_DATA
&& size
< FIELD_OFFSET(DDEDATA
, Value
)) ||
1459 (info
->msg
== WM_DDE_POKE
&& size
< FIELD_OFFSET(DDEPOKE
, Value
))
1463 else if (info
->msg
!= WM_DDE_DATA
) return FALSE
;
1468 if ((ptr
= GlobalLock( (HGLOBAL
)uiLo
) ))
1470 DDEDATA
*dde_data
= (DDEDATA
*)ptr
;
1471 TRACE("unused %d, fResponse %d, fRelease %d, fDeferUpd %d, fAckReq %d, cfFormat %d\n",
1472 dde_data
->unused
, dde_data
->fResponse
, dde_data
->fRelease
,
1473 dde_data
->reserved
, dde_data
->fAckReq
, dde_data
->cfFormat
);
1474 push_data( data
, ptr
, size
);
1475 hunlock
= (HGLOBAL
)uiLo
;
1478 TRACE( "send ddepack %u %lx\n", size
, uiHi
);
1480 case WM_DDE_EXECUTE
:
1483 if ((ptr
= GlobalLock( (HGLOBAL
)info
->lparam
) ))
1485 push_data(data
, ptr
, GlobalSize( (HGLOBAL
)info
->lparam
));
1486 /* so that the other side can send it back on ACK */
1488 hunlock
= (HGLOBAL
)info
->lparam
;
1493 SERVER_START_REQ( send_message
)
1495 req
->id
= info
->dest_tid
;
1496 req
->type
= info
->type
;
1498 req
->win
= info
->hwnd
;
1499 req
->msg
= info
->msg
;
1500 req
->wparam
= info
->wparam
;
1502 req
->timeout
= TIMEOUT_INFINITE
;
1503 for (i
= 0; i
< data
->count
; i
++)
1504 wine_server_add_data( req
, data
->data
[i
], data
->size
[i
] );
1505 if ((res
= wine_server_call( req
)))
1507 if (res
== STATUS_INVALID_PARAMETER
)
1508 /* FIXME: find a STATUS_ value for this one */
1509 SetLastError( ERROR_INVALID_THREAD_ID
);
1511 SetLastError( RtlNtStatusToDosError(res
) );
1514 FreeDDElParam(info
->msg
, info
->lparam
);
1517 if (hunlock
) GlobalUnlock(hunlock
);
1522 /***********************************************************************
1523 * unpack_dde_message
1525 * Unpack a posted DDE message received from another process.
1527 static BOOL
unpack_dde_message( HWND hwnd
, UINT message
, WPARAM
*wparam
, LPARAM
*lparam
,
1528 void **buffer
, size_t size
)
1530 UINT_PTR uiLo
, uiHi
;
1539 /* hMem is being passed */
1540 if (size
!= sizeof(HGLOBAL
)) return FALSE
;
1541 if (!buffer
|| !*buffer
) return FALSE
;
1543 memcpy( &hMem
, *buffer
, size
);
1544 uiHi
= (UINT_PTR
)hMem
;
1545 TRACE("recv dde-ack %lx mem=%lx[%lx]\n", uiLo
, uiHi
, GlobalSize( hMem
));
1549 uiLo
= LOWORD( *lparam
);
1550 uiHi
= HIWORD( *lparam
);
1551 TRACE("recv dde-ack %lx atom=%lx\n", uiLo
, uiHi
);
1553 *lparam
= PackDDElParam( WM_DDE_ACK
, uiLo
, uiHi
);
1558 if ((!buffer
|| !*buffer
) && message
!= WM_DDE_DATA
) return FALSE
;
1562 if (!(hMem
= GlobalAlloc( GMEM_MOVEABLE
|GMEM_DDESHARE
, size
)))
1564 if ((ptr
= GlobalLock( hMem
)))
1566 memcpy( ptr
, *buffer
, size
);
1567 GlobalUnlock( hMem
);
1575 uiLo
= (UINT_PTR
)hMem
;
1577 *lparam
= PackDDElParam( message
, uiLo
, uiHi
);
1579 case WM_DDE_EXECUTE
:
1582 if (!buffer
|| !*buffer
) return FALSE
;
1583 if (!(hMem
= GlobalAlloc( GMEM_MOVEABLE
|GMEM_DDESHARE
, size
))) return FALSE
;
1584 if ((ptr
= GlobalLock( hMem
)))
1586 memcpy( ptr
, *buffer
, size
);
1587 GlobalUnlock( hMem
);
1588 TRACE( "exec: pairing c=%08lx s=%p\n", *lparam
, hMem
);
1589 if (!dde_add_pair( (HGLOBAL
)*lparam
, hMem
))
1600 } else return FALSE
;
1601 *lparam
= (LPARAM
)hMem
;
1607 /***********************************************************************
1610 * Call a window procedure and the corresponding hooks.
1612 static LRESULT
call_window_proc( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
,
1613 BOOL unicode
, BOOL same_thread
, enum wm_char_mapping mapping
)
1617 CWPRETSTRUCT cwpret
;
1619 if (msg
& 0x80000000)
1621 result
= handle_internal_message( hwnd
, msg
, wparam
, lparam
);
1625 /* first the WH_CALLWNDPROC hook */
1626 hwnd
= WIN_GetFullHandle( hwnd
);
1627 cwp
.lParam
= lparam
;
1628 cwp
.wParam
= wparam
;
1631 HOOK_CallHooks( WH_CALLWNDPROC
, HC_ACTION
, same_thread
, (LPARAM
)&cwp
, unicode
);
1633 /* now call the window procedure */
1634 if (!WINPROC_call_window( hwnd
, msg
, wparam
, lparam
, &result
, unicode
, mapping
)) goto done
;
1636 /* and finally the WH_CALLWNDPROCRET hook */
1637 cwpret
.lResult
= result
;
1638 cwpret
.lParam
= lparam
;
1639 cwpret
.wParam
= wparam
;
1640 cwpret
.message
= msg
;
1642 HOOK_CallHooks( WH_CALLWNDPROCRET
, HC_ACTION
, same_thread
, (LPARAM
)&cwpret
, unicode
);
1648 /***********************************************************************
1649 * send_parent_notify
1651 * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
1652 * the window has the WS_EX_NOPARENTNOTIFY style.
1654 static void send_parent_notify( HWND hwnd
, WORD event
, WORD idChild
, POINT pt
)
1656 /* pt has to be in the client coordinates of the parent window */
1657 MapWindowPoints( 0, hwnd
, &pt
, 1 );
1662 if (!(GetWindowLongW( hwnd
, GWL_STYLE
) & WS_CHILD
)) break;
1663 if (GetWindowLongW( hwnd
, GWL_EXSTYLE
) & WS_EX_NOPARENTNOTIFY
) break;
1664 if (!(parent
= GetParent(hwnd
))) break;
1665 if (parent
== GetDesktopWindow()) break;
1666 MapWindowPoints( hwnd
, parent
, &pt
, 1 );
1668 SendMessageW( hwnd
, WM_PARENTNOTIFY
,
1669 MAKEWPARAM( event
, idChild
), MAKELPARAM( pt
.x
, pt
.y
) );
1674 /***********************************************************************
1675 * accept_hardware_message
1677 * Tell the server we have passed the message to the app
1678 * (even though we may end up dropping it later on)
1680 static void accept_hardware_message( UINT hw_id
, BOOL remove
, HWND new_hwnd
)
1682 SERVER_START_REQ( accept_hardware_message
)
1685 req
->remove
= remove
;
1686 req
->new_win
= new_hwnd
;
1687 if (wine_server_call( req
))
1688 FIXME("Failed to reply to MSG_HARDWARE message. Message may not be removed from queue.\n");
1694 /***********************************************************************
1695 * process_keyboard_message
1697 * returns TRUE if the contents of 'msg' should be passed to the application
1699 static BOOL
process_keyboard_message( MSG
*msg
, UINT hw_id
, HWND hwnd_filter
,
1700 UINT first
, UINT last
, BOOL remove
)
1704 if (msg
->message
== WM_KEYDOWN
|| msg
->message
== WM_SYSKEYDOWN
||
1705 msg
->message
== WM_KEYUP
|| msg
->message
== WM_SYSKEYUP
)
1706 switch (msg
->wParam
)
1708 case VK_LSHIFT
: case VK_RSHIFT
:
1709 msg
->wParam
= VK_SHIFT
;
1711 case VK_LCONTROL
: case VK_RCONTROL
:
1712 msg
->wParam
= VK_CONTROL
;
1714 case VK_LMENU
: case VK_RMENU
:
1715 msg
->wParam
= VK_MENU
;
1719 /* FIXME: is this really the right place for this hook? */
1720 event
.message
= msg
->message
;
1721 event
.hwnd
= msg
->hwnd
;
1722 event
.time
= msg
->time
;
1723 event
.paramL
= (msg
->wParam
& 0xFF) | (HIWORD(msg
->lParam
) << 8);
1724 event
.paramH
= msg
->lParam
& 0x7FFF;
1725 if (HIWORD(msg
->lParam
) & 0x0100) event
.paramH
|= 0x8000; /* special_key - bit */
1726 HOOK_CallHooks( WH_JOURNALRECORD
, HC_ACTION
, 0, (LPARAM
)&event
, TRUE
);
1728 /* check message filters */
1729 if (msg
->message
< first
|| msg
->message
> last
) return FALSE
;
1730 if (!check_hwnd_filter( msg
, hwnd_filter
)) return FALSE
;
1734 if((msg
->message
== WM_KEYDOWN
) &&
1735 (msg
->hwnd
!= GetDesktopWindow()))
1737 /* Handle F1 key by sending out WM_HELP message */
1738 if (msg
->wParam
== VK_F1
)
1740 PostMessageW( msg
->hwnd
, WM_KEYF1
, 0, 0 );
1742 else if(msg
->wParam
>= VK_BROWSER_BACK
&&
1743 msg
->wParam
<= VK_LAUNCH_APP2
)
1745 /* FIXME: Process keystate */
1746 SendMessageW(msg
->hwnd
, WM_APPCOMMAND
, (WPARAM
)msg
->hwnd
, MAKELPARAM(0, (FAPPCOMMAND_KEY
| (msg
->wParam
- VK_BROWSER_BACK
+ 1))));
1749 else if (msg
->message
== WM_KEYUP
)
1751 /* Handle VK_APPS key by posting a WM_CONTEXTMENU message */
1752 if (msg
->wParam
== VK_APPS
&& !MENU_IsMenuActive())
1753 PostMessageW(msg
->hwnd
, WM_CONTEXTMENU
, (WPARAM
)msg
->hwnd
, (LPARAM
)-1);
1757 if (HOOK_CallHooks( WH_KEYBOARD
, remove
? HC_ACTION
: HC_NOREMOVE
,
1758 LOWORD(msg
->wParam
), msg
->lParam
, TRUE
))
1760 /* skip this message */
1761 HOOK_CallHooks( WH_CBT
, HCBT_KEYSKIPPED
, LOWORD(msg
->wParam
), msg
->lParam
, TRUE
);
1762 accept_hardware_message( hw_id
, TRUE
, 0 );
1765 accept_hardware_message( hw_id
, remove
, 0 );
1767 if ( msg
->message
== WM_KEYDOWN
|| msg
->message
== WM_KEYUP
)
1768 if ( ImmProcessKey(msg
->hwnd
, GetKeyboardLayout(0), msg
->wParam
, msg
->lParam
, 0) )
1769 msg
->wParam
= VK_PROCESSKEY
;
1775 /***********************************************************************
1776 * process_mouse_message
1778 * returns TRUE if the contents of 'msg' should be passed to the application
1780 static BOOL
process_mouse_message( MSG
*msg
, UINT hw_id
, ULONG_PTR extra_info
, HWND hwnd_filter
,
1781 UINT first
, UINT last
, BOOL remove
)
1790 MOUSEHOOKSTRUCT hook
;
1793 /* find the window to dispatch this mouse message to */
1795 GetGUIThreadInfo( GetCurrentThreadId(), &info
);
1796 if (info
.hwndCapture
)
1799 msg
->hwnd
= info
.hwndCapture
;
1803 msg
->hwnd
= WINPOS_WindowFromPoint( msg
->hwnd
, msg
->pt
, &hittest
);
1806 if (!msg
->hwnd
|| !WIN_IsCurrentThread( msg
->hwnd
))
1808 accept_hardware_message( hw_id
, TRUE
, msg
->hwnd
);
1812 /* FIXME: is this really the right place for this hook? */
1813 event
.message
= msg
->message
;
1814 event
.time
= msg
->time
;
1815 event
.hwnd
= msg
->hwnd
;
1816 event
.paramL
= msg
->pt
.x
;
1817 event
.paramH
= msg
->pt
.y
;
1818 HOOK_CallHooks( WH_JOURNALRECORD
, HC_ACTION
, 0, (LPARAM
)&event
, TRUE
);
1820 if (!check_hwnd_filter( msg
, hwnd_filter
)) return FALSE
;
1823 message
= msg
->message
;
1824 /* Note: windows has no concept of a non-client wheel message */
1825 if (message
!= WM_MOUSEWHEEL
)
1827 if (hittest
!= HTCLIENT
)
1829 message
+= WM_NCMOUSEMOVE
- WM_MOUSEMOVE
;
1830 msg
->wParam
= hittest
;
1834 /* coordinates don't get translated while tracking a menu */
1835 /* FIXME: should differentiate popups and top-level menus */
1836 if (!(info
.flags
& GUI_INMENUMODE
))
1837 ScreenToClient( msg
->hwnd
, &pt
);
1840 msg
->lParam
= MAKELONG( pt
.x
, pt
.y
);
1842 /* translate double clicks */
1844 if ((msg
->message
== WM_LBUTTONDOWN
) ||
1845 (msg
->message
== WM_RBUTTONDOWN
) ||
1846 (msg
->message
== WM_MBUTTONDOWN
) ||
1847 (msg
->message
== WM_XBUTTONDOWN
))
1849 BOOL update
= remove
;
1851 /* translate double clicks -
1852 * note that ...MOUSEMOVEs can slip in between
1853 * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
1855 if ((info
.flags
& (GUI_INMENUMODE
|GUI_INMOVESIZE
)) ||
1856 hittest
!= HTCLIENT
||
1857 (GetClassLongA( msg
->hwnd
, GCL_STYLE
) & CS_DBLCLKS
))
1859 if ((msg
->message
== clk_msg
.message
) &&
1860 (msg
->hwnd
== clk_msg
.hwnd
) &&
1861 (msg
->wParam
== clk_msg
.wParam
) &&
1862 (msg
->time
- clk_msg
.time
< GetDoubleClickTime()) &&
1863 (abs(msg
->pt
.x
- clk_msg
.pt
.x
) < GetSystemMetrics(SM_CXDOUBLECLK
)/2) &&
1864 (abs(msg
->pt
.y
- clk_msg
.pt
.y
) < GetSystemMetrics(SM_CYDOUBLECLK
)/2))
1866 message
+= (WM_LBUTTONDBLCLK
- WM_LBUTTONDOWN
);
1869 clk_msg
.message
= 0; /* clear the double click conditions */
1874 if (message
< first
|| message
> last
) return FALSE
;
1875 /* update static double click conditions */
1876 if (update
) clk_msg
= *msg
;
1880 if (message
< first
|| message
> last
) return FALSE
;
1883 /* message is accepted now (but may still get dropped) */
1886 hook
.hwnd
= msg
->hwnd
;
1887 hook
.wHitTestCode
= hittest
;
1888 hook
.dwExtraInfo
= extra_info
;
1889 if (HOOK_CallHooks( WH_MOUSE
, remove
? HC_ACTION
: HC_NOREMOVE
,
1890 message
, (LPARAM
)&hook
, TRUE
))
1893 hook
.hwnd
= msg
->hwnd
;
1894 hook
.wHitTestCode
= hittest
;
1895 hook
.dwExtraInfo
= extra_info
;
1896 HOOK_CallHooks( WH_CBT
, HCBT_CLICKSKIPPED
, message
, (LPARAM
)&hook
, TRUE
);
1897 accept_hardware_message( hw_id
, TRUE
, 0 );
1901 if ((hittest
== HTERROR
) || (hittest
== HTNOWHERE
))
1903 SendMessageW( msg
->hwnd
, WM_SETCURSOR
, (WPARAM
)msg
->hwnd
,
1904 MAKELONG( hittest
, msg
->message
));
1905 accept_hardware_message( hw_id
, TRUE
, 0 );
1909 accept_hardware_message( hw_id
, remove
, 0 );
1911 if (!remove
|| info
.hwndCapture
)
1913 msg
->message
= message
;
1919 if ((msg
->message
== WM_LBUTTONDOWN
) ||
1920 (msg
->message
== WM_RBUTTONDOWN
) ||
1921 (msg
->message
== WM_MBUTTONDOWN
) ||
1922 (msg
->message
== WM_XBUTTONDOWN
))
1924 /* Send the WM_PARENTNOTIFY,
1925 * note that even for double/nonclient clicks
1926 * notification message is still WM_L/M/RBUTTONDOWN.
1928 send_parent_notify( msg
->hwnd
, msg
->message
, 0, msg
->pt
);
1930 /* Activate the window if needed */
1932 if (msg
->hwnd
!= info
.hwndActive
)
1934 HWND hwndTop
= msg
->hwnd
;
1937 if ((GetWindowLongW( hwndTop
, GWL_STYLE
) & (WS_POPUP
|WS_CHILD
)) != WS_CHILD
) break;
1938 hwndTop
= GetParent( hwndTop
);
1941 if (hwndTop
&& hwndTop
!= GetDesktopWindow())
1943 LONG ret
= SendMessageW( msg
->hwnd
, WM_MOUSEACTIVATE
, (WPARAM
)hwndTop
,
1944 MAKELONG( hittest
, msg
->message
) );
1947 case MA_NOACTIVATEANDEAT
:
1952 case MA_ACTIVATEANDEAT
:
1957 if (!FOCUS_MouseActivate( hwndTop
)) eatMsg
= TRUE
;
1960 WARN( "unknown WM_MOUSEACTIVATE code %d\n", ret
);
1967 /* send the WM_SETCURSOR message */
1969 /* Windows sends the normal mouse message as the message parameter
1970 in the WM_SETCURSOR message even if it's non-client mouse message */
1971 SendMessageW( msg
->hwnd
, WM_SETCURSOR
, (WPARAM
)msg
->hwnd
, MAKELONG( hittest
, msg
->message
));
1973 msg
->message
= message
;
1978 /***********************************************************************
1979 * process_hardware_message
1981 * Process a hardware message; return TRUE if message should be passed on to the app
1983 static BOOL
process_hardware_message( MSG
*msg
, UINT hw_id
, ULONG_PTR extra_info
, HWND hwnd_filter
,
1984 UINT first
, UINT last
, BOOL remove
)
1986 if (is_keyboard_message( msg
->message
))
1987 return process_keyboard_message( msg
, hw_id
, hwnd_filter
, first
, last
, remove
);
1989 if (is_mouse_message( msg
->message
))
1990 return process_mouse_message( msg
, hw_id
, extra_info
, hwnd_filter
, first
, last
, remove
);
1992 ERR( "unknown message type %x\n", msg
->message
);
1997 /***********************************************************************
1998 * call_sendmsg_callback
2000 * Call the callback function of SendMessageCallback.
2002 static inline void call_sendmsg_callback( SENDASYNCPROC callback
, HWND hwnd
, UINT msg
,
2003 ULONG_PTR data
, LRESULT result
)
2005 if (!callback
) return;
2007 if (TRACE_ON(relay
))
2008 DPRINTF( "%04x:Call message callback %p (hwnd=%p,msg=%s,data=%08lx,result=%08lx)\n",
2009 GetCurrentThreadId(), callback
, hwnd
, SPY_GetMsgName( msg
, hwnd
),
2011 callback( hwnd
, msg
, data
, result
);
2012 if (TRACE_ON(relay
))
2013 DPRINTF( "%04x:Ret message callback %p (hwnd=%p,msg=%s,data=%08lx,result=%08lx)\n",
2014 GetCurrentThreadId(), callback
, hwnd
, SPY_GetMsgName( msg
, hwnd
),
2019 /***********************************************************************
2022 * Peek for a message matching the given parameters. Return FALSE if none available.
2023 * All pending sent messages are processed before returning.
2025 static BOOL
peek_message( MSG
*msg
, HWND hwnd
, UINT first
, UINT last
, UINT flags
)
2028 ULONG_PTR extra_info
= 0;
2029 struct user_thread_info
*thread_info
= get_user_thread_info();
2030 struct received_message_info info
, *old_info
;
2031 unsigned int wake_mask
, changed_mask
= HIWORD(flags
);
2032 unsigned int hw_id
= 0; /* id of previous hardware message */
2034 if (!first
&& !last
) last
= ~0;
2035 if (!changed_mask
) changed_mask
= QS_ALLINPUT
;
2036 wake_mask
= changed_mask
& (QS_SENDMESSAGE
| QS_SMRESULT
);
2041 void *buffer
= NULL
;
2042 size_t size
= 0, buffer_size
= 0;
2044 do /* loop while buffer is too small */
2046 if (buffer_size
&& !(buffer
= HeapAlloc( GetProcessHeap(), 0, buffer_size
)))
2048 SERVER_START_REQ( get_message
)
2051 req
->get_win
= hwnd
;
2052 req
->get_first
= first
;
2053 req
->get_last
= last
;
2055 req
->wake_mask
= wake_mask
;
2056 req
->changed_mask
= changed_mask
;
2057 if (buffer_size
) wine_server_set_reply( req
, buffer
, buffer_size
);
2058 if (!(res
= wine_server_call( req
)))
2060 size
= wine_server_reply_size( reply
);
2061 info
.type
= reply
->type
;
2062 info
.msg
.hwnd
= reply
->win
;
2063 info
.msg
.message
= reply
->msg
;
2064 info
.msg
.wParam
= reply
->wparam
;
2065 info
.msg
.lParam
= reply
->lparam
;
2066 info
.msg
.time
= reply
->time
;
2067 info
.msg
.pt
.x
= reply
->x
;
2068 info
.msg
.pt
.y
= reply
->y
;
2069 hw_id
= reply
->hw_id
;
2070 extra_info
= reply
->info
;
2071 thread_info
->active_hooks
= reply
->active_hooks
;
2075 HeapFree( GetProcessHeap(), 0, buffer
);
2076 buffer_size
= reply
->total
;
2080 } while (res
== STATUS_BUFFER_OVERFLOW
);
2082 if (res
) return FALSE
;
2084 TRACE( "got type %d msg %x (%s) hwnd %p wp %lx lp %lx\n",
2085 info
.type
, info
.msg
.message
,
2086 (info
.type
== MSG_WINEVENT
) ? "MSG_WINEVENT" : SPY_GetMsgName(info
.msg
.message
, info
.msg
.hwnd
),
2087 info
.msg
.hwnd
, info
.msg
.wParam
, info
.msg
.lParam
);
2093 info
.flags
= ISMEX_SEND
;
2096 info
.flags
= ISMEX_NOTIFY
;
2099 info
.flags
= ISMEX_CALLBACK
;
2101 case MSG_CALLBACK_RESULT
:
2102 if (size
>= sizeof(struct callback_msg_data
))
2104 const struct callback_msg_data
*data
= (const struct callback_msg_data
*)buffer
;
2105 call_sendmsg_callback( data
->callback
, info
.msg
.hwnd
,
2106 info
.msg
.message
, data
->data
, data
->result
);
2110 if (size
>= sizeof(struct winevent_msg_data
))
2112 WINEVENTPROC hook_proc
;
2113 const struct winevent_msg_data
*data
= (const struct winevent_msg_data
*)buffer
;
2115 hook_proc
= data
->hook_proc
;
2116 size
-= sizeof(*data
);
2119 WCHAR module
[MAX_PATH
];
2121 size
= min( size
, (MAX_PATH
- 1) * sizeof(WCHAR
) );
2122 memcpy( module
, buffer
, size
);
2123 module
[size
/ sizeof(WCHAR
)] = 0;
2124 if (!(hook_proc
= get_hook_proc( hook_proc
, module
)))
2126 ERR( "invalid winevent hook module name %s\n", debugstr_w(module
) );
2131 if (TRACE_ON(relay
))
2132 DPRINTF( "%04x:Call winevent proc %p (hook=%p,event=%x,hwnd=%p,object_id=%lx,child_id=%lx,tid=%04x,time=%x)\n",
2133 GetCurrentThreadId(), hook_proc
,
2134 data
->hook
, info
.msg
.message
, info
.msg
.hwnd
, info
.msg
.wParam
,
2135 info
.msg
.lParam
, data
->tid
, info
.msg
.time
);
2137 hook_proc( data
->hook
, info
.msg
.message
, info
.msg
.hwnd
, info
.msg
.wParam
,
2138 info
.msg
.lParam
, data
->tid
, info
.msg
.time
);
2140 if (TRACE_ON(relay
))
2141 DPRINTF( "%04x:Ret winevent proc %p (hook=%p,event=%x,hwnd=%p,object_id=%lx,child_id=%lx,tid=%04x,time=%x)\n",
2142 GetCurrentThreadId(), hook_proc
,
2143 data
->hook
, info
.msg
.message
, info
.msg
.hwnd
, info
.msg
.wParam
,
2144 info
.msg
.lParam
, data
->tid
, info
.msg
.time
);
2147 case MSG_OTHER_PROCESS
:
2148 info
.flags
= ISMEX_SEND
;
2149 if (!unpack_message( info
.msg
.hwnd
, info
.msg
.message
, &info
.msg
.wParam
,
2150 &info
.msg
.lParam
, &buffer
, size
))
2153 reply_message( &info
, 0, TRUE
);
2158 if (!process_hardware_message( &info
.msg
, hw_id
, extra_info
,
2159 hwnd
, first
, last
, flags
& PM_REMOVE
))
2161 TRACE("dropping msg %x\n", info
.msg
.message
);
2162 goto next
; /* ignore it */
2164 thread_info
->GetMessagePosVal
= MAKELONG( info
.msg
.pt
.x
, info
.msg
.pt
.y
);
2167 thread_info
->GetMessageExtraInfoVal
= extra_info
;
2168 if (info
.msg
.message
>= WM_DDE_FIRST
&& info
.msg
.message
<= WM_DDE_LAST
)
2170 if (!unpack_dde_message( info
.msg
.hwnd
, info
.msg
.message
, &info
.msg
.wParam
,
2171 &info
.msg
.lParam
, &buffer
, size
))
2172 goto next
; /* ignore it */
2175 HeapFree( GetProcessHeap(), 0, buffer
);
2179 /* if we get here, we have a sent message; call the window procedure */
2180 old_info
= thread_info
->receive_info
;
2181 thread_info
->receive_info
= &info
;
2182 result
= call_window_proc( info
.msg
.hwnd
, info
.msg
.message
, info
.msg
.wParam
,
2183 info
.msg
.lParam
, (info
.type
!= MSG_ASCII
), FALSE
,
2184 WMCHAR_MAP_RECVMESSAGE
);
2185 reply_message( &info
, result
, TRUE
);
2186 thread_info
->receive_info
= old_info
;
2188 /* if some PM_QS* flags were specified, only handle sent messages from now on */
2189 if (HIWORD(flags
)) flags
= PM_QS_SENDMESSAGE
| LOWORD(flags
);
2191 HeapFree( GetProcessHeap(), 0, buffer
);
2196 /***********************************************************************
2197 * process_sent_messages
2199 * Process all pending sent messages.
2201 static inline void process_sent_messages(void)
2204 peek_message( &msg
, 0, 0, 0, PM_REMOVE
| PM_QS_SENDMESSAGE
);
2208 /***********************************************************************
2209 * get_server_queue_handle
2211 * Get a handle to the server message queue for the current thread.
2213 static HANDLE
get_server_queue_handle(void)
2215 struct user_thread_info
*thread_info
= get_user_thread_info();
2218 if (!(ret
= thread_info
->server_queue
))
2220 SERVER_START_REQ( get_msg_queue
)
2222 wine_server_call( req
);
2223 ret
= reply
->handle
;
2226 thread_info
->server_queue
= ret
;
2227 if (!ret
) ERR( "Cannot get server thread queue\n" );
2233 /***********************************************************************
2234 * wait_message_reply
2236 * Wait until a sent message gets replied to.
2238 static void wait_message_reply( UINT flags
)
2240 HANDLE server_queue
= get_server_queue_handle();
2244 unsigned int wake_bits
= 0;
2247 SERVER_START_REQ( set_queue_mask
)
2249 req
->wake_mask
= QS_SMRESULT
| ((flags
& SMTO_BLOCK
) ? 0 : QS_SENDMESSAGE
);
2250 req
->changed_mask
= req
->wake_mask
;
2252 if (!wine_server_call( req
))
2253 wake_bits
= reply
->wake_bits
;
2257 if (wake_bits
& QS_SMRESULT
) return; /* got a result */
2258 if (wake_bits
& QS_SENDMESSAGE
)
2260 /* Process the sent message immediately */
2261 process_sent_messages();
2265 /* now wait for it */
2267 ReleaseThunkLock( &dwlc
);
2268 res
= USER_Driver
->pMsgWaitForMultipleObjectsEx( 1, &server_queue
,
2269 INFINITE
, QS_SENDMESSAGE
, 0 );
2270 if (dwlc
) RestoreThunkLock( dwlc
);
2274 /***********************************************************************
2275 * put_message_in_queue
2277 * Put a sent message into the destination queue.
2278 * For inter-process message, reply_size is set to expected size of reply data.
2280 static BOOL
put_message_in_queue( const struct send_message_info
*info
, size_t *reply_size
)
2282 struct packed_message data
;
2283 message_data_t msg_data
;
2286 timeout_t timeout
= TIMEOUT_INFINITE
;
2288 /* Check for INFINITE timeout for compatibility with Win9x,
2289 * although Windows >= NT does not do so
2291 if (info
->type
!= MSG_NOTIFY
&&
2292 info
->type
!= MSG_CALLBACK
&&
2293 info
->type
!= MSG_POSTED
&&
2295 info
->timeout
!= INFINITE
)
2297 /* timeout is signed despite the prototype */
2298 timeout
= (timeout_t
)max( 0, (int)info
->timeout
) * -10000;
2302 if (info
->type
== MSG_OTHER_PROCESS
)
2304 *reply_size
= pack_message( info
->hwnd
, info
->msg
, info
->wparam
, info
->lparam
, &data
);
2305 if (data
.count
== -1)
2307 WARN( "cannot pack message %x\n", info
->msg
);
2311 else if (info
->type
== MSG_CALLBACK
)
2313 msg_data
.callback
.callback
= info
->callback
;
2314 msg_data
.callback
.data
= info
->data
;
2315 msg_data
.callback
.result
= 0;
2316 data
.data
[0] = &msg_data
;
2317 data
.size
[0] = sizeof(msg_data
.callback
);
2320 else if (info
->type
== MSG_POSTED
&& info
->msg
>= WM_DDE_FIRST
&& info
->msg
<= WM_DDE_LAST
)
2322 return post_dde_message( &data
, info
);
2325 SERVER_START_REQ( send_message
)
2327 req
->id
= info
->dest_tid
;
2328 req
->type
= info
->type
;
2330 req
->win
= info
->hwnd
;
2331 req
->msg
= info
->msg
;
2332 req
->wparam
= info
->wparam
;
2333 req
->lparam
= info
->lparam
;
2334 req
->timeout
= timeout
;
2336 if (info
->flags
& SMTO_ABORTIFHUNG
) req
->flags
|= SEND_MSG_ABORT_IF_HUNG
;
2337 for (i
= 0; i
< data
.count
; i
++) wine_server_add_data( req
, data
.data
[i
], data
.size
[i
] );
2338 if ((res
= wine_server_call( req
)))
2340 if (res
== STATUS_INVALID_PARAMETER
)
2341 /* FIXME: find a STATUS_ value for this one */
2342 SetLastError( ERROR_INVALID_THREAD_ID
);
2344 SetLastError( RtlNtStatusToDosError(res
) );
2352 /***********************************************************************
2355 * Retrieve a message reply from the server.
2357 static LRESULT
retrieve_reply( const struct send_message_info
*info
,
2358 size_t reply_size
, LRESULT
*result
)
2361 void *reply_data
= NULL
;
2365 if (!(reply_data
= HeapAlloc( GetProcessHeap(), 0, reply_size
)))
2367 WARN( "no memory for reply, will be truncated\n" );
2371 SERVER_START_REQ( get_message_reply
)
2374 if (reply_size
) wine_server_set_reply( req
, reply_data
, reply_size
);
2375 if (!(status
= wine_server_call( req
))) *result
= reply
->result
;
2376 reply_size
= wine_server_reply_size( reply
);
2379 if (!status
&& reply_size
)
2380 unpack_reply( info
->hwnd
, info
->msg
, info
->wparam
, info
->lparam
, reply_data
, reply_size
);
2382 HeapFree( GetProcessHeap(), 0, reply_data
);
2384 TRACE( "hwnd %p msg %x (%s) wp %lx lp %lx got reply %lx (err=%d)\n",
2385 info
->hwnd
, info
->msg
, SPY_GetMsgName(info
->msg
, info
->hwnd
), info
->wparam
,
2386 info
->lparam
, *result
, status
);
2388 /* MSDN states that last error is 0 on timeout, but at least NT4 returns ERROR_TIMEOUT */
2389 if (status
) SetLastError( RtlNtStatusToDosError(status
) );
2394 /***********************************************************************
2395 * send_inter_thread_message
2397 static LRESULT
send_inter_thread_message( const struct send_message_info
*info
, LRESULT
*res_ptr
)
2399 size_t reply_size
= 0;
2401 TRACE( "hwnd %p msg %x (%s) wp %lx lp %lx\n",
2402 info
->hwnd
, info
->msg
, SPY_GetMsgName(info
->msg
, info
->hwnd
), info
->wparam
, info
->lparam
);
2404 USER_CheckNotLock();
2406 if (!put_message_in_queue( info
, &reply_size
)) return 0;
2408 /* there's no reply to wait for on notify/callback messages */
2409 if (info
->type
== MSG_NOTIFY
|| info
->type
== MSG_CALLBACK
) return 1;
2411 wait_message_reply( info
->flags
);
2412 return retrieve_reply( info
, reply_size
, res_ptr
);
2416 /***********************************************************************
2417 * send_inter_thread_callback
2419 static LRESULT
send_inter_thread_callback( HWND hwnd
, UINT msg
, WPARAM wp
, LPARAM lp
,
2420 LRESULT
*result
, void *arg
)
2422 struct send_message_info
*info
= arg
;
2427 return send_inter_thread_message( info
, result
);
2431 /***********************************************************************
2434 * Backend implementation of the various SendMessage functions.
2436 static BOOL
send_message( struct send_message_info
*info
, DWORD_PTR
*res_ptr
, BOOL unicode
)
2442 if (is_broadcast(info
->hwnd
))
2444 EnumWindows( broadcast_message_callback
, (LPARAM
)info
);
2445 if (res_ptr
) *res_ptr
= 1;
2449 if (!(info
->dest_tid
= GetWindowThreadProcessId( info
->hwnd
, &dest_pid
))) return FALSE
;
2451 if (USER_IsExitingThread( info
->dest_tid
)) return FALSE
;
2453 SPY_EnterMessage( SPY_SENDMESSAGE
, info
->hwnd
, info
->msg
, info
->wparam
, info
->lparam
);
2455 if (info
->dest_tid
== GetCurrentThreadId())
2457 result
= call_window_proc( info
->hwnd
, info
->msg
, info
->wparam
, info
->lparam
,
2458 unicode
, TRUE
, info
->wm_char
);
2459 if (info
->type
== MSG_CALLBACK
)
2460 call_sendmsg_callback( info
->callback
, info
->hwnd
, info
->msg
, info
->data
, result
);
2465 if (dest_pid
!= GetCurrentProcessId() && (info
->type
== MSG_ASCII
|| info
->type
== MSG_UNICODE
))
2466 info
->type
= MSG_OTHER_PROCESS
;
2468 /* MSG_ASCII can be sent unconverted except for WM_CHAR; everything else needs to be Unicode */
2469 if (!unicode
&& is_unicode_message( info
->msg
) &&
2470 (info
->type
!= MSG_ASCII
|| info
->msg
== WM_CHAR
))
2471 ret
= WINPROC_CallProcAtoW( send_inter_thread_callback
, info
->hwnd
, info
->msg
,
2472 info
->wparam
, info
->lparam
, &result
, info
, info
->wm_char
);
2474 ret
= send_inter_thread_message( info
, &result
);
2477 SPY_ExitMessage( SPY_RESULT_OK
, info
->hwnd
, info
->msg
, result
, info
->wparam
, info
->lparam
);
2478 if (ret
&& res_ptr
) *res_ptr
= result
;
2483 /***********************************************************************
2484 * MSG_SendInternalMessageTimeout
2486 * Same as SendMessageTimeoutW but sends the message to a specific thread
2487 * without requiring a window handle. Only works for internal Wine messages.
2489 LRESULT
MSG_SendInternalMessageTimeout( DWORD dest_pid
, DWORD dest_tid
,
2490 UINT msg
, WPARAM wparam
, LPARAM lparam
,
2491 UINT flags
, UINT timeout
, PDWORD_PTR res_ptr
)
2493 struct send_message_info info
;
2494 LRESULT ret
, result
;
2496 assert( msg
& 0x80000000 ); /* must be an internal Wine message */
2498 info
.type
= MSG_UNICODE
;
2499 info
.dest_tid
= dest_tid
;
2502 info
.wparam
= wparam
;
2503 info
.lparam
= lparam
;
2505 info
.timeout
= timeout
;
2507 if (USER_IsExitingThread( dest_tid
)) return 0;
2509 if (dest_tid
== GetCurrentThreadId())
2511 result
= handle_internal_message( 0, msg
, wparam
, lparam
);
2516 if (dest_pid
!= GetCurrentProcessId()) info
.type
= MSG_OTHER_PROCESS
;
2517 ret
= send_inter_thread_message( &info
, &result
);
2519 if (ret
&& res_ptr
) *res_ptr
= result
;
2524 /***********************************************************************
2525 * SendMessageTimeoutW (USER32.@)
2527 LRESULT WINAPI
SendMessageTimeoutW( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
,
2528 UINT flags
, UINT timeout
, PDWORD_PTR res_ptr
)
2530 struct send_message_info info
;
2532 info
.type
= MSG_UNICODE
;
2535 info
.wparam
= wparam
;
2536 info
.lparam
= lparam
;
2538 info
.timeout
= timeout
;
2540 return send_message( &info
, res_ptr
, TRUE
);
2543 /***********************************************************************
2544 * SendMessageTimeoutA (USER32.@)
2546 LRESULT WINAPI
SendMessageTimeoutA( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
,
2547 UINT flags
, UINT timeout
, PDWORD_PTR res_ptr
)
2549 struct send_message_info info
;
2551 info
.type
= MSG_ASCII
;
2554 info
.wparam
= wparam
;
2555 info
.lparam
= lparam
;
2557 info
.timeout
= timeout
;
2558 info
.wm_char
= WMCHAR_MAP_SENDMESSAGETIMEOUT
;
2560 return send_message( &info
, res_ptr
, FALSE
);
2564 /***********************************************************************
2565 * SendMessageW (USER32.@)
2567 LRESULT WINAPI
SendMessageW( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2570 struct send_message_info info
;
2572 info
.type
= MSG_UNICODE
;
2575 info
.wparam
= wparam
;
2576 info
.lparam
= lparam
;
2577 info
.flags
= SMTO_NORMAL
;
2580 send_message( &info
, &res
, TRUE
);
2585 /***********************************************************************
2586 * SendMessageA (USER32.@)
2588 LRESULT WINAPI
SendMessageA( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2591 struct send_message_info info
;
2593 info
.type
= MSG_ASCII
;
2596 info
.wparam
= wparam
;
2597 info
.lparam
= lparam
;
2598 info
.flags
= SMTO_NORMAL
;
2600 info
.wm_char
= WMCHAR_MAP_SENDMESSAGE
;
2602 send_message( &info
, &res
, FALSE
);
2607 /***********************************************************************
2608 * SendNotifyMessageA (USER32.@)
2610 BOOL WINAPI
SendNotifyMessageA( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2612 struct send_message_info info
;
2614 if (is_pointer_message(msg
))
2616 SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
2620 info
.type
= MSG_NOTIFY
;
2623 info
.wparam
= wparam
;
2624 info
.lparam
= lparam
;
2626 info
.wm_char
= WMCHAR_MAP_SENDMESSAGETIMEOUT
;
2628 return send_message( &info
, NULL
, FALSE
);
2632 /***********************************************************************
2633 * SendNotifyMessageW (USER32.@)
2635 BOOL WINAPI
SendNotifyMessageW( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2637 struct send_message_info info
;
2639 if (is_pointer_message(msg
))
2641 SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
2645 info
.type
= MSG_NOTIFY
;
2648 info
.wparam
= wparam
;
2649 info
.lparam
= lparam
;
2652 return send_message( &info
, NULL
, TRUE
);
2656 /***********************************************************************
2657 * SendMessageCallbackA (USER32.@)
2659 BOOL WINAPI
SendMessageCallbackA( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
,
2660 SENDASYNCPROC callback
, ULONG_PTR data
)
2662 struct send_message_info info
;
2664 if (is_pointer_message(msg
))
2666 SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
2670 info
.type
= MSG_CALLBACK
;
2673 info
.wparam
= wparam
;
2674 info
.lparam
= lparam
;
2675 info
.callback
= callback
;
2678 info
.wm_char
= WMCHAR_MAP_SENDMESSAGETIMEOUT
;
2680 return send_message( &info
, NULL
, FALSE
);
2684 /***********************************************************************
2685 * SendMessageCallbackW (USER32.@)
2687 BOOL WINAPI
SendMessageCallbackW( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
,
2688 SENDASYNCPROC callback
, ULONG_PTR data
)
2690 struct send_message_info info
;
2692 if (is_pointer_message(msg
))
2694 SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
2698 info
.type
= MSG_CALLBACK
;
2701 info
.wparam
= wparam
;
2702 info
.lparam
= lparam
;
2703 info
.callback
= callback
;
2707 return send_message( &info
, NULL
, TRUE
);
2711 /***********************************************************************
2712 * ReplyMessage (USER32.@)
2714 BOOL WINAPI
ReplyMessage( LRESULT result
)
2716 struct received_message_info
*info
= get_user_thread_info()->receive_info
;
2718 if (!info
) return FALSE
;
2719 reply_message( info
, result
, FALSE
);
2724 /***********************************************************************
2725 * InSendMessage (USER32.@)
2727 BOOL WINAPI
InSendMessage(void)
2729 return (InSendMessageEx(NULL
) & (ISMEX_SEND
|ISMEX_REPLIED
)) == ISMEX_SEND
;
2733 /***********************************************************************
2734 * InSendMessageEx (USER32.@)
2736 DWORD WINAPI
InSendMessageEx( LPVOID reserved
)
2738 struct received_message_info
*info
= get_user_thread_info()->receive_info
;
2740 if (info
) return info
->flags
;
2741 return ISMEX_NOSEND
;
2745 /***********************************************************************
2746 * PostMessageA (USER32.@)
2748 BOOL WINAPI
PostMessageA( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2750 if (!map_wparam_AtoW( msg
, &wparam
, WMCHAR_MAP_POSTMESSAGE
)) return TRUE
;
2751 return PostMessageW( hwnd
, msg
, wparam
, lparam
);
2755 /***********************************************************************
2756 * PostMessageW (USER32.@)
2758 BOOL WINAPI
PostMessageW( HWND hwnd
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2760 struct send_message_info info
;
2762 if (is_pointer_message( msg
))
2764 SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
2768 TRACE( "hwnd %p msg %x (%s) wp %lx lp %lx\n",
2769 hwnd
, msg
, SPY_GetMsgName(msg
, hwnd
), wparam
, lparam
);
2771 info
.type
= MSG_POSTED
;
2774 info
.wparam
= wparam
;
2775 info
.lparam
= lparam
;
2778 if (is_broadcast(hwnd
))
2780 EnumWindows( broadcast_message_callback
, (LPARAM
)&info
);
2784 if (!hwnd
) return PostThreadMessageW( GetCurrentThreadId(), msg
, wparam
, lparam
);
2786 if (!(info
.dest_tid
= GetWindowThreadProcessId( hwnd
, NULL
))) return FALSE
;
2788 if (USER_IsExitingThread( info
.dest_tid
)) return TRUE
;
2790 return put_message_in_queue( &info
, NULL
);
2794 /**********************************************************************
2795 * PostThreadMessageA (USER32.@)
2797 BOOL WINAPI
PostThreadMessageA( DWORD thread
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2799 if (!map_wparam_AtoW( msg
, &wparam
, WMCHAR_MAP_POSTMESSAGE
)) return TRUE
;
2800 return PostThreadMessageW( thread
, msg
, wparam
, lparam
);
2804 /**********************************************************************
2805 * PostThreadMessageW (USER32.@)
2807 BOOL WINAPI
PostThreadMessageW( DWORD thread
, UINT msg
, WPARAM wparam
, LPARAM lparam
)
2809 struct send_message_info info
;
2811 if (is_pointer_message( msg
))
2813 SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
2816 if (USER_IsExitingThread( thread
)) return TRUE
;
2818 info
.type
= MSG_POSTED
;
2819 info
.dest_tid
= thread
;
2822 info
.wparam
= wparam
;
2823 info
.lparam
= lparam
;
2825 return put_message_in_queue( &info
, NULL
);
2829 /***********************************************************************
2830 * PostQuitMessage (USER32.@)
2832 * Posts a quit message to the current thread's message queue.
2835 * exit_code [I] Exit code to return from message loop.
2841 * This function is not the same as calling:
2842 *|PostThreadMessage(GetCurrentThreadId(), WM_QUIT, exit_code, 0);
2843 * It instead sets a flag in the message queue that signals it to generate
2844 * a WM_QUIT message when there are no other pending sent or posted messages
2847 void WINAPI
PostQuitMessage( INT exit_code
)
2849 SERVER_START_REQ( post_quit_message
)
2851 req
->exit_code
= exit_code
;
2852 wine_server_call( req
);
2858 /***********************************************************************
2859 * PeekMessageW (USER32.@)
2861 BOOL WINAPI
PeekMessageW( MSG
*msg_out
, HWND hwnd
, UINT first
, UINT last
, UINT flags
)
2863 struct user_thread_info
*thread_info
= get_user_thread_info();
2866 USER_CheckNotLock();
2868 /* check for graphics events */
2869 USER_Driver
->pMsgWaitForMultipleObjectsEx( 0, NULL
, 0, QS_ALLINPUT
, 0 );
2871 hwnd
= WIN_GetFullHandle( hwnd
);
2875 if (!peek_message( &msg
, hwnd
, first
, last
, flags
))
2877 if (!(flags
& PM_NOYIELD
))
2880 ReleaseThunkLock(&count
);
2882 if (count
) RestoreThunkLock(count
);
2886 if (msg
.message
& 0x80000000)
2888 if (!(flags
& PM_REMOVE
))
2890 /* Have to remove the message explicitly.
2891 Do this before handling it, because the message handler may
2892 call PeekMessage again */
2893 peek_message( &msg
, msg
.hwnd
, msg
.message
, msg
.message
, flags
| PM_REMOVE
);
2895 handle_internal_message( msg
.hwnd
, msg
.message
, msg
.wParam
, msg
.lParam
);
2900 thread_info
->GetMessageTimeVal
= msg
.time
;
2901 msg
.pt
.x
= (short)LOWORD( thread_info
->GetMessagePosVal
);
2902 msg
.pt
.y
= (short)HIWORD( thread_info
->GetMessagePosVal
);
2904 HOOK_CallHooks( WH_GETMESSAGE
, HC_ACTION
, flags
& PM_REMOVE
, (LPARAM
)&msg
, TRUE
);
2906 /* copy back our internal safe copy of message data to msg_out.
2907 * msg_out is a variable from the *program*, so it can't be used
2908 * internally as it can get "corrupted" by our use of SendMessage()
2909 * (back to the program) inside the message handling itself. */
2912 SetLastError( ERROR_NOACCESS
);
2920 /***********************************************************************
2921 * PeekMessageA (USER32.@)
2923 BOOL WINAPI
PeekMessageA( MSG
*msg
, HWND hwnd
, UINT first
, UINT last
, UINT flags
)
2925 if (get_pending_wmchar( msg
, first
, last
, (flags
& PM_REMOVE
) )) return TRUE
;
2926 if (!PeekMessageW( msg
, hwnd
, first
, last
, flags
)) return FALSE
;
2927 map_wparam_WtoA( msg
, (flags
& PM_REMOVE
) );
2932 /***********************************************************************
2933 * GetMessageW (USER32.@)
2935 BOOL WINAPI
GetMessageW( MSG
*msg
, HWND hwnd
, UINT first
, UINT last
)
2937 HANDLE server_queue
= get_server_queue_handle();
2938 int mask
= QS_POSTMESSAGE
| QS_SENDMESSAGE
; /* Always selected */
2942 if ((first
<= WM_KEYLAST
) && (last
>= WM_KEYFIRST
)) mask
|= QS_KEY
;
2943 if ( ((first
<= WM_MOUSELAST
) && (last
>= WM_MOUSEFIRST
)) ||
2944 ((first
<= WM_NCMOUSELAST
) && (last
>= WM_NCMOUSEFIRST
)) ) mask
|= QS_MOUSE
;
2945 if ((first
<= WM_TIMER
) && (last
>= WM_TIMER
)) mask
|= QS_TIMER
;
2946 if ((first
<= WM_SYSTIMER
) && (last
>= WM_SYSTIMER
)) mask
|= QS_TIMER
;
2947 if ((first
<= WM_PAINT
) && (last
>= WM_PAINT
)) mask
|= QS_PAINT
;
2949 else mask
= QS_ALLINPUT
;
2951 while (!PeekMessageW( msg
, hwnd
, first
, last
, PM_REMOVE
| PM_NOYIELD
| (mask
<< 16) ))
2955 ReleaseThunkLock( &dwlc
);
2956 USER_Driver
->pMsgWaitForMultipleObjectsEx( 1, &server_queue
, INFINITE
, mask
, 0 );
2957 if (dwlc
) RestoreThunkLock( dwlc
);
2960 return (msg
->message
!= WM_QUIT
);
2964 /***********************************************************************
2965 * GetMessageA (USER32.@)
2967 BOOL WINAPI
GetMessageA( MSG
*msg
, HWND hwnd
, UINT first
, UINT last
)
2969 if (get_pending_wmchar( msg
, first
, last
, TRUE
)) return TRUE
;
2970 GetMessageW( msg
, hwnd
, first
, last
);
2971 map_wparam_WtoA( msg
, TRUE
);
2972 return (msg
->message
!= WM_QUIT
);
2976 /***********************************************************************
2977 * IsDialogMessageA (USER32.@)
2978 * IsDialogMessage (USER32.@)
2980 BOOL WINAPI
IsDialogMessageA( HWND hwndDlg
, LPMSG pmsg
)
2983 map_wparam_AtoW( msg
.message
, &msg
.wParam
, WMCHAR_MAP_NOMAPPING
);
2984 return IsDialogMessageW( hwndDlg
, &msg
);
2988 /***********************************************************************
2989 * TranslateMessage (USER32.@)
2991 * Implementation of TranslateMessage.
2993 * TranslateMessage translates virtual-key messages into character-messages,
2995 * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
2996 * ditto replacing WM_* with WM_SYS*
2997 * This produces WM_CHAR messages only for keys mapped to ASCII characters
2998 * by the keyboard driver.
3000 * If the message is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP, the
3001 * return value is nonzero, regardless of the translation.
3004 BOOL WINAPI
TranslateMessage( const MSG
*msg
)
3010 if (msg
->message
< WM_KEYFIRST
|| msg
->message
> WM_KEYLAST
) return FALSE
;
3011 if (msg
->message
!= WM_KEYDOWN
&& msg
->message
!= WM_SYSKEYDOWN
) return TRUE
;
3013 TRACE_(key
)("Translating key %s (%04lx), scancode %02x\n",
3014 SPY_GetVKeyName(msg
->wParam
), msg
->wParam
, LOBYTE(HIWORD(msg
->lParam
)));
3016 if ( msg
->wParam
== VK_PROCESSKEY
)
3017 return ImmTranslateMessage(msg
->hwnd
, msg
->message
, msg
->wParam
, msg
->lParam
);
3019 GetKeyboardState( state
);
3020 /* FIXME : should handle ToUnicode yielding 2 */
3021 switch (ToUnicode(msg
->wParam
, HIWORD(msg
->lParam
), state
, wp
, 2, 0))
3024 message
= (msg
->message
== WM_KEYDOWN
) ? WM_CHAR
: WM_SYSCHAR
;
3025 TRACE_(key
)("1 -> PostMessageW(%p,%s,%04x,%08lx)\n",
3026 msg
->hwnd
, SPY_GetMsgName(message
, msg
->hwnd
), wp
[0], msg
->lParam
);
3027 PostMessageW( msg
->hwnd
, message
, wp
[0], msg
->lParam
);
3031 message
= (msg
->message
== WM_KEYDOWN
) ? WM_DEADCHAR
: WM_SYSDEADCHAR
;
3032 TRACE_(key
)("-1 -> PostMessageW(%p,%s,%04x,%08lx)\n",
3033 msg
->hwnd
, SPY_GetMsgName(message
, msg
->hwnd
), wp
[0], msg
->lParam
);
3034 PostMessageW( msg
->hwnd
, message
, wp
[0], msg
->lParam
);
3041 /***********************************************************************
3042 * DispatchMessageA (USER32.@)
3044 * See DispatchMessageW.
3046 LRESULT WINAPI
DispatchMessageA( const MSG
* msg
)
3050 /* Process timer messages */
3051 if ((msg
->message
== WM_TIMER
) || (msg
->message
== WM_SYSTIMER
))
3053 if (msg
->lParam
) return CallWindowProcA( (WNDPROC
)msg
->lParam
, msg
->hwnd
,
3054 msg
->message
, msg
->wParam
, GetTickCount() );
3056 if (!msg
->hwnd
) return 0;
3058 SPY_EnterMessage( SPY_DISPATCHMESSAGE
, msg
->hwnd
, msg
->message
,
3059 msg
->wParam
, msg
->lParam
);
3061 if (!WINPROC_call_window( msg
->hwnd
, msg
->message
, msg
->wParam
, msg
->lParam
,
3062 &retval
, FALSE
, WMCHAR_MAP_DISPATCHMESSAGE
))
3064 if (!IsWindow( msg
->hwnd
)) SetLastError( ERROR_INVALID_WINDOW_HANDLE
);
3065 else SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
3069 SPY_ExitMessage( SPY_RESULT_OK
, msg
->hwnd
, msg
->message
, retval
,
3070 msg
->wParam
, msg
->lParam
);
3072 if (msg
->message
== WM_PAINT
)
3074 /* send a WM_NCPAINT and WM_ERASEBKGND if the non-client area is still invalid */
3075 HRGN hrgn
= CreateRectRgn( 0, 0, 0, 0 );
3076 GetUpdateRgn( msg
->hwnd
, hrgn
, TRUE
);
3077 DeleteObject( hrgn
);
3083 /***********************************************************************
3084 * DispatchMessageW (USER32.@) Process a message
3086 * Process the message specified in the structure *_msg_.
3088 * If the lpMsg parameter points to a WM_TIMER message and the
3089 * parameter of the WM_TIMER message is not NULL, the lParam parameter
3090 * points to the function that is called instead of the window
3093 * The message must be valid.
3097 * DispatchMessage() returns the result of the window procedure invoked.
3104 LRESULT WINAPI
DispatchMessageW( const MSG
* msg
)
3108 /* Process timer messages */
3109 if ((msg
->message
== WM_TIMER
) || (msg
->message
== WM_SYSTIMER
))
3111 if (msg
->lParam
) return CallWindowProcW( (WNDPROC
)msg
->lParam
, msg
->hwnd
,
3112 msg
->message
, msg
->wParam
, GetTickCount() );
3114 if (!msg
->hwnd
) return 0;
3116 SPY_EnterMessage( SPY_DISPATCHMESSAGE
, msg
->hwnd
, msg
->message
,
3117 msg
->wParam
, msg
->lParam
);
3119 if (!WINPROC_call_window( msg
->hwnd
, msg
->message
, msg
->wParam
, msg
->lParam
,
3120 &retval
, TRUE
, WMCHAR_MAP_DISPATCHMESSAGE
))
3122 if (!IsWindow( msg
->hwnd
)) SetLastError( ERROR_INVALID_WINDOW_HANDLE
);
3123 else SetLastError( ERROR_MESSAGE_SYNC_ONLY
);
3127 SPY_ExitMessage( SPY_RESULT_OK
, msg
->hwnd
, msg
->message
, retval
,
3128 msg
->wParam
, msg
->lParam
);
3130 if (msg
->message
== WM_PAINT
)
3132 /* send a WM_NCPAINT and WM_ERASEBKGND if the non-client area is still invalid */
3133 HRGN hrgn
= CreateRectRgn( 0, 0, 0, 0 );
3134 GetUpdateRgn( msg
->hwnd
, hrgn
, TRUE
);
3135 DeleteObject( hrgn
);
3141 /***********************************************************************
3142 * GetMessagePos (USER.119)
3143 * GetMessagePos (USER32.@)
3145 * The GetMessagePos() function returns a long value representing a
3146 * cursor position, in screen coordinates, when the last message
3147 * retrieved by the GetMessage() function occurs. The x-coordinate is
3148 * in the low-order word of the return value, the y-coordinate is in
3149 * the high-order word. The application can use the MAKEPOINT()
3150 * macro to obtain a POINT structure from the return value.
3152 * For the current cursor position, use GetCursorPos().
3156 * Cursor position of last message on success, zero on failure.
3163 DWORD WINAPI
GetMessagePos(void)
3165 return get_user_thread_info()->GetMessagePosVal
;
3169 /***********************************************************************
3170 * GetMessageTime (USER.120)
3171 * GetMessageTime (USER32.@)
3173 * GetMessageTime() returns the message time for the last message
3174 * retrieved by the function. The time is measured in milliseconds with
3175 * the same offset as GetTickCount().
3177 * Since the tick count wraps, this is only useful for moderately short
3178 * relative time comparisons.
3182 * Time of last message on success, zero on failure.
3184 LONG WINAPI
GetMessageTime(void)
3186 return get_user_thread_info()->GetMessageTimeVal
;
3190 /***********************************************************************
3191 * GetMessageExtraInfo (USER.288)
3192 * GetMessageExtraInfo (USER32.@)
3194 LPARAM WINAPI
GetMessageExtraInfo(void)
3196 return get_user_thread_info()->GetMessageExtraInfoVal
;
3200 /***********************************************************************
3201 * SetMessageExtraInfo (USER32.@)
3203 LPARAM WINAPI
SetMessageExtraInfo(LPARAM lParam
)
3205 struct user_thread_info
*thread_info
= get_user_thread_info();
3206 LONG old_value
= thread_info
->GetMessageExtraInfoVal
;
3207 thread_info
->GetMessageExtraInfoVal
= lParam
;
3212 /***********************************************************************
3213 * WaitMessage (USER.112) Suspend thread pending messages
3214 * WaitMessage (USER32.@) Suspend thread pending messages
3216 * WaitMessage() suspends a thread until events appear in the thread's
3219 BOOL WINAPI
WaitMessage(void)
3221 return (MsgWaitForMultipleObjectsEx( 0, NULL
, INFINITE
, QS_ALLINPUT
, 0 ) != WAIT_FAILED
);
3225 /***********************************************************************
3226 * MsgWaitForMultipleObjectsEx (USER32.@)
3228 DWORD WINAPI
MsgWaitForMultipleObjectsEx( DWORD count
, CONST HANDLE
*pHandles
,
3229 DWORD timeout
, DWORD mask
, DWORD flags
)
3231 HANDLE handles
[MAXIMUM_WAIT_OBJECTS
];
3234 if (count
> MAXIMUM_WAIT_OBJECTS
-1)
3236 SetLastError( ERROR_INVALID_PARAMETER
);
3240 /* set the queue mask */
3241 SERVER_START_REQ( set_queue_mask
)
3243 req
->wake_mask
= (flags
& MWMO_INPUTAVAILABLE
) ? mask
: 0;
3244 req
->changed_mask
= mask
;
3246 wine_server_call( req
);
3250 /* add the queue to the handle list */
3251 for (i
= 0; i
< count
; i
++) handles
[i
] = pHandles
[i
];
3252 handles
[count
] = get_server_queue_handle();
3254 ReleaseThunkLock( &lock
);
3255 ret
= USER_Driver
->pMsgWaitForMultipleObjectsEx( count
+1, handles
, timeout
, mask
, flags
);
3256 if (lock
) RestoreThunkLock( lock
);
3261 /***********************************************************************
3262 * MsgWaitForMultipleObjects (USER32.@)
3264 DWORD WINAPI
MsgWaitForMultipleObjects( DWORD count
, CONST HANDLE
*handles
,
3265 BOOL wait_all
, DWORD timeout
, DWORD mask
)
3267 return MsgWaitForMultipleObjectsEx( count
, handles
, timeout
, mask
,
3268 wait_all
? MWMO_WAITALL
: 0 );
3272 /***********************************************************************
3273 * WaitForInputIdle (USER32.@)
3275 DWORD WINAPI
WaitForInputIdle( HANDLE hProcess
, DWORD dwTimeOut
)
3277 DWORD start_time
, elapsed
, ret
;
3280 handles
[0] = hProcess
;
3281 SERVER_START_REQ( get_process_idle_event
)
3283 req
->handle
= hProcess
;
3284 if (!(ret
= wine_server_call_err( req
))) handles
[1] = reply
->event
;
3287 if (ret
) return WAIT_FAILED
; /* error */
3288 if (!handles
[1]) return 0; /* no event to wait on */
3290 start_time
= GetTickCount();
3293 TRACE("waiting for %p\n", handles
[1] );
3296 ret
= MsgWaitForMultipleObjects ( 2, handles
, FALSE
, dwTimeOut
- elapsed
, QS_SENDMESSAGE
);
3301 case WAIT_OBJECT_0
+2:
3302 process_sent_messages();
3306 TRACE("timeout or error\n");
3309 TRACE("finished\n");
3312 if (dwTimeOut
!= INFINITE
)
3314 elapsed
= GetTickCount() - start_time
;
3315 if (elapsed
> dwTimeOut
)
3321 return WAIT_TIMEOUT
;
3325 /***********************************************************************
3326 * UserYield (USER.332)
3328 void WINAPI
UserYield16(void)
3332 /* Handle sent messages */
3333 process_sent_messages();
3336 ReleaseThunkLock(&count
);
3340 RestoreThunkLock(count
);
3341 /* Handle sent messages again */
3342 process_sent_messages();
3347 /***********************************************************************
3348 * RegisterWindowMessageA (USER32.@)
3349 * RegisterWindowMessage (USER.118)
3351 UINT WINAPI
RegisterWindowMessageA( LPCSTR str
)
3353 UINT ret
= GlobalAddAtomA(str
);
3354 TRACE("%s, ret=%x\n", str
, ret
);
3359 /***********************************************************************
3360 * RegisterWindowMessageW (USER32.@)
3362 UINT WINAPI
RegisterWindowMessageW( LPCWSTR str
)
3364 UINT ret
= GlobalAddAtomW(str
);
3365 TRACE("%s ret=%x\n", debugstr_w(str
), ret
);
3369 typedef struct BroadcastParm
3380 static BOOL CALLBACK
bcast_childwindow( HWND hw
, LPARAM lp
)
3382 BroadcastParm
*parm
= (BroadcastParm
*)lp
;
3383 DWORD_PTR retval
= 0;
3386 if (parm
->flags
& BSF_IGNORECURRENTTASK
&& WIN_IsCurrentProcess(hw
))
3388 TRACE("Not telling myself %p\n", hw
);
3392 /* I don't know 100% for sure if this is what Windows does, but it fits the tests */
3393 if (parm
->flags
& BSF_QUERY
)
3395 TRACE("Telling window %p using SendMessageTimeout\n", hw
);
3397 /* Not tested for conflicting flags */
3398 if (parm
->flags
& BSF_FORCEIFHUNG
|| parm
->flags
& BSF_NOHANG
)
3399 lresult
= SendMessageTimeoutW( hw
, parm
->msg
, parm
->wp
, parm
->lp
, SMTO_ABORTIFHUNG
, 2000, &retval
);
3400 else if (parm
->flags
& BSF_NOTIMEOUTIFNOTHUNG
)
3401 lresult
= SendMessageTimeoutW( hw
, parm
->msg
, parm
->wp
, parm
->lp
, SMTO_NOTIMEOUTIFNOTHUNG
, 2000, &retval
);
3403 lresult
= SendMessageTimeoutW( hw
, parm
->msg
, parm
->wp
, parm
->lp
, SMTO_NORMAL
, 2000, &retval
);
3405 if (!lresult
&& GetLastError() == ERROR_TIMEOUT
)
3407 WARN("Timed out!\n");
3408 if (!(parm
->flags
& BSF_FORCEIFHUNG
))
3411 if (retval
== BROADCAST_QUERY_DENY
)
3420 else if (parm
->flags
& BSF_POSTMESSAGE
)
3422 TRACE("Telling window %p using PostMessage\n", hw
);
3423 PostMessageW( hw
, parm
->msg
, parm
->wp
, parm
->lp
);
3427 TRACE("Telling window %p using SendNotifyMessage\n", hw
);
3428 SendNotifyMessageW( hw
, parm
->msg
, parm
->wp
, parm
->lp
);
3434 static BOOL CALLBACK
bcast_desktop( LPWSTR desktop
, LPARAM lp
)
3438 BroadcastParm
*parm
= (BroadcastParm
*)lp
;
3440 TRACE("desktop: %s\n", debugstr_w( desktop
));
3442 hdesktop
= open_winstation_desktop( parm
->winsta
, desktop
, 0, FALSE
, DESKTOP_ENUMERATE
|DESKTOP_WRITEOBJECTS
|STANDARD_RIGHTS_WRITE
);
3445 FIXME("Could not open desktop %s\n", debugstr_w(desktop
));
3449 ret
= EnumDesktopWindows( hdesktop
, bcast_childwindow
, lp
);
3450 CloseDesktop(hdesktop
);
3451 TRACE("-->%d\n", ret
);
3452 return parm
->success
;
3455 static BOOL CALLBACK
bcast_winsta( LPWSTR winsta
, LPARAM lp
)
3458 HWINSTA hwinsta
= OpenWindowStationW( winsta
, FALSE
, WINSTA_ENUMDESKTOPS
);
3459 TRACE("hwinsta: %p/%s/%08x\n", hwinsta
, debugstr_w( winsta
), GetLastError());
3462 ((BroadcastParm
*)lp
)->winsta
= hwinsta
;
3463 ret
= EnumDesktopsW( hwinsta
, bcast_desktop
, lp
);
3464 CloseWindowStation( hwinsta
);
3465 TRACE("-->%d\n", ret
);
3469 /***********************************************************************
3470 * BroadcastSystemMessageA (USER32.@)
3471 * BroadcastSystemMessage (USER32.@)
3473 LONG WINAPI
BroadcastSystemMessageA( DWORD flags
, LPDWORD recipients
, UINT msg
, WPARAM wp
, LPARAM lp
)
3475 return BroadcastSystemMessageExA( flags
, recipients
, msg
, wp
, lp
, NULL
);
3479 /***********************************************************************
3480 * BroadcastSystemMessageW (USER32.@)
3482 LONG WINAPI
BroadcastSystemMessageW( DWORD flags
, LPDWORD recipients
, UINT msg
, WPARAM wp
, LPARAM lp
)
3484 return BroadcastSystemMessageExW( flags
, recipients
, msg
, wp
, lp
, NULL
);
3487 /***********************************************************************
3488 * BroadcastSystemMessageExA (USER32.@)
3490 LONG WINAPI
BroadcastSystemMessageExA( DWORD flags
, LPDWORD recipients
, UINT msg
, WPARAM wp
, LPARAM lp
, PBSMINFO pinfo
)
3492 map_wparam_AtoW( msg
, &wp
, WMCHAR_MAP_NOMAPPING
);
3493 return BroadcastSystemMessageExW( flags
, recipients
, msg
, wp
, lp
, NULL
);
3497 /***********************************************************************
3498 * BroadcastSystemMessageExW (USER32.@)
3500 LONG WINAPI
BroadcastSystemMessageExW( DWORD flags
, LPDWORD recipients
, UINT msg
, WPARAM wp
, LPARAM lp
, PBSMINFO pinfo
)
3503 DWORD recips
= BSM_ALLCOMPONENTS
;
3505 static const DWORD all_flags
= ( BSF_QUERY
| BSF_IGNORECURRENTTASK
| BSF_FLUSHDISK
| BSF_NOHANG
3506 | BSF_POSTMESSAGE
| BSF_FORCEIFHUNG
| BSF_NOTIMEOUTIFNOTHUNG
3507 | BSF_ALLOWSFW
| BSF_SENDNOTIFYMESSAGE
| BSF_RETURNHDESK
| BSF_LUID
);
3509 TRACE("Flags: %08x, recipients: %p(0x%x), msg: %04x, wparam: %08lx, lparam: %08lx\n", flags
, recipients
,
3510 (recipients
? *recipients
: recips
), msg
, wp
, lp
);
3512 if (flags
& ~all_flags
)
3514 SetLastError(ERROR_INVALID_PARAMETER
);
3519 recipients
= &recips
;
3521 if ( pinfo
&& flags
& BSF_QUERY
)
3522 FIXME("Not returning PBSMINFO information yet\n");
3525 parm
.recipients
= recipients
;
3529 parm
.success
= TRUE
;
3531 if (*recipients
& BSM_ALLDESKTOPS
|| *recipients
== BSM_ALLCOMPONENTS
)
3532 ret
= EnumWindowStationsW(bcast_winsta
, (LONG_PTR
)&parm
);
3533 else if (*recipients
& BSM_APPLICATIONS
)
3535 EnumWindows(bcast_childwindow
, (LONG_PTR
)&parm
);
3539 FIXME("Recipients %08x not supported!\n", *recipients
);
3544 /***********************************************************************
3545 * SetMessageQueue (USER32.@)
3547 BOOL WINAPI
SetMessageQueue( INT size
)
3549 /* now obsolete the message queue will be expanded dynamically as necessary */
3554 /***********************************************************************
3555 * MessageBeep (USER32.@)
3557 BOOL WINAPI
MessageBeep( UINT i
)
3560 SystemParametersInfoA( SPI_GETBEEP
, 0, &active
, FALSE
);
3561 if (active
) USER_Driver
->pBeep();
3566 /***********************************************************************
3567 * SetTimer (USER32.@)
3569 UINT_PTR WINAPI
SetTimer( HWND hwnd
, UINT_PTR id
, UINT timeout
, TIMERPROC proc
)
3572 WNDPROC winproc
= 0;
3574 if (proc
) winproc
= WINPROC_AllocProc( (WNDPROC
)proc
, NULL
);
3576 SERVER_START_REQ( set_win_timer
)
3579 req
->msg
= WM_TIMER
;
3581 req
->rate
= max( timeout
, SYS_TIMER_RATE
);
3582 req
->lparam
= (unsigned long)winproc
;
3583 if (!wine_server_call_err( req
))
3586 if (!ret
) ret
= TRUE
;
3592 TRACE("Added %p %lx %p timeout %d\n", hwnd
, id
, winproc
, timeout
);
3597 /***********************************************************************
3598 * SetSystemTimer (USER32.@)
3600 UINT_PTR WINAPI
SetSystemTimer( HWND hwnd
, UINT_PTR id
, UINT timeout
, TIMERPROC proc
)
3603 WNDPROC winproc
= 0;
3605 if (proc
) winproc
= WINPROC_AllocProc( (WNDPROC
)proc
, NULL
);
3607 SERVER_START_REQ( set_win_timer
)
3610 req
->msg
= WM_SYSTIMER
;
3612 req
->rate
= max( timeout
, SYS_TIMER_RATE
);
3613 req
->lparam
= (unsigned long)winproc
;
3614 if (!wine_server_call_err( req
))
3617 if (!ret
) ret
= TRUE
;
3623 TRACE("Added %p %lx %p timeout %d\n", hwnd
, id
, winproc
, timeout
);
3628 /***********************************************************************
3629 * KillTimer (USER32.@)
3631 BOOL WINAPI
KillTimer( HWND hwnd
, UINT_PTR id
)
3635 SERVER_START_REQ( kill_win_timer
)
3638 req
->msg
= WM_TIMER
;
3640 ret
= !wine_server_call_err( req
);
3647 /***********************************************************************
3648 * KillSystemTimer (USER32.@)
3650 BOOL WINAPI
KillSystemTimer( HWND hwnd
, UINT_PTR id
)
3654 SERVER_START_REQ( kill_win_timer
)
3657 req
->msg
= WM_SYSTIMER
;
3659 ret
= !wine_server_call_err( req
);
3666 /**********************************************************************
3667 * GetGUIThreadInfo (USER32.@)
3669 BOOL WINAPI
GetGUIThreadInfo( DWORD id
, GUITHREADINFO
*info
)
3673 SERVER_START_REQ( get_thread_input
)
3676 if ((ret
= !wine_server_call_err( req
)))
3679 info
->hwndActive
= reply
->active
;
3680 info
->hwndFocus
= reply
->focus
;
3681 info
->hwndCapture
= reply
->capture
;
3682 info
->hwndMenuOwner
= reply
->menu_owner
;
3683 info
->hwndMoveSize
= reply
->move_size
;
3684 info
->hwndCaret
= reply
->caret
;
3685 info
->rcCaret
.left
= reply
->rect
.left
;
3686 info
->rcCaret
.top
= reply
->rect
.top
;
3687 info
->rcCaret
.right
= reply
->rect
.right
;
3688 info
->rcCaret
.bottom
= reply
->rect
.bottom
;
3689 if (reply
->menu_owner
) info
->flags
|= GUI_INMENUMODE
;
3690 if (reply
->move_size
) info
->flags
|= GUI_INMOVESIZE
;
3691 if (reply
->caret
) info
->flags
|= GUI_CARETBLINKING
;
3699 /******************************************************************
3700 * IsHungAppWindow (USER32.@)
3703 BOOL WINAPI
IsHungAppWindow( HWND hWnd
)
3707 SERVER_START_REQ( is_window_hung
)
3710 ret
= !wine_server_call_err( req
) && reply
->is_hung
;