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

Last change on this file since 10205 was 10205, checked in by sandervl, 22 years ago

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