?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed some direct accesses to GDI internal pen/brush/font
[wine/dcerpc.git] / windows / message.c
blob47d410d0adcd667761ea1240dea641d7308d24a6
1 /*
2 * Message queues related functions
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 */
6
7 #include <stdlib.h>
8 #include <string.h>
9 #include <ctype.h>
10 #include <sys/time.h>
11 #include <sys/types.h>
12
13 #include "wine/winbase16.h"
14 #include "wine/winuser16.h"
15 #include "message.h"
16 #include "winerror.h"
17 #include "wine/server.h"
18 #include "win.h"
19 #include "heap.h"
20 #include "hook.h"
21 #include "input.h"
22 #include "spy.h"
23 #include "winpos.h"
24 #include "dde.h"
25 #include "queue.h"
26 #include "winproc.h"
27 #include "user.h"
28 #include "thread.h"
29 #include "task.h"
30 #include "controls.h"
31 #include "debugtools.h"
32
33 DEFAULT_DEBUG_CHANNEL(msg);
34 DECLARE_DEBUG_CHANNEL(key);
35
36 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
37 #define WM_NCMOUSELAST WM_NCMBUTTONDBLCLK
38
39 #define QMSG_WIN16 1
40 #define QMSG_WIN32A 2
41 #define QMSG_WIN32W 3
42
43 static UINT doubleClickSpeed = 452;
44
45 static BOOL MSG_ConvertMsg( MSG *msg, int srcType, int dstType );
46
47
48
49 /* flag for messages that contain pointers */
50 /* 16 messages per entry, messages 0..15 map to bits 0..15 */
51
52 #define SET(msg) (1 << ((msg) & 15))
53
54 static const unsigned short message_pointer_flags[] =
55 {
56 /* 0x00 - 0x0f */
57 SET(WM_CREATE) | SET(WM_GETTEXT) | SET(WM_SETTEXT),
58 /* 0x10 - 0x1f */
59 SET(WM_WININICHANGE),
60 /* 0x20 - 0x2f */
61 SET(WM_GETMINMAXINFO) | SET(WM_DRAWITEM) | SET(WM_MEASUREITEM) | SET(WM_DELETEITEM),
62 /* 0x30 - 0x3f */
63 SET(WM_COMPAREITEM),
64 /* 0x40 - 0x4f */
65 SET(WM_WINDOWPOSCHANGING) | SET(WM_WINDOWPOSCHANGED) | SET(WM_COPYDATA) | SET(WM_NOTIFY),
66 /* 0x50 - 0x5f */
67 SET(WM_HELP),
68 /* 0x60 - 0x6f */
69 0,
70 /* 0x70 - 0x7f */
71 SET(WM_STYLECHANGING) | SET(WM_STYLECHANGED),
72 /* 0x80 - 0x8f */
73 SET(WM_NCCREATE) | SET(WM_NCCALCSIZE) | SET(WM_GETDLGCODE),
74 /* 0x90 - 0x9f */
75 0,
76 /* 0xa0 - 0xaf */
77 0,
78 /* 0xb0 - 0xbf */
79 SET(EM_GETSEL) | SET(EM_GETRECT) | SET(EM_SETRECT) | SET(EM_SETRECTNP),
80 /* 0xc0 - 0xcf */
81 SET(EM_REPLACESEL) | SET(EM_GETLINE) | SET(EM_SETTABSTOPS),
82 /* 0xd0 - 0xdf */
83 0,
84 /* 0xe0 - 0xef */
85 0,
86 /* 0xf0 - 0xff */
87 0,
88 /* 0x100 - 0x10f */
89 0,
90 /* 0x110 - 0x11f */
91 0,
92 /* 0x120 - 0x12f */
93 0,
94 /* 0x130 - 0x13f */
95 0,
96 /* 0x140 - 0x14f */
97 SET(CB_ADDSTRING) | SET(CB_DIR) | SET(CB_GETLBTEXT) | SET(CB_INSERTSTRING) |
98 SET(CB_FINDSTRING) | SET(CB_SELECTSTRING),
99 /* 0x150 - 0x15f */
100 SET(CB_GETDROPPEDCONTROLRECT) | SET(CB_FINDSTRINGEXACT),
101 /* 0x160 - 0x16f */
102 0,
103 /* 0x170 - 0x17f */
104 0,
105 /* 0x180 - 0x18f */
106 SET(LB_ADDSTRING) | SET(LB_INSERTSTRING) | SET(LB_GETTEXT) | SET(LB_SELECTSTRING) |
107 SET(LB_DIR) | SET(LB_FINDSTRING),
108 /* 0x190 - 0x19f */
109 SET(LB_GETSELITEMS) | SET(LB_SETTABSTOPS) | SET(LB_ADDFILE) | SET(LB_GETITEMRECT),
110 /* 0x1a0 - 0x1af */
111 SET(LB_FINDSTRINGEXACT),
112 /* 0x1b0 - 0x1bf */
113 0,
114 /* 0x1c0 - 0x1cf */
115 0,
116 /* 0x1d0 - 0x1df */
117 0,
118 /* 0x1e0 - 0x1ef */
119 0,
120 /* 0x1f0 - 0x1ff */
121 0,
122 /* 0x200 - 0x20f */
123 0,
124 /* 0x210 - 0x21f */
125 0,
126 /* 0x220 - 0x22f */
127 SET(WM_MDICREATE) | SET(WM_MDIGETACTIVE) | SET(WM_DROPOBJECT) |
128 SET(WM_QUERYDROPOBJECT) | SET(WM_DRAGSELECT) | SET(WM_DRAGMOVE)
129 };
130
131 #undef SET
132
133 /***********************************************************************
134 * is_pointer_message
135 */
136 inline static int is_pointer_message( UINT message )
137 {
138 if (message >= 8*sizeof(message_pointer_flags)) return FALSE;
139 return (message_pointer_flags[message / 16] & (1 << (message & 15))) != 0;
140 }
141
142
143 /***********************************************************************
144 * is_keyboard_message
145 */
146 inline static BOOL is_keyboard_message( UINT message )
147 {
148 return (message >= WM_KEYFIRST && message <= WM_KEYLAST);
149 }
150
151
152 /***********************************************************************
153 * is_mouse_message
154 */
155 inline static BOOL is_mouse_message( UINT message )
156 {
157 return ((message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST) ||
158 (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST));
159 }
160
161
162 /***********************************************************************
163 * check_message_filter
164 */
165 inline static BOOL check_message_filter( const MSG *msg, HWND hwnd, UINT first, UINT last )
166 {
167 if (hwnd)
168 {
169 if (msg->hwnd != hwnd && !IsChild( hwnd, msg->hwnd )) return FALSE;
170 }
171 if (first || last)
172 {
173 return (msg->message >= first && msg->message <= last);
174 }
175 return TRUE;
176 }
177
178
179 /***********************************************************************
180 * map_wparam_AtoW
181 *
182 * Convert the wparam of an ASCII message to Unicode.
183 */
184 static WPARAM map_wparam_AtoW( UINT message, WPARAM wparam )
185 {
186 if (message == WM_CHARTOITEM ||
187 message == EM_SETPASSWORDCHAR ||
188 message == WM_CHAR ||
189 message == WM_DEADCHAR ||
190 message == WM_SYSCHAR ||
191 message == WM_SYSDEADCHAR ||
192 message == WM_MENUCHAR)
193 {
194 char ch = LOWORD(wparam);
195 WCHAR wch;
196 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
197 wparam = MAKEWPARAM( wch, HIWORD(wparam) );
198 }
199 return wparam;
200 }
201
202
203 /***********************************************************************
204 * map_wparam_WtoA
205 *
206 * Convert the wparam of a Unicode message to ASCII.
207 */
208 static WPARAM map_wparam_WtoA( UINT message, WPARAM wparam )
209 {
210 if (message == WM_CHARTOITEM ||
211 message == EM_SETPASSWORDCHAR ||
212 message == WM_CHAR ||
213 message == WM_DEADCHAR ||
214 message == WM_SYSCHAR ||
215 message == WM_SYSDEADCHAR ||
216 message == WM_MENUCHAR)
217 {
218 WCHAR wch = LOWORD(wparam);
219 char ch;
220 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL );
221 wparam = MAKEWPARAM( ch, HIWORD(wparam) );
222 }
223 return wparam;
224 }
225
226
227 /***********************************************************************
228 * queue_hardware_message
229 *
230 * store a hardware message in the thread queue
231 */
232 static void queue_hardware_message( MSG *msg, ULONG_PTR extra_info, enum message_kind kind )
233 {
234 SERVER_START_REQ( send_message )
235 {
236 req->kind = kind;
237 req->id = (void *)GetWindowThreadProcessId( msg->hwnd, NULL );
238 req->type = 0;
239 req->win = msg->hwnd;
240 req->msg = msg->message;
241 req->wparam = msg->wParam;
242 req->lparam = msg->lParam;
243 req->x = msg->pt.x;
244 req->y = msg->pt.y;
245 req->time = msg->time;
246 req->info = extra_info;
247 SERVER_CALL();
248 }
249 SERVER_END_REQ;
250 }
251
252
253 /***********************************************************************
254 * MSG_SendParentNotify
255 *
256 * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
257 * the window has the WS_EX_NOPARENTNOTIFY style.
258 */
259 static void MSG_SendParentNotify( HWND hwnd, WORD event, WORD idChild, POINT pt )
260 {
261 WND *tmpWnd = WIN_FindWndPtr(hwnd);
262
263 /* pt has to be in the client coordinates of the parent window */
264 MapWindowPoints( 0, tmpWnd->hwndSelf, &pt, 1 );
265 while (tmpWnd)
266 {
267 if (!(tmpWnd->dwStyle & WS_CHILD) || (tmpWnd->dwExStyle & WS_EX_NOPARENTNOTIFY))
268 {
269 WIN_ReleaseWndPtr(tmpWnd);
270 break;
271 }
272 pt.x += tmpWnd->rectClient.left;
273 pt.y += tmpWnd->rectClient.top;
274 WIN_UpdateWndPtr(&tmpWnd,tmpWnd->parent);
275 SendMessageA( tmpWnd->hwndSelf, WM_PARENTNOTIFY,
276 MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
277 }
278 }
279
280
281 /***********************************************************************
282 * MSG_JournalPlayBackMsg
283 *
284 * Get an EVENTMSG struct via call JOURNALPLAYBACK hook function
285 */
286 static void MSG_JournalPlayBackMsg(void)
287 {
288 EVENTMSG tmpMsg;
289 MSG msg;
290 LRESULT wtime;
291 int keyDown,i;
292
293 if (!HOOK_IsHooked( WH_JOURNALPLAYBACK )) return;
294
295 wtime=HOOK_CallHooksA( WH_JOURNALPLAYBACK, HC_GETNEXT, 0, (LPARAM)&tmpMsg );
296 /* TRACE(msg,"Playback wait time =%ld\n",wtime); */
297 if (wtime<=0)
298 {
299 wtime=0;
300 msg.message = tmpMsg.message;
301 msg.hwnd = tmpMsg.hwnd;
302 msg.time = tmpMsg.time;
303 if ((tmpMsg.message >= WM_KEYFIRST) && (tmpMsg.message <= WM_KEYLAST))
304 {
305 msg.wParam = tmpMsg.paramL & 0xFF;
306 msg.lParam = MAKELONG(tmpMsg.paramH&0x7ffff,tmpMsg.paramL>>8);
307 if (tmpMsg.message == WM_KEYDOWN || tmpMsg.message == WM_SYSKEYDOWN)
308 {
309 for (keyDown=i=0; i<256 && !keyDown; i++)
310 if (InputKeyStateTable[i] & 0x80)
311 keyDown++;
312 if (!keyDown)
313 msg.lParam |= 0x40000000;
314 AsyncKeyStateTable[msg.wParam]=InputKeyStateTable[msg.wParam] |= 0x80;
315 }
316 else /* WM_KEYUP, WM_SYSKEYUP */
317 {
318 msg.lParam |= 0xC0000000;
319 AsyncKeyStateTable[msg.wParam]=InputKeyStateTable[msg.wParam] &= ~0x80;
320 }
321 if (InputKeyStateTable[VK_MENU] & 0x80)
322 msg.lParam |= 0x20000000;
323 if (tmpMsg.paramH & 0x8000) /*special_key bit*/
324 msg.lParam |= 0x01000000;
325
326 msg.pt.x = msg.pt.y = 0;
327 queue_hardware_message( &msg, 0, RAW_HW_MESSAGE );
328 }
329 else if ((tmpMsg.message>= WM_MOUSEFIRST) && (tmpMsg.message <= WM_MOUSELAST))
330 {
331 switch (tmpMsg.message)
332 {
333 case WM_LBUTTONDOWN:
334 MouseButtonsStates[0]=AsyncMouseButtonsStates[0]=TRUE;break;
335 case WM_LBUTTONUP:
336 MouseButtonsStates[0]=AsyncMouseButtonsStates[0]=FALSE;break;
337 case WM_MBUTTONDOWN:
338 MouseButtonsStates[1]=AsyncMouseButtonsStates[1]=TRUE;break;
339 case WM_MBUTTONUP:
340 MouseButtonsStates[1]=AsyncMouseButtonsStates[1]=FALSE;break;
341 case WM_RBUTTONDOWN:
342 MouseButtonsStates[2]=AsyncMouseButtonsStates[2]=TRUE;break;
343 case WM_RBUTTONUP:
344 MouseButtonsStates[2]=AsyncMouseButtonsStates[2]=FALSE;break;
345 }
346 AsyncKeyStateTable[VK_LBUTTON]= InputKeyStateTable[VK_LBUTTON] = MouseButtonsStates[0] ? 0x80 : 0;
347 AsyncKeyStateTable[VK_MBUTTON]= InputKeyStateTable[VK_MBUTTON] = MouseButtonsStates[1] ? 0x80 : 0;
348 AsyncKeyStateTable[VK_RBUTTON]= InputKeyStateTable[VK_RBUTTON] = MouseButtonsStates[2] ? 0x80 : 0;
349 SetCursorPos(tmpMsg.paramL,tmpMsg.paramH);
350 msg.lParam=MAKELONG(tmpMsg.paramL,tmpMsg.paramH);
351 msg.wParam=0;
352 if (MouseButtonsStates[0]) msg.wParam |= MK_LBUTTON;
353 if (MouseButtonsStates[1]) msg.wParam |= MK_MBUTTON;
354 if (MouseButtonsStates[2]) msg.wParam |= MK_RBUTTON;
355
356 msg.pt.x = tmpMsg.paramL;
357 msg.pt.y = tmpMsg.paramH;
358 queue_hardware_message( &msg, 0, RAW_HW_MESSAGE );
359 }
360 HOOK_CallHooksA( WH_JOURNALPLAYBACK, HC_SKIP, 0, (LPARAM)&tmpMsg);
361 }
362 else
363 {
364 if( tmpMsg.message == WM_QUEUESYNC )
365 if (HOOK_IsHooked( WH_CBT ))
366 HOOK_CallHooksA( WH_CBT, HCBT_QS, 0, 0L);
367 }
368 }
369
370
371 /***********************************************************************
372 * process_raw_keyboard_message
373 *
374 * returns TRUE if the contents of 'msg' should be passed to the application
375 */
376 static BOOL process_raw_keyboard_message( MSG *msg, ULONG_PTR extra_info )
377 {
378 if (!(msg->hwnd = GetFocus()))
379 {
380 /* Send the message to the active window instead, */
381 /* translating messages to their WM_SYS equivalent */
382 msg->hwnd = GetActiveWindow();
383 if (msg->message < WM_SYSKEYDOWN) msg->message += WM_SYSKEYDOWN - WM_KEYDOWN;
384 }
385
386 if (HOOK_IsHooked( WH_JOURNALRECORD ))
387 {
388 EVENTMSG event;
389
390 event.message = msg->message;
391 event.hwnd = msg->hwnd;
392 event.time = msg->time;
393 event.paramL = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
394 event.paramH = msg->lParam & 0x7FFF;
395 if (HIWORD(msg->lParam) & 0x0100) event.paramH |= 0x8000; /* special_key - bit */
396 HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event );
397 }
398
399 return (msg->hwnd != 0);
400 }
401
402
403 /***********************************************************************
404 * process_cooked_keyboard_message
405 *
406 * returns TRUE if the contents of 'msg' should be passed to the application
407 */
408 static BOOL process_cooked_keyboard_message( MSG *msg, BOOL remove )
409 {
410 if (remove)
411 {
412 /* Handle F1 key by sending out WM_HELP message */
413 if ((msg->message == WM_KEYUP) &&
414 (msg->wParam == VK_F1) &&
415 (msg->hwnd != GetDesktopWindow()) &&
416 !MENU_IsMenuActive())
417 {
418 HELPINFO hi;
419 hi.cbSize = sizeof(HELPINFO);
420 hi.iContextType = HELPINFO_WINDOW;
421 hi.iCtrlId = GetWindowLongA( msg->hwnd, GWL_ID );
422 hi.hItemHandle = msg->hwnd;
423 hi.dwContextId = GetWindowContextHelpId( msg->hwnd );
424 hi.MousePos = msg->pt;
425 SendMessageA(msg->hwnd, WM_HELP, 0, (LPARAM)&hi);
426 }
427 }
428
429 if (HOOK_CallHooksA( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
430 LOWORD(msg->wParam), msg->lParam ))
431 {
432 /* skip this message */
433 HOOK_CallHooksA( WH_CBT, HCBT_KEYSKIPPED, LOWORD(msg->wParam), msg->lParam );
434 return FALSE;
435 }
436 return TRUE;
437 }
438
439
440 /***********************************************************************
441 * process_raw_mouse_message
442 *
443 * returns TRUE if the contents of 'msg' should be passed to the application
444 */
445 static BOOL process_raw_mouse_message( MSG *msg, ULONG_PTR extra_info )
446 {
447 static MSG clk_msg;
448
449 POINT pt;
450 INT ht, hittest;
451
452 /* find the window to dispatch this mouse message to */
453
454 hittest = HTCLIENT;
455 if (!(msg->hwnd = PERQDATA_GetCaptureWnd( &ht )))
456 {
457 /* If no capture HWND, find window which contains the mouse position.
458 * Also find the position of the cursor hot spot (hittest) */
459 HWND hWndScope = (HWND)extra_info;
460
461 if (!IsWindow(hWndScope)) hWndScope = 0;
462 if (!(msg->hwnd = WINPOS_WindowFromPoint( hWndScope, msg->pt, &hittest )))
463 msg->hwnd = GetDesktopWindow();
464 ht = hittest;
465 }
466
467 if (HOOK_IsHooked( WH_JOURNALRECORD ))
468 {
469 EVENTMSG event;
470 event.message = msg->message;
471 event.time = msg->time;
472 event.hwnd = msg->hwnd;
473 event.paramL = msg->pt.x;
474 event.paramH = msg->pt.y;
475 HOOK_CallHooksA( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event );
476 }
477
478 /* translate double clicks */
479
480 if ((msg->message == WM_LBUTTONDOWN) ||
481 (msg->message == WM_RBUTTONDOWN) ||
482 (msg->message == WM_MBUTTONDOWN))
483 {
484 BOOL update = TRUE;
485 /* translate double clicks -
486 * note that ...MOUSEMOVEs can slip in between
487 * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
488
489 if (GetClassLongA( msg->hwnd, GCL_STYLE ) & CS_DBLCLKS || ht != HTCLIENT )
490 {
491 if ((msg->message == clk_msg.message) &&
492 (msg->hwnd == clk_msg.hwnd) &&
493 (msg->time - clk_msg.time < doubleClickSpeed) &&
494 (abs(msg->pt.x - clk_msg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK)/2) &&
495 (abs(msg->pt.y - clk_msg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK)/2))
496 {
497 msg->message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
498 clk_msg.message = 0;
499 update = FALSE;
500 }
501 }
502 /* update static double click conditions */
503 if (update) clk_msg = *msg;
504 }
505
506 pt = msg->pt;
507 /* Note: windows has no concept of a non-client wheel message */
508 if (hittest != HTCLIENT && msg->message != WM_MOUSEWHEEL)
509 {
510 msg->message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
511 msg->wParam = hittest;
512 }
513 else ScreenToClient( msg->hwnd, &pt );
514 msg->lParam = MAKELONG( pt.x, pt.y );
515 return TRUE;
516 }
517
518
519 /***********************************************************************
520 * process_cooked_mouse_message
521 *
522 * returns TRUE if the contents of 'msg' should be passed to the application
523 */
524 static BOOL process_cooked_mouse_message( MSG *msg, BOOL remove )
525 {
526 INT hittest = HTCLIENT;
527 UINT raw_message = msg->message;
528 BOOL eatMsg;
529
530 if (msg->message >= WM_NCMOUSEFIRST && msg->message <= WM_NCMOUSELAST)
531 {
532 raw_message += WM_MOUSEFIRST - WM_NCMOUSEFIRST;
533 hittest = msg->wParam;
534 }
535 if (raw_message == WM_LBUTTONDBLCLK ||
536 raw_message == WM_RBUTTONDBLCLK ||
537 raw_message == WM_MBUTTONDBLCLK)
538 {
539 raw_message += WM_LBUTTONDOWN - WM_LBUTTONDBLCLK;
540 }
541
542 if (HOOK_IsHooked( WH_MOUSE ))
543 {
544 MOUSEHOOKSTRUCT hook;
545 hook.pt = msg->pt;
546 hook.hwnd = msg->hwnd;
547 hook.wHitTestCode = hittest;
548 hook.dwExtraInfo = 0;
549 if (HOOK_CallHooksA( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
550 msg->message, (LPARAM)&hook ))
551 {
552 hook.pt = msg->pt;
553 hook.hwnd = msg->hwnd;
554 hook.wHitTestCode = hittest;
555 hook.dwExtraInfo = 0;
556 HOOK_CallHooksA( WH_CBT, HCBT_CLICKSKIPPED, msg->message, (LPARAM)&hook );
557 return FALSE;
558 }
559 }
560
561 if ((hittest == HTERROR) || (hittest == HTNOWHERE))
562 {
563 SendMessageA( msg->hwnd, WM_SETCURSOR, msg->hwnd, MAKELONG( hittest, raw_message ));
564 return FALSE;
565 }
566
567 if (!remove || GetCapture()) return TRUE;
568
569 eatMsg = FALSE;
570
571 if ((raw_message == WM_LBUTTONDOWN) ||
572 (raw_message == WM_RBUTTONDOWN) ||
573 (raw_message == WM_MBUTTONDOWN))
574 {
575 HWND hwndTop = WIN_GetTopParent( msg->hwnd );
576
577 /* Send the WM_PARENTNOTIFY,
578 * note that even for double/nonclient clicks
579 * notification message is still WM_L/M/RBUTTONDOWN.
580 */
581 MSG_SendParentNotify( msg->hwnd, raw_message, 0, msg->pt );
582
583 /* Activate the window if needed */
584
585 if (msg->hwnd != GetActiveWindow() && hwndTop != GetDesktopWindow())
586 {
587 LONG ret = SendMessageA( msg->hwnd, WM_MOUSEACTIVATE, hwndTop,
588 MAKELONG( hittest, raw_message ) );
589
590 switch(ret)
591 {
592 case MA_NOACTIVATEANDEAT:
593 eatMsg = TRUE;
594 /* fall through */
595 case MA_NOACTIVATE:
596 break;
597 case MA_ACTIVATEANDEAT:
598 eatMsg = TRUE;
599 /* fall through */
600 case MA_ACTIVATE:
601 if (hwndTop != GetForegroundWindow() )
602 {
603 if (!WINPOS_SetActiveWindow( hwndTop, TRUE , TRUE ))
604 eatMsg = TRUE;
605 }
606 break;
607 default:
608 WARN( "unknown WM_MOUSEACTIVATE code %ld\n", ret );
609 break;
610 }
611 }
612 }
613
614 /* send the WM_SETCURSOR message */
615
616 /* Windows sends the normal mouse message as the message parameter
617 in the WM_SETCURSOR message even if it's non-client mouse message */
618 SendMessageA( msg->hwnd, WM_SETCURSOR, msg->hwnd, MAKELONG( hittest, raw_message ));
619
620 return !eatMsg;
621 }
622
623
624 /***********************************************************************
625 * process_hardware_message
626 *
627 * returns TRUE if the contents of 'msg' should be passed to the application
628 */
629 static BOOL process_raw_hardware_message( MSG *msg, ULONG_PTR extra_info, HWND hwnd_filter,
630 UINT first, UINT last, BOOL remove )
631 {
632 if (is_keyboard_message( msg->message ))
633 {
634 if (!process_raw_keyboard_message( msg, extra_info )) return FALSE;
635 }
636 else if (is_mouse_message( msg->message ))
637 {
638 if (!process_raw_mouse_message( msg, extra_info )) return FALSE;
639 }
640 else
641 {
642 ERR( "unknown message type %x\n", msg->message );
643 return FALSE;
644 }
645
646 /* check destination thread and filters */
647 if (!check_message_filter( msg, hwnd_filter, first, last ) ||
648 GetWindowThreadProcessId( msg->hwnd, NULL ) != GetCurrentThreadId())
649 {
650 /* queue it for later, or for another thread */
651 queue_hardware_message( msg, extra_info, COOKED_HW_MESSAGE );
652 return FALSE;
653 }
654
655 /* save the message in the cooked queue if we didn't want to remove it */
656 if (!remove) queue_hardware_message( msg, extra_info, COOKED_HW_MESSAGE );
657 return TRUE;
658 }
659
660
661 /***********************************************************************
662 * process_cooked_hardware_message
663 *
664 * returns TRUE if the contents of 'msg' should be passed to the application
665 */
666 static BOOL process_cooked_hardware_message( MSG *msg, BOOL remove )
667 {
668 if (is_keyboard_message( msg->message ))
669 return process_cooked_keyboard_message( msg, remove );
670
671 if (is_mouse_message( msg->message ))
672 return process_cooked_mouse_message( msg, remove );
673
674 ERR( "unknown message type %x\n", msg->message );
675 return FALSE;
676 }
677
678
679 /***********************************************************************
680 * handle_sent_message
681 *
682 * Handle the reception of a sent message by calling the corresponding window proc
683 */
684 static void handle_sent_message( MSG *msg, int type, ULONG_PTR extra_info )
685 {
686 LRESULT result = 0;
687 MESSAGEQUEUE *queue = QUEUE_Lock( GetFastQueue16() );
688 ULONG_PTR old_extra_info = queue->GetMessageExtraInfoVal; /* save ExtraInfo */
689 WND *wndPtr = WIN_FindWndPtr( msg->hwnd );
690
691 TRACE( "got hwnd %x msg %x (%s) wp %x lp %lx\n",
692 msg->hwnd, msg->message, SPY_GetMsgName(msg->message),
693 msg->wParam, msg->lParam );
694
695 queue->GetMessageExtraInfoVal = extra_info;
696
697 /* call the right version of CallWindowProcXX */
698 switch(type)
699 {
700 case QMSG_WIN16:
701 result = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
702 (HWND16) msg->hwnd,
703 (UINT16) msg->message,
704 LOWORD(msg->wParam),
705 msg->lParam );
706 break;
707 case QMSG_WIN32A:
708 result = CallWindowProcA( wndPtr->winproc, msg->hwnd, msg->message,
709 msg->wParam, msg->lParam );
710 break;
711 case QMSG_WIN32W:
712 result = CallWindowProcW( wndPtr->winproc, msg->hwnd, msg->message,
713 msg->wParam, msg->lParam );
714 break;
715 }
716
717 queue->GetMessageExtraInfoVal = old_extra_info; /* Restore extra info */
718 WIN_ReleaseWndPtr(wndPtr);
719 QUEUE_Unlock( queue );
720
721 SERVER_START_REQ( reply_message )
722 {
723 req->result = result;
724 req->remove = 1;
725 SERVER_CALL();
726 }
727 SERVER_END_REQ;
728 }
729
730
731 /***********************************************************************
732 * process_sent_messages
733 *
734 * Process all pending sent messages
735 */
736 static void process_sent_messages(void)
737 {
738 MSG msg;
739 int type;
740 unsigned int res;
741 ULONG_PTR extra_info;
742
743 for (;;)
744 {
745 SERVER_START_REQ( get_message )
746 {
747 req->flags = GET_MSG_REMOVE | GET_MSG_SENT_ONLY;
748 req->get_win = 0;
749 req->get_first = 0;
750 req->get_last = ~0;
751 if (!(res = SERVER_CALL()))
752 {
753 type = req->type;
754 msg.hwnd = req->win;
755 msg.message = req->msg;
756 msg.wParam = req->wparam;
757 msg.lParam = req->lparam;
758 msg.time = req->time;
759 msg.pt.x = req->x;
760 msg.pt.y = req->y;
761 extra_info = req->info;
762 }
763 }
764 SERVER_END_REQ;
765
766 if (res) break;
767 handle_sent_message( &msg, type, extra_info );
768 }
769 }
770
771
772
773 /***********************************************************************
774 * peek_message
775 *
776 * Peek for a message matching the given parameters. Return FALSE if none available.
777 */
778 static BOOL peek_message( HWND hwnd, UINT first, UINT last, int flags, int type,
779 MSG *msg, ULONG_PTR *extra_info )
780 {
781 BOOL ret = FALSE;
782 enum message_kind kind;
783 int msg_type;
784
785 if (!first && !last) last = ~0;
786
787 for (;;)
788 {
789 SERVER_START_REQ( get_message )
790 {
791 req->flags = flags;
792 req->get_win = hwnd;
793 req->get_first = first;
794 req->get_last = last;
795 if ((ret = !SERVER_CALL()))
796 {
797 kind = req->kind;
798 msg_type = req->type;
799 msg->hwnd = req->win;
800 msg->message = req->msg;
801 msg->wParam = req->wparam;
802 msg->lParam = req->lparam;
803 msg->time = req->time;
804 msg->pt.x = req->x;
805 msg->pt.y = req->y;
806 *extra_info = req->info;
807 }
808 }
809 SERVER_END_REQ;
810
811 if (!ret) return FALSE;
812
813 switch(kind)
814 {
815 case SEND_MESSAGE:
816 handle_sent_message( msg, msg_type, *extra_info );
817 continue;
818 case POST_MESSAGE:
819 /* try to convert message to requested type */
820 if (!MSG_ConvertMsg( msg, msg_type, type ))
821 {
822 ERR( "Message %s of wrong type contains pointer parameters. Skipped!\n",
823 SPY_GetMsgName(msg->message));
824 /* remove it */
825 flags |= GET_MSG_REMOVE_LAST;
826 continue;
827 }
828 break;
829 case RAW_HW_MESSAGE:
830 if (!process_raw_hardware_message( msg, *extra_info,
831 hwnd, first, last, flags & GET_MSG_REMOVE ))
832 continue;
833 /* fall through */
834 case COOKED_HW_MESSAGE:
835 if (!process_cooked_hardware_message( msg, flags & GET_MSG_REMOVE ))
836 {
837 flags |= GET_MSG_REMOVE_LAST;
838 continue;
839 }
840 break;
841 }
842
843 /* now we got something */
844 TRACE( "got hwnd %x msg %x (%s) wp %x lp %lx\n",
845 msg->hwnd, msg->message, SPY_GetMsgName(msg->message),
846 msg->wParam, msg->lParam );
847 return TRUE;
848 }
849 }
850
851
852 /***********************************************************************
853 * wait_queue_bits
854 *
855 * See "Windows Internals", p.447
856 *
857 * return values:
858 * 0 if exit with timeout
859 * 1 otherwise
860 */
861 static int wait_queue_bits( WORD bits, DWORD timeout )
862 {
863 MESSAGEQUEUE *queue;
864 HQUEUE16 hQueue;
865
866 TRACE_(msg)("q %04x waiting for %04x\n", GetFastQueue16(), bits);
867
868 hQueue = GetFastQueue16();
869 if (!(queue = QUEUE_Lock( hQueue ))) return 0;
870
871 for (;;)
872 {
873 unsigned int wake_bits = 0, changed_bits = 0;
874 DWORD dwlc;
875
876 SERVER_START_REQ( set_queue_mask )
877 {
878 req->wake_mask = QS_SENDMESSAGE;
879 req->changed_mask = bits | QS_SENDMESSAGE;
880 req->skip_wait = 1;
881 if (!SERVER_CALL())
882 {
883 wake_bits = req->wake_bits;
884 changed_bits = req->changed_bits;
885 }
886 }
887 SERVER_END_REQ;
888
889 if (changed_bits & bits)
890 {
891 /* One of the bits is set; we can return */
892 QUEUE_Unlock( queue );
893 return 1;
894 }
895 if (wake_bits & QS_SENDMESSAGE)
896 {
897 /* Process the sent message immediately */
898 process_sent_messages();
899 continue; /* nested sm crux */
900 }
901
902 TRACE_(msg)("(%04x) mask=%08x, bits=%08x, changed=%08x, waiting\n",
903 queue->self, bits, wake_bits, changed_bits );
904
905 ReleaseThunkLock( &dwlc );
906 if (dwlc) TRACE_(msg)("had win16 lock\n");
907
908 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
909 USER_Driver.pMsgWaitForMultipleObjectsEx( 1, &queue->server_queue, timeout, 0, 0 );
910 else
911 WaitForSingleObject( queue->server_queue, timeout );
912 if (dwlc) RestoreThunkLock( dwlc );
913 }
914 }
915
916
917 /**********************************************************************
918 * SetDoubleClickTime (USER.20)
919 */
920 void WINAPI SetDoubleClickTime16( UINT16 interval )
921 {
922 SetDoubleClickTime( interval );
923 }
924
925
926 /**********************************************************************
927 * SetDoubleClickTime (USER32.@)
928 */
929 BOOL WINAPI SetDoubleClickTime( UINT interval )
930 {
931 doubleClickSpeed = interval ? interval : 500;
932 return TRUE;
933 }
934
935
936 /**********************************************************************
937 * GetDoubleClickTime (USER.21)
938 */
939 UINT16 WINAPI GetDoubleClickTime16(void)
940 {
941 return doubleClickSpeed;
942 }
943
944
945 /**********************************************************************
946 * GetDoubleClickTime (USER32.@)
947 */
948 UINT WINAPI GetDoubleClickTime(void)
949 {
950 return doubleClickSpeed;
951 }
952
953
954 /***********************************************************************
955 * MSG_SendMessageInterThread
956 *
957 * Implementation of an inter-task SendMessage.
958 * Return values:
959 * 0 if error or timeout
960 * 1 if successful
961 */
962 static LRESULT MSG_SendMessageInterThread( DWORD dest_tid, HWND hwnd, UINT msg,
963 WPARAM wParam, LPARAM lParam,
964 DWORD timeout, WORD type,
965 LRESULT *pRes)
966 {
967 BOOL ret;
968 int iWndsLocks;
969 LRESULT result = 0;
970
971 TRACE( "hwnd %x msg %x (%s) wp %x lp %lx\n", hwnd, msg, SPY_GetMsgName(msg), wParam, lParam );
972
973 SERVER_START_REQ( send_message )
974 {
975 req->kind = SEND_MESSAGE;
976 req->id = (void *)dest_tid;
977 req->type = type;
978 req->win = hwnd;
979 req->msg = msg;
980 req->wparam = wParam;
981 req->lparam = lParam;
982 req->x = 0;
983 req->y = 0;
984 req->time = GetCurrentTime();
985 req->info = 0;
986 ret = !SERVER_CALL_ERR();
987 }
988 SERVER_END_REQ;
989 if (!ret) return 0;
990
991 iWndsLocks = WIN_SuspendWndsLock();
992
993 /* wait for the result */
994 wait_queue_bits( QS_SMRESULT, timeout );
995
996 SERVER_START_REQ( get_message_reply )
997 {
998 req->cancel = 1;
999 if ((ret = !SERVER_CALL_ERR())) result = req->result;
1000 }
1001 SERVER_END_REQ;
1002
1003 TRACE( "hwnd %x msg %x (%s) wp %x lp %lx got reply %lx (err=%ld)\n",
1004 hwnd, msg, SPY_GetMsgName(msg), wParam, lParam, result, GetLastError() );
1005
1006 if (!ret && (GetLastError() == ERROR_IO_PENDING))
1007 {
1008 if (timeout == INFINITE) ERR("no timeout but no result\n");
1009 SetLastError(0); /* timeout */
1010 }
1011
1012 if (pRes) *pRes = result;
1013
1014 WIN_RestoreWndsLock(iWndsLocks);
1015 return ret;
1016 }
1017
1018
1019 /***********************************************************************
1020 * ReplyMessage (USER.115)
1021 */
1022 void WINAPI ReplyMessage16( LRESULT result )
1023 {
1024 ReplyMessage( result );
1025 }
1026
1027 /***********************************************************************
1028 * ReplyMessage (USER32.@)
1029 */
1030 BOOL WINAPI ReplyMessage( LRESULT result )
1031 {
1032 BOOL ret;
1033 SERVER_START_REQ( reply_message )
1034 {
1035 req->result = result;
1036 req->remove = 0;
1037 ret = !SERVER_CALL_ERR();
1038 }
1039 SERVER_END_REQ;
1040 return ret;
1041 }
1042
1043 /***********************************************************************
1044 * MSG_ConvertMsg
1045 */
1046 static BOOL MSG_ConvertMsg( MSG *msg, int srcType, int dstType )
1047 {
1048 if (srcType == QMSG_WIN32A || dstType == QMSG_WIN32A)
1049 {
1050 /* posted messages are always either Win16 or Unicode Win32,
1051 * QMSG_WIN32A is only for sent messages */
1052 ERR( "invalid type %d/%d\n", srcType, dstType );
1053 return FALSE;
1054 }
1055
1056 if (!srcType || srcType == dstType) return TRUE;
1057
1058 if (srcType == QMSG_WIN16)
1059 {
1060 if (dstType == QMSG_WIN32W)
1061 {
1062 switch ( WINPROC_MapMsg16To32W( msg->hwnd, msg->message, msg->wParam,
1063 &msg->message, &msg->wParam, &msg->lParam ) )
1064 {
1065 case 0:
1066 return TRUE;
1067 case 1:
1068 /* Pointer messages were mapped --> need to free allocated memory and fail */
1069 WINPROC_UnmapMsg16To32W( msg->hwnd, msg->message, msg->wParam, msg->lParam, 0 );
1070 default:
1071 return FALSE;
1072 }
1073 }
1074 }
1075 else if (srcType == QMSG_WIN32W)
1076 {
1077 if (dstType == QMSG_WIN16)
1078 {
1079 UINT16 msg16;
1080 MSGPARAM16 mp16;
1081
1082 mp16.lParam = msg->lParam;
1083 switch ( WINPROC_MapMsg32WTo16( msg->hwnd, msg->message, msg->wParam,
1084 &msg16, &mp16.wParam, &mp16.lParam ) )
1085 {
1086 case 0:
1087 msg->message = msg16;
1088 msg->wParam = mp16.wParam;
1089 msg->lParam = mp16.lParam;
1090 return TRUE;
1091 case 1:
1092 /* Pointer messages were mapped --> need to free allocated memory and fail */
1093 WINPROC_UnmapMsg32WTo16( msg->hwnd, msg->message, msg->wParam, msg->lParam, &mp16 );
1094 default:
1095 return FALSE;
1096 }
1097 }
1098 }
1099
1100 FIXME( "Invalid message type(s): %d / %d\n", srcType, dstType );
1101 return FALSE;
1102 }
1103
1104
1105 /***********************************************************************
1106 * MSG_PeekMessage
1107 */
1108 static BOOL MSG_PeekMessage( int type, LPMSG msg_out, HWND hwnd,
1109 DWORD first, DWORD last, WORD flags, BOOL peek )
1110 {
1111 int mask, msg_flags = 0;
1112 MESSAGEQUEUE *msgQueue;
1113 int iWndsLocks;
1114 MSG msg;
1115 ULONG_PTR extra_info;
1116
1117 mask = QS_POSTMESSAGE | QS_SENDMESSAGE; /* Always selected */
1118 if (first || last)
1119 {
1120 if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
1121 if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
1122 ((first <= WM_NCMOUSELAST) && (last >= WM_NCMOUSEFIRST)) ) mask |= QS_MOUSE;
1123 if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
1124 if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
1125 if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
1126 }
1127 else mask |= QS_MOUSE | QS_KEY | QS_TIMER | QS_PAINT;
1128
1129 if (IsTaskLocked16()) flags |= PM_NOYIELD;
1130
1131 iWndsLocks = WIN_SuspendWndsLock();
1132
1133 /* check for graphics events */
1134 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
1135 USER_Driver.pMsgWaitForMultipleObjectsEx( 0, NULL, 0, 0, 0 );
1136
1137 if (flags & PM_REMOVE) msg_flags |= GET_MSG_REMOVE;
1138
1139 while(1)
1140 {
1141 if (peek_message( hwnd, first, last, msg_flags, type, &msg, &extra_info ))
1142 {
1143 /* need to fill the window handle for WM_PAINT message */
1144 if (msg.message == WM_PAINT)
1145 {
1146 if ((msg.hwnd = WIN_FindWinToRepaint( hwnd )))
1147 {
1148 if (IsIconic( msg.hwnd ) && GetClassLongA( msg.hwnd, GCL_HICON ))
1149 {
1150 msg.message = WM_PAINTICON;
1151 msg.wParam = 1;
1152 }
1153 if( !hwnd || msg.hwnd == hwnd || IsChild(hwnd,msg.hwnd) )
1154 {
1155 /* clear internal paint flag */
1156 RedrawWindow( msg.hwnd, NULL, 0,
1157 RDW_NOINTERNALPAINT | RDW_NOCHILDREN );
1158 break;
1159 }
1160 }
1161 }
1162 else break;
1163 }
1164
1165 /* FIXME: should be done before checking for hw events */
1166 MSG_JournalPlayBackMsg();
1167
1168 if (peek)
1169 {
1170 #if 0 /* FIXME */
1171 if (!(flags & PM_NOYIELD)) UserYield16();
1172 #endif
1173 WIN_RestoreWndsLock(iWndsLocks);
1174 return FALSE;
1175 }
1176
1177 wait_queue_bits( mask, INFINITE );
1178 }
1179
1180 WIN_RestoreWndsLock(iWndsLocks);
1181
1182 if ((msgQueue = QUEUE_Lock( GetFastQueue16() )))
1183 {
1184 msgQueue->GetMessageTimeVal = msg.time;
1185 msgQueue->GetMessagePosVal = MAKELONG( msg.pt.x, msg.pt.y );
1186 msgQueue->GetMessageExtraInfoVal = extra_info;
1187 QUEUE_Unlock( msgQueue );
1188 }
1189
1190 /* We got a message */
1191 if (flags & PM_REMOVE)
1192 {
1193 if (msg.message == WM_KEYDOWN || msg.message == WM_SYSKEYDOWN)
1194 {
1195 BYTE *p = &QueueKeyStateTable[msg.wParam & 0xff];
1196
1197 if (!(*p & 0x80))
1198 *p ^= 0x01;
1199 *p |= 0x80;
1200 }
1201 else if (msg.message == WM_KEYUP || msg.message == WM_SYSKEYUP)
1202 QueueKeyStateTable[msg.wParam & 0xff] &= ~0x80;
1203 }
1204
1205 /* copy back our internal safe copy of message data to msg_out.
1206 * msg_out is a variable from the *program*, so it can't be used
1207 * internally as it can get "corrupted" by our use of SendMessage()
1208 * (back to the program) inside the message handling itself. */
1209 *msg_out = msg;
1210 if (peek)
1211 return TRUE;
1212
1213 else
1214 return (msg.message != WM_QUIT);
1215 }
1216
1217 /***********************************************************************
1218 * MSG_InternalGetMessage
1219 *
1220 * GetMessage() function for internal use. Behave like GetMessage(),
1221 * but also call message filters and optionally send WM_ENTERIDLE messages.
1222 * 'hwnd' must be the handle of the dialog or menu window.
1223 * 'code' is the message filter value (MSGF_??? codes).
1224 */
1225 BOOL MSG_InternalGetMessage( MSG *msg, HWND hwnd, HWND hwndOwner, UINT first, UINT last,
1226 WPARAM code, WORD flags, BOOL sendIdle, BOOL* idleSent )
1227 {
1228 for (;;)
1229 {
1230 if (sendIdle)
1231 {
1232 if (!MSG_PeekMessage( QMSG_WIN32W, msg, 0, first, last, flags, TRUE ))
1233 {
1234 /* No message present -> send ENTERIDLE and wait */
1235 if (IsWindow(hwndOwner))
1236 {
1237 SendMessageA( hwndOwner, WM_ENTERIDLE,
1238 code, (LPARAM)hwnd );
1239
1240 if (idleSent!=NULL)
1241 *idleSent=TRUE;
1242 }
1243 MSG_PeekMessage( QMSG_WIN32W, msg, 0, first, last, flags, FALSE );
1244 }
1245 }
1246 else /* Always wait for a message */
1247 MSG_PeekMessage( QMSG_WIN32W, msg, 0, first, last, flags, FALSE );
1248
1249 /* Call message filters */
1250
1251 if (HOOK_IsHooked( WH_SYSMSGFILTER ) || HOOK_IsHooked( WH_MSGFILTER ))
1252 {
1253 MSG tmp_msg = *msg;
1254
1255 if (HOOK_CallHooksW( WH_SYSMSGFILTER, code, 0, (LPARAM)&tmp_msg ) ||
1256 HOOK_CallHooksW( WH_MSGFILTER, code, 0, (LPARAM)&tmp_msg ))
1257 {
1258 /* Message filtered -> remove it from the queue if it's still there. */
1259 if (!(flags & PM_REMOVE))
1260 MSG_PeekMessage( QMSG_WIN32W, msg, 0, first, last, PM_REMOVE, TRUE );
1261 continue;
1262 }
1263 }
1264 /* need to return an ASCII message (FIXME) */
1265 msg->wParam = map_wparam_WtoA( msg->message, msg->wParam );
1266 return (msg->message != WM_QUIT);
1267 }
1268 }
1269
1270
1271 /***********************************************************************
1272 * PeekMessage32 (USER.819)
1273 */
1274 BOOL16 WINAPI PeekMessage32_16( SEGPTR msg16_32, HWND16 hwnd,
1275 UINT16 first, UINT16 last, UINT16 flags,
1276 BOOL16 wHaveParamHigh )
1277 {
1278 BOOL ret;
1279 MSG32_16 *lpmsg16_32 = MapSL(msg16_32);
1280 MSG msg;
1281
1282 ret = MSG_PeekMessage( QMSG_WIN16, &msg, hwnd, first, last, flags, TRUE );
1283
1284 lpmsg16_32->msg.hwnd = msg.hwnd;
1285 lpmsg16_32->msg.message = msg.message;
1286 lpmsg16_32->msg.wParam = LOWORD(msg.wParam);
1287 lpmsg16_32->msg.lParam = msg.lParam;
1288 lpmsg16_32->msg.time = msg.time;
1289 lpmsg16_32->msg.pt.x = (INT16)msg.pt.x;
1290 lpmsg16_32->msg.pt.y = (INT16)msg.pt.y;
1291
1292 if ( wHaveParamHigh )
1293 lpmsg16_32->wParamHigh = HIWORD(msg.wParam);
1294
1295 HOOK_CallHooks16( WH_GETMESSAGE, HC_ACTION, flags & PM_REMOVE, (LPARAM)msg16_32 );
1296 return ret;
1297 }
1298
1299 /***********************************************************************
1300 * PeekMessage (USER.109)
1301 */
1302 BOOL16 WINAPI PeekMessage16( SEGPTR msg, HWND16 hwnd,
1303 UINT16 first, UINT16 last, UINT16 flags )
1304 {
1305 return PeekMessage32_16( msg, hwnd, first, last, flags, FALSE );
1306 }
1307
1308 /***********************************************************************
1309 * PeekMessageA (USER32.@)
1310 */
1311 BOOL WINAPI PeekMessageA( LPMSG lpmsg, HWND hwnd, UINT min, UINT max, UINT flags )
1312 {
1313 BOOL ret = PeekMessageW( lpmsg, hwnd, min, max, flags );
1314 if (ret) lpmsg->wParam = map_wparam_WtoA( lpmsg->message, lpmsg->wParam );
1315 return ret;
1316 }
1317
1318 /***********************************************************************
1319 * PeekMessageW (USER32.@) Check queue for messages
1320 *
1321 * Checks for a message in the thread's queue, filtered as for
1322 * GetMessage(). Returns immediately whether a message is available
1323 * or not.
1324 *
1325 * Whether a retrieved message is removed from the queue is set by the
1326 * _wRemoveMsg_ flags, which should be one of the following values:
1327 *
1328 * PM_NOREMOVE Do not remove the message from the queue.
1329 *
1330 * PM_REMOVE Remove the message from the queue.
1331 *
1332 * In addition, PM_NOYIELD may be combined into _wRemoveMsg_ to
1333 * request that the system not yield control during PeekMessage();
1334 * however applications may not rely on scheduling behavior.
1335 *
1336 * RETURNS
1337 *
1338 * Nonzero if a message is available and is retrieved, zero otherwise.
1339 *
1340 * CONFORMANCE
1341 *
1342 * ECMA-234, Win32
1343 *
1344 */
1345 BOOL WINAPI PeekMessageW(
1346 LPMSG lpmsg, /* [out] buffer to receive message */
1347 HWND hwnd, /* [in] restrict to messages for hwnd */
1348 UINT min, /* [in] minimum message to receive */
1349 UINT max, /* [in] maximum message to receive */
1350 UINT wRemoveMsg /* [in] removal flags */
1351 )
1352 {
1353 BOOL ret = MSG_PeekMessage( QMSG_WIN32W, lpmsg, hwnd, min, max, wRemoveMsg, TRUE );
1354 if (ret) HOOK_CallHooksW( WH_GETMESSAGE, HC_ACTION,
1355 wRemoveMsg & PM_REMOVE, (LPARAM)lpmsg );
1356 return ret;
1357 }
1358
1359
1360 /***********************************************************************
1361 * GetMessage32 (USER.820)
1362 */
1363 BOOL16 WINAPI GetMessage32_16( SEGPTR msg16_32, HWND16 hWnd, UINT16 first,
1364 UINT16 last, BOOL16 wHaveParamHigh )
1365 {
1366 MSG32_16 *lpmsg16_32 = MapSL(msg16_32);
1367 MSG msg;
1368
1369 MSG_PeekMessage( QMSG_WIN16, &msg, hWnd, first, last, PM_REMOVE, FALSE );
1370
1371 lpmsg16_32->msg.hwnd = msg.hwnd;
1372 lpmsg16_32->msg.message = msg.message;
1373 lpmsg16_32->msg.wParam = LOWORD(msg.wParam);
1374 lpmsg16_32->msg.lParam = msg.lParam;
1375 lpmsg16_32->msg.time = msg.time;
1376 lpmsg16_32->msg.pt.x = (INT16)msg.pt.x;
1377 lpmsg16_32->msg.pt.y = (INT16)msg.pt.y;
1378
1379 if ( wHaveParamHigh )
1380 lpmsg16_32->wParamHigh = HIWORD(msg.wParam);
1381
1382 TRACE( "message %04x, hwnd %04x, filter(%04x - %04x)\n",
1383 lpmsg16_32->msg.message, hWnd, first, last );
1384
1385 HOOK_CallHooks16( WH_GETMESSAGE, HC_ACTION, PM_REMOVE, (LPARAM)msg16_32 );
1386 return lpmsg16_32->msg.message != WM_QUIT;
1387 }
1388
1389 /***********************************************************************
1390 * GetMessage (USER.108)
1391 */
1392 BOOL16 WINAPI GetMessage16( SEGPTR msg, HWND16 hwnd, UINT16 first, UINT16 last)
1393 {
1394 return GetMessage32_16( msg, hwnd, first, last, FALSE );
1395 }
1396
1397 /***********************************************************************
1398 * GetMessageA (USER32.@)
1399 */
1400 BOOL WINAPI GetMessageA( MSG *lpmsg, HWND hwnd, UINT min, UINT max )
1401 {
1402 GetMessageW( lpmsg, hwnd, min, max );
1403 lpmsg->wParam = map_wparam_WtoA( lpmsg->message, lpmsg->wParam );
1404 return lpmsg->message != WM_QUIT;
1405 }
1406
1407 /***********************************************************************
1408 * GetMessageW (USER32.@) Retrieve next message
1409 *
1410 * GetMessage retrieves the next event from the calling thread's
1411 * queue and deposits it in *lpmsg.
1412 *
1413 * If _hwnd_ is not NULL, only messages for window _hwnd_ and its
1414 * children as specified by IsChild() are retrieved. If _hwnd_ is NULL
1415 * all application messages are retrieved.
1416 *
1417 * _min_ and _max_ specify the range of messages of interest. If
1418 * min==max==0, no filtering is performed. Useful examples are
1419 * WM_KEYFIRST and WM_KEYLAST to retrieve keyboard input, and
1420 * WM_MOUSEFIRST and WM_MOUSELAST to retrieve mouse input.
1421 *
1422 * WM_PAINT messages are not removed from the queue; they remain until
1423 * processed. Other messages are removed from the queue.
1424 *
1425 * RETURNS
1426 *
1427 * -1 on error, 0 if message is WM_QUIT, nonzero otherwise.
1428 *
1429 * CONFORMANCE
1430 *
1431 * ECMA-234, Win32
1432 *
1433 */
1434 BOOL WINAPI GetMessageW(
1435 MSG* lpmsg, /* [out] buffer to receive message */
1436 HWND hwnd, /* [in] restrict to messages for hwnd */
1437 UINT min, /* [in] minimum message to receive */
1438 UINT max /* [in] maximum message to receive */
1439 )
1440 {
1441 MSG_PeekMessage( QMSG_WIN32W, lpmsg, hwnd, min, max, PM_REMOVE, FALSE );
1442
1443 TRACE( "message %04x, hwnd %04x, filter(%04x - %04x)\n",
1444 lpmsg->message, hwnd, min, max );
1445
1446 HOOK_CallHooksW( WH_GETMESSAGE, HC_ACTION, PM_REMOVE, (LPARAM)lpmsg );
1447 return lpmsg->message != WM_QUIT;
1448 }
1449
1450 /***********************************************************************
1451 * MSG_PostToQueue
1452 */
1453 static BOOL MSG_PostToQueue( DWORD tid, int type, HWND hwnd,
1454 UINT message, WPARAM wParam, LPARAM lParam )
1455 {
1456 unsigned int res;
1457
1458 TRACE( "posting %x %x (%s) %x %lx\n", hwnd, message, SPY_GetMsgName(message), wParam, lParam );
1459
1460 SERVER_START_REQ( send_message )
1461 {
1462 req->kind = POST_MESSAGE;
1463 req->id = (void *)tid;
1464 req->type = type;
1465 req->win = hwnd;
1466 req->msg = message;
1467 req->wparam = wParam;
1468 req->lparam = lParam;
1469 req->x = 0;
1470 req->y = 0;
1471 req->time = GetCurrentTime();
1472 req->info = 0;
1473 res = SERVER_CALL();
1474 }
1475 SERVER_END_REQ;
1476
1477 if (res)
1478 {
1479 if (res == STATUS_INVALID_PARAMETER)
1480 SetLastError( ERROR_INVALID_THREAD_ID );
1481 else
1482 SetLastError( RtlNtStatusToDosError(res) );
1483 }
1484 return !res;
1485 }
1486
1487
1488 /***********************************************************************
1489 * MSG_PostMessage
1490 */
1491 static BOOL MSG_PostMessage( int type, HWND hwnd, UINT message,
1492 WPARAM wParam, LPARAM lParam )
1493 {
1494 WND *wndPtr;
1495
1496 if (hwnd == HWND_BROADCAST)
1497 {
1498 WND *pDesktop = WIN_GetDesktop();
1499 TRACE("HWND_BROADCAST !\n");
1500
1501 for (wndPtr=WIN_LockWndPtr(pDesktop->child); wndPtr; WIN_UpdateWndPtr(&wndPtr,wndPtr->next))
1502 {
1503 if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
1504 {
1505 TRACE("BROADCAST Message to hWnd=%04x m=%04X w=%04X l=%08lX !\n",
1506 wndPtr->hwndSelf, message, wParam, lParam);
1507 MSG_PostToQueue( GetWindowThreadProcessId( wndPtr->hwndSelf, NULL ), type,
1508 wndPtr->hwndSelf, message, wParam, lParam );
1509 }
1510 }
1511 WIN_ReleaseDesktop();
1512 TRACE("End of HWND_BROADCAST !\n");
1513 return TRUE;
1514 }
1515
1516 return MSG_PostToQueue( GetWindowThreadProcessId( hwnd, NULL ),
1517 type, hwnd, message, wParam, lParam );
1518 }
1519
1520
1521 /***********************************************************************
1522 * PostMessage (USER.110)
1523 */
1524 BOOL16 WINAPI PostMessage16( HWND16 hwnd, UINT16 message, WPARAM16 wParam,
1525 LPARAM lParam )
1526 {
1527 return (BOOL16) MSG_PostMessage( QMSG_WIN16, hwnd, message, wParam, lParam );
1528 }
1529
1530 /***********************************************************************
1531 * PostMessageA (USER32.@)
1532 */
1533 BOOL WINAPI PostMessageA( HWND hwnd, UINT message, WPARAM wParam,
1534 LPARAM lParam )
1535 {
1536 return PostMessageW( hwnd, message, map_wparam_AtoW( message, wParam ), lParam );
1537 }
1538
1539 /***********************************************************************
1540 * PostMessageW (USER32.@)
1541 */
1542 BOOL WINAPI PostMessageW( HWND hwnd, UINT message, WPARAM wParam,
1543 LPARAM lParam )
1544 {
1545 /* See thread on wine-devel around 6.2.2001. Basically posted messages
1546 * that are known to contain pointers are dropped by the Windows 32bit
1547 * PostMessage() with return FALSE; and invalid parameter last error.
1548 * (tested against NT4 by Gerard Patel)
1549 */
1550 if (is_pointer_message(message))
1551 {
1552 SetLastError(ERROR_INVALID_PARAMETER);
1553 return FALSE;
1554 }
1555 return MSG_PostMessage( QMSG_WIN32W, hwnd, message, wParam, lParam );
1556 }
1557
1558 /***********************************************************************
1559 * PostAppMessage (USER.116)
1560 * PostAppMessage16 (USER32.@)
1561 */
1562 BOOL16 WINAPI PostAppMessage16( HTASK16 hTask, UINT16 message,
1563 WPARAM16 wParam, LPARAM lParam )
1564 {
1565 TDB *pTask = TASK_GetPtr( hTask );
1566 if (!pTask) return FALSE;
1567 return MSG_PostToQueue( (DWORD)pTask->teb->tid, QMSG_WIN16, 0, message, wParam, lParam );
1568 }
1569
1570 /**********************************************************************
1571 * PostThreadMessageA (USER32.@)
1572 */
1573 BOOL WINAPI PostThreadMessageA( DWORD idThread, UINT message,
1574 WPARAM wParam, LPARAM lParam )
1575 {
1576 return PostThreadMessageW( idThread, message, map_wparam_AtoW( message, wParam ), lParam );
1577 }
1578
1579 /**********************************************************************
1580 * PostThreadMessageW (USER32.@)
1581 */
1582 BOOL WINAPI PostThreadMessageW( DWORD idThread, UINT message,
1583 WPARAM wParam, LPARAM lParam )
1584 {
1585 if (is_pointer_message( message ))
1586 {
1587 SetLastError( ERROR_INVALID_PARAMETER );
1588 return FALSE;
1589 }
1590 return MSG_PostToQueue( idThread, QMSG_WIN32W, 0, message, wParam, lParam );
1591 }
1592
1593
1594 /************************************************************************
1595 * MSG_CallWndProcHook32
1596 */
1597 static void MSG_CallWndProcHook( LPMSG pmsg, BOOL bUnicode )
1598 {
1599 CWPSTRUCT cwp;
1600
1601 cwp.lParam = pmsg->lParam;
1602 cwp.wParam = pmsg->wParam;
1603 cwp.message = pmsg->message;
1604 cwp.hwnd = pmsg->hwnd;
1605
1606 if (bUnicode) HOOK_CallHooksW(WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp);
1607 else HOOK_CallHooksA( WH_CALLWNDPROC, HC_ACTION, 1, (LPARAM)&cwp );
1608
1609 pmsg->lParam = cwp.lParam;
1610 pmsg->wParam = cwp.wParam;
1611 pmsg->message = cwp.message;
1612 pmsg->hwnd = cwp.hwnd;
1613 }
1614
1615
1616 /***********************************************************************
1617 * MSG_SendMessage
1618 *
1619 * return values: 0 if timeout occurs
1620 * 1 otherwise
1621 */
1622 static LRESULT MSG_SendMessage( HWND hwnd, UINT msg, WPARAM wParam,
1623 LPARAM lParam, DWORD timeout, WORD type,
1624 LRESULT *pRes)
1625 {
1626 WND * wndPtr = 0;
1627 WND **list, **ppWnd;
1628 LRESULT ret = 1;
1629 DWORD dest_tid;
1630 WNDPROC winproc;
1631
1632 if (pRes) *pRes = 0;
1633
1634 if (hwnd == HWND_BROADCAST|| hwnd == HWND_TOPMOST)
1635 {
1636 if (pRes) *pRes = 1;
1637
1638 if (!(list = WIN_BuildWinArray( WIN_GetDesktop(), 0, NULL )))
1639 {
1640 WIN_ReleaseDesktop();
1641 return 1;
1642 }
1643 WIN_ReleaseDesktop();
1644
1645 TRACE("HWND_BROADCAST !\n");
1646 for (ppWnd = list; *ppWnd; ppWnd++)
1647 {
1648 WIN_UpdateWndPtr(&wndPtr,*ppWnd);
1649 if (!IsWindow(wndPtr->hwndSelf)) continue;
1650 if (wndPtr->dwStyle & WS_POPUP || wndPtr->dwStyle & WS_CAPTION)
1651 {
1652 TRACE("BROADCAST Message to hWnd=%04x m=%04X w=%04lX l=%08lX !\n",
1653 wndPtr->hwndSelf, msg, (DWORD)wParam, lParam);
1654 MSG_SendMessage( wndPtr->hwndSelf, msg, wParam, lParam,
1655 timeout, type, pRes);
1656 }
1657 }
1658 WIN_ReleaseWndPtr(wndPtr);
1659 WIN_ReleaseWinArray(list);
1660 TRACE("End of HWND_BROADCAST !\n");
1661 return 1;
1662 }
1663
1664 if (HOOK_IsHooked( WH_CALLWNDPROC ))
1665 {
1666 switch(type)
1667 {
1668 case QMSG_WIN16:
1669 {
1670 LPCWPSTRUCT16 pmsg;
1671
1672 if ((pmsg = SEGPTR_NEW(CWPSTRUCT16)))
1673 {
1674 pmsg->hwnd = hwnd & 0xffff;
1675 pmsg->message= msg & 0xffff;
1676 pmsg->wParam = wParam & 0xffff;
1677 pmsg->lParam = lParam;
1678 HOOK_CallHooks16( WH_CALLWNDPROC, HC_ACTION, 1,
1679 (LPARAM)SEGPTR_GET(pmsg) );
1680 hwnd = pmsg->hwnd;
1681 msg = pmsg->message;
1682 wParam = pmsg->wParam;
1683 lParam = pmsg->lParam;
1684 SEGPTR_FREE( pmsg );
1685 }
1686 }
1687 break;
1688 case QMSG_WIN32A:
1689 MSG_CallWndProcHook( (LPMSG)&hwnd, FALSE);
1690 break;
1691 case QMSG_WIN32W:
1692 MSG_CallWndProcHook( (LPMSG)&hwnd, TRUE);
1693 break;
1694 }
1695 }
1696
1697 if (!(wndPtr = WIN_FindWndPtr( hwnd )))
1698 {
1699 WARN("invalid hwnd %04x\n", hwnd );
1700 return 0;
1701 }
1702 if (QUEUE_IsExitingQueue(wndPtr->hmemTaskQ))
1703 {
1704 WIN_ReleaseWndPtr( wndPtr );
1705 return 0; /* Don't send anything if the task is dying */
1706 }
1707 winproc = (WNDPROC)wndPtr->winproc;
1708 WIN_ReleaseWndPtr( wndPtr );
1709
1710 if (type != QMSG_WIN16)
1711 SPY_EnterMessage( SPY_SENDMESSAGE, hwnd, msg, wParam, lParam );
1712 else
1713 SPY_EnterMessage( SPY_SENDMESSAGE16, hwnd, msg, wParam, lParam );
1714
1715 dest_tid = GetWindowThreadProcessId( hwnd, NULL );
1716 if (dest_tid && dest_tid != GetCurrentThreadId())
1717 {
1718 ret = MSG_SendMessageInterThread( dest_tid, hwnd, msg,
1719 wParam, lParam, timeout, type, pRes );
1720 }
1721 else
1722 {
1723 LRESULT res = 0;
1724
1725 /* Call the right CallWindowProc flavor */
1726 switch(type)
1727 {
1728 case QMSG_WIN16:
1729 res = CallWindowProc16( (WNDPROC16)winproc, hwnd, msg, wParam, lParam );
1730 break;
1731 case QMSG_WIN32A:
1732 res = CallWindowProcA( winproc, hwnd, msg, wParam, lParam );
1733 break;
1734 case QMSG_WIN32W:
1735 res = CallWindowProcW( winproc, hwnd, msg, wParam, lParam );
1736 break;
1737 }
1738 if (pRes) *pRes = res;
1739 }
1740
1741 if (type != QMSG_WIN16)
1742 SPY_ExitMessage( SPY_RESULT_OK, hwnd, msg, pRes?*pRes:0, wParam, lParam );
1743 else
1744 SPY_ExitMessage( SPY_RESULT_OK16, hwnd, msg, pRes?*pRes:0, wParam, lParam );
1745
1746 return ret;
1747 }
1748
1749
1750 /***********************************************************************
1751 * SendMessage (USER.111)
1752 */
1753 LRESULT WINAPI SendMessage16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam,
1754 LPARAM lParam)
1755 {
1756 LRESULT res;
1757 MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE, QMSG_WIN16, &res);
1758 return res;
1759 }
1760
1761
1762 /***********************************************************************
1763 * SendMessageA (USER32.@)
1764 */
1765 LRESULT WINAPI SendMessageA( HWND hwnd, UINT msg, WPARAM wParam,
1766 LPARAM lParam )
1767 {
1768 LRESULT res;
1769
1770 MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE, QMSG_WIN32A, &res);
1771
1772 return res;
1773 }
1774
1775
1776 /***********************************************************************
1777 * SendMessageW (USER32.@) Send Window Message
1778 *
1779 * Sends a message to the window procedure of the specified window.
1780 * SendMessage() will not return until the called window procedure
1781 * either returns or calls ReplyMessage().
1782 *
1783 * Use PostMessage() to send message and return immediately. A window
1784 * procedure may use InSendMessage() to detect
1785 * SendMessage()-originated messages.
1786 *
1787 * Applications which communicate via HWND_BROADCAST may use
1788 * RegisterWindowMessage() to obtain a unique message to avoid conflicts
1789 * with other applications.
1790 *
1791 * CONFORMANCE
1792 *
1793 * ECMA-234, Win32
1794 */
1795 LRESULT WINAPI SendMessageW(
1796 HWND hwnd, /* [in] Window to send message to. If HWND_BROADCAST,
1797 the message will be sent to all top-level windows. */
1798
1799 UINT msg, /* [in] message */
1800 WPARAM wParam, /* [in] message parameter */
1801 LPARAM lParam /* [in] additional message parameter */
1802 ) {
1803 LRESULT res;
1804
1805 MSG_SendMessage(hwnd, msg, wParam, lParam, INFINITE, QMSG_WIN32W, &res);
1806
1807 return res;
1808 }
1809
1810
1811 /***********************************************************************
1812 * SendMessageTimeout (not a WINAPI)
1813 */
1814 LRESULT WINAPI SendMessageTimeout16( HWND16 hwnd, UINT16 msg, WPARAM16 wParam,
1815 LPARAM lParam, UINT16 flags,
1816 UINT16 timeout, LPWORD resultp)
1817 {
1818 LRESULT ret;
1819 LRESULT msgRet;
1820
1821 /* FIXME: need support for SMTO_BLOCK */
1822
1823 ret = MSG_SendMessage(hwnd, msg, wParam, lParam, timeout, QMSG_WIN16, &msgRet);
1824 if (resultp) *resultp = (WORD) msgRet;
1825 return ret;
1826 }
1827
1828
1829 /***********************************************************************
1830 * SendMessageTimeoutA (USER32.@)
1831 */
1832 LRESULT WINAPI SendMessageTimeoutA( HWND hwnd, UINT msg, WPARAM wParam,
1833 LPARAM lParam, UINT flags,
1834 UINT timeout, LPDWORD resultp)
1835 {
1836 LRESULT ret;
1837 LRESULT msgRet;
1838
1839 /* FIXME: need support for SMTO_BLOCK */
1840
1841 ret = MSG_SendMessage(hwnd, msg, wParam, lParam, timeout, QMSG_WIN32A, &msgRet);
1842
1843 if (resultp) *resultp = (DWORD) msgRet;
1844 return ret;
1845 }
1846
1847
1848 /***********************************************************************
1849 * SendMessageTimeoutW (USER32.@)
1850 */
1851 LRESULT WINAPI SendMessageTimeoutW( HWND hwnd, UINT msg, WPARAM wParam,
1852 LPARAM lParam, UINT flags,
1853 UINT timeout, LPDWORD resultp)
1854 {
1855 LRESULT ret;
1856 LRESULT msgRet;
1857
1858 /* FIXME: need support for SMTO_BLOCK */
1859
1860 ret = MSG_SendMessage(hwnd, msg, wParam, lParam, timeout, QMSG_WIN32W, &msgRet);
1861
1862 if (resultp) *resultp = (DWORD) msgRet;
1863 return ret;
1864 }
1865
1866
1867 /***********************************************************************
1868 * SendNotifyMessageA (USER32.@)
1869 */
1870 BOOL WINAPI SendNotifyMessageA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1871 {
1872 return SendNotifyMessageW( hwnd, msg, map_wparam_AtoW( msg, wParam ), lParam );
1873 }
1874
1875
1876 /***********************************************************************
1877 * SendNotifyMessageW (USER32.@)
1878 */
1879 BOOL WINAPI SendNotifyMessageW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
1880 {
1881 if (is_pointer_message(msg))
1882 {
1883 SetLastError(ERROR_INVALID_PARAMETER);
1884 return FALSE;
1885 }
1886 return MSG_SendMessage( hwnd, msg, wParam, lParam, INFINITE, QMSG_WIN32W, NULL );
1887 }
1888
1889
1890 /***********************************************************************
1891 * SendMessageCallbackA (USER32.@)
1892 */
1893 BOOL WINAPI SendMessageCallbackA( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1894 SENDASYNCPROC callback, ULONG_PTR data )
1895 {
1896 return SendMessageCallbackW( hwnd, msg, map_wparam_AtoW( msg, wParam ),
1897 lParam, callback, data );
1898 }
1899
1900
1901 /***********************************************************************
1902 * SendMessageCallbackW (USER32.@)
1903 *
1904 * FIXME: It's like PostMessage. The callback gets called when the message
1905 * is processed. We have to modify the message processing for an exact
1906 * implementation...
1907 * The callback is only called when the thread that called us calls one of
1908 * Get/Peek/WaitMessage.
1909 */
1910 BOOL WINAPI SendMessageCallbackW( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam,
1911 SENDASYNCPROC callback, ULONG_PTR data )
1912 {
1913 LRESULT result;
1914
1915 if (is_pointer_message(msg))
1916 {
1917 SetLastError(ERROR_INVALID_PARAMETER);
1918 return FALSE;
1919 }
1920 FIXME( "(0x%04x,0x%04x,0x%08x,0x%08lx,%p,0x%08x),stub!\n",
1921 hwnd, msg, wParam, lParam, callback, data );
1922
1923 if (hwnd == HWND_BROADCAST)
1924 {
1925 PostMessageW( hwnd, msg, wParam, lParam );
1926 FIXME("Broadcast: Callback will not be called!\n");
1927 return TRUE;
1928 }
1929 result = SendMessageW( hwnd, msg, wParam, lParam );
1930 callback( hwnd, msg, data, result );
1931 return TRUE;
1932 }
1933
1934
1935 /***********************************************************************
1936 * WaitMessage (USER.112) Suspend thread pending messages
1937 * WaitMessage (USER32.@) Suspend thread pending messages
1938 *
1939 * WaitMessage() suspends a thread until events appear in the thread's
1940 * queue.
1941 */
1942 BOOL WINAPI WaitMessage(void)
1943 {
1944 return (MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, 0 ) != WAIT_FAILED);
1945 }
1946
1947
1948 /***********************************************************************
1949 * MsgWaitForMultipleObjectsEx (USER32.@)
1950 */
1951 DWORD WINAPI MsgWaitForMultipleObjectsEx( DWORD count, CONST HANDLE *pHandles,
1952 DWORD timeout, DWORD mask, DWORD flags )
1953 {
1954 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
1955 DWORD i, ret;
1956 HQUEUE16 hQueue = GetFastQueue16();
1957 MESSAGEQUEUE *msgQueue;
1958
1959 if (count > MAXIMUM_WAIT_OBJECTS-1)
1960 {
1961 SetLastError( ERROR_INVALID_PARAMETER );
1962 return WAIT_FAILED;
1963 }
1964
1965 if (!(msgQueue = QUEUE_Lock( hQueue ))) return WAIT_FAILED;
1966
1967 /* set the queue mask */
1968 SERVER_START_REQ( set_queue_mask )
1969 {
1970 req->wake_mask = (flags & MWMO_INPUTAVAILABLE) ? mask : 0;
1971 req->changed_mask = mask;
1972 req->skip_wait = 0;
1973 SERVER_CALL();
1974 }
1975 SERVER_END_REQ;
1976
1977 /* Add the thread event to the handle list */
1978 for (i = 0; i < count; i++) handles[i] = pHandles[i];
1979 handles[count] = msgQueue->server_queue;
1980
1981
1982 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
1983 {
1984 ret = USER_Driver.pMsgWaitForMultipleObjectsEx( count+1, handles, timeout, mask, flags );
1985 if (ret == count+1) ret = count; /* pretend the msg queue is ready */
1986 }
1987 else
1988 ret = WaitForMultipleObjectsEx( count+1, handles, flags & MWMO_WAITALL,
1989 timeout, flags & MWMO_ALERTABLE );
1990 QUEUE_Unlock( msgQueue );
1991 return ret;
1992 }
1993
1994
1995 /***********************************************************************
1996 * MsgWaitForMultipleObjects (USER32.@)
1997 */
1998 DWORD WINAPI MsgWaitForMultipleObjects( DWORD count, CONST HANDLE *handles,
1999 BOOL wait_all, DWORD timeout, DWORD mask )
2000 {
2001 return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
2002 wait_all ? MWMO_WAITALL : 0 );
2003 }
2004
2005
2006 /***********************************************************************
2007 * MsgWaitForMultipleObjects (USER.640)
2008 */
2009 DWORD WINAPI MsgWaitForMultipleObjects16( DWORD count, CONST HANDLE *handles,
2010 BOOL wait_all, DWORD timeout, DWORD mask )
2011 {
2012 return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
2013 wait_all ? MWMO_WAITALL : 0 );
2014 }
2015
2016
2017 /***********************************************************************
2018 * WaitForInputIdle (USER32.@)
2019 */
2020 DWORD WINAPI WaitForInputIdle( HANDLE hProcess, DWORD dwTimeOut )
2021 {
2022 DWORD cur_time, ret;
2023 HANDLE idle_event = -1;
2024
2025 SERVER_START_REQ( wait_input_idle )
2026 {
2027 req->handle = hProcess;
2028 req->timeout = dwTimeOut;
2029 if (!(ret = SERVER_CALL_ERR())) idle_event = req->event;
2030 }
2031 SERVER_END_REQ;
2032 if (ret) return 0xffffffff; /* error */
2033 if (!idle_event) return 0; /* no event to wait on */
2034
2035 cur_time = GetTickCount();
2036
2037 TRACE("waiting for %x\n", idle_event );
2038 while ( dwTimeOut > GetTickCount() - cur_time || dwTimeOut == INFINITE )
2039 {
2040 ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut, QS_SENDMESSAGE );
2041 if ( ret == ( WAIT_OBJECT_0 + 1 ))
2042 {
2043 process_sent_messages();
2044 continue;
2045 }
2046 if ( ret == WAIT_TIMEOUT || ret == 0xFFFFFFFF )
2047 {
2048 TRACE("timeout or error\n");
2049 return ret;
2050 }
2051 else
2052 {
2053 TRACE("finished\n");
2054 return 0;
2055 }
2056 }
2057
2058 return WAIT_TIMEOUT;
2059 }
2060
2061
2062 /***********************************************************************
2063 * UserYield (USER.332)
2064 * UserYield16 (USER32.@)
2065 */
2066 void WINAPI UserYield16(void)
2067 {
2068 /* Handle sent messages */
2069 process_sent_messages();
2070
2071 /* Yield */
2072 OldYield16();
2073
2074 /* Handle sent messages again */
2075 process_sent_messages();
2076 }
2077
2078
2079 struct accent_char
2080 {
2081 BYTE ac_accent;
2082 BYTE ac_char;
2083 BYTE ac_result;
2084 };
2085
2086 static const struct accent_char accent_chars[] =
2087 {
2088 /* A good idea should be to read /usr/X11/lib/X11/locale/iso8859-x/Compose */
2089 {'`', 'A', '\300'}, {'`', 'a', '\340'},
2090 {'\'', 'A', '\301'}, {'\'', 'a', '\341'},
2091 {'^', 'A', '\302'}, {'^', 'a', '\342'},
2092 {'~', 'A', '\303'}, {'~', 'a', '\343'},
2093 {'"', 'A', '\304'}, {'"', 'a', '\344'},
2094 {'O', 'A', '\305'}, {'o', 'a', '\345'},
2095 {'0', 'A', '\305'}, {'0', 'a', '\345'},
2096 {'A', 'A', '\305'}, {'a', 'a', '\345'},
2097 {'A', 'E', '\306'}, {'a', 'e', '\346'},
2098 {',', 'C', '\307'}, {',', 'c', '\347'},
2099 {'`', 'E', '\310'}, {'`', 'e', '\350'},
2100 {'\'', 'E', '\311'}, {'\'', 'e', '\351'},
2101 {'^', 'E', '\312'}, {'^', 'e', '\352'},
2102 {'"', 'E', '\313'}, {'"', 'e', '\353'},
2103 {'`', 'I', '\314'}, {'`', 'i', '\354'},
2104 {'\'', 'I', '\315'}, {'\'', 'i', '\355'},
2105 {'^', 'I', '\316'}, {'^', 'i', '\356'},
2106 {'"', 'I', '\317'}, {'"', 'i', '\357'},
2107 {'-', 'D', '\320'}, {'-', 'd', '\360'},
2108 {'~', 'N', '\321'}, {'~', 'n', '\361'},
2109 {'`', 'O', '\322'}, {'`', 'o', '\362'},
2110 {'\'', 'O', '\323'}, {'\'', 'o', '\363'},
2111 {'^', 'O', '\324'}, {'^', 'o', '\364'},
2112 {'~', 'O', '\325'}, {'~', 'o', '\365'},
2113 {'"', 'O', '\326'}, {'"', 'o', '\366'},
2114 {'/', 'O', '\330'}, {'/', 'o', '\370'},
2115 {'`', 'U', '\331'}, {'`', 'u', '\371'},
2116 {'\'', 'U', '\332'}, {'\'', 'u', '\372'},
2117 {'^', 'U', '\333'}, {'^', 'u', '\373'},
2118 {'"', 'U', '\334'}, {'"', 'u', '\374'},
2119 {'\'', 'Y', '\335'}, {'\'', 'y', '\375'},
2120 {'T', 'H', '\336'}, {'t', 'h', '\376'},
2121 {'s', 's', '\337'}, {'"', 'y', '\377'},
2122 {'s', 'z', '\337'}, {'i', 'j', '\377'},
2123 /* iso-8859-2 uses this */
2124 {'<', 'L', '\245'}, {'<', 'l', '\265'}, /* caron */
2125 {'<', 'S', '\251'}, {'<', 's', '\271'},
2126 {'<', 'T', '\253'}, {'<', 't', '\273'},
2127 {'<', 'Z', '\256'}, {'<', 'z', '\276'},
2128 {'<', 'C', '\310'}, {'<', 'c', '\350'},
2129 {'<', 'E', '\314'}, {'<', 'e', '\354'},
2130 {'<', 'D', '\317'}, {'<', 'd', '\357'},
2131 {'<', 'N', '\322'}, {'<', 'n', '\362'},
2132 {'<', 'R', '\330'}, {'<', 'r', '\370'},
2133 {';', 'A', '\241'}, {';', 'a', '\261'}, /* ogonek */
2134 {';', 'E', '\312'}, {';', 'e', '\332'},
2135 {'\'', 'Z', '\254'}, {'\'', 'z', '\274'}, /* acute */
2136 {'\'', 'R', '\300'}, {'\'', 'r', '\340'},
2137 {'\'', 'L', '\305'}, {'\'', 'l', '\345'},
2138 {'\'', 'C', '\306'}, {'\'', 'c', '\346'},
2139 {'\'', 'N', '\321'}, {'\'', 'n', '\361'},
2140 /* collision whith S, from iso-8859-9 !!! */
2141 {',', 'S', '\252'}, {',', 's', '\272'}, /* cedilla */
2142 {',', 'T', '\336'}, {',', 't', '\376'},
2143 {'.', 'Z', '\257'}, {'.', 'z', '\277'}, /* dot above */
2144 {'/', 'L', '\243'}, {'/', 'l', '\263'}, /* slash */
2145 {'/', 'D', '\320'}, {'/', 'd', '\360'},
2146 {'(', 'A', '\303'}, {'(', 'a', '\343'}, /* breve */
2147 {'\275', 'O', '\325'}, {'\275', 'o', '\365'}, /* double acute */
2148 {'\275', 'U', '\334'}, {'\275', 'u', '\374'},
2149 {'0', 'U', '\332'}, {'0', 'u', '\372'}, /* ring above */
2150 /* iso-8859-3 uses this */
2151 {'/', 'H', '\241'}, {'/', 'h', '\261'}, /* slash */
2152 {'>', 'H', '\246'}, {'>', 'h', '\266'}, /* circumflex */
2153 {'>', 'J', '\254'}, {'>', 'j', '\274'},
2154 {'>', 'C', '\306'}, {'>', 'c', '\346'},
2155 {'>', 'G', '\330'}, {'>', 'g', '\370'},
2156 {'>', 'S', '\336'}, {'>', 's', '\376'},
2157 /* collision whith G( from iso-8859-9 !!! */
2158 {'(', 'G', '\253'}, {'(', 'g', '\273'}, /* breve */
2159 {'(', 'U', '\335'}, {'(', 'u', '\375'},
2160 /* collision whith I. from iso-8859-3 !!! */
2161 {'.', 'I', '\251'}, {'.', 'i', '\271'}, /* dot above */
2162 {'.', 'C', '\305'}, {'.', 'c', '\345'},
2163 {'.', 'G', '\325'}, {'.', 'g', '\365'},
2164 /* iso-8859-4 uses this */
2165 {',', 'R', '\243'}, {',', 'r', '\263'}, /* cedilla */
2166 {',', 'L', '\246'}, {',', 'l', '\266'},
2167 {',', 'G', '\253'}, {',', 'g', '\273'},
2168 {',', 'N', '\321'}, {',', 'n', '\361'},
2169 {',', 'K', '\323'}, {',', 'k', '\363'},
2170 {'~', 'I', '\245'}, {'~', 'i', '\265'}, /* tilde */
2171 {'-', 'E', '\252'}, {'-', 'e', '\272'}, /* macron */
2172 {'-', 'A', '\300'}, {'-', 'a', '\340'},
2173 {'-', 'I', '\317'}, {'-', 'i', '\357'},
2174 {'-', 'O', '\322'}, {'-', 'o', '\362'},
2175 {'-', 'U', '\336'}, {'-', 'u', '\376'},
2176 {'/', 'T', '\254'}, {'/', 't', '\274'}, /* slash */
2177 {'.', 'E', '\314'}, {'.', 'e', '\344'}, /* dot above */
2178 {';', 'I', '\307'}, {';', 'i', '\347'}, /* ogonek */
2179 {';', 'U', '\331'}, {';', 'u', '\371'},
2180 /* iso-8859-9 uses this */
2181 /* iso-8859-9 has really bad choosen G( S, and I. as they collide
2182 * whith the same letters on other iso-8859-x (that is they are on
2183 * different places :-( ), if you use turkish uncomment these and
2184 * comment out the lines in iso-8859-2 and iso-8859-3 sections
2185 * FIXME: should be dynamic according to chosen language
2186 * if/when Wine has turkish support.
2187 */
2188 /* collision whith G( from iso-8859-3 !!! */
2189 /* {'(', 'G', '\320'}, {'(', 'g', '\360'}, */ /* breve */
2190 /* collision whith S, from iso-8859-2 !!! */
2191 /* {',', 'S', '\336'}, {',', 's', '\376'}, */ /* cedilla */
2192 /* collision whith I. from iso-8859-3 !!! */
2193 /* {'.', 'I', '\335'}, {'.', 'i', '\375'}, */ /* dot above */
2194 };
2195
2196
2197 /***********************************************************************
2198 * MSG_DoTranslateMessage
2199 *
2200 * Implementation of TranslateMessage.
2201 *
2202 * TranslateMessage translates virtual-key messages into character-messages,
2203 * as follows :
2204 * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
2205 * ditto replacing WM_* with WM_SYS*
2206 * This produces WM_CHAR messages only for keys mapped to ASCII characters
2207 * by the keyboard driver.
2208 */
2209 static BOOL MSG_DoTranslateMessage( UINT message, HWND hwnd,
2210 WPARAM wParam, LPARAM lParam )
2211 {
2212 static int dead_char;
2213 WCHAR wp[2];
2214
2215 if (message != WM_MOUSEMOVE && message != WM_TIMER)
2216 TRACE("(%s, %04X, %08lX)\n",
2217 SPY_GetMsgName(message), wParam, lParam );
2218 if(message >= WM_KEYFIRST && message <= WM_KEYLAST)
2219 TRACE_(key)("(%s, %04X, %08lX)\n",
2220 SPY_GetMsgName(message), wParam, lParam );
2221
2222 if ((message != WM_KEYDOWN) && (message != WM_SYSKEYDOWN)) return FALSE;
2223
2224 TRACE_(key)("Translating key %s (%04x), scancode %02x\n",
2225 SPY_GetVKeyName(wParam), wParam, LOBYTE(HIWORD(lParam)));
2226
2227 /* FIXME : should handle ToUnicode yielding 2 */
2228 switch (ToUnicode(wParam, HIWORD(lParam), QueueKeyStateTable, wp, 2, 0))
2229 {
2230 case 1:
2231 message = (message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
2232 /* Should dead chars handling go in ToAscii ? */
2233 if (dead_char)
2234 {
2235 int i;
2236
2237 if (wp[0] == ' ') wp[0] = dead_char;
2238 if (dead_char == 0xa2) dead_char = '(';
2239 else if (dead_char == 0xa8) dead_char = '"';
2240 else if (dead_char == 0xb2) dead_char = ';';
2241 else if (dead_char == 0xb4) dead_char = '\'';
2242 else if (dead_char == 0xb7) dead_char = '<';
2243 else if (dead_char == 0xb8) dead_char = ',';
2244 else if (dead_char == 0xff) dead_char = '.';
2245 for (i = 0; i < sizeof(accent_chars)/sizeof(accent_chars[0]); i++)
2246 if ((accent_chars[i].ac_accent == dead_char) &&
2247 (accent_chars[i].ac_char == wp[0]))
2248 {
2249 wp[0] = accent_chars[i].ac_result;
2250 break;
2251 }
2252 dead_char = 0;
2253 }
2254 TRACE_(key)("1 -> PostMessage(%s)\n", SPY_GetMsgName(message));
2255 PostMessageW( hwnd, message, wp[0], lParam );
2256 return TRUE;
2257
2258 case -1:
2259 message = (message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
2260 dead_char = wp[0];
2261 TRACE_(key)("-1 -> PostMessage(%s)\n", SPY_GetMsgName(message));
2262 PostMessageW( hwnd, message, wp[0], lParam );
2263 return TRUE;
2264 }
2265 return FALSE;
2266 }
2267
2268
2269 /***********************************************************************
2270 * TranslateMessage (USER.113)
2271 */
2272 BOOL16 WINAPI TranslateMessage16( const MSG16 *msg )
2273 {
2274 return MSG_DoTranslateMessage( msg->message, msg->hwnd,
2275 msg->wParam, msg->lParam );
2276 }
2277
2278
2279 /***********************************************************************
2280 * TranslateMessage32 (USER.821)
2281 */
2282 BOOL16 WINAPI TranslateMessage32_16( const MSG32_16 *msg, BOOL16 wHaveParamHigh )
2283 {
2284 WPARAM wParam;
2285
2286 if (wHaveParamHigh)
2287 wParam = MAKELONG(msg->msg.wParam, msg->wParamHigh);
2288 else
2289 wParam = (WPARAM)msg->msg.wParam;
2290
2291 return MSG_DoTranslateMessage( msg->msg.message, msg->msg.hwnd,
2292 wParam, msg->msg.lParam );
2293 }
2294
2295 /***********************************************************************
2296 * TranslateMessage (USER32.@)
2297 */
2298 BOOL WINAPI TranslateMessage( const MSG *msg )
2299 {
2300 return MSG_DoTranslateMessage( msg->message, msg->hwnd,
2301 msg->wParam, msg->lParam );
2302 }
2303
2304
2305 /***********************************************************************
2306 * DispatchMessage (USER.114)
2307 */
2308 LONG WINAPI DispatchMessage16( const MSG16* msg )
2309 {
2310 WND * wndPtr;
2311 LONG retval;
2312 int painting;
2313
2314 /* Process timer messages */
2315 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
2316 {
2317 if (msg->lParam)
2318 {
2319 /* before calling window proc, verify whether timer is still valid;
2320 there's a slim chance that the application kills the timer
2321 between GetMessage and DispatchMessage API calls */
2322 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (HWINDOWPROC) msg->lParam))
2323 return 0; /* invalid winproc */
2324
2325 return CallWindowProc16( (WNDPROC16)msg->lParam, msg->hwnd,
2326 msg->message, msg->wParam, GetTickCount() );
2327 }
2328 }
2329
2330 if (!msg->hwnd) return 0;
2331 if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
2332 if (!wndPtr->winproc)
2333 {
2334 retval = 0;
2335 goto END;
2336 }
2337 painting = (msg->message == WM_PAINT);
2338 if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
2339
2340 SPY_EnterMessage( SPY_DISPATCHMESSAGE16, msg->hwnd, msg->message,
2341 msg->wParam, msg->lParam );
2342 retval = CallWindowProc16( (WNDPROC16)wndPtr->winproc,
2343 msg->hwnd, msg->message,
2344 msg->wParam, msg->lParam );
2345 SPY_ExitMessage( SPY_RESULT_OK16, msg->hwnd, msg->message, retval,
2346 msg->wParam, msg->lParam );
2347
2348 WIN_ReleaseWndPtr(wndPtr);
2349 wndPtr = WIN_FindWndPtr(msg->hwnd);
2350 if (painting && wndPtr &&
2351 (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
2352 {
2353 ERR("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
2354 msg->hwnd);
2355 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
2356 /* Validate the update region to avoid infinite WM_PAINT loop */
2357 RedrawWindow( wndPtr->hwndSelf, NULL, 0,
2358 RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
2359 }
2360 END:
2361 WIN_ReleaseWndPtr(wndPtr);
2362 return retval;
2363 }
2364
2365
2366 /***********************************************************************
2367 * DispatchMessage32 (USER.822)
2368 */
2369 LONG WINAPI DispatchMessage32_16( const MSG32_16* lpmsg16_32, BOOL16 wHaveParamHigh )
2370 {
2371 if (wHaveParamHigh == FALSE)
2372 return DispatchMessage16(&(lpmsg16_32->msg));
2373 else
2374 {
2375 MSG msg;
2376
2377 msg.hwnd = lpmsg16_32->msg.hwnd;
2378 msg.message = lpmsg16_32->msg.message;
2379 msg.wParam = MAKELONG(lpmsg16_32->msg.wParam, lpmsg16_32->wParamHigh);
2380 msg.lParam = lpmsg16_32->msg.lParam;
2381 msg.time = lpmsg16_32->msg.time;
2382 msg.pt.x = (INT)lpmsg16_32->msg.pt.x;
2383 msg.pt.y = (INT)lpmsg16_32->msg.pt.y;
2384 return DispatchMessageA(&msg);
2385 }
2386 }
2387
2388 /***********************************************************************
2389 * DispatchMessageA (USER32.@)
2390 */
2391 LONG WINAPI DispatchMessageA( const MSG* msg )
2392 {
2393 WND * wndPtr;
2394 LONG retval;
2395 int painting;
2396
2397 /* Process timer messages */
2398 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
2399 {
2400 if (msg->lParam)
2401 {
2402 /* HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2403
2404 /* before calling window proc, verify whether timer is still valid;
2405 there's a slim chance that the application kills the timer
2406 between GetMessage and DispatchMessage API calls */
2407 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (HWINDOWPROC) msg->lParam))
2408 return 0; /* invalid winproc */
2409
2410 return CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
2411 msg->message, msg->wParam, GetTickCount() );
2412 }
2413 }
2414
2415 if (!msg->hwnd) return 0;
2416 if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
2417 if (!wndPtr->winproc)
2418 {
2419 retval = 0;
2420 goto END;
2421 }
2422 painting = (msg->message == WM_PAINT);
2423 if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
2424 /* HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2425
2426 SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
2427 msg->wParam, msg->lParam );
2428 retval = CallWindowProcA( (WNDPROC)wndPtr->winproc,
2429 msg->hwnd, msg->message,
2430 msg->wParam, msg->lParam );
2431 SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
2432 msg->wParam, msg->lParam );
2433
2434 WIN_ReleaseWndPtr(wndPtr);
2435 wndPtr = WIN_FindWndPtr(msg->hwnd);
2436
2437 if (painting && wndPtr &&
2438 (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
2439 {
2440 ERR("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
2441 msg->hwnd);
2442 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
2443 /* Validate the update region to avoid infinite WM_PAINT loop */
2444 RedrawWindow( wndPtr->hwndSelf, NULL, 0,
2445 RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
2446 }
2447 END:
2448 WIN_ReleaseWndPtr(wndPtr);
2449 return retval;
2450 }
2451
2452
2453 /***********************************************************************
2454 * DispatchMessageW (USER32.@) Process Message
2455 *
2456 * Process the message specified in the structure *_msg_.
2457 *
2458 * If the lpMsg parameter points to a WM_TIMER message and the
2459 * parameter of the WM_TIMER message is not NULL, the lParam parameter
2460 * points to the function that is called instead of the window
2461 * procedure.
2462 *
2463 * The message must be valid.
2464 *
2465 * RETURNS
2466 *
2467 * DispatchMessage() returns the result of the window procedure invoked.
2468 *
2469 * CONFORMANCE
2470 *
2471 * ECMA-234, Win32
2472 *
2473 */
2474 LONG WINAPI DispatchMessageW( const MSG* msg )
2475 {
2476 WND * wndPtr;
2477 LONG retval;
2478 int painting;
2479
2480 /* Process timer messages */
2481 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
2482 {
2483 if (msg->lParam)
2484 {
2485 /* HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2486
2487 /* before calling window proc, verify whether timer is still valid;
2488 there's a slim chance that the application kills the timer
2489 between GetMessage and DispatchMessage API calls */
2490 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (HWINDOWPROC) msg->lParam))
2491 return 0; /* invalid winproc */
2492
2493 return CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
2494 msg->message, msg->wParam, GetTickCount() );
2495 }
2496 }
2497
2498 if (!msg->hwnd) return 0;
2499 if (!(wndPtr = WIN_FindWndPtr( msg->hwnd ))) return 0;
2500 if (!wndPtr->winproc)
2501 {
2502 retval = 0;
2503 goto END;
2504 }
2505 painting = (msg->message == WM_PAINT);
2506 if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
2507 /* HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
2508
2509 SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
2510 msg->wParam, msg->lParam );
2511 retval = CallWindowProcW( (WNDPROC)wndPtr->winproc,
2512 msg->hwnd, msg->message,
2513 msg->wParam, msg->lParam );
2514 SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
2515 msg->wParam, msg->lParam );
2516
2517 WIN_ReleaseWndPtr(wndPtr);
2518 wndPtr = WIN_FindWndPtr(msg->hwnd);
2519
2520 if (painting && wndPtr &&
2521 (wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate)
2522 {
2523 ERR("BeginPaint not called on WM_PAINT for hwnd %04x!\n",
2524 msg->hwnd);
2525 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
2526 /* Validate the update region to avoid infinite WM_PAINT loop */
2527 RedrawWindow( wndPtr->hwndSelf, NULL, 0,
2528 RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
2529 }
2530 END:
2531 WIN_ReleaseWndPtr(wndPtr);
2532 return retval;
2533 }
2534
2535
2536 /***********************************************************************
2537 * RegisterWindowMessage (USER.118)
2538 * RegisterWindowMessageA (USER32.@)
2539 */
2540 WORD WINAPI RegisterWindowMessageA( LPCSTR str )
2541 {
2542 TRACE("%s\n", str );
2543 return GlobalAddAtomA( str );
2544 }
2545
2546
2547 /***********************************************************************
2548 * RegisterWindowMessageW (USER32.@)
2549 */
2550 WORD WINAPI RegisterWindowMessageW( LPCWSTR str )
2551 {
2552 TRACE("%p\n", str );
2553 return GlobalAddAtomW( str );
2554 }
2555
2556
2557 /***********************************************************************
2558 * InSendMessage (USER.192)
2559 */
2560 BOOL16 WINAPI InSendMessage16(void)
2561 {
2562 return InSendMessage();
2563 }
2564
2565
2566 /***********************************************************************
2567 * InSendMessage (USER32.@)
2568 */
2569 BOOL WINAPI InSendMessage(void)
2570 {
2571 return (InSendMessageEx(NULL) & (ISMEX_SEND|ISMEX_REPLIED)) == ISMEX_SEND;
2572 }
2573
2574
2575 /***********************************************************************
2576 * InSendMessageEx (USER32.@)
2577 */
2578 DWORD WINAPI InSendMessageEx( LPVOID reserved )
2579 {
2580 DWORD ret = 0;
2581 SERVER_START_REQ( in_send_message )
2582 {
2583 if (!SERVER_CALL_ERR()) ret = req->flags;
2584 }
2585 SERVER_END_REQ;
2586 return ret;
2587 }
2588
2589
2590 /***********************************************************************
2591 * BroadcastSystemMessage (USER32.@)
2592 */
2593 LONG WINAPI BroadcastSystemMessage(
2594 DWORD dwFlags,LPDWORD recipients,UINT uMessage,WPARAM wParam,
2595 LPARAM lParam
2596 ) {
2597 FIXME("(%08lx,%08lx,%08x,%08x,%08lx): stub!\n",
2598 dwFlags,*recipients,uMessage,wParam,lParam
2599 );
2600 return 0;
2601 }
widl and rpcrt4 development