source: trunk/src/user32/windowmsg.cpp

Last change on this file was 22033, checked in by dmik, 13 years ago

user32: Partly implement MsgWaitForMultipleObjectsEx.

Needed for Flash 11.4.
File size: 46.9 KB
Line 
1/* $Id: windowmsg.cpp,v 1.51 2004-05-24 09:02:01 sandervl Exp $ */
2/*
3 * Win32 window message APIs for OS/2
4 *
5 * Copyright 1999-2001 Sander van Leeuwen
6 *
7 * Parts based on Wine Windows code (windows\message.c) 990508
8 *
9 * Copyright 1993, 1994 Alexandre Julliard
10 *
11 * TODO: GetQueueStatus: QS_HOTKEY (oslibmsg.cpp) & low word bits
12 * TODO: MsgWaitForMultipleObjects: timeout isn't handled correctly (can return too late)
13 *
14 * Project Odin Software License can be found in LICENSE.TXT
15 *
16 */
17
18#include <odin.h>
19#include <odinwrap.h>
20#include <os2sel.h>
21
22#include <string.h>
23#include <os2win.h>
24#include <misc.h>
25#include "win32wbase.h"
26#include <win.h>
27#include <heapstring.h>
28#include <handlemanager.h>
29#include <wprocess.h>
30#include "oslibutil.h"
31#include "oslibwin.h"
32#include "oslibmsg.h"
33#include "hook.h"
34#define INCL_TIMERWIN32
35#include "timer.h"
36#include "callwrap.h"
37
38#define DBG_LOCALLOG DBG_windowmsg
39#include "dbglocal.h"
40
41ODINDEBUGCHANNEL(USER32-WINDOWMSG)
42
43//******************************************************************************
44//******************************************************************************
45LONG WIN32API DispatchMessageA(const MSG * msg)
46{
47 dprintf2(("DispatchMessageA %x %x %x %x %x", msg->hwnd, msg->message, msg->wParam, msg->lParam, msg->time));
48
49 /* Process timer messages */
50 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
51 {
52 if (msg->lParam)
53 {
54/* HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
55
56 /* before calling window proc, verify whether timer is still valid;
57 there's a slim chance that the application kills the timer
58 between GetMessage and DispatchMessage API calls */
59 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, msg->lParam))
60 return 0; /* invalid winproc */
61
62 return CallWindowProcA( (WNDPROC)msg->lParam, msg->hwnd,
63 msg->message, msg->wParam, GetTickCount() );
64 }
65 }
66
67 return OSLibWinDispatchMsg((MSG *)msg);
68}
69//******************************************************************************
70//******************************************************************************
71LONG WIN32API DispatchMessageW( const MSG * msg)
72{
73 dprintf2(("DispatchMessageW %x %x %x %x %x", msg->hwnd, msg->message, msg->wParam, msg->lParam, msg->time));
74
75 /* Process timer messages */
76 if ((msg->message == WM_TIMER) || (msg->message == WM_SYSTIMER))
77 {
78 if (msg->lParam)
79 {
80/* HOOK_CallHooks32A( WH_CALLWNDPROC, HC_ACTION, 0, FIXME ); */
81
82 /* before calling window proc, verify whether timer is still valid;
83 there's a slim chance that the application kills the timer
84 between GetMessage and DispatchMessage API calls */
85 if (!TIMER_IsTimerValid(msg->hwnd, (UINT) msg->wParam, msg->lParam))
86 return 0; /* invalid winproc */
87
88 return CallWindowProcW( (WNDPROC)msg->lParam, msg->hwnd,
89 msg->message, msg->wParam, GetTickCount() );
90 }
91 }
92 return OSLibWinDispatchMsg((MSG *)msg, TRUE);
93}
94//******************************************************************************
95//******************************************************************************
96BOOL WIN32API TranslateMessage(const MSG *msg)
97{
98 // check the message code
99 if ( (msg->message < WM_KEYDOWN) ||
100 (msg->message > WM_SYSKEYUP)||
101 (msg->message == WM_CHAR) ||
102#ifdef __WIN32OS2__
103 (msg->message == WM_DEADCHAR)||
104 (msg->message == WM_IME_CHAR) )
105#else
106 (msg->message == WM_DEADCHAR) )
107#endif
108 {
109 /* TODO: Investigate - is this really invalid parameters? */
110 SetLastError(ERROR_INVALID_PARAMETER);
111 return FALSE;
112 }
113
114 // only WM_KEYDOWN, WM_KEYUP, WM_SYSKEYDOWN, WM_SYSKEYUP
115 // can go into TranslateMessage
116
117 return OSLibWinTranslateMessage((MSG *)msg);
118}
119//******************************************************************************
120//******************************************************************************
121BOOL WIN32API GetMessageA( LPMSG pMsg, HWND hwnd, UINT uMsgFilterMin, UINT uMsgFilterMax)
122{
123 BOOL ret;
124 TEB *pTeb = GetThreadTEB();
125
126 dprintf2(("GetMessageA %x %x-%x", hwnd, uMsgFilterMin, uMsgFilterMax));
127 do
128 {
129 ret = OSLibWinGetMsg(pMsg, hwnd, uMsgFilterMin, uMsgFilterMax);
130 if(ret) dprintf2(("GetMessageA %x %x %x %x", hwnd, pMsg->message, pMsg->wParam, pMsg->lParam));
131 } while ( pTeb->o.odin.tidAttachedInputThread
132 && OSLibForwardMessageToAttachedThread(pTeb, pMsg, NULL));
133 HOOK_CallHooksA(WH_GETMESSAGE, HC_ACTION, PM_REMOVE, (LPARAM)pMsg);
134 return ret;
135}
136//******************************************************************************
137//******************************************************************************
138BOOL WIN32API GetMessageW( LPMSG pMsg, HWND hwnd, UINT uMsgFilterMin, UINT uMsgFilterMax)
139{
140 BOOL ret;
141 TEB *pTeb = GetThreadTEB();
142
143 dprintf2(("GetMessageW %x %x-%x", hwnd, uMsgFilterMin, uMsgFilterMax));
144 do
145 {
146 ret = OSLibWinGetMsg(pMsg, hwnd, uMsgFilterMin, uMsgFilterMax, TRUE);
147 } while ( pTeb->o.odin.tidAttachedInputThread
148 && OSLibForwardMessageToAttachedThread(pTeb, pMsg, NULL));
149 HOOK_CallHooksW(WH_GETMESSAGE, HC_ACTION, PM_REMOVE, (LPARAM)pMsg);
150 return ret;
151}
152//******************************************************************************
153//******************************************************************************
154BOOL WIN32API PeekMessageA(LPMSG msg, HWND hwndOwner, UINT uMsgFilterMin,
155 UINT uMsgFilterMax, UINT fuRemoveMsg)
156{
157 BOOL fFoundMsg;
158 TEB *pTeb = GetThreadTEB();
159
160 dprintf2(("PeekMessageA %x %d-%d %d", hwndOwner, uMsgFilterMin, uMsgFilterMax, fuRemoveMsg));
161 do
162 {
163 fFoundMsg = OSLibWinPeekMsg(msg, hwndOwner, uMsgFilterMin, uMsgFilterMax, fuRemoveMsg, FALSE);
164 if ( fFoundMsg
165 && pTeb->o.odin.tidAttachedInputThread
166 && OSLibForwardMessageToAttachedThread(pTeb, msg, NULL))
167 {
168 if (!fuRemoveMsg)
169 OSLibWinPeekMsg(msg, hwndOwner, uMsgFilterMin, uMsgFilterMax, TRUE, FALSE);
170 continue;
171 }
172 } while (0);
173
174 if (fFoundMsg) {
175 dprintf2(("PeekMessageA %x %d-%d %d found message %x %d %x %x", hwndOwner, uMsgFilterMin, uMsgFilterMax, fuRemoveMsg, msg->hwnd, msg->message, msg->wParam, msg->lParam));
176 HOOK_CallHooksA(WH_GETMESSAGE, HC_ACTION, fuRemoveMsg & PM_REMOVE, (LPARAM)msg );
177 if (msg->message == WM_QUIT && (fuRemoveMsg & PM_REMOVE)) {
178 //TODO: Post WM_QUERYENDSESSION message when WM_QUIT received and system is shutting down
179 }
180 }
181 return fFoundMsg;
182}
183//******************************************************************************
184//******************************************************************************
185BOOL WIN32API PeekMessageW(LPMSG msg, HWND hwndOwner, UINT uMsgFilterMin,
186 UINT uMsgFilterMax, UINT fuRemoveMsg)
187{
188 BOOL fFoundMsg;
189 TEB *pTeb = GetThreadTEB();
190
191 dprintf2(("PeekMessageW %x %d-%d %d", hwndOwner, uMsgFilterMin, uMsgFilterMax, fuRemoveMsg));
192 do
193 {
194 fFoundMsg = OSLibWinPeekMsg(msg, hwndOwner, uMsgFilterMin, uMsgFilterMax, fuRemoveMsg, TRUE);
195 if ( fFoundMsg
196 && pTeb->o.odin.tidAttachedInputThread
197 && OSLibForwardMessageToAttachedThread(pTeb, msg, NULL))
198 {
199 if (!fuRemoveMsg)
200 OSLibWinPeekMsg(msg, hwndOwner, uMsgFilterMin, uMsgFilterMax, TRUE, TRUE);
201 continue;
202 }
203 } while (0);
204
205 if(fFoundMsg) {
206 dprintf2(("PeekMessageW %x %d-%d %d found message %x %d %x %x", hwndOwner, uMsgFilterMin, uMsgFilterMax, fuRemoveMsg, msg->hwnd, msg->message, msg->wParam, msg->lParam));
207 HOOK_CallHooksW(WH_GETMESSAGE, HC_ACTION, fuRemoveMsg & PM_REMOVE, (LPARAM)msg );
208 if (msg->message == WM_QUIT && (fuRemoveMsg & (PM_REMOVE))) {
209 //TODO: Post WM_QUERYENDSESSION message when WM_QUIT received and system is shutting down
210 }
211 }
212 return fFoundMsg;
213}
214//******************************************************************************
215//TODO:
216//******************************************************************************
217LONG WIN32API GetMessageExtraInfo()
218{
219 dprintf(("USER32: GetMessageExtraInfo %x", GetThreadMessageExtraInfo()));
220 return GetThreadMessageExtraInfo();
221}
222//******************************************************************************
223//******************************************************************************
224LPARAM WIN32API SetMessageExtraInfo(LPARAM lParam)
225{
226 dprintf(("USER32: SetMessageExtraInfo %x", lParam));
227 return SetThreadMessageExtraInfo(lParam);
228}
229//******************************************************************************
230//******************************************************************************
231DWORD WIN32API GetMessagePos(void)
232{
233 DWORD pos;
234
235 pos = OSLibWinGetMessagePos();
236 dprintf(("USER32: GetMessagePos -> (%d,%d)", LOWORD(pos), HIWORD(pos)));
237 return pos;
238}
239//******************************************************************************
240//******************************************************************************
241LONG WIN32API GetMessageTime(void)
242{
243 dprintf(("USER32: GetMessageTime"));
244 return OSLibWinGetMessageTime();
245}
246//******************************************************************************
247//******************************************************************************
248BOOL WIN32API WaitMessage(void)
249{
250#ifdef DEBUG
251 MSG msg;
252
253 if(PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE) == FALSE) {
254 dprintf2(("USER32: WaitMessage %x", GetThreadHAB()));
255 }
256 else dprintf2(("USER32: WaitMessage %x; message %x present", GetThreadHAB(), msg.message));
257#endif
258
259 BOOL ret = OSLibWinWaitMessage();
260#ifdef DEBUG
261 if(PeekMessageA(&msg, 0, 0, 0, PM_NOREMOVE) == FALSE) {
262 dprintf2(("USER32: WaitMessage returned with no message in the queue"));
263 }
264#endif
265 return ret;
266}
267//******************************************************************************
268//******************************************************************************
269BOOL WIN32API InSendMessage(void)
270{
271 dprintf(("USER32: InSendMessage"));
272 return OSLibWinInSendMessage();
273}
274//******************************************************************************
275//******************************************************************************
276BOOL WIN32API ReplyMessage(LRESULT result)
277{
278 dprintf(("USER32: ReplyMessage %x", result));
279 return OSLibWinReplyMessage(result);
280}
281//******************************************************************************
282//******************************************************************************
283VOID WIN32API PostQuitMessage( int nExitCode)
284{
285 dprintf(("USER32: PostQuitMessage\n"));
286 OSLibWinPostQuitMessage(nExitCode);
287}
288//******************************************************************************
289//******************************************************************************
290UINT WIN32API RegisterWindowMessageA(LPCSTR lpString)
291{
292 UINT rc;
293
294 rc = GlobalAddAtomA(lpString);
295 dprintf(("USER32: RegisterWindowMessageA %s returned %X\n", lpString, rc));
296 return(rc);
297}
298//******************************************************************************
299//******************************************************************************
300UINT WIN32API RegisterWindowMessageW( LPCWSTR lpString)
301{
302 dprintf(("USER32: RegisterWindowMessageW\n"));
303 return GlobalAddAtomW(lpString);
304}
305//******************************************************************************
306//No need to support this (obsolete, not implemented by Win32)
307//******************************************************************************
308BOOL WIN32API SetMessageQueue(int cMessagesMax)
309{
310 dprintf(("USER32: SetMessageQueue\n"));
311 return(TRUE);
312}
313//******************************************************************************
314
315/**
316 * Attach one threads input queue to another thread.
317 *
318 * @returns Success indicator.
319 * @param idAttach Thread ID of the thread to attach/detach the input
320 * of idAttachTo to.
321 * @param idAttachTo The Thread ID of the thread which input is to be taken
322 * over or reattached.
323 * @param fAttach If set attach the input queue of thread idAttachTo
324 * to idAttach.
325 * If clear detach the input queue of thread idAttach
326 * reattaching it to idAttachTo.
327 * @status partially implemented.
328 * @author knut st. osmundsen <bird-srcspam@anduin.net>
329 * @remark One cannot attach a threads input queue to it self.
330 * @remark This implemenation requires the thread which input is 'forwarded' to
331 * process it's message queue. Window (and wine) will not bother that thread
332 * at all with the messages. (DEADLOCK WARNING)
333 * @todo Not sure if all this is 100% ok according to the windows reality.
334 * I'm sure some error cases aren't caught.
335 */
336BOOL WIN32API AttachThreadInput(DWORD idAttach, DWORD idAttachTo, BOOL fAttach)
337{
338 dprintf(("USER32: AttachThreadInput\n"));
339 if (idAttach != idAttachTo)
340 {
341 /* pray noone frees the TEB while we're working on it... */
342 TEB *pTeb = GetTEBFromThreadId(idAttach);
343 if (pTeb)
344 {
345 TEB *pTebTo = GetTEBFromThreadId(idAttachTo);
346 if (pTebTo)
347 {
348 if (fAttach)
349 { /* attach. */
350 if (pTebTo->o.odin.tidAttachedInputThread)
351 {
352 dprintf(("USER32: AttachThreadInput: WARNING! %#x is already attached to %#x\n", idAttachTo, pTebTo->o.odin.tidAttachedInputThread));
353 DebugInt3();
354 }
355 pTebTo->o.odin.tidAttachedInputThread = idAttach;
356 dprintf(("USER32: AttachThreadInput: Attached input from %#x to %#x\n", idAttachTo, idAttach));
357 }
358 else
359 { /* deattach - i.e. undo previous AttachThreadInput(,,TRUE). */
360 if (pTebTo->o.odin.tidAttachedInputThread != idAttach)
361 {
362 dprintf(("USER32: AttachThreadInput: WARNING! %#x is not attached to %#x\n", idAttachTo, pTebTo->o.odin.tidAttachedInputThread));
363 DebugInt3();
364 }
365 pTebTo->o.odin.tidAttachedInputThread = 0;
366 dprintf(("USER32: AttachThreadInput: Detached input from %#x to %#x\n", idAttach, idAttachTo));
367 }
368 return TRUE;
369 }
370 else
371 {
372 dprintf(("USER32: AttachThreadInput: Invalid tid=%#x\n", idAttachTo));
373 SetLastError(ERROR_INVALID_PARAMETER);
374 }
375 }
376 else
377 {
378 dprintf(("USER32: AttachThreadInput: Invalid tid=%#x\n", idAttach));
379 SetLastError(ERROR_INVALID_PARAMETER);
380 }
381 }
382 else
383 {
384 dprintf(("USER32: AttachThreadInput idAttach == idAttachTo (== %#x)\n", idAttach));
385 SetLastError(ERROR_ACCESS_DENIED);
386 }
387 return FALSE;
388}
389
390//******************************************************************************
391/**********************************************************************
392 * WINPROC_TestCBForStr
393 *
394 * Return TRUE if the lparam is a string
395 */
396BOOL WINPROC_TestCBForStr ( HWND hwnd )
397{
398 BOOL retvalue;
399 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
400 retvalue = ( !(LOWORD(dwStyle) & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)) ||
401 (LOWORD(dwStyle) & CBS_HASSTRINGS) );
402 return retvalue;
403}
404/**********************************************************************
405 * WINPROC_TestLBForStr
406 *
407 * Return TRUE if the lparam is a string
408 */
409BOOL WINPROC_TestLBForStr ( HWND hwnd )
410{
411 BOOL retvalue;
412 DWORD dwStyle = GetWindowLongA(hwnd,GWL_STYLE);
413 retvalue = ( !(LOWORD(dwStyle) & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)) ||
414 (LOWORD(dwStyle) & LBS_HASSTRINGS) );
415 return retvalue;
416}
417
418/**********************************************************************
419 * WINPROC_MapMsg32ATo32W
420 *
421 * Map a message from Ansi to Unicode.
422 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
423 *
424 * FIXME:
425 * WM_CHAR, WM_CHARTOITEM, WM_DEADCHAR, WM_MENUCHAR, WM_SYSCHAR, WM_SYSDEADCHAR
426 *
427 * FIXME:
428 * WM_GETTEXT/WM_SETTEXT and static control with SS_ICON style:
429 * the first four bytes are the handle of the icon
430 * when the WM_SETTEXT message has been used to set the icon
431 */
432INT WINPROC_MapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam )
433{
434 switch(msg)
435 {
436 case WM_GETTEXT:
437 case WM_ASKCBFORMATNAME:
438 {
439 LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
440 *pwparam * sizeof(WCHAR) + sizeof(LPARAM) );
441 if (!ptr) return -1;
442 *ptr++ = *plparam; /* Store previous lParam */
443 *plparam = (LPARAM)ptr;
444 }
445 return 1;
446 /* lparam is string (0-terminated) */
447 case WM_SETTEXT:
448 case WM_WININICHANGE:
449 case WM_DEVMODECHANGE:
450 case CB_DIR:
451 case LB_DIR:
452 case LB_ADDFILE:
453#ifndef __WIN32OS2__
454 case CB_FINDSTRING:
455 case CB_FINDSTRINGEXACT:
456 case CB_SELECTSTRING:
457 case LB_FINDSTRING:
458 case LB_SELECTSTRING:
459#endif
460 case EM_REPLACESEL:
461 *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
462 return (*plparam ? 1 : -1);
463
464 case WM_NCCREATE:
465 case WM_CREATE:
466 {
467 CREATESTRUCTW *cs = (CREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0,
468 sizeof(*cs) );
469 if (!cs) return -1;
470 *cs = *(CREATESTRUCTW *)*plparam;
471 if (HIWORD(cs->lpszName))
472 cs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
473 (LPCSTR)cs->lpszName );
474 if (HIWORD(cs->lpszClass))
475 cs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
476 (LPCSTR)cs->lpszClass );
477 *plparam = (LPARAM)cs;
478 }
479 return 1;
480 case WM_MDICREATE:
481 {
482 MDICREATESTRUCTW *cs =
483 (MDICREATESTRUCTW *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
484 if (!cs) return -1;
485 *cs = *(MDICREATESTRUCTW *)*plparam;
486 if (HIWORD(cs->szClass))
487 cs->szClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
488 (LPCSTR)cs->szClass );
489 if (HIWORD(cs->szTitle))
490 cs->szTitle = HEAP_strdupAtoW( GetProcessHeap(), 0,
491 (LPCSTR)cs->szTitle );
492 *plparam = (LPARAM)cs;
493 }
494 return 1;
495
496/* Listbox */
497 case LB_ADDSTRING:
498#ifdef __WIN32OS2__
499 case LB_FINDSTRING:
500 case LB_FINDSTRINGEXACT:
501 case LB_SELECTSTRING:
502#endif
503 case LB_INSERTSTRING:
504 if ( WINPROC_TestLBForStr( hwnd ))
505 *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
506 return (*plparam ? 1 : -1);
507
508 case LB_GETTEXT: /* fixme: fixed sized buffer */
509 { if ( WINPROC_TestLBForStr( hwnd ))
510 { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
511 if (!ptr) return -1;
512 *ptr++ = *plparam; /* Store previous lParam */
513 *plparam = (LPARAM)ptr;
514 }
515 }
516 return 1;
517
518/* Combobox */
519 case CB_ADDSTRING:
520#ifdef __WIN32OS2__
521 case CB_FINDSTRING:
522 case CB_FINDSTRINGEXACT:
523 case CB_SELECTSTRING:
524#endif
525 case CB_INSERTSTRING:
526 if ( WINPROC_TestCBForStr( hwnd ))
527 *plparam = (LPARAM)HEAP_strdupAtoW( GetProcessHeap(), 0, (LPCSTR)*plparam );
528 return (*plparam ? 1 : -1);
529
530 case CB_GETLBTEXT: /* fixme: fixed sized buffer */
531 { if ( WINPROC_TestCBForStr( hwnd ))
532 { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 * sizeof(WCHAR) + sizeof(LPARAM) );
533 if (!ptr) return -1;
534 *ptr++ = *plparam; /* Store previous lParam */
535 *plparam = (LPARAM)ptr;
536 }
537 }
538 return 1;
539
540/* Multiline edit */
541 case EM_GETLINE:
542 { WORD len = (WORD)*plparam;
543 LPARAM *ptr = (LPARAM *) HEAP_xalloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
544 if (!ptr) return -1;
545 *ptr++ = *plparam; /* Store previous lParam */
546 *((WORD *) ptr) = len; /* Store the length */
547 *plparam = (LPARAM)ptr;
548 }
549 return 1;
550
551 case WM_CHARTOITEM:
552 case WM_MENUCHAR:
553 case WM_CHAR:
554 case WM_DEADCHAR:
555 case WM_SYSCHAR:
556 case WM_SYSDEADCHAR:
557 case EM_SETPASSWORDCHAR:
558 {
559 char ch = LOWORD(*pwparam);
560 WCHAR wch;
561 MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
562 *pwparam = MAKEWPARAM( wch, HIWORD(*pwparam) );
563 }
564 return 0;
565
566#ifdef __WIN32OS2__
567 case WM_IME_CHAR:
568 {
569 // always DBCS char
570 CHAR charA[ 2 ];
571
572 charA[ 0 ] = ( CHAR )( *pwparam >> 8 );
573 charA[ 1 ] = ( CHAR )*pwparam;
574
575 MultiByteToWideChar( CP_ACP, 0, ( LPSTR )charA, 2, ( LPWSTR )pwparam, 1);
576
577 return 0;
578 }
579#endif
580
581 case WM_PAINTCLIPBOARD:
582 case WM_SIZECLIPBOARD:
583 // FIXME_(msg)("message %s (0x%x) needs translation, please report\n", SPY_GetMsgName(msg), msg );
584 return -1;
585 default: /* No translation needed */
586 return 0;
587 }
588}
589
590
591/**********************************************************************
592 * WINPROC_UnmapMsg32ATo32W
593 *
594 * Unmap a message that was mapped from Ansi to Unicode.
595 */
596void WINPROC_UnmapMsg32ATo32W( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
597{
598 switch(msg)
599 {
600 case WM_GETTEXT:
601 case WM_ASKCBFORMATNAME:
602 {
603 LPARAM *ptr = (LPARAM *)lParam - 1;
604 lstrcpynWtoA( (LPSTR)*ptr, (LPWSTR)lParam, wParam );
605 HeapFree( GetProcessHeap(), 0, ptr );
606 }
607 break;
608
609 case WM_NCCREATE:
610 case WM_CREATE:
611 {
612 CREATESTRUCTW *cs = (CREATESTRUCTW *)lParam;
613 if (HIWORD(cs->lpszName))
614 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszName );
615 if (HIWORD(cs->lpszClass))
616 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszClass );
617 HeapFree( GetProcessHeap(), 0, cs );
618 }
619 break;
620
621 case WM_MDICREATE:
622 {
623 MDICREATESTRUCTW *cs = (MDICREATESTRUCTW *)lParam;
624 if (HIWORD(cs->szTitle))
625 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
626 if (HIWORD(cs->szClass))
627 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
628 HeapFree( GetProcessHeap(), 0, cs );
629 }
630 break;
631
632 case WM_SETTEXT:
633 case WM_WININICHANGE:
634 case WM_DEVMODECHANGE:
635 case CB_DIR:
636 case LB_DIR:
637 case LB_ADDFILE:
638#ifndef __WIN32OS2__
639 case CB_FINDSTRING:
640 case CB_FINDSTRINGEXACT:
641 case CB_SELECTSTRING:
642 case LB_FINDSTRING:
643 case LB_SELECTSTRING:
644#endif
645 case EM_REPLACESEL:
646 HeapFree( GetProcessHeap(), 0, (void *)lParam );
647 break;
648
649/* Listbox */
650 case LB_ADDSTRING:
651#ifdef __WIN32OS2__
652 case LB_FINDSTRING:
653 case LB_FINDSTRINGEXACT:
654 case LB_SELECTSTRING:
655#endif
656 case LB_INSERTSTRING:
657 if ( WINPROC_TestLBForStr( hwnd ))
658 HeapFree( GetProcessHeap(), 0, (void *)lParam );
659 break;
660
661 case LB_GETTEXT:
662 { if ( WINPROC_TestLBForStr( hwnd ))
663 { LPARAM *ptr = (LPARAM *)lParam - 1;
664 lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
665 HeapFree( GetProcessHeap(), 0, ptr );
666 }
667 }
668 break;
669
670/* Combobox */
671 case CB_ADDSTRING:
672#ifdef __WIN32OS2__
673 case CB_FINDSTRING:
674 case CB_FINDSTRINGEXACT:
675 case CB_SELECTSTRING:
676#endif
677 case CB_INSERTSTRING:
678 if ( WINPROC_TestCBForStr( hwnd ))
679 HeapFree( GetProcessHeap(), 0, (void *)lParam );
680 break;
681
682 case CB_GETLBTEXT:
683 { if ( WINPROC_TestCBForStr( hwnd ))
684 { LPARAM *ptr = (LPARAM *)lParam - 1;
685 lstrcpyWtoA( (LPSTR)*ptr, (LPWSTR)(lParam) );
686 HeapFree( GetProcessHeap(), 0, ptr );
687 }
688 }
689 break;
690
691/* Multiline edit */
692 case EM_GETLINE:
693 { LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lParam */
694#ifdef __WIN32OS2__
695 WORD len = *(WORD *) ptr;
696#else
697 WORD len = *(WORD *) lParam;
698#endif
699 lstrcpynWtoA( (LPSTR)*ptr , (LPWSTR)lParam, len );
700 HeapFree( GetProcessHeap(), 0, ptr );
701 }
702 break;
703 }
704}
705
706
707/**********************************************************************
708 * WINPROC_MapMsg32WTo32A
709 *
710 * Map a message from Unicode to Ansi.
711 * Return value is -1 on error, 0 if OK, 1 if an UnmapMsg call is needed.
712 */
713INT WINPROC_MapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM *pwparam, LPARAM *plparam)
714{ switch(msg)
715 {
716 case WM_GETTEXT:
717 case WM_ASKCBFORMATNAME:
718 {
719#ifdef __WIN32OS2__
720 *pwparam = *pwparam * sizeof( WCHAR ); //DBCS
721#endif
722 LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0,
723 *pwparam + sizeof(LPARAM) );
724 if (!ptr) return -1;
725 *ptr++ = *plparam; /* Store previous lParam */
726 *plparam = (LPARAM)ptr;
727 }
728 return 1;
729
730 case WM_SETTEXT:
731 case WM_WININICHANGE:
732 case WM_DEVMODECHANGE:
733 case CB_DIR:
734 case LB_DIR:
735 case LB_ADDFILE:
736#ifndef __WIN32OS2__
737 case CB_FINDSTRING:
738 case CB_FINDSTRINGEXACT:
739 case CB_SELECTSTRING:
740 case LB_FINDSTRING:
741 case LB_SELECTSTRING:
742#endif
743 case EM_REPLACESEL:
744 *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
745 return (*plparam ? 1 : -1);
746
747 case WM_NCCREATE:
748 case WM_CREATE:
749 {
750 CREATESTRUCTA *cs = (CREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0,
751 sizeof(*cs) );
752 if (!cs) return -1;
753 *cs = *(CREATESTRUCTA *)*plparam;
754 if (HIWORD(cs->lpszName))
755 cs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
756 (LPCWSTR)cs->lpszName );
757 if (HIWORD(cs->lpszClass))
758 cs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
759 (LPCWSTR)cs->lpszClass);
760 *plparam = (LPARAM)cs;
761 }
762 return 1;
763 case WM_MDICREATE:
764 {
765 MDICREATESTRUCTA *cs =
766 (MDICREATESTRUCTA *)HeapAlloc( GetProcessHeap(), 0, sizeof(*cs) );
767
768 if (!cs) return -1;
769 *cs = *(MDICREATESTRUCTA *)*plparam;
770 if (HIWORD(cs->szTitle))
771 cs->szTitle = HEAP_strdupWtoA( GetProcessHeap(), 0,
772 (LPCWSTR)cs->szTitle );
773 if (HIWORD(cs->szClass))
774 cs->szClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
775 (LPCWSTR)cs->szClass );
776 *plparam = (LPARAM)cs;
777 }
778 return 1;
779
780/* Listbox */
781 case LB_ADDSTRING:
782#ifdef __WIN32OS2__
783 case LB_FINDSTRING:
784 case LB_FINDSTRINGEXACT:
785 case LB_SELECTSTRING:
786#endif
787 case LB_INSERTSTRING:
788 if ( WINPROC_TestLBForStr( hwnd ))
789 *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
790 return (*plparam ? 1 : -1);
791
792 case LB_GETTEXT: /* fixme: fixed sized buffer */
793 { if ( WINPROC_TestLBForStr( hwnd ))
794 { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
795 if (!ptr) return -1;
796 *ptr++ = *plparam; /* Store previous lParam */
797 *plparam = (LPARAM)ptr;
798 }
799 }
800 return 1;
801
802/* Combobox */
803 case CB_ADDSTRING:
804#ifdef __WIN32OS2__
805 case CB_FINDSTRING:
806 case CB_FINDSTRINGEXACT:
807 case CB_SELECTSTRING:
808#endif
809 case CB_INSERTSTRING:
810 if ( WINPROC_TestCBForStr( hwnd ))
811 *plparam = (LPARAM)HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)*plparam );
812 return (*plparam ? 1 : -1);
813
814 case CB_GETLBTEXT: /* fixme: fixed sized buffer */
815 { if ( WINPROC_TestCBForStr( hwnd ))
816 { LPARAM *ptr = (LPARAM *)HeapAlloc( GetProcessHeap(), 0, 256 + sizeof(LPARAM) );
817 if (!ptr) return -1;
818 *ptr++ = *plparam; /* Store previous lParam */
819 *plparam = (LPARAM)ptr;
820 }
821 }
822 return 1;
823
824/* Multiline edit */
825 case EM_GETLINE:
826 { WORD len = (WORD)*plparam;
827#ifdef __WIN32OS2__
828 LPARAM *ptr = (LPARAM *) HEAP_xalloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(WCHAR) );
829#else
830 LPARAM *ptr = (LPARAM *) HEAP_xalloc( GetProcessHeap(), 0, sizeof(LPARAM) + sizeof (WORD) + len*sizeof(CHAR) );
831#endif
832 if (!ptr) return -1;
833 *ptr++ = *plparam; /* Store previous lParam */
834#ifdef __WIN32OS2__
835 *((WORD *) ptr) = len * sizeof(WCHAR); /* Store the length */
836#else
837 *((WORD *) ptr) = len; /* Store the length */
838#endif
839 *plparam = (LPARAM)ptr;
840 }
841 return 1;
842
843 case WM_CHARTOITEM:
844 case WM_MENUCHAR:
845 case WM_CHAR:
846 case WM_DEADCHAR:
847 case WM_SYSCHAR:
848 case WM_SYSDEADCHAR:
849 case EM_SETPASSWORDCHAR:
850 {
851 WCHAR wch = LOWORD(*pwparam);
852 char ch;
853 WideCharToMultiByte( CP_ACP, 0, &wch, 1, &ch, 1, NULL, NULL );
854 *pwparam = MAKEWPARAM( ch, HIWORD(*pwparam) );
855 }
856 return 0;
857
858#ifdef __WIN32OS2__
859 case WM_IME_CHAR:
860 { // always DBCS char
861 CHAR charA[ 2 ];
862
863 WideCharToMultiByte( CP_ACP, 0, ( LPWSTR )pwparam, 1, ( LPSTR )charA, 2, 0, 0 );
864 *pwparam = ( charA[ 0 ] << 8 ) | charA[ 1 ];
865
866 return 0;
867 }
868#endif
869
870 case WM_PAINTCLIPBOARD:
871 case WM_SIZECLIPBOARD:
872 // FIXME_(msg)("message %s (%04x) needs translation, please report\n",SPY_GetMsgName(msg),msg );
873 return -1;
874 default: /* No translation needed */
875 return 0;
876 }
877}
878
879
880/**********************************************************************
881 * WINPROC_UnmapMsg32WTo32A
882 *
883 * Unmap a message that was mapped from Unicode to Ansi.
884 */
885void WINPROC_UnmapMsg32WTo32A( HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam )
886{
887 switch(msg)
888 {
889 case WM_GETTEXT:
890 case WM_ASKCBFORMATNAME:
891 {
892 LPARAM *ptr = (LPARAM *)lParam - 1;
893
894#ifdef __WIN32OS2__
895 wParam = wParam / sizeof( WCHAR );
896#endif
897 lstrcpynAtoW( (LPWSTR)*ptr, (LPSTR)lParam, wParam );
898 HeapFree( GetProcessHeap(), 0, ptr );
899 }
900 break;
901
902 case WM_SETTEXT:
903 case WM_WININICHANGE:
904 case WM_DEVMODECHANGE:
905 case CB_DIR:
906 case LB_DIR:
907 case LB_ADDFILE:
908#ifndef __WIN32OS2__
909 case CB_FINDSTRING:
910 case CB_FINDSTRINGEXACT:
911 case CB_SELECTSTRING:
912 case LB_FINDSTRING:
913 case LB_SELECTSTRING:
914#endif
915 case EM_REPLACESEL:
916 HeapFree( GetProcessHeap(), 0, (void *)lParam );
917 break;
918
919 case WM_NCCREATE:
920 case WM_CREATE:
921 {
922 CREATESTRUCTA *cs = (CREATESTRUCTA *)lParam;
923 if (HIWORD(cs->lpszName))
924 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszName );
925 if (HIWORD(cs->lpszClass))
926 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->lpszClass );
927 HeapFree( GetProcessHeap(), 0, cs );
928 }
929 break;
930
931 case WM_MDICREATE:
932 {
933 MDICREATESTRUCTA *cs = (MDICREATESTRUCTA *)lParam;
934 if (HIWORD(cs->szTitle))
935 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szTitle );
936 if (HIWORD(cs->szClass))
937 HeapFree( GetProcessHeap(), 0, (LPVOID)cs->szClass );
938 HeapFree( GetProcessHeap(), 0, cs );
939 }
940 break;
941
942/* Listbox */
943 case LB_ADDSTRING:
944#ifdef __WIN32OS2__
945 case LB_FINDSTRING:
946 case LB_FINDSTRINGEXACT:
947 case LB_SELECTSTRING:
948#endif
949 case LB_INSERTSTRING:
950 if ( WINPROC_TestLBForStr( hwnd ))
951 HeapFree( GetProcessHeap(), 0, (void *)lParam );
952 break;
953
954 case LB_GETTEXT:
955 { if ( WINPROC_TestLBForStr( hwnd ))
956 { LPARAM *ptr = (LPARAM *)lParam - 1;
957 lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
958 HeapFree(GetProcessHeap(), 0, ptr );
959 }
960 }
961 break;
962
963/* Combobox */
964 case CB_ADDSTRING:
965#ifdef __WIN32OS2__
966 case CB_FINDSTRING:
967 case CB_FINDSTRINGEXACT:
968 case CB_SELECTSTRING:
969#endif
970 case CB_INSERTSTRING:
971 if ( WINPROC_TestCBForStr( hwnd ))
972 HeapFree( GetProcessHeap(), 0, (void *)lParam );
973 break;
974
975 case CB_GETLBTEXT:
976 { if ( WINPROC_TestCBForStr( hwnd ))
977 { LPARAM *ptr = (LPARAM *)lParam - 1;
978 lstrcpyAtoW( (LPWSTR)*ptr, (LPSTR)(lParam) );
979 HeapFree( GetProcessHeap(), 0, ptr );
980 }
981 }
982 break;
983
984/* Multiline edit */
985 case EM_GETLINE:
986 { LPARAM * ptr = (LPARAM *)lParam - 1; /* get the old lparam */
987 WORD len = *(WORD *)ptr;
988
989 lstrcpynAtoW( (LPWSTR) *ptr, (LPSTR)lParam, len );
990 HeapFree( GetProcessHeap(), 0, ptr );
991 }
992 break;
993 }
994}
995
996/**********************************************************************
997 * WINPROC_CallProc32ATo32W
998 *
999 * Call a window procedure, translating args from Ansi to Unicode.
1000 */
1001LRESULT WINPROC_CallProc32ATo32W( WNDPROC func, HWND hwnd,
1002 UINT msg, WPARAM wParam,
1003 LPARAM lParam )
1004{
1005 LRESULT result;
1006
1007 if (WINPROC_MapMsg32ATo32W( hwnd, msg, &wParam, &lParam ) == -1) return 0;
1008
1009 result = WrapCallback4(func, hwnd, msg, wParam, lParam );
1010 WINPROC_UnmapMsg32ATo32W( hwnd, msg, wParam, lParam );
1011
1012#ifdef __WIN32OS2__
1013 if(IsDBCSEnv())
1014 {
1015 switch( msg )
1016 {
1017 case WM_GETTEXTLENGTH :
1018 {
1019 LPWSTR ustr = ( LPWSTR )HeapAlloc( GetProcessHeap(), 0, ( result + 1 ) * sizeof( WCHAR ));
1020 result = WrapCallback4(func, hwnd, WM_GETTEXT, ( WPARAM )( result + 1 ), ( LPARAM )ustr );
1021 result = lstrlenWtoA( ustr, result );
1022 HeapFree( GetProcessHeap(), 0, ustr );
1023 break;
1024 }
1025
1026 case LB_GETTEXTLEN :
1027 {
1028 LPWSTR ustr = ( LPWSTR )HeapAlloc( GetProcessHeap(), 0, ( result + 1 ) * sizeof( WCHAR ));
1029 result = WrapCallback4(func, hwnd, LB_GETTEXT, wParam, ( LPARAM )ustr );
1030 if( result != LB_ERR )
1031 result = lstrlenWtoA( ustr, result );
1032
1033 HeapFree( GetProcessHeap(), 0, ustr );
1034 break;
1035 }
1036
1037
1038 case CB_GETLBTEXTLEN :
1039 {
1040 LPWSTR ustr = ( LPWSTR )HeapAlloc( GetProcessHeap(), 0, ( result + 1 ) * sizeof( WCHAR ));
1041 result = WrapCallback4(func, hwnd, CB_GETLBTEXT, wParam, ( LPARAM )ustr );
1042 if( result != CB_ERR )
1043 result = lstrlenWtoA( ustr, result );
1044
1045 HeapFree( GetProcessHeap(), 0, ustr );
1046 break;
1047 }
1048 }
1049 }
1050#endif
1051 return result;
1052}
1053
1054/**********************************************************************
1055 * WINPROC_CallProc32WTo32A
1056 *
1057 * Call a window procedure, translating args from Unicode to Ansi.
1058 */
1059LRESULT WINPROC_CallProc32WTo32A( WNDPROC func, HWND hwnd,
1060 UINT msg, WPARAM wParam,
1061 LPARAM lParam )
1062{
1063 LRESULT result;
1064
1065 if (WINPROC_MapMsg32WTo32A( hwnd, msg, &wParam, &lParam ) == -1) return 0;
1066
1067 result = WrapCallback4(func, hwnd, msg, wParam, lParam );
1068 WINPROC_UnmapMsg32WTo32A( hwnd, msg, wParam, lParam );
1069
1070#ifdef __WIN32OS2__
1071 if( IsDBCSEnv() )
1072 {
1073 switch( msg )
1074 {
1075 case WM_GETTEXTLENGTH :
1076 {
1077 LPSTR astr = ( LPSTR )HeapAlloc( GetProcessHeap(), 0, result + 1 );
1078 result = WrapCallback4(func, hwnd, WM_GETTEXT, ( WPARAM )( result + 1 ), ( LPARAM )astr );
1079 result = lstrlenAtoW( astr, result );
1080 HeapFree( GetProcessHeap(), 0, astr );
1081 break;
1082 }
1083
1084 case LB_GETTEXTLEN :
1085 {
1086 LPSTR astr = ( LPSTR )HeapAlloc( GetProcessHeap(), 0, result + 1 );
1087 result = WrapCallback4(func, hwnd, LB_GETTEXT, wParam, ( LPARAM )astr );
1088 if( result != LB_ERR )
1089 result = lstrlenAtoW( astr, result );
1090
1091 HeapFree( GetProcessHeap(), 0, astr );
1092 break;
1093 }
1094
1095
1096 case CB_GETLBTEXTLEN :
1097 {
1098 LPSTR astr = ( LPSTR )HeapAlloc( GetProcessHeap(), 0, result + 1 );
1099 result = WrapCallback4(func, hwnd, CB_GETLBTEXT, wParam, ( LPARAM )astr );
1100 if( result != CB_ERR )
1101 result = lstrlenAtoW( astr, result );
1102
1103 HeapFree( GetProcessHeap(), 0, astr );
1104 break;
1105 }
1106 }
1107 }
1108#endif
1109 return result;
1110}
1111//******************************************************************************
1112//TODO: QS_HOTKEY (oslibmsg.cpp) & low word bits
1113//high word = messages currently in queue
1114//low word = messages that have been added to the queue and are still in the
1115// queue since the last call to GetQueueStatus
1116//******************************************************************************
1117DWORD WIN32API GetQueueStatus(UINT flags)
1118{
1119 DWORD queueStatus;
1120
1121 queueStatus = OSLibWinQueryQueueStatus(flags);
1122
1123 dprintf(("USER32: GetQueueStatus %x returned %x", flags, queueStatus & MAKELONG(flags, flags)));
1124
1125 return queueStatus & MAKELONG(flags, flags);
1126}
1127/*****************************************************************************
1128 * Name : BOOL WIN32API GetInputState
1129 * Purpose : The GetInputState function determines whether there are
1130 * mouse-button or keyboard messages in the calling thread's message queue.
1131 * Parameters:
1132 * Variables :
1133 * Result : If the queue contains one or more new mouse-button or keyboard
1134 * messages, the return value is TRUE.
1135 * If the function fails, the return value is FALSE.
1136 * Remark :
1137 * Status : UNTESTED STUB
1138 *
1139 * Author : Patrick Haller [Thu, 1998/02/26 11:55]
1140 *****************************************************************************/
1141BOOL WIN32API GetInputState(VOID)
1142{
1143 DWORD queueStatus;
1144 BOOL rc;
1145
1146 queueStatus = OSLibWinQueryQueueStatus(QS_INPUT);
1147
1148 rc = (queueStatus & (QS_KEY | QS_MOUSEBUTTON)) ? TRUE : FALSE;
1149 dprintf(("USER32:GetInputState() returned %d", rc));
1150 return rc;
1151}
1152//******************************************************************************
1153/* Synchronization Functions */
1154//******************************************************************************
1155DWORD WIN32API MsgWaitForMultipleObjects(DWORD nCount, LPHANDLE pHandles, BOOL fWaitAll,
1156 DWORD dwMilliseconds, DWORD dwWakeMask)
1157{
1158 DWORD curtime, endtime, ret;
1159 MSG msg;
1160
1161 //TODO: Functions such as GetMessage, PeekMessage and WaitMessage can mark messages as old
1162 // MsgWaitForMultipleObjects shouldn't return until new input has arrived (MSDN)
1163 // We are not 100% correct with this implementation. GetQueueStatus checks all messages
1164 // in the queue.
1165 // Very obscure behaviour, so it's unlikely any application depends on it
1166
1167 //4 cases:
1168 //1: Wait for all -> check for message arrival, call WaitForMultipleObjects
1169 //2: Timeout = 0 ms -> call WaitForMultipleObjects with timeout 0, check for message arrival
1170 //3: nCount = 0 -> check for message arrival
1171 //4: rest -> check for either message arrival or signalled object
1172
1173 dprintf(("MsgWaitForMultipleObjects %x %x %d %d %x", nCount, pHandles, fWaitAll, dwMilliseconds, dwWakeMask));
1174 if(fWaitAll) //case 1
1175 { //wait for message arrival first
1176 curtime = GetCurrentTime();
1177 endtime = curtime + dwMilliseconds;
1178 while(curtime < endtime || dwMilliseconds == INFINITE) {
1179 if(OSLibWinWaitMessage() == FALSE) {
1180 dprintf(("OSLibWinWaitMessage returned FALSE!"));
1181 return WAIT_ABANDONED;
1182 }
1183 if(GetQueueStatus(dwWakeMask) != 0) {
1184 break;
1185 }
1186 //TODO: Ignoring all messages could be dangerous. But processing them,
1187 //while the app doesn't expect any, isn't safe either.
1188 if(PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
1189 {
1190 if (msg.message == WM_QUIT) {
1191 dprintf(("ERROR: MsgWaitForMultipleObjects call abandoned because WM_QUIT msg was received!!"));
1192 return WAIT_ABANDONED;
1193 }
1194
1195 /* otherwise dispatch it */
1196 DispatchMessageA(&msg);
1197 }
1198 curtime = GetCurrentTime();
1199 }
1200 if(dwMilliseconds != INFINITE && curtime > endtime) {
1201 dprintf(("No messages found in specified time"));
1202 return WAIT_TIMEOUT;
1203 }
1204 //ok, the right message has arrived, now try to grab all objects
1205 ret = WaitForMultipleObjects(nCount, pHandles, fWaitAll, dwMilliseconds);
1206 if(ret >= WAIT_OBJECT_0 + nCount) {
1207 //failure
1208 dprintf(("WaitForMultipleObjects failed with %d", ret));
1209 return ret;
1210 }
1211 return ret;
1212 }
1213 if(dwMilliseconds == 0) { //case 2
1214 if(nCount) {
1215 ret = WaitForMultipleObjects(nCount, pHandles, fWaitAll, dwMilliseconds);
1216 if(ret < WAIT_OBJECT_0 + nCount) {
1217 return ret;
1218 }
1219 }
1220 if(GetQueueStatus(dwWakeMask) == 0) {
1221 return WAIT_TIMEOUT;
1222 }
1223 return WAIT_OBJECT_0 + nCount; //right message has arrived
1224 }
1225 if(nCount == 0) //case 3
1226 {
1227 //SvL: Check time, wait for any message, check msg type and determine if
1228 // we have to return
1229 //TODO: Timeout isn't handled correctly (can return too late)
1230 curtime = GetCurrentTime();
1231 endtime = curtime + dwMilliseconds;
1232 while(curtime < endtime || dwMilliseconds == INFINITE) {
1233 if(OSLibWinWaitMessage() == FALSE) {
1234 dprintf(("OSLibWinWaitMessage returned FALSE!"));
1235 return WAIT_ABANDONED;
1236 }
1237 if(GetQueueStatus(dwWakeMask) != 0) {
1238 return WAIT_OBJECT_0;
1239 }
1240 //TODO: Ignoring all messages could be dangerous. But processing them,
1241 //while the app doesn't expect any, isn't safe either.
1242 if(PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
1243 {
1244 if (msg.message == WM_QUIT) {
1245 dprintf(("ERROR: MsgWaitForMultipleObjects call abandoned because WM_QUIT msg was received!!"));
1246 return WAIT_ABANDONED;
1247 }
1248
1249 /* otherwise dispatch it */
1250 DispatchMessageA(&msg);
1251 }
1252 curtime = GetCurrentTime();
1253 }
1254 return WAIT_TIMEOUT;
1255 }
1256
1257 //Case 4:
1258#if 1
1259 //Note: The WGSS implementation of this function is flawed. Returns
1260 // when a message is sent to the msg queue, regardless of dwWakeMask
1261 TEB *teb = GetTEBFromThreadId(GetCurrentThreadId());
1262 if(teb == NULL) {
1263 DebugInt3();
1264 return WAIT_ABANDONED;
1265 }
1266 //check if any object is already signalled
1267 ret = WaitForMultipleObjects(nCount, pHandles, fWaitAll, 0);
1268 if(ret < WAIT_OBJECT_0 + nCount) {
1269 return ret;
1270 }
1271 //if the msg queue already contains the messages defined by dwWakeMask,
1272 //then return immediately
1273 if(GetQueueStatus(dwWakeMask) != 0) {
1274 return WAIT_OBJECT_0+nCount;
1275 }
1276 if(dwWakeMask & QS_POSTMESSAGE) {
1277 HANDLE *pHandlesTmp = (HANDLE *)alloca((nCount+1)*sizeof(HANDLE));
1278 if(pHandlesTmp == NULL || !teb->o.odin.hPostMsgEvent) {
1279 DebugInt3();
1280 return WAIT_ABANDONED;
1281 }
1282 memcpy(pHandlesTmp, pHandles, nCount*sizeof(HANDLE));
1283 pHandlesTmp[nCount] = teb->o.odin.hPostMsgEvent;
1284
1285 //mark this thread as waiting for window messages
1286 teb->o.odin.dwWakeMask = dwWakeMask;
1287
1288 ResetEvent(teb->o.odin.hPostMsgEvent);
1289 ret = HMMsgWaitForMultipleObjects(nCount+1,pHandlesTmp,fWaitAll,dwMilliseconds,dwWakeMask);
1290
1291 //unmark thread
1292 teb->o.odin.dwWakeMask = 0;
1293
1294 //nCount + 2 -> message event -> return nCount + 1
1295 return (ret == nCount + 2) ? (nCount + 1) : ret;
1296 }
1297 //Call handlemanager function as we need to translate handles (KERNEL32)
1298 ret = HMMsgWaitForMultipleObjects(nCount,pHandles,fWaitAll,dwMilliseconds,dwWakeMask);
1299 return ret;
1300#else
1301 //This method has a high latency (too high for some apps)
1302 //TODO: Timeout isn't handled correctly (can return too late)
1303 curtime = GetCurrentTime();
1304 endtime = curtime + dwMilliseconds;
1305 while(curtime < endtime || dwMilliseconds == INFINITE) {
1306 //check queue status for presence of requested message types
1307 if(GetQueueStatus(dwWakeMask) != 0) {
1308 dprintf(("Found message(s) we were looking for. Return success"));
1309 return WAIT_OBJECT_0 + nCount; //present, return success
1310 }
1311 //TODO: Ignoring all messages could be dangerous. But processing them,
1312 //while the app doesn't expect any, isn't safe either.
1313 if(PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
1314 {
1315 if (msg.message == WM_QUIT) {
1316 dprintf(("ERROR: MsgWaitForMultipleObjects call abandoned because WM_QUIT msg was received!!"));
1317 return WAIT_ABANDONED;
1318 }
1319
1320 /* otherwise dispatch it */
1321 DispatchMessageA(&msg);
1322 }
1323 //check if any object is signalled (timeout 10ms)
1324 ret = WaitForMultipleObjects(nCount, pHandles, fWaitAll, 4);
1325 if(ret < WAIT_OBJECT_0 + nCount) {
1326 //an object was signalled, return immediately
1327 dprintf(("WaitForMultipleObjects success with %d", ret));
1328 return ret;
1329 }
1330 else
1331 if(ret != WAIT_TIMEOUT) {
1332 //failure, abort
1333 dprintf(("WaitForMultipleObjects failed with %d", ret));
1334 return ret;
1335 }
1336 curtime = GetCurrentTime();
1337 }
1338 return WAIT_TIMEOUT;
1339#endif
1340}
1341//******************************************************************************
1342/* Synchronization Functions */
1343//******************************************************************************
1344DWORD WIN32API MsgWaitForMultipleObjectsEx(DWORD nCount, LPHANDLE pHandles,
1345 DWORD dwMilliseconds, DWORD dwWakeMask,
1346 DWORD dwFlags)
1347{
1348 if (dwFlags == 0) {
1349 return MsgWaitForMultipleObjects(nCount, pHandles, FALSE, dwMilliseconds, dwWakeMask);
1350 }
1351 if (dwFlags == 0x0001 /*MWMO_WAITALL*/) {
1352 return MsgWaitForMultipleObjects(nCount, pHandles, TRUE, dwMilliseconds, dwWakeMask);
1353 }
1354
1355 dprintf(("USER32: MsgWaitForMultipleObjectsEx() with dwFlags=%x not implemented\n",
1356 dwFlags));
1357 SetLastError(ERROR_NOT_SUPPORTED);
1358 return WAIT_FAILED;
1359}
Note: See TracBrowser for help on using the repository browser.