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