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