source: trunk/src/user32/oslibmsg.cpp@ 21955

Last change on this file since 21955 was 21955, checked in by dmik, 14 years ago

Make sure GetQueueStatus() correctly reports QS_KEY state.

Due to a bug in WinQueryQueueStatus(), QS_KEY would be
always set on return if the associated window is active, even
if there were no WM_CHAR messages actually in the queue.
This broke the newer Flash (see Flash #39 for details).

GetInputState() was also affected by this problem; it would always
return TRUE for active windows.
File size: 33.7 KB
Line 
1/* $Id: oslibmsg.cpp,v 1.76 2003-08-22 13:16:44 sandervl Exp $ */
2/*
3 * Window message translation functions for OS/2
4 *
5 *
6 * Copyright 1999 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 *
9 * Project Odin Software License can be found in LICENSE.TXT
10 *
11 * TODO: Some messages that are sent to the frame window are directly passed on to the client
12 * -> Get/PeekMessage never gets them as we return a dummy message for non-client windows
13 * (i.e. menu WM_COMMAND messages)
14 *
15 * TODO: Filter translation isn't correct! (for posted messages or messages that don't have
16 * a PM version)
17 *
18 * TODO: Flaw in our message handling; we don't handle posted/sent (by the app)
19 * system messages properly if removed from the queue with PeekMessage.
20 * e.g.
21 * PostMessage(WM_KEYDOWN)
22 * PeekMessage(any, PM_NOREMOVE)
23 * ...
24 * PeekMessage(WM_KEYDOWN, WM_KEYDOWN, PM_REMOVE)
25 *
26 * So what we really need is a complete win to os2 message translation
27 * in Post/SendMessage. Quite a lot of work though...
28 *
29 */
30#define INCL_WIN
31#define INCL_PM
32#define INCL_DOSPROCESS
33#define INCL_WINMESSAGEMGR
34#define INCL_DOSSEMAPHORES
35#define INCL_DOSERRORS
36#include <os2wrap.h>
37#include <odinwrap.h>
38#include <string.h>
39#include <misc.h>
40#include "oslibmsg.h"
41#include <winconst.h>
42#include <win32api.h>
43#include <winuser32.h>
44#include "oslibutil.h"
45#include "timer.h"
46#include <thread.h>
47#include <wprocess.h>
48#include <winnls.h>
49#include "pmwindow.h"
50#include "oslibwin.h"
51#include <win/hook.h>
52#include <winscan.h>
53#include <winkeyboard.h>
54#include "user32api.h"
55
56#define DBG_LOCALLOG DBG_oslibmsg
57#include "dbglocal.h"
58
59
60ODINDEBUGCHANNEL(USER32-OSLIBMSG)
61
62
63
64typedef BOOL (EXPENTRY FNTRANS)(MSG *, QMSG *);
65typedef FNTRANS *PFNTRANS;
66
67typedef struct
68{
69 ULONG msgOS2;
70 ULONG msgWin32;
71// PFNTRANS toOS2;
72// PFNTRANS toWIN32;
73} MSGTRANSTAB, *PMSGTRANSTAB;
74
75//NOTE: Must be ordered by win32 message id!!
76MSGTRANSTAB MsgTransTab[] = {
77 WM_NULL, WINWM_NULL,
78 WM_CREATE, WINWM_CREATE,
79 WM_DESTROY, WINWM_DESTROY,
80 WM_MOVE, WINWM_MOVE, //TODO: Sent directly
81 WM_SIZE, WINWM_SIZE, //TODO: Sent directly
82 WM_ACTIVATE, WINWM_ACTIVATE,
83 WM_SETFOCUS, WINWM_SETFOCUS,
84 WM_SETFOCUS, WINWM_KILLFOCUS,
85 WM_ENABLE, WINWM_ENABLE,
86 WM_PAINT, WINWM_PAINT,
87 WM_CLOSE, WINWM_CLOSE,
88 WM_QUIT, WINWM_QUIT,
89 WM_SHOW, WINWM_SHOWWINDOW,
90
91 WM_HITTEST, WINWM_NCHITTEST,
92
93 //todo: not always right if mouse msg turns out to be for the client window
94 WM_MOUSEMOVE, WINWM_NCMOUSEMOVE,
95 WM_BUTTON1DOWN, WINWM_NCLBUTTONDOWN,
96 WM_BUTTON1UP, WINWM_NCLBUTTONUP,
97 WM_BUTTON1DBLCLK, WINWM_NCLBUTTONDBLCLK,
98 WM_BUTTON2DOWN, WINWM_NCRBUTTONDOWN,
99 WM_BUTTON2UP, WINWM_NCRBUTTONUP,
100 WM_BUTTON2DBLCLK, WINWM_NCRBUTTONDBLCLK,
101 WM_BUTTON3DOWN, WINWM_NCMBUTTONDOWN,
102 WM_BUTTON3UP, WINWM_NCMBUTTONUP,
103 WM_BUTTON3DBLCLK, WINWM_NCMBUTTONDBLCLK,
104
105 //TODO: Needs better translation!
106 WM_CHAR, WINWM_KEYDOWN, //WM_KEYFIRST
107 WM_CHAR, WINWM_KEYUP,
108 WM_CHAR, WINWM_CHAR,
109 WM_CHAR, WINWM_DEADCHAR,
110 WM_CHAR, WINWM_SYSKEYDOWN,
111 WM_CHAR, WINWM_SYSKEYUP,
112 WM_CHAR, WINWM_SYSCHAR,
113 WM_CHAR, WINWM_SYSDEADCHAR,
114 WM_CHAR, WINWM_KEYLAST,
115
116 //
117 WM_TIMER, WINWM_TIMER,
118
119 //
120 //todo: not always right if mouse msg turns out to be for the nonclient window
121 WM_MOUSEMOVE, WINWM_MOUSEMOVE, //WM_MOUSEFIRST
122 WM_BUTTON1DOWN, WINWM_LBUTTONDOWN,
123 WM_BUTTON1UP, WINWM_LBUTTONUP,
124 WM_BUTTON1DBLCLK, WINWM_LBUTTONDBLCLK,
125 WM_BUTTON2DOWN, WINWM_RBUTTONDOWN,
126 WM_BUTTON2UP, WINWM_RBUTTONUP,
127 WM_BUTTON2DBLCLK, WINWM_RBUTTONDBLCLK,
128 WM_BUTTON3DOWN, WINWM_MBUTTONDOWN,
129 WM_BUTTON3UP, WINWM_MBUTTONUP,
130 WM_BUTTON3DBLCLK, WINWM_MBUTTONDBLCLK,
131 WM_VSCROLL, WINWM_MOUSEWHEEL, //WM_MOUSELAST
132 999999999, 999999999,
133};
134#define MAX_MSGTRANSTAB (sizeof(MsgTransTab)/sizeof(MsgTransTab[0]))
135
136//******************************************************************************
137//******************************************************************************
138void WinToOS2MsgTranslate(MSG *winMsg, QMSG *os2Msg, BOOL isUnicode)
139{
140 dprintf(("WinToOS2MsgTranslate not implemented"));
141// memcpy(os2Msg, winMsg, sizeof(MSG));
142// os2Msg->hwnd = Win32ToOS2Handle(winMsg->hwnd);
143// os2Msg->reserved = 0;
144}
145//******************************************************************************
146//TODO: NOT COMPLETE nor 100% CORRECT!!!
147//If both the minimum & maximum message are unknown, the result can be wrong (max > min)!
148//******************************************************************************
149ULONG TranslateWinMsg(ULONG msg, BOOL fMinFilter, BOOL fExactMatch = FALSE)
150{
151 if(msg == 0)
152 return 0;
153
154 if(msg >= WINWM_USER)
155 return msg + WIN32APP_POSTMSG;
156
157 for(int i=0;i<MAX_MSGTRANSTAB;i++)
158 {
159 if(fExactMatch) {
160 if(MsgTransTab[i].msgWin32 == msg)
161 return MsgTransTab[i].msgOS2;
162 }
163 else {
164 if(fMinFilter && MsgTransTab[i].msgWin32 >= msg) {
165 return MsgTransTab[i].msgOS2;
166 }
167 else
168 if(!fMinFilter && MsgTransTab[i].msgWin32 >= msg) {
169 if(MsgTransTab[i].msgWin32 == msg)
170 return MsgTransTab[i].msgOS2;
171 else return MsgTransTab[i-1].msgOS2;
172 }
173 }
174 }
175
176 //not found, get everything
177 dprintf2(("WARNING: TranslateWinMsg: message %x not found", msg));
178 return 0;
179}
180//******************************************************************************
181//******************************************************************************
182void OSLibWinPostQuitMessage(ULONG nExitCode)
183{
184 APIRET rc;
185
186 //NOTE: mp2 must always be zero or else we won't be able to distinguish
187 // between the WM_QUIT sent by us and the one sent by the window list!!
188 rc = WinPostQueueMsg(NULLHANDLE, WM_QUIT, MPFROMLONG(nExitCode), 0);
189 dprintf(("WinPostQueueMsg %d returned %d", nExitCode, rc));
190}
191//******************************************************************************
192//******************************************************************************
193LONG OSLibWinDispatchMsg(MSG *msg, BOOL isUnicode)
194{
195 TEB *teb;
196 QMSG os2msg;
197 LONG rc;
198
199 teb = GetThreadTEB();
200 if(teb == NULL) {
201 DebugInt3();
202 return FALSE;
203 }
204
205 //TODO: What to do if app changed msg? (translate)
206 // WinToOS2MsgTranslate(msg, &qmsg, isUnicode);
207
208 if(!memcmp(msg, &teb->o.odin.winmsg, sizeof(MSG)) || msg->hwnd == 0) {
209 memcpy(&os2msg, &teb->o.odin.os2msg, sizeof(QMSG));
210 teb->o.odin.os2msg.time = -1;
211 teb->o.odin.winmsg.time = -1;
212 if(msg->hwnd) {
213 teb->o.odin.nrOfMsgs = 1;
214 teb->o.odin.msgstate++; //odd -> next call to our PM window handler should dispatch the translated msg
215 memcpy(&teb->o.odin.msg, msg, sizeof(MSG));
216 }
217 if(os2msg.hwnd || os2msg.msg == WM_QUIT) {
218 memset(&teb->o.odin.os2msg, 0, sizeof(teb->o.odin.os2msg));
219 memset(&teb->o.odin.winmsg, 0, sizeof(teb->o.odin.winmsg));
220 return (LONG)WinDispatchMsg(teb->o.odin.hab, &os2msg);
221 }
222 //SvL: Don't dispatch messages sent by PostThreadMessage (correct??)
223 // Or WM_TIMER msgs with no window handle or timer proc
224 return 0;
225
226 }
227 else {//is this allowed?
228// dprintf(("WARNING: OSLibWinDispatchMsg: called with own message!"));
229 return isUnicode ? SendMessageW(msg->hwnd, msg->message, msg->wParam, msg->lParam) :
230 SendMessageA(msg->hwnd, msg->message, msg->wParam, msg->lParam);
231 }
232}
233//******************************************************************************
234// ReturnQueuedWMCHAR:
235//
236// Check for a queued WM_CHAR message (e.g. inserted by TranslateMessage)
237//******************************************************************************
238BOOL ReturnQueuedWMCHAR(LPMSG pMsg, TEB *teb, HWND hwnd, UINT uMsgFilterMin, UINT uMsgFilterMax,
239 BOOL isUnicode, BOOL fRemove)
240{
241 if(teb->o.odin.fTranslated && (!hwnd || hwnd == teb->o.odin.msgWCHAR.hwnd))
242 {
243 dprintf(("Return queued WM_CHAR message hwnd=%x msg=%d wParam=%x lParam=%x", teb->o.odin.msgWCHAR.hwnd, teb->o.odin.msgWCHAR.message, teb->o.odin.msgWCHAR.wParam, teb->o.odin.msgWCHAR.lParam));
244
245 if(uMsgFilterMin) {
246 if(teb->o.odin.msgWCHAR.message < uMsgFilterMin)
247 return FALSE;
248 }
249 if(uMsgFilterMax) {
250 if(teb->o.odin.msgWCHAR.message > uMsgFilterMax)
251 return FALSE;
252 }
253
254 if(fRemove & PM_REMOVE_W) {
255 teb->o.odin.fTranslated = FALSE;
256 teb->o.odin.os2msg.msg = 0;
257 teb->o.odin.os2msg.hwnd = 0;
258 }
259 memcpy(pMsg, &teb->o.odin.msgWCHAR, sizeof(MSG));
260 //After SetFocus(0), all keystrokes are converted in WM_SYS*
261 if(pMsg->message == WINWM_CHAR && fIgnoreKeystrokes) {
262 pMsg->message = WINWM_SYSCHAR;
263 }
264
265 if(!IsWindow(pMsg->hwnd)) {
266 //could be a queued char message for a window that was just destroyed
267 //when that's the case, we ignore it (MFC assertions are triggered by this)
268 teb->o.odin.fTranslated = FALSE;
269 teb->o.odin.os2msg.msg = 0;
270 teb->o.odin.os2msg.hwnd = 0;
271 return FALSE;
272 }
273
274 // @@@PH verify this
275 // if this is a keyup or keydown message, we've got to
276 // call the keyboard hook here
277 // send keyboard messages to the registered hooks
278 if(fRemove & PM_REMOVE_W)
279 {
280 switch (pMsg->message)
281 {
282 case WINWM_KEYDOWN:
283 case WINWM_KEYUP:
284 case WINWM_SYSKEYDOWN:
285 case WINWM_SYSKEYUP:
286 // only supposed to be called upon WM_KEYDOWN
287 // and WM_KEYUP according to docs.
288 if(ProcessKbdHook(pMsg, fRemove))
289 return FALSE;
290 break;
291 }
292 }
293
294 //GetMessageW and PeekMessageW expect the character code in UTF-16
295 //(we save it in ascii format)
296 if(isUnicode && (pMsg->message == WINWM_CHAR || pMsg->message == WINWM_SYSCHAR))
297 {
298 CHAR charA;
299 WCHAR charW;
300
301 charA = pMsg->wParam;
302 MultiByteToWideChar(CP_ACP, 0, &charA, 1, &charW, 1);
303 pMsg->wParam= charW;
304 dprintf(("ReturnQueuedWMCHAR: Convert to Unicode src=%x res=%x", charA, charW));
305 }
306 return TRUE;
307 }
308 return FALSE;
309}
310//******************************************************************************
311//******************************************************************************
312BOOL OSLibWinGetMsg(LPMSG pMsg, HWND hwnd, UINT uMsgFilterMin, UINT uMsgFilterMax,
313 BOOL isUnicode)
314{
315 BOOL rc, eaten;
316 TEB *teb;
317 QMSG os2msg;
318 HWND hwndOS2 = 0;
319 ULONG filtermin, filtermax;
320
321 if(hwnd) {
322 hwndOS2 = Win32ToOS2Handle(hwnd);
323 if(hwndOS2 == NULL) {
324 memset(pMsg, 0, sizeof(MSG));
325 dprintf(("GetMsg: window %x NOT FOUND!", hwnd));
326 SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
327 return TRUE;
328 }
329 }
330
331 teb = GetThreadTEB();
332 if(teb == NULL) {
333 DebugInt3();
334 return TRUE;
335 }
336
337 //check for a queued WM_CHAR message (e.g. inserted by TranslateMessage)
338 if(ReturnQueuedWMCHAR(pMsg, teb, hwnd, uMsgFilterMin, uMsgFilterMax, isUnicode, PM_REMOVE_W) == TRUE)
339 {
340 return (pMsg->message != WINWM_QUIT);
341 }
342
343continuegetmsg:
344 if(hwnd) {
345 filtermin = TranslateWinMsg(uMsgFilterMin, TRUE);
346 filtermax = TranslateWinMsg(uMsgFilterMax, FALSE);
347 if(filtermin > filtermax) {
348 ULONG tmp = filtermin;
349 filtermin = filtermax;
350 filtermax = tmp;
351 }
352 do {
353 WinWaitMsg(teb->o.odin.hab, filtermin, filtermax);
354 rc = OSLibWinPeekMsg(pMsg, hwnd, uMsgFilterMin, uMsgFilterMax, PM_REMOVE_W, isUnicode);
355 }
356 while(rc == FALSE);
357
358 return (pMsg->message != WINWM_QUIT);
359 }
360 else
361 {
362 filtermin = TranslateWinMsg(uMsgFilterMin, TRUE);
363 filtermax = TranslateWinMsg(uMsgFilterMax, FALSE);
364 if(filtermin > filtermax) {
365 ULONG tmp = filtermin;
366 filtermin = filtermax;
367 filtermax = filtermin;
368 }
369 rc = WinGetMsg(teb->o.odin.hab, &os2msg, 0, filtermin, filtermax);
370 if (os2msg.msg == WM_QUIT && ((ULONG)os2msg.mp2 != 0) ) {
371 // Don't return FALSE when the window list sends us
372 // a WM_QUIT message, improper killing can lead to
373 // application crashes.
374 // In the WM_QUIT handler in pmwindow we send a WM_CLOSE
375 // in this case. When the app calls PostQuitMessage (mp2 == 0),
376 // then we handle it the normal way
377 rc = 1;
378 }
379 }
380 if(OS2ToWinMsgTranslate((PVOID)teb, &os2msg, pMsg, isUnicode, MSG_REMOVE) == FALSE) {
381 //dispatch untranslated message immediately
382 WinDispatchMsg(teb->o.odin.hab, &os2msg);
383 //and get the next one
384 return OSLibWinGetMsg(pMsg, hwnd, uMsgFilterMin, uMsgFilterMax, isUnicode);
385 }
386
387 memcpy(&teb->o.odin.os2msg, &os2msg, sizeof(QMSG));
388 memcpy(&teb->o.odin.winmsg, pMsg, sizeof(MSG));
389
390 // send keyboard messages to the registered hooks
391 switch (pMsg->message)
392 {
393 case WINWM_KEYDOWN:
394 case WINWM_KEYUP:
395 case WINWM_SYSKEYDOWN:
396 case WINWM_SYSKEYUP:
397 // only supposed to be called upon WM_KEYDOWN
398 // and WM_KEYUP according to docs.
399 dprintf(("OSLibWinGetMsg: ProcessKbdHook call"));
400 if(ProcessKbdHook(pMsg, TRUE))
401 goto continuegetmsg;
402 break;
403 case WINWM_IME_CHAR:
404 // prevent from calling wrong DispatchMsg() (DBCS generated WM_CHAR)
405 memset( &teb->o.odin.winmsg, 0, sizeof( MSG ));
406 break;
407 }
408 return rc;
409}
410
411
412//******************************************************************************
413//PeekMessage retrieves only messages associated with the window identified by the
414//hwnd parameter or any of its children as specified by the IsChild function, and within
415//the range of message values given by the uMsgFilterMin and uMsgFilterMax
416//parameters. If hwnd is NULL, PeekMessage retrieves messages for any window that
417//belongs to the current thread making the call. (PeekMessage does not retrieve
418//messages for windows that belong to other threads.) If hwnd is -1, PeekMessage only
419//returns messages with a hwnd value of NULL, as posted by the PostAppMessage
420//function. If uMsgFilterMin and uMsgFilterMax are both zero, PeekMessage returns all
421//available messages (no range filtering is performed).
422//TODO: Not working as specified right now!
423//******************************************************************************
424BOOL OSLibWinPeekMsg(LPMSG pMsg, HWND hwnd, UINT uMsgFilterMin, UINT uMsgFilterMax,
425 DWORD fRemove, BOOL isUnicode)
426{
427 BOOL rc, eaten;
428 TEB *teb;
429 QMSG os2msg;
430 HWND hwndOS2 = 0;
431
432 if(uMsgFilterMin > uMsgFilterMax) {
433 //TODO: is this correct behaviour?
434 dprintf(("!ERROR!: invalid message filter range!!!"));
435 SetLastError(ERROR_INVALID_PARAMETER_W);
436 return FALSE;
437 }
438 if(hwnd && hwnd != -1) {
439 hwndOS2 = Win32ToOS2Handle(hwnd);
440 if(hwndOS2 == NULL) {
441 dprintf(("PeekMsg: window %x NOT FOUND!", hwnd));
442 SetLastError(ERROR_INVALID_WINDOW_HANDLE_W);
443 return FALSE;
444 }
445 }
446
447 teb = GetThreadTEB();
448 if(teb == NULL) {
449 DebugInt3();
450 return FALSE;
451 }
452
453 //check for a queued WM_CHAR message (e.g. inserted by TranslateMessage)
454 if(ReturnQueuedWMCHAR(pMsg, teb, hwnd, uMsgFilterMin, uMsgFilterMax, isUnicode, fRemove) == TRUE)
455 {
456 return TRUE;
457 }
458
459continuepeekmsg:
460 if(uMsgFilterMin && uMsgFilterMax)
461 { //we can't use the PM message filter (since the message nrs aren't similar), so we must
462 //filter each message seperately
463 //to do so, we will translate each win32 message in the filter range and call WinPeekMsg
464 ULONG ulPMFilter;
465
466 for(int i=0;i<uMsgFilterMax-uMsgFilterMin+1;i++)
467 {
468 rc = 0;
469
470 ulPMFilter = TranslateWinMsg(uMsgFilterMin+i, TRUE, TRUE);
471 if(ulPMFilter) {
472 rc = WinPeekMsg(teb->o.odin.hab, &os2msg, hwndOS2, ulPMFilter, ulPMFilter,
473 (fRemove & PM_REMOVE_W) ? PM_REMOVE : PM_NOREMOVE);
474 //Sadly indeed WinPeekMsg sometimes does not filter well!
475 if (rc && (os2msg.msg != ulPMFilter)) {// drop this message
476 dprintf(("WARNING: WinPeekMsg returns %x even though we filter for %x", os2msg.msg, ulPMFilter));
477 rc = 0;
478 }
479 }
480 if(rc) {
481 break;
482 }
483 }
484 }
485 else {
486 rc = WinPeekMsg(teb->o.odin.hab, &os2msg, hwndOS2, 0, 0, (fRemove & PM_REMOVE_W) ? PM_REMOVE : PM_NOREMOVE);
487 }
488 if(rc == FALSE) {
489 return FALSE;
490 }
491
492 // @@@PH
493 // warning - OS2ToWinMsgTranslate might insert additional messages
494 // into the queue
495 if(OS2ToWinMsgTranslate((PVOID)teb, &os2msg, pMsg, isUnicode, (fRemove & PM_REMOVE_W) ? MSG_REMOVE : MSG_NOREMOVE) == FALSE)
496 {
497 //unused PM message; dispatch immediately and grab next one
498 dprintf2(("OSLibWinPeekMsg: Untranslated message; dispatched immediately"));
499 if(!(fRemove & PM_REMOVE_W)) {
500 rc = WinPeekMsg(teb->o.odin.hab, &os2msg, os2msg.hwnd, os2msg.msg,
501 os2msg.msg, PM_REMOVE);
502 }
503 WinDispatchMsg(teb->o.odin.hab, &os2msg);
504 return OSLibWinPeekMsg(pMsg, hwnd, uMsgFilterMin, uMsgFilterMax, fRemove, isUnicode);
505 }
506 //TODO: This is not safe! There's no guarantee this message will be dispatched and it might overwrite a previous message
507 if(fRemove & PM_REMOVE_W) {
508 memcpy(&teb->o.odin.os2msg, &os2msg, sizeof(QMSG));
509 memcpy(&teb->o.odin.winmsg, pMsg, sizeof(MSG));
510 }
511
512 // send keyboard messages to the registered hooks
513 if(fRemove & PM_REMOVE_W) {
514 switch (pMsg->message)
515 {
516 case WINWM_KEYDOWN:
517 case WINWM_KEYUP:
518 case WINWM_SYSKEYDOWN:
519 case WINWM_SYSKEYUP:
520 // only supposed to be called upon WM_KEYDOWN
521 // and WM_KEYUP according to docs.
522 dprintf(("OSLibWinPeekMsg: ProcessKbdHook call"));
523 if(ProcessKbdHook(pMsg, fRemove))
524 goto continuepeekmsg;
525 break;
526 case WINWM_IME_CHAR:
527 // prevent from calling wrong DispatchMsg() (DBCS generated WM_CHAR)
528 memset( &teb->o.odin.winmsg, 0, sizeof( MSG ));
529 break;
530 }
531 }
532
533 return rc;
534}
535//******************************************************************************
536//******************************************************************************
537ULONG OSLibWinQueryMsgTime()
538{
539 return WinQueryMsgTime(GetThreadHAB());
540}
541//******************************************************************************
542//******************************************************************************
543BOOL OSLibWinWaitMessage()
544{
545 return WinWaitMsg(GetThreadHAB(), 0, 0);
546}
547//******************************************************************************
548//TODO: QS_HOTKEY
549//******************************************************************************
550ULONG OSLibWinQueryQueueStatus(ULONG flags)
551{
552 ULONG statusOS2, statusWin32 = 0;
553
554 statusOS2 = WinQueryQueueStatus(HWND_DESKTOP);
555 dprintf(("*** 3 %x", statusOS2));
556
557 if (flags & QS_KEY)
558 {
559 // WinQueryQueueStatus() has a bug which causes it to always return
560 // the QS_KEY bit set when the associated window is active, regardless
561 // of whether thiere are WM_CHAR messages in the queue or not. We try to
562 // fix this by looking up the queue ourselves if the caller actually
563 // wants this state to be checked
564 QMSG qmsg;
565 BOOL haveKey = WinPeekMsg (0, &qmsg, 0, WM_CHAR, WM_CHAR, PM_NOREMOVE);
566 if (haveKey)
567 {
568 // set the proper "summary" status
569 statusOS2 |= (QS_KEY << 16);
570 }
571 else
572 {
573 statusOS2 &= ~(QS_KEY << 16);
574 // according to PMREF, the "added" field is a subset of the
575 // "summary" field, so it makes no sense to have it set when it is
576 // reset in "summary"
577 statusOS2 &= ~(QS_KEY);
578 }
579 }
580
581 // convert the flags since last call (low word)
582
583 if(statusOS2 & QS_KEY)
584 statusWin32 |= QS_KEY_W;
585 if(statusOS2 & QS_MOUSEBUTTON)
586 statusWin32 |= QS_MOUSEBUTTON_W;
587 if(statusOS2 & QS_MOUSEMOVE)
588 statusWin32 |= QS_MOUSEMOVE_W;
589 if(statusOS2 & QS_TIMER)
590 statusWin32 |= QS_TIMER_W;
591 if(statusOS2 & QS_PAINT)
592 statusWin32 |= QS_PAINT_W;
593 if(statusOS2 & QS_POSTMSG)
594 statusWin32 |= QS_POSTMESSAGE_W;
595 if(statusOS2 & QS_SENDMSG)
596 statusWin32 |= QS_SENDMESSAGE_W;
597
598 // convert the summary flags (high word)
599
600 statusOS2 >>= 16;
601
602 if(statusOS2 & QS_KEY)
603 statusWin32 |= QS_KEY_W << 16;
604 if(statusOS2 & QS_MOUSEBUTTON)
605 statusWin32 |= QS_MOUSEBUTTON_W << 16;
606 if(statusOS2 & QS_MOUSEMOVE)
607 statusWin32 |= QS_MOUSEMOVE_W << 16;
608 if(statusOS2 & QS_TIMER)
609 statusWin32 |= QS_TIMER_W << 16;
610 if(statusOS2 & QS_PAINT)
611 statusWin32 |= QS_PAINT_W << 16;
612 if(statusOS2 & QS_POSTMSG)
613 statusWin32 |= QS_POSTMESSAGE_W << 16;
614 if(statusOS2 & QS_SENDMSG)
615 statusWin32 |= QS_SENDMESSAGE_W << 16;
616
617 return statusWin32;
618}
619//******************************************************************************
620//******************************************************************************
621BOOL OSLibWinInSendMessage()
622{
623 return WinInSendMsg(GetThreadHAB());
624}
625//******************************************************************************
626//******************************************************************************
627DWORD OSLibWinGetMessagePos()
628{
629 APIRET rc;
630 POINTL ptl;
631
632 rc = WinQueryMsgPos(GetThreadHAB(), &ptl);
633 if(!rc) {
634 return 0;
635 }
636 //convert to windows coordinates
637 return MAKEULONG(ptl.x,mapScreenY(ptl.y));
638}
639//******************************************************************************
640//******************************************************************************
641LONG OSLibWinGetMessageTime()
642{
643 return (LONG)WinQueryMsgTime(GetThreadHAB());
644}
645//******************************************************************************
646//******************************************************************************
647BOOL OSLibWinReplyMessage(ULONG result)
648{
649 return (BOOL)WinReplyMsg( NULLHANDLE, NULLHANDLE, HMQ_CURRENT, (MRESULT)result);
650}
651
652//******************************************************************************
653
654/**
655 * Send and Post message helper for packing down interprocess and interthread messages.
656 *
657 * @returns Pointer to packet on success. (shared memory)
658 * @returns NULL on failure with SendMessage return code suggestion in *pRc if pRc is set.
659 * @param hwndOdin Odin window handle. (NULL allowed)
660 * @param hwndOS2 OS/2 window handle.
661 * @param msg Message id.
662 * @param wParam Message param.
663 * @param lParam Message param.
664 * @param fUnicode Unicode or ansi indicator.
665 * @param pRc Where to store SendMessage return code. Optional.
666 * @author knut st. osmundsen<bird@anduin.net>
667 */
668void * OSLibPackMessage(HWND hwndOdin, HWND hwndOS2, ULONG msg, ULONG wParam, ULONG lParam, BOOL fUnicode, PULONG pRc)
669{
670 POSTMSG_PACKET * pMsgPacket;
671
672 /*
673 * Pack message by id.
674 */
675 switch (msg)
676 {
677 /*
678 * lParam = PCOPYDATASTRUCT.
679 * Must move this to shared memory together with any
680 * data it's pointing at.
681 *
682 * We put everything into the package that might ease cleanup...
683 * WARNING! Currently there are cleanup hacks which works with acrobat.
684 */
685 case WINWM_COPYDATA:
686 {
687 PCOPYDATASTRUCT_W pOrg = (PCOPYDATASTRUCT_W)lParam;
688 dprintf(("user32::oslibmsg::OSLibPackMessage - WM_COPYDATA: lParam=%#x dwData=%#x cbData=%d lpData=%#x",
689 pOrg, pOrg ? pOrg->dwData : -1, pOrg ? pOrg->cbData : -1, pOrg ? pOrg->lpData : (LPVOID)-1));
690
691 /*
692 * Calc packet size.
693 */
694 unsigned cb = sizeof(POSTMSG_PACKET);
695 if (pOrg)
696 {
697 cb += sizeof(COPYDATASTRUCT_W);
698 if (pOrg->lpData && pOrg->cbData)
699 cb += 16 + pOrg->cbData; //add 16 Bytes for safty and alignment.
700 }
701
702 /*
703 * Allocate packet.
704 */
705 pMsgPacket = (POSTMSG_PACKET *)_smalloc(cb);
706 if (!pMsgPacket)
707 {
708 dprintf(("user32::oslibmsg::OSLibPackMessage - WM_COPYDATA: failed to allocate %d shared bytes for packing", cb));
709 DebugInt3();
710 if (pRc)
711 *pRc = FALSE;
712 //@todo figure out which error to set. This is plain guesswork!
713 SetLastError(ERROR_NOT_ENOUGH_MEMORY_W);
714 break;
715 }
716
717 /*
718 * Initialize packet.
719 */
720 PCOPYDATASTRUCT_W pNew = (PCOPYDATASTRUCT_W)(pMsgPacket + 1);
721 pMsgPacket->wParam = wParam;
722 pMsgPacket->lParam = (LPARAM)pNew;
723 *pNew = *pOrg;
724 if (pNew->cbData && pNew->lpData)
725 {
726 pNew->lpData = (LPVOID)(((unsigned)(pNew + 1) + 15) & ~15); //16byte align for safty.
727 //@todo what about a safe_memcpy?
728 memcpy(pNew->lpData, pOrg->lpData, pNew->cbData);
729 }
730
731 /* done! */
732 dprintf(("user32::oslibmsg::OSLibPackMessage - WM_COPYDATA: Packed down %d bytes at %#x (pMsgPacket)",
733 cb, pMsgPacket));
734 break;
735 }
736
737
738 /*
739 * Default packing
740 */
741 default:
742 {
743 ULONG pid;
744
745 GetWindowThreadProcessId(hwndOdin, &pid);
746
747 //use shared or local memory depending on the target window
748 //(sfree can be used for any heap)
749 if(pid != GetCurrentProcessId()) {
750 pMsgPacket = (POSTMSG_PACKET *)_smalloc(sizeof(POSTMSG_PACKET));
751 }
752 else pMsgPacket = (POSTMSG_PACKET *)malloc(sizeof(POSTMSG_PACKET));
753
754 if (!pMsgPacket)
755 {
756 dprintf(("user32::oslibmsg::OSLibPackMessage - allocated packet structure is NULL"));
757 if (pRc)
758 { // Can't find any better return code than 0 :/
759 *pRc = 0;
760 }
761 DebugInt3();
762 break;
763 }
764 pMsgPacket->wParam = wParam;
765 pMsgPacket->lParam = lParam;
766 }
767
768 }
769
770 return pMsgPacket;
771}
772
773
774/**
775 * Send an inter thread/proces message.
776 *
777 * @returns
778 * @param hwndWin32 Odin window handle.
779 * @param hwndOS2 OS/2 window handle
780 * @param msg Odin message id.
781 * @param wParam Message param.
782 * @param lParam Message param.
783 * @param fUnicode Unicode indicator.
784 */
785ULONG OSLibSendMessage(HWND hwndWin32, HWND hwndOS2, ULONG msg, ULONG wParam, ULONG lParam, BOOL fUnicode)
786{
787 ULONG rc; /* return code on packing failure */
788 void * pvMsgPacket; /* packed message (shared memory) */
789
790 if(GetDesktopWindow() == hwndWin32) {
791 dprintf(("Ignore messages sent to the desktop window"));
792 return TRUE;
793 }
794
795 /*
796 * Call message packer.
797 */
798 pvMsgPacket = OSLibPackMessage(hwndWin32, hwndOS2, msg, wParam, lParam, fUnicode, &rc);
799 if (!pvMsgPacket)
800 {
801 dprintf(("user32::oslibmsg::OSLibSendMessage - Failed to pack message !!"));
802 DebugInt3();
803 return rc;
804 }
805
806 return (ULONG)WinSendMsg(hwndOS2, WIN32APP_POSTMSG+msg, (MPARAM)((fUnicode) ? WIN32MSG_MAGICW : WIN32MSG_MAGICA), pvMsgPacket);
807}
808//******************************************************************************
809//******************************************************************************
810BOOL OSLibSendWinMessage(HWND hwnd, ULONG winmsg, ULONG extra /*= 0*/)
811{
812 if (winmsg == WINWM_MOUSEWHEEL)
813 {
814 return (BOOL)WinSendMsg(Win32ToOS2Handle(hwnd), TranslateWinMsg(winmsg, TRUE),
815 0, MPFROM2SHORT(0, extra < 0 ? SB_LINEDOWN : SB_LINEUP));
816 }
817 return (BOOL)WinSendMsg(Win32ToOS2Handle(hwnd), TranslateWinMsg(winmsg, TRUE), 0, 0);
818}
819//******************************************************************************
820//******************************************************************************
821ULONG OSLibWinBroadcastMsg(ULONG msg, ULONG wParam, ULONG lParam, BOOL fSend)
822{
823 #ifdef DEBUG
824 if (msg == WINWM_COPYDATA)
825 {
826 dprintf(("user32::oslibmsg::OSLibWinBroadcastMsg - WM_COPYDATA will not work outside this process !!!"));
827 DebugInt3();
828 }
829 #endif
830 return WinBroadcastMsg(HWND_DESKTOP, WIN32APP_POSTMSG+msg, (MPARAM)wParam, (MPARAM)lParam,
831 (fSend) ? BMSG_SEND : BMSG_POST);
832}
833
834
835/**
836 * Post a message.
837 *
838 * @returns Success indicator.
839 *
840 * @param hwndWin32 Odin window handle.
841 * @param hwndOS2 OS/2 window handle
842 * @param msg Odin message id.
843 * @param wParam Message param.
844 * @param lParam Message param.
845 * @param fUnicode Unicode indicator.
846 */
847BOOL OSLibPostMessage(HWND hwndWin32, HWND hwndOS2, ULONG msg, ULONG wParam, ULONG lParam, BOOL fUnicode)
848{
849 void * pvMsgPacket; /* packed message (shared memory) */
850
851 if(GetDesktopWindow() == hwndWin32) {
852 dprintf(("Ignore messages posted to the desktop window"));
853 return TRUE;
854 }
855
856 /*
857 * Call message packer.
858 */
859 pvMsgPacket = OSLibPackMessage(hwndWin32, hwndOS2, msg, wParam, lParam, fUnicode, NULL);
860 if (!pvMsgPacket)
861 {
862 dprintf(("user32::oslibmsg::OSLibPostMessage - Failed to pack message !!"));
863 DebugInt3();
864 return FALSE;
865 }
866
867 /*
868 * Post the message.
869 * Signal the receiver for if it's doing MsgWaitForMultipleObjects() at the time.
870 */
871 TEB *teb = GetTEBFromThreadId(GetWindowThreadProcessId(hwndWin32, NULL));
872 BOOL ret = WinPostMsg(hwndOS2,
873 WIN32APP_POSTMSG+msg,
874 (MPARAM)((fUnicode) ? WIN32MSG_MAGICW : WIN32MSG_MAGICA),
875 pvMsgPacket);
876 if (teb && (teb->o.odin.dwWakeMask & QS_POSTMESSAGE_W))
877 {
878 //thread is blocked in MsgWaitForMultipleObjects waiting for
879 //posted messages
880 dprintf(("PostMessage: Wake up thread %x which is blocked in MsgWaitForMultipleObjects", teb->o.odin.threadId));
881 SetEvent(teb->o.odin.hPostMsgEvent);
882 }
883 return ret;
884}
885//******************************************************************************
886//Direct posting of messages that must remain invisible to the win32 app
887//******************************************************************************
888BOOL OSLibPostMessageDirect(HWND hwnd, ULONG msg, ULONG wParam, ULONG lParam)
889{
890 return WinPostMsg(hwnd, msg, (MPARAM)wParam, (MPARAM)lParam);
891}
892//******************************************************************************
893//******************************************************************************
894BOOL OSLibPostThreadMessage(ULONG threadid, UINT msg, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
895{
896 TEB *teb = GetTEBFromThreadId(threadid);
897 POSTMSG_PACKET *packet = (POSTMSG_PACKET *)_smalloc(sizeof(POSTMSG_PACKET));
898 BOOL ret;
899
900 if (NULL == packet)
901 {
902 dprintf(("user32::oslibmsg::OSLibPostMessage - allocated packet structure is NULL"));
903
904 DebugInt3();
905 // PH: we can provide a correct returncode
906 return FALSE;
907 }
908
909 if(teb == NULL) {
910 dprintf(("OSLibPostThreadMessage: thread %x not found!", threadid));
911 return FALSE;
912 }
913 dprintf(("PostThreadMessageA %x %x %x %x -> hmq %x", threadid, msg, wParam, lParam, teb->o.odin.hmq));
914 packet->wParam = wParam;
915 packet->lParam = lParam;
916
917 ret = WinPostQueueMsg((HMQ)teb->o.odin.hmq, WIN32APP_POSTMSG+msg,
918 (MPARAM)((fUnicode) ? WIN32MSG_MAGICW : WIN32MSG_MAGICA),
919 (MPARAM)packet);
920
921 if(ret == FALSE)
922 {
923 SetLastError(ERROR_INVALID_PARAMETER_W);
924 return FALSE;
925 }
926
927 if(teb->o.odin.dwWakeMask & QS_POSTMESSAGE_W) {
928 //thread is blocked in MsgWaitForMultipleObjects waiting for
929 //posted messages
930 dprintf(("PostMessage: Wake up thread %x which is blocked in MsgWaitForMultipleObjects", teb->o.odin.threadId));
931 SetEvent(teb->o.odin.hPostMsgEvent);
932 }
933
934 SetLastError(ERROR_SUCCESS_W);
935 return TRUE;
936}
937//******************************************************************************
938//******************************************************************************
939DWORD GetThreadMessageExtraInfo()
940{
941 TEB *teb;
942
943 teb = GetThreadTEB();
944 if(teb)
945 {
946 return teb->o.odin.dwMsgExtraInfo;
947 }
948 dprintf(("GetThreadMessageExtraInfo: teb == NULL!!"));
949 return 0;
950}
951//******************************************************************************
952//******************************************************************************
953DWORD SetThreadMessageExtraInfo(DWORD lParam)
954{
955 TEB *teb;
956
957 teb = GetThreadTEB();
958 if(teb)
959 {
960 teb->o.odin.dwMsgExtraInfo = lParam;
961 }
962 else dprintf(("SetThreadMessageExtraInfo: teb == NULL!!"));
963 return 0;
964}
965//******************************************************************************
966//******************************************************************************
Note: See TracBrowser for help on using the repository browser.