?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Support default output name (a.out); some configure scripts check for
[wine/multimedia.git] / windows / message.c
blob8527cf95f483d6cbe4e4566e4dd9394de41915eb
1 /*
2 * Message queues related functions
3 *
4 * Copyright 1993, 1994 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "config.h"
22
23 #include <stdlib.h>
24 #include <string.h>
25 #include <ctype.h>
26 #ifdef HAVE_SYS_TIME_H
27 # include <sys/time.h>
28 #endif
29 #include <sys/types.h>
30
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winuser.h"
34 #include "message.h"
35 #include "winerror.h"
36 #include "wine/server.h"
37 #include "controls.h"
38 #include "dde.h"
39 #include "heap.h"
40 #include "message.h"
41 #include "thread.h"
42 #include "user.h"
43 #include "win.h"
44 #include "winpos.h"
45 #include "winproc.h"
46 #include "wine/debug.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(msg);
49 WINE_DECLARE_DEBUG_CHANNEL(key);
50
51 #define WM_NCMOUSEFIRST WM_NCMOUSEMOVE
52 #define WM_NCMOUSELAST WM_NCMBUTTONDBLCLK
53
54
55 /***********************************************************************
56 * is_keyboard_message
57 */
58 inline static BOOL is_keyboard_message( UINT message )
59 {
60 return (message >= WM_KEYFIRST && message <= WM_KEYLAST);
61 }
62
63
64 /***********************************************************************
65 * is_mouse_message
66 */
67 inline static BOOL is_mouse_message( UINT message )
68 {
69 return ((message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST) ||
70 (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST));
71 }
72
73
74 /***********************************************************************
75 * check_message_filter
76 */
77 inline static BOOL check_message_filter( const MSG *msg, HWND hwnd, UINT first, UINT last )
78 {
79 if (hwnd)
80 {
81 if (msg->hwnd != hwnd && !IsChild( hwnd, msg->hwnd )) return FALSE;
82 }
83 if (first || last)
84 {
85 return (msg->message >= first && msg->message <= last);
86 }
87 return TRUE;
88 }
89
90
91 /***********************************************************************
92 * process_sent_messages
93 *
94 * Process all pending sent messages.
95 */
96 inline static void process_sent_messages(void)
97 {
98 MSG msg;
99 MSG_peek_message( &msg, 0, 0, 0, GET_MSG_REMOVE | GET_MSG_SENT_ONLY );
100 }
101
102
103 /***********************************************************************
104 * queue_hardware_message
105 *
106 * store a hardware message in the thread queue
107 */
108 #if 0
109 static void queue_hardware_message( MSG *msg, ULONG_PTR extra_info )
110 {
111 SERVER_START_REQ( send_message )
112 {
113 req->type = MSG_HARDWARE;
114 req->id = GetWindowThreadProcessId( msg->hwnd, NULL );
115 req->win = msg->hwnd;
116 req->msg = msg->message;
117 req->wparam = msg->wParam;
118 req->lparam = msg->lParam;
119 req->x = msg->pt.x;
120 req->y = msg->pt.y;
121 req->time = msg->time;
122 req->info = extra_info;
123 req->timeout = 0;
124 wine_server_call( req );
125 }
126 SERVER_END_REQ;
127 }
128 #endif
129
130
131 /***********************************************************************
132 * MSG_SendParentNotify
133 *
134 * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
135 * the window has the WS_EX_NOPARENTNOTIFY style.
136 */
137 static void MSG_SendParentNotify( HWND hwnd, WORD event, WORD idChild, POINT pt )
138 {
139 /* pt has to be in the client coordinates of the parent window */
140 MapWindowPoints( 0, hwnd, &pt, 1 );
141 for (;;)
142 {
143 HWND parent;
144
145 if (!(GetWindowLongA( hwnd, GWL_STYLE ) & WS_CHILD)) break;
146 if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_NOPARENTNOTIFY) break;
147 if (!(parent = GetParent(hwnd))) break;
148 MapWindowPoints( hwnd, parent, &pt, 1 );
149 hwnd = parent;
150 SendMessageA( hwnd, WM_PARENTNOTIFY,
151 MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
152 }
153 }
154
155
156 #if 0 /* this is broken for now, will require proper support in the server */
157
158 /***********************************************************************
159 * MSG_JournalPlayBackMsg
160 *
161 * Get an EVENTMSG struct via call JOURNALPLAYBACK hook function
162 */
163 void MSG_JournalPlayBackMsg(void)
164 {
165 EVENTMSG tmpMsg;
166 MSG msg;
167 LRESULT wtime;
168 int keyDown,i;
169
170 wtime=HOOK_CallHooks( WH_JOURNALPLAYBACK, HC_GETNEXT, 0, (LPARAM)&tmpMsg, TRUE );
171 /* TRACE(msg,"Playback wait time =%ld\n",wtime); */
172 if (wtime<=0)
173 {
174 wtime=0;
175 msg.message = tmpMsg.message;
176 msg.hwnd = tmpMsg.hwnd;
177 msg.time = tmpMsg.time;
178 if ((tmpMsg.message >= WM_KEYFIRST) && (tmpMsg.message <= WM_KEYLAST))
179 {
180 msg.wParam = tmpMsg.paramL & 0xFF;
181 msg.lParam = MAKELONG(tmpMsg.paramH&0x7ffff,tmpMsg.paramL>>8);
182 if (tmpMsg.message == WM_KEYDOWN || tmpMsg.message == WM_SYSKEYDOWN)
183 {
184 for (keyDown=i=0; i<256 && !keyDown; i++)
185 if (InputKeyStateTable[i] & 0x80)
186 keyDown++;
187 if (!keyDown)
188 msg.lParam |= 0x40000000;
189 InputKeyStateTable[msg.wParam] |= 0x80;
190 AsyncKeyStateTable[msg.wParam] |= 0x80;
191 }
192 else /* WM_KEYUP, WM_SYSKEYUP */
193 {
194 msg.lParam |= 0xC0000000;
195 InputKeyStateTable[msg.wParam] &= ~0x80;
196 }
197 if (InputKeyStateTable[VK_MENU] & 0x80)
198 msg.lParam |= 0x20000000;
199 if (tmpMsg.paramH & 0x8000) /*special_key bit*/
200 msg.lParam |= 0x01000000;
201
202 msg.pt.x = msg.pt.y = 0;
203 queue_hardware_message( &msg, 0 );
204 }
205 else if ((tmpMsg.message>= WM_MOUSEFIRST) && (tmpMsg.message <= WM_MOUSELAST))
206 {
207 switch (tmpMsg.message)
208 {
209 case WM_LBUTTONDOWN:
210 InputKeyStateTable[VK_LBUTTON] |= 0x80;
211 AsyncKeyStateTable[VK_LBUTTON] |= 0x80;
212 break;
213 case WM_LBUTTONUP:
214 InputKeyStateTable[VK_LBUTTON] &= ~0x80;
215 break;
216 case WM_MBUTTONDOWN:
217 InputKeyStateTable[VK_MBUTTON] |= 0x80;
218 AsyncKeyStateTable[VK_MBUTTON] |= 0x80;
219 break;
220 case WM_MBUTTONUP:
221 InputKeyStateTable[VK_MBUTTON] &= ~0x80;
222 break;
223 case WM_RBUTTONDOWN:
224 InputKeyStateTable[VK_RBUTTON] |= 0x80;
225 AsyncKeyStateTable[VK_RBUTTON] |= 0x80;
226 break;
227 case WM_RBUTTONUP:
228 InputKeyStateTable[VK_RBUTTON] &= ~0x80;
229 break;
230 }
231 SetCursorPos(tmpMsg.paramL,tmpMsg.paramH);
232 msg.lParam=MAKELONG(tmpMsg.paramL,tmpMsg.paramH);
233 msg.wParam=0;
234 if (InputKeyStateTable[VK_LBUTTON] & 0x80) msg.wParam |= MK_LBUTTON;
235 if (InputKeyStateTable[VK_MBUTTON] & 0x80) msg.wParam |= MK_MBUTTON;
236 if (InputKeyStateTable[VK_RBUTTON] & 0x80) msg.wParam |= MK_RBUTTON;
237
238 msg.pt.x = tmpMsg.paramL;
239 msg.pt.y = tmpMsg.paramH;
240 queue_hardware_message( &msg, 0 );
241 }
242 HOOK_CallHooks( WH_JOURNALPLAYBACK, HC_SKIP, 0, (LPARAM)&tmpMsg, TRUE );
243 }
244 else
245 {
246 if( tmpMsg.message == WM_QUEUESYNC ) HOOK_CallHooks( WH_CBT, HCBT_QS, 0, 0, TRUE );
247 }
248 }
249 #endif
250
251
252 /***********************************************************************
253 * process_raw_keyboard_message
254 *
255 * returns TRUE if the contents of 'msg' should be passed to the application
256 */
257 static void process_raw_keyboard_message( MSG *msg )
258 {
259 EVENTMSG event;
260
261 event.message = msg->message;
262 event.hwnd = msg->hwnd;
263 event.time = msg->time;
264 event.paramL = (msg->wParam & 0xFF) | (HIWORD(msg->lParam) << 8);
265 event.paramH = msg->lParam & 0x7FFF;
266 if (HIWORD(msg->lParam) & 0x0100) event.paramH |= 0x8000; /* special_key - bit */
267 HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event, TRUE );
268 }
269
270
271 /***********************************************************************
272 * process_cooked_keyboard_message
273 *
274 * returns TRUE if the contents of 'msg' should be passed to the application
275 */
276 static BOOL process_cooked_keyboard_message( MSG *msg, BOOL remove )
277 {
278 if (remove)
279 {
280 /* Handle F1 key by sending out WM_HELP message */
281 if ((msg->message == WM_KEYUP) &&
282 (msg->wParam == VK_F1) &&
283 (msg->hwnd != GetDesktopWindow()) &&
284 !MENU_IsMenuActive())
285 {
286 HELPINFO hi;
287 hi.cbSize = sizeof(HELPINFO);
288 hi.iContextType = HELPINFO_WINDOW;
289 hi.iCtrlId = GetWindowLongA( msg->hwnd, GWL_ID );
290 hi.hItemHandle = msg->hwnd;
291 hi.dwContextId = GetWindowContextHelpId( msg->hwnd );
292 hi.MousePos = msg->pt;
293 SendMessageA(msg->hwnd, WM_HELP, 0, (LPARAM)&hi);
294 }
295 }
296
297 if (HOOK_CallHooks( WH_KEYBOARD, remove ? HC_ACTION : HC_NOREMOVE,
298 LOWORD(msg->wParam), msg->lParam, TRUE ))
299 {
300 /* skip this message */
301 HOOK_CallHooks( WH_CBT, HCBT_KEYSKIPPED, LOWORD(msg->wParam), msg->lParam, TRUE );
302 return FALSE;
303 }
304 return TRUE;
305 }
306
307
308 /***********************************************************************
309 * process_raw_mouse_message
310 */
311 static void process_raw_mouse_message( MSG *msg, BOOL remove )
312 {
313 static MSG clk_msg;
314
315 POINT pt;
316 INT hittest;
317 EVENTMSG event;
318 GUITHREADINFO info;
319 HWND hWndScope = msg->hwnd;
320
321 /* find the window to dispatch this mouse message to */
322
323 hittest = HTCLIENT;
324 GetGUIThreadInfo( GetCurrentThreadId(), &info );
325 if (!(msg->hwnd = info.hwndCapture))
326 {
327 /* If no capture HWND, find window which contains the mouse position.
328 * Also find the position of the cursor hot spot (hittest) */
329 if (!IsWindow(hWndScope)) hWndScope = 0;
330 if (!(msg->hwnd = WINPOS_WindowFromPoint( hWndScope, msg->pt, &hittest )))
331 msg->hwnd = GetDesktopWindow();
332 }
333
334 event.message = msg->message;
335 event.time = msg->time;
336 event.hwnd = msg->hwnd;
337 event.paramL = msg->pt.x;
338 event.paramH = msg->pt.y;
339 HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event, TRUE );
340
341 /* translate double clicks */
342
343 if ((msg->message == WM_LBUTTONDOWN) ||
344 (msg->message == WM_RBUTTONDOWN) ||
345 (msg->message == WM_MBUTTONDOWN))
346 {
347 BOOL update = remove;
348 /* translate double clicks -
349 * note that ...MOUSEMOVEs can slip in between
350 * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
351
352 if ((info.flags & (GUI_INMENUMODE|GUI_INMOVESIZE)) ||
353 hittest != HTCLIENT ||
354 (GetClassLongA( msg->hwnd, GCL_STYLE ) & CS_DBLCLKS))
355 {
356 if ((msg->message == clk_msg.message) &&
357 (msg->hwnd == clk_msg.hwnd) &&
358 (msg->time - clk_msg.time < GetDoubleClickTime()) &&
359 (abs(msg->pt.x - clk_msg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK)/2) &&
360 (abs(msg->pt.y - clk_msg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK)/2))
361 {
362 msg->message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
363 if (remove)
364 {
365 clk_msg.message = 0;
366 update = FALSE;
367 }
368 }
369 }
370 /* update static double click conditions */
371 if (update) clk_msg = *msg;
372 }
373
374 pt = msg->pt;
375 /* Note: windows has no concept of a non-client wheel message */
376 if (hittest != HTCLIENT && msg->message != WM_MOUSEWHEEL)
377 {
378 msg->message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
379 msg->wParam = hittest;
380 }
381 else
382 {
383 /* coordinates don't get translated while tracking a menu */
384 /* FIXME: should differentiate popups and top-level menus */
385 if (!(info.flags & GUI_INMENUMODE)) ScreenToClient( msg->hwnd, &pt );
386 }
387 msg->lParam = MAKELONG( pt.x, pt.y );
388 }
389
390
391 /***********************************************************************
392 * process_cooked_mouse_message
393 *
394 * returns TRUE if the contents of 'msg' should be passed to the application
395 */
396 static BOOL process_cooked_mouse_message( MSG *msg, ULONG_PTR extra_info, BOOL remove )
397 {
398 MOUSEHOOKSTRUCT hook;
399 INT hittest = HTCLIENT;
400 UINT raw_message = msg->message;
401 BOOL eatMsg;
402
403 if (msg->message >= WM_NCMOUSEFIRST && msg->message <= WM_NCMOUSELAST)
404 {
405 raw_message += WM_MOUSEFIRST - WM_NCMOUSEFIRST;
406 hittest = msg->wParam;
407 }
408 if (raw_message == WM_LBUTTONDBLCLK ||
409 raw_message == WM_RBUTTONDBLCLK ||
410 raw_message == WM_MBUTTONDBLCLK)
411 {
412 raw_message += WM_LBUTTONDOWN - WM_LBUTTONDBLCLK;
413 }
414
415 hook.pt = msg->pt;
416 hook.hwnd = msg->hwnd;
417 hook.wHitTestCode = hittest;
418 hook.dwExtraInfo = extra_info;
419 if (HOOK_CallHooks( WH_MOUSE, remove ? HC_ACTION : HC_NOREMOVE,
420 msg->message, (LPARAM)&hook, TRUE ))
421 {
422 hook.pt = msg->pt;
423 hook.hwnd = msg->hwnd;
424 hook.wHitTestCode = hittest;
425 hook.dwExtraInfo = extra_info;
426 HOOK_CallHooks( WH_CBT, HCBT_CLICKSKIPPED, msg->message, (LPARAM)&hook, TRUE );
427 return FALSE;
428 }
429
430 if ((hittest == HTERROR) || (hittest == HTNOWHERE))
431 {
432 SendMessageA( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
433 MAKELONG( hittest, raw_message ));
434 return FALSE;
435 }
436
437 if (!remove || GetCapture()) return TRUE;
438
439 eatMsg = FALSE;
440
441 if ((raw_message == WM_LBUTTONDOWN) ||
442 (raw_message == WM_RBUTTONDOWN) ||
443 (raw_message == WM_MBUTTONDOWN))
444 {
445 /* Send the WM_PARENTNOTIFY,
446 * note that even for double/nonclient clicks
447 * notification message is still WM_L/M/RBUTTONDOWN.
448 */
449 MSG_SendParentNotify( msg->hwnd, raw_message, 0, msg->pt );
450
451 /* Activate the window if needed */
452
453 if (msg->hwnd != GetActiveWindow())
454 {
455 HWND hwndTop = msg->hwnd;
456 while (hwndTop)
457 {
458 if ((GetWindowLongW( hwndTop, GWL_STYLE ) & (WS_POPUP|WS_CHILD)) != WS_CHILD) break;
459 hwndTop = GetParent( hwndTop );
460 }
461
462 if (hwndTop && hwndTop != GetDesktopWindow())
463 {
464 LONG ret = SendMessageA( msg->hwnd, WM_MOUSEACTIVATE, (WPARAM)hwndTop,
465 MAKELONG( hittest, raw_message ) );
466 switch(ret)
467 {
468 case MA_NOACTIVATEANDEAT:
469 eatMsg = TRUE;
470 /* fall through */
471 case MA_NOACTIVATE:
472 break;
473 case MA_ACTIVATEANDEAT:
474 eatMsg = TRUE;
475 /* fall through */
476 case MA_ACTIVATE:
477 case 0:
478 if (!FOCUS_MouseActivate( hwndTop )) eatMsg = TRUE;
479 break;
480 default:
481 WARN( "unknown WM_MOUSEACTIVATE code %ld\n", ret );
482 break;
483 }
484 }
485 }
486 }
487
488 /* send the WM_SETCURSOR message */
489
490 /* Windows sends the normal mouse message as the message parameter
491 in the WM_SETCURSOR message even if it's non-client mouse message */
492 SendMessageA( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
493 MAKELONG( hittest, raw_message ));
494
495 return !eatMsg;
496 }
497
498
499 /***********************************************************************
500 * process_hardware_message
501 *
502 * returns TRUE if the contents of 'msg' should be passed to the application
503 */
504 BOOL MSG_process_raw_hardware_message( MSG *msg, ULONG_PTR extra_info, HWND hwnd_filter,
505 UINT first, UINT last, BOOL remove )
506 {
507 if (is_keyboard_message( msg->message ))
508 {
509 process_raw_keyboard_message( msg );
510 }
511 else if (is_mouse_message( msg->message ))
512 {
513 process_raw_mouse_message( msg, remove );
514 }
515 else
516 {
517 ERR( "unknown message type %x\n", msg->message );
518 return FALSE;
519 }
520 return check_message_filter( msg, hwnd_filter, first, last );
521 }
522
523
524 /***********************************************************************
525 * MSG_process_cooked_hardware_message
526 *
527 * returns TRUE if the contents of 'msg' should be passed to the application
528 */
529 BOOL MSG_process_cooked_hardware_message( MSG *msg, ULONG_PTR extra_info, BOOL remove )
530 {
531 if (is_keyboard_message( msg->message ))
532 return process_cooked_keyboard_message( msg, remove );
533
534 if (is_mouse_message( msg->message ))
535 return process_cooked_mouse_message( msg, extra_info, remove );
536
537 ERR( "unknown message type %x\n", msg->message );
538 return FALSE;
539 }
540
541
542 /***********************************************************************
543 * WaitMessage (USER.112) Suspend thread pending messages
544 * WaitMessage (USER32.@) Suspend thread pending messages
545 *
546 * WaitMessage() suspends a thread until events appear in the thread's
547 * queue.
548 */
549 BOOL WINAPI WaitMessage(void)
550 {
551 return (MsgWaitForMultipleObjectsEx( 0, NULL, INFINITE, QS_ALLINPUT, 0 ) != WAIT_FAILED);
552 }
553
554
555 /***********************************************************************
556 * MsgWaitForMultipleObjectsEx (USER32.@)
557 */
558 DWORD WINAPI MsgWaitForMultipleObjectsEx( DWORD count, CONST HANDLE *pHandles,
559 DWORD timeout, DWORD mask, DWORD flags )
560 {
561 HANDLE handles[MAXIMUM_WAIT_OBJECTS];
562 DWORD i, ret, lock;
563 MESSAGEQUEUE *msgQueue;
564
565 if (count > MAXIMUM_WAIT_OBJECTS-1)
566 {
567 SetLastError( ERROR_INVALID_PARAMETER );
568 return WAIT_FAILED;
569 }
570
571 if (!(msgQueue = QUEUE_Current())) return WAIT_FAILED;
572
573 /* set the queue mask */
574 SERVER_START_REQ( set_queue_mask )
575 {
576 req->wake_mask = (flags & MWMO_INPUTAVAILABLE) ? mask : 0;
577 req->changed_mask = mask;
578 req->skip_wait = 0;
579 wine_server_call( req );
580 }
581 SERVER_END_REQ;
582
583 /* Add the thread event to the handle list */
584 for (i = 0; i < count; i++) handles[i] = pHandles[i];
585 handles[count] = msgQueue->server_queue;
586
587 ReleaseThunkLock( &lock );
588 if (USER_Driver.pMsgWaitForMultipleObjectsEx)
589 {
590 ret = USER_Driver.pMsgWaitForMultipleObjectsEx( count+1, handles, timeout, mask, flags );
591 if (ret == count+1) ret = count; /* pretend the msg queue is ready */
592 }
593 else
594 ret = WaitForMultipleObjectsEx( count+1, handles, flags & MWMO_WAITALL,
595 timeout, flags & MWMO_ALERTABLE );
596 if (lock) RestoreThunkLock( lock );
597 return ret;
598 }
599
600
601 /***********************************************************************
602 * MsgWaitForMultipleObjects (USER32.@)
603 */
604 DWORD WINAPI MsgWaitForMultipleObjects( DWORD count, CONST HANDLE *handles,
605 BOOL wait_all, DWORD timeout, DWORD mask )
606 {
607 return MsgWaitForMultipleObjectsEx( count, handles, timeout, mask,
608 wait_all ? MWMO_WAITALL : 0 );
609 }
610
611
612 /***********************************************************************
613 * WaitForInputIdle (USER32.@)
614 */
615 DWORD WINAPI WaitForInputIdle( HANDLE hProcess, DWORD dwTimeOut )
616 {
617 DWORD start_time, elapsed, ret;
618 HANDLE idle_event = (HANDLE)-1;
619
620 SERVER_START_REQ( wait_input_idle )
621 {
622 req->handle = hProcess;
623 req->timeout = dwTimeOut;
624 if (!(ret = wine_server_call_err( req ))) idle_event = reply->event;
625 }
626 SERVER_END_REQ;
627 if (ret) return WAIT_FAILED; /* error */
628 if (!idle_event) return 0; /* no event to wait on */
629
630 start_time = GetTickCount();
631 elapsed = 0;
632
633 TRACE("waiting for %p\n", idle_event );
634 do
635 {
636 ret = MsgWaitForMultipleObjects ( 1, &idle_event, FALSE, dwTimeOut - elapsed, QS_SENDMESSAGE );
637 switch (ret)
638 {
639 case WAIT_OBJECT_0+1:
640 process_sent_messages();
641 break;
642 case WAIT_TIMEOUT:
643 case WAIT_FAILED:
644 TRACE("timeout or error\n");
645 return ret;
646 default:
647 TRACE("finished\n");
648 return 0;
649 }
650 if (dwTimeOut != INFINITE)
651 {
652 elapsed = GetTickCount() - start_time;
653 if (elapsed > dwTimeOut)
654 break;
655 }
656 }
657 while (1);
658
659 return WAIT_TIMEOUT;
660 }
661
662
663 /***********************************************************************
664 * UserYield (USER.332)
665 */
666 void WINAPI UserYield16(void)
667 {
668 DWORD count;
669
670 /* Handle sent messages */
671 process_sent_messages();
672
673 /* Yield */
674 ReleaseThunkLock(&count);
675 if (count)
676 {
677 RestoreThunkLock(count);
678 /* Handle sent messages again */
679 process_sent_messages();
680 }
681 }
682
683
684 struct accent_char
685 {
686 BYTE ac_accent;
687 BYTE ac_char;
688 BYTE ac_result;
689 };
690
691 static const struct accent_char accent_chars[] =
692 {
693 /* A good idea should be to read /usr/X11/lib/X11/locale/iso8859-x/Compose */
694 {'`', 'A', '\300'}, {'`', 'a', '\340'},
695 {'\'', 'A', '\301'}, {'\'', 'a', '\341'},
696 {'^', 'A', '\302'}, {'^', 'a', '\342'},
697 {'~', 'A', '\303'}, {'~', 'a', '\343'},
698 {'"', 'A', '\304'}, {'"', 'a', '\344'},
699 {'O', 'A', '\305'}, {'o', 'a', '\345'},
700 {'0', 'A', '\305'}, {'0', 'a', '\345'},
701 {'A', 'A', '\305'}, {'a', 'a', '\345'},
702 {'A', 'E', '\306'}, {'a', 'e', '\346'},
703 {',', 'C', '\307'}, {',', 'c', '\347'},
704 {'`', 'E', '\310'}, {'`', 'e', '\350'},
705 {'\'', 'E', '\311'}, {'\'', 'e', '\351'},
706 {'^', 'E', '\312'}, {'^', 'e', '\352'},
707 {'"', 'E', '\313'}, {'"', 'e', '\353'},
708 {'`', 'I', '\314'}, {'`', 'i', '\354'},
709 {'\'', 'I', '\315'}, {'\'', 'i', '\355'},
710 {'^', 'I', '\316'}, {'^', 'i', '\356'},
711 {'"', 'I', '\317'}, {'"', 'i', '\357'},
712 {'-', 'D', '\320'}, {'-', 'd', '\360'},
713 {'~', 'N', '\321'}, {'~', 'n', '\361'},
714 {'`', 'O', '\322'}, {'`', 'o', '\362'},
715 {'\'', 'O', '\323'}, {'\'', 'o', '\363'},
716 {'^', 'O', '\324'}, {'^', 'o', '\364'},
717 {'~', 'O', '\325'}, {'~', 'o', '\365'},
718 {'"', 'O', '\326'}, {'"', 'o', '\366'},
719 {'/', 'O', '\330'}, {'/', 'o', '\370'},
720 {'`', 'U', '\331'}, {'`', 'u', '\371'},
721 {'\'', 'U', '\332'}, {'\'', 'u', '\372'},
722 {'^', 'U', '\333'}, {'^', 'u', '\373'},
723 {'"', 'U', '\334'}, {'"', 'u', '\374'},
724 {'\'', 'Y', '\335'}, {'\'', 'y', '\375'},
725 {'T', 'H', '\336'}, {'t', 'h', '\376'},
726 {'s', 's', '\337'}, {'"', 'y', '\377'},
727 {'s', 'z', '\337'}, {'i', 'j', '\377'},
728 /* iso-8859-2 uses this */
729 {'<', 'L', '\245'}, {'<', 'l', '\265'}, /* caron */
730 {'<', 'S', '\251'}, {'<', 's', '\271'},
731 {'<', 'T', '\253'}, {'<', 't', '\273'},
732 {'<', 'Z', '\256'}, {'<', 'z', '\276'},
733 {'<', 'C', '\310'}, {'<', 'c', '\350'},
734 {'<', 'E', '\314'}, {'<', 'e', '\354'},
735 {'<', 'D', '\317'}, {'<', 'd', '\357'},
736 {'<', 'N', '\322'}, {'<', 'n', '\362'},
737 {'<', 'R', '\330'}, {'<', 'r', '\370'},
738 {';', 'A', '\241'}, {';', 'a', '\261'}, /* ogonek */
739 {';', 'E', '\312'}, {';', 'e', '\332'},
740 {'\'', 'Z', '\254'}, {'\'', 'z', '\274'}, /* acute */
741 {'\'', 'R', '\300'}, {'\'', 'r', '\340'},
742 {'\'', 'L', '\305'}, {'\'', 'l', '\345'},
743 {'\'', 'C', '\306'}, {'\'', 'c', '\346'},
744 {'\'', 'N', '\321'}, {'\'', 'n', '\361'},
745 /* collision whith S, from iso-8859-9 !!! */
746 {',', 'S', '\252'}, {',', 's', '\272'}, /* cedilla */
747 {',', 'T', '\336'}, {',', 't', '\376'},
748 {'.', 'Z', '\257'}, {'.', 'z', '\277'}, /* dot above */
749 {'/', 'L', '\243'}, {'/', 'l', '\263'}, /* slash */
750 {'/', 'D', '\320'}, {'/', 'd', '\360'},
751 {'(', 'A', '\303'}, {'(', 'a', '\343'}, /* breve */
752 {'\275', 'O', '\325'}, {'\275', 'o', '\365'}, /* double acute */
753 {'\275', 'U', '\334'}, {'\275', 'u', '\374'},
754 {'0', 'U', '\332'}, {'0', 'u', '\372'}, /* ring above */
755 /* iso-8859-3 uses this */
756 {'/', 'H', '\241'}, {'/', 'h', '\261'}, /* slash */
757 {'>', 'H', '\246'}, {'>', 'h', '\266'}, /* circumflex */
758 {'>', 'J', '\254'}, {'>', 'j', '\274'},
759 {'>', 'C', '\306'}, {'>', 'c', '\346'},
760 {'>', 'G', '\330'}, {'>', 'g', '\370'},
761 {'>', 'S', '\336'}, {'>', 's', '\376'},
762 /* collision whith G( from iso-8859-9 !!! */
763 {'(', 'G', '\253'}, {'(', 'g', '\273'}, /* breve */
764 {'(', 'U', '\335'}, {'(', 'u', '\375'},
765 /* collision whith I. from iso-8859-3 !!! */
766 {'.', 'I', '\251'}, {'.', 'i', '\271'}, /* dot above */
767 {'.', 'C', '\305'}, {'.', 'c', '\345'},
768 {'.', 'G', '\325'}, {'.', 'g', '\365'},
769 /* iso-8859-4 uses this */
770 {',', 'R', '\243'}, {',', 'r', '\263'}, /* cedilla */
771 {',', 'L', '\246'}, {',', 'l', '\266'},
772 {',', 'G', '\253'}, {',', 'g', '\273'},
773 {',', 'N', '\321'}, {',', 'n', '\361'},
774 {',', 'K', '\323'}, {',', 'k', '\363'},
775 {'~', 'I', '\245'}, {'~', 'i', '\265'}, /* tilde */
776 {'-', 'E', '\252'}, {'-', 'e', '\272'}, /* macron */
777 {'-', 'A', '\300'}, {'-', 'a', '\340'},
778 {'-', 'I', '\317'}, {'-', 'i', '\357'},
779 {'-', 'O', '\322'}, {'-', 'o', '\362'},
780 {'-', 'U', '\336'}, {'-', 'u', '\376'},
781 {'/', 'T', '\254'}, {'/', 't', '\274'}, /* slash */
782 {'.', 'E', '\314'}, {'.', 'e', '\344'}, /* dot above */
783 {';', 'I', '\307'}, {';', 'i', '\347'}, /* ogonek */
784 {';', 'U', '\331'}, {';', 'u', '\371'},
785 /* iso-8859-9 uses this */
786 /* iso-8859-9 has really bad choosen G( S, and I. as they collide
787 * whith the same letters on other iso-8859-x (that is they are on
788 * different places :-( ), if you use turkish uncomment these and
789 * comment out the lines in iso-8859-2 and iso-8859-3 sections
790 * FIXME: should be dynamic according to chosen language
791 * if/when Wine has turkish support.
792 */
793 /* collision whith G( from iso-8859-3 !!! */
794 /* {'(', 'G', '\320'}, {'(', 'g', '\360'}, */ /* breve */
795 /* collision whith S, from iso-8859-2 !!! */
796 /* {',', 'S', '\336'}, {',', 's', '\376'}, */ /* cedilla */
797 /* collision whith I. from iso-8859-3 !!! */
798 /* {'.', 'I', '\335'}, {'.', 'i', '\375'}, */ /* dot above */
799 };
800
801
802 /***********************************************************************
803 * TranslateMessage (USER32.@)
804 *
805 * Implementation of TranslateMessage.
806 *
807 * TranslateMessage translates virtual-key messages into character-messages,
808 * as follows :
809 * WM_KEYDOWN/WM_KEYUP combinations produce a WM_CHAR or WM_DEADCHAR message.
810 * ditto replacing WM_* with WM_SYS*
811 * This produces WM_CHAR messages only for keys mapped to ASCII characters
812 * by the keyboard driver.
813 *
814 * If the message is WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, or WM_SYSKEYUP, the
815 * return value is nonzero, regardless of the translation.
816 *
817 */
818 BOOL WINAPI TranslateMessage( const MSG *msg )
819 {
820 static int dead_char;
821 UINT message;
822 WCHAR wp[2];
823 BOOL rc = FALSE;
824 BYTE state[256];
825
826 if (msg->message >= WM_KEYFIRST && msg->message <= WM_KEYLAST)
827 {
828 TRACE_(key)("(%s, %04X, %08lX)\n",
829 SPY_GetMsgName(msg->message, msg->hwnd), msg->wParam, msg->lParam );
830
831 /* Return code must be TRUE no matter what! */
832 rc = TRUE;
833 }
834
835 if ((msg->message != WM_KEYDOWN) && (msg->message != WM_SYSKEYDOWN)) return rc;
836
837 TRACE_(key)("Translating key %s (%04x), scancode %02x\n",
838 SPY_GetVKeyName(msg->wParam), msg->wParam, LOBYTE(HIWORD(msg->lParam)));
839
840 GetKeyboardState( state );
841 /* FIXME : should handle ToUnicode yielding 2 */
842 switch (ToUnicode(msg->wParam, HIWORD(msg->lParam), state, wp, 2, 0))
843 {
844 case 1:
845 message = (msg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
846 /* Should dead chars handling go in ToAscii ? */
847 if (dead_char)
848 {
849 int i;
850
851 if (wp[0] == ' ') wp[0] = dead_char;
852 if (dead_char == 0xa2) dead_char = '(';
853 else if (dead_char == 0xa8) dead_char = '"';
854 else if (dead_char == 0xb2) dead_char = ';';
855 else if (dead_char == 0xb4) dead_char = '\'';
856 else if (dead_char == 0xb7) dead_char = '<';
857 else if (dead_char == 0xb8) dead_char = ',';
858 else if (dead_char == 0xff) dead_char = '.';
859 for (i = 0; i < sizeof(accent_chars)/sizeof(accent_chars[0]); i++)
860 if ((accent_chars[i].ac_accent == dead_char) &&
861 (accent_chars[i].ac_char == wp[0]))
862 {
863 wp[0] = accent_chars[i].ac_result;
864 break;
865 }
866 dead_char = 0;
867 }
868 TRACE_(key)("1 -> PostMessage(%s)\n", SPY_GetMsgName(message, msg->hwnd));
869 PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
870 break;
871
872 case -1:
873 message = (msg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
874 dead_char = wp[0];
875 TRACE_(key)("-1 -> PostMessage(%s)\n", SPY_GetMsgName(message, msg->hwnd));
876 PostMessageW( msg->hwnd, message, wp[0], msg->lParam );
877 return TRUE;
878 }
879 return rc;
880 }
881
882
883 /***********************************************************************
884 * DispatchMessageA (USER32.@)
885 */
886 LONG WINAPI DispatchMessageA( const MSG* msg )
887 {
888 WND * wndPtr;
889 LONG retval;
890 int painting;
891 WNDPROC winproc;
892
893 /* Process timer messages */
894 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
895 {
896 if (msg->lParam)
897 {
898 /* HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
899
900 /* before calling window proc, verify whether timer is still valid;
901 there's a slim chance that the application kills the timer
902 between GetMessage and DispatchMessage API calls */
903 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (WNDPROC)msg->lParam))
904 return 0; /* invalid winproc */
905
906 return CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
907 msg->message, msg->wParam, GetTickCount() );
908 }
909 }
910
911 if (!(wndPtr = WIN_GetPtr( msg->hwnd )))
912 {
913 if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
914 return 0;
915 }
916 if (wndPtr == WND_OTHER_PROCESS)
917 {
918 if (IsWindow( msg->hwnd ))
919 ERR( "cannot dispatch msg to other process window %p\n", msg->hwnd );
920 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
921 return 0;
922 }
923 if (!(winproc = wndPtr->winproc))
924 {
925 WIN_ReleasePtr( wndPtr );
926 return 0;
927 }
928 painting = (msg->message == WM_PAINT);
929 if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
930 WIN_ReleasePtr( wndPtr );
931 /* hook_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
932
933 SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
934 msg->wParam, msg->lParam );
935 retval = CallWindowProcA( winproc, msg->hwnd, msg->message,
936 msg->wParam, msg->lParam );
937 SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
938 msg->wParam, msg->lParam );
939
940 if (painting && (wndPtr = WIN_GetPtr( msg->hwnd )) && (wndPtr != WND_OTHER_PROCESS))
941 {
942 BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
943 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
944 WIN_ReleasePtr( wndPtr );
945 if (validate)
946 {
947 ERR( "BeginPaint not called on WM_PAINT for hwnd %p!\n", msg->hwnd );
948 /* Validate the update region to avoid infinite WM_PAINT loop */
949 RedrawWindow( msg->hwnd, NULL, 0,
950 RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
951 }
952 }
953 return retval;
954 }
955
956
957 /***********************************************************************
958 * DispatchMessageW (USER32.@) Process Message
959 *
960 * Process the message specified in the structure *_msg_.
961 *
962 * If the lpMsg parameter points to a WM_TIMER message and the
963 * parameter of the WM_TIMER message is not NULL, the lParam parameter
964 * points to the function that is called instead of the window
965 * procedure.
966 *
967 * The message must be valid.
968 *
969 * RETURNS
970 *
971 * DispatchMessage() returns the result of the window procedure invoked.
972 *
973 * CONFORMANCE
974 *
975 * ECMA-234, Win32
976 *
977 */
978 LONG WINAPI DispatchMessageW( const MSG* msg )
979 {
980 WND * wndPtr;
981 LONG retval;
982 int painting;
983 WNDPROC winproc;
984
985 /* Process timer messages */
986 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
987 {
988 if (msg->lParam)
989 {
990 /* HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
991
992 /* before calling window proc, verify whether timer is still valid;
993 there's a slim chance that the application kills the timer
994 between GetMessage and DispatchMessage API calls */
995 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, (WNDPROC)msg->lParam))
996 return 0; /* invalid winproc */
997
998 return CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
999 msg->message, msg->wParam, GetTickCount() );
1000 }
1001 }
1002
1003 if (!(wndPtr = WIN_GetPtr( msg->hwnd )))
1004 {
1005 if (msg->hwnd) SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1006 return 0;
1007 }
1008 if (wndPtr == WND_OTHER_PROCESS)
1009 {
1010 if (IsWindow( msg->hwnd ))
1011 ERR( "cannot dispatch msg to other process window %p\n", msg->hwnd );
1012 SetLastError( ERROR_INVALID_WINDOW_HANDLE );
1013 return 0;
1014 }
1015 if (!(winproc = wndPtr->winproc))
1016 {
1017 WIN_ReleasePtr( wndPtr );
1018 return 0;
1019 }
1020 painting = (msg->message == WM_PAINT);
1021 if (painting) wndPtr->flags |= WIN_NEEDS_BEGINPAINT;
1022 WIN_ReleasePtr( wndPtr );
1023 /* HOOK_CallHooks32W( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
1024
1025 SPY_EnterMessage( SPY_DISPATCHMESSAGE, msg->hwnd, msg->message,
1026 msg->wParam, msg->lParam );
1027 retval = CallWindowProcW( winproc, msg->hwnd, msg->message,
1028 msg->wParam, msg->lParam );
1029 SPY_ExitMessage( SPY_RESULT_OK, msg->hwnd, msg->message, retval,
1030 msg->wParam, msg->lParam );
1031
1032 if (painting && (wndPtr = WIN_GetPtr( msg->hwnd )) && (wndPtr != WND_OTHER_PROCESS))
1033 {
1034 BOOL validate = ((wndPtr->flags & WIN_NEEDS_BEGINPAINT) && wndPtr->hrgnUpdate);
1035 wndPtr->flags &= ~WIN_NEEDS_BEGINPAINT;
1036 WIN_ReleasePtr( wndPtr );
1037 if (validate)
1038 {
1039 ERR( "BeginPaint not called on WM_PAINT for hwnd %p!\n", msg->hwnd );
1040 /* Validate the update region to avoid infinite WM_PAINT loop */
1041 RedrawWindow( msg->hwnd, NULL, 0,
1042 RDW_NOFRAME | RDW_VALIDATE | RDW_NOCHILDREN | RDW_NOINTERNALPAINT );
1043 }
1044 }
1045 return retval;
1046 }
1047
1048
1049 /***********************************************************************
1050 * RegisterWindowMessage (USER.118)
1051 * RegisterWindowMessageA (USER32.@)
1052 */
1053 WORD WINAPI RegisterWindowMessageA( LPCSTR str )
1054 {
1055 TRACE("%s\n", str );
1056 return GlobalAddAtomA( str );
1057 }
1058
1059
1060 /***********************************************************************
1061 * RegisterWindowMessageW (USER32.@)
1062 */
1063 WORD WINAPI RegisterWindowMessageW( LPCWSTR str )
1064 {
1065 TRACE("%p\n", str );
1066 return GlobalAddAtomW( str );
1067 }
1068
1069
1070 /***********************************************************************
1071 * BroadcastSystemMessage (USER32.@)
1072 * BroadcastSystemMessageA (USER32.@)
1073 */
1074 LONG WINAPI BroadcastSystemMessage(
1075 DWORD dwFlags,LPDWORD recipients,UINT uMessage,WPARAM wParam,
1076 LPARAM lParam )
1077 {
1078 if ((*recipients & BSM_APPLICATIONS)||
1079 (*recipients == BSM_ALLCOMPONENTS))
1080 {
1081 FIXME("(%08lx,%08lx,%08x,%08x,%08lx): semi-stub!\n",
1082 dwFlags,*recipients,uMessage,wParam,lParam);
1083 PostMessageA(HWND_BROADCAST,uMessage,wParam,lParam);
1084 return 1;
1085 }
1086 else
1087 {
1088 FIXME("(%08lx,%08lx,%08x,%08x,%08lx): stub!\n",
1089 dwFlags,*recipients,uMessage,wParam,lParam);
1090 return -1;
1091 }
1092 }
Maarten's multimedia branch