Context Navigation

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

Visit:

Last change on this file since 21527 was 21527, checked in by dmik, 15 years ago
user32: Fixed: GetMessage/PeekMessage could fail if filter was specified.
File size: 32.1 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
60	ODINDEBUGCHANNEL(USER32-OSLIBMSG)
61
62
63
64	typedef BOOL (EXPENTRY FNTRANS)(MSG , QMSG );
65	typedef FNTRANS *PFNTRANS;
66
67	typedef 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!!
76	MSGTRANSTAB 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	//******************************************************************************
138	void 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	//******************************************************************************
149	ULONG 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	//******************************************************************************
182	void 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	//******************************************************************************
193	LONG 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	//******************************************************************************
238	BOOL 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	//******************************************************************************
312	BOOL 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
343	continuegetmsg:
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	//******************************************************************************
424	BOOL 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
459	continuepeekmsg:
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	//******************************************************************************
537	ULONG OSLibWinQueryMsgTime()
538	{
539	return WinQueryMsgTime(GetThreadHAB());
540	}
541	//******************************************************************************
542	//******************************************************************************
543	BOOL OSLibWinWaitMessage()
544	{
545	return WinWaitMsg(GetThreadHAB(), 0, 0);
546	}
547	//******************************************************************************
548	//TODO: QS_HOTKEY
549	//******************************************************************************
550	ULONG OSLibWinQueryQueueStatus()
551	{
552	ULONG statusOS2, statusWin32 = 0;
553
554	statusOS2 = WinQueryQueueStatus(HWND_DESKTOP);
555
556	if(statusOS2 & QS_KEY)
557	statusWin32 \|= QS_KEY_W;
558	if(statusOS2 & QS_MOUSEBUTTON)
559	statusWin32 \|= QS_MOUSEBUTTON_W;
560	if(statusOS2 & QS_MOUSEMOVE)
561	statusWin32 \|= QS_MOUSEMOVE_W;
562	if(statusOS2 & QS_TIMER)
563	statusWin32 \|= QS_TIMER_W;
564	if(statusOS2 & QS_PAINT)
565	statusWin32 \|= QS_PAINT_W;
566	if(statusOS2 & QS_POSTMSG)
567	statusWin32 \|= QS_POSTMESSAGE_W;
568	if(statusOS2 & QS_SENDMSG)
569	statusWin32 \|= QS_SENDMESSAGE_W;
570
571	return statusWin32;
572	}
573	//******************************************************************************
574	//******************************************************************************
575	BOOL OSLibWinInSendMessage()
576	{
577	return WinInSendMsg(GetThreadHAB());
578	}
579	//******************************************************************************
580	//******************************************************************************
581	DWORD OSLibWinGetMessagePos()
582	{
583	APIRET rc;
584	POINTL ptl;
585
586	rc = WinQueryMsgPos(GetThreadHAB(), &ptl);
587	if(!rc) {
588	return 0;
589	}
590	//convert to windows coordinates
591	return MAKEULONG(ptl.x,mapScreenY(ptl.y));
592	}
593	//******************************************************************************
594	//******************************************************************************
595	LONG OSLibWinGetMessageTime()
596	{
597	return (LONG)WinQueryMsgTime(GetThreadHAB());
598	}
599	//******************************************************************************
600	//******************************************************************************
601	BOOL OSLibWinReplyMessage(ULONG result)
602	{
603	return (BOOL)WinReplyMsg( NULLHANDLE, NULLHANDLE, HMQ_CURRENT, (MRESULT)result);
604	}
605
606	//******************************************************************************
607
608	/**
609	* Send and Post message helper for packing down interprocess and interthread messages.
610	*
611	* @returns Pointer to packet on success. (shared memory)
612	* @returns NULL on failure with SendMessage return code suggestion in *pRc if pRc is set.
613	* @param hwndOdin Odin window handle. (NULL allowed)
614	* @param hwndOS2 OS/2 window handle.
615	* @param msg Message id.
616	* @param wParam Message param.
617	* @param lParam Message param.
618	* @param fUnicode Unicode or ansi indicator.
619	* @param pRc Where to store SendMessage return code. Optional.
620	* @author knut st. osmundsen<bird@anduin.net>
621	*/
622	void * OSLibPackMessage(HWND hwndOdin, HWND hwndOS2, ULONG msg, ULONG wParam, ULONG lParam, BOOL fUnicode, PULONG pRc)
623	{
624	POSTMSG_PACKET * pMsgPacket;
625
626	/*
627	* Pack message by id.
628	*/
629	switch (msg)
630	{
631	/*
632	* lParam = PCOPYDATASTRUCT.
633	* Must move this to shared memory together with any
634	* data it's pointing at.
635	*
636	* We put everything into the package that might ease cleanup...
637	* WARNING! Currently there are cleanup hacks which works with acrobat.
638	*/
639	case WINWM_COPYDATA:
640	{
641	PCOPYDATASTRUCT_W pOrg = (PCOPYDATASTRUCT_W)lParam;
642	dprintf(("user32::oslibmsg::OSLibPackMessage - WM_COPYDATA: lParam=%#x dwData=%#x cbData=%d lpData=%#x",
643	pOrg, pOrg ? pOrg->dwData : -1, pOrg ? pOrg->cbData : -1, pOrg ? pOrg->lpData : (LPVOID)-1));
644
645	/*
646	* Calc packet size.
647	*/
648	unsigned cb = sizeof(POSTMSG_PACKET);
649	if (pOrg)
650	{
651	cb += sizeof(COPYDATASTRUCT_W);
652	if (pOrg->lpData && pOrg->cbData)
653	cb += 16 + pOrg->cbData; //add 16 Bytes for safty and alignment.
654	}
655
656	/*
657	* Allocate packet.
658	*/
659	pMsgPacket = (POSTMSG_PACKET *)_smalloc(cb);
660	if (!pMsgPacket)
661	{
662	dprintf(("user32::oslibmsg::OSLibPackMessage - WM_COPYDATA: failed to allocate %d shared bytes for packing", cb));
663	DebugInt3();
664	if (pRc)
665	*pRc = FALSE;
666	//@todo figure out which error to set. This is plain guesswork!
667	SetLastError(ERROR_NOT_ENOUGH_MEMORY_W);
668	break;
669	}
670
671	/*
672	* Initialize packet.
673	*/
674	PCOPYDATASTRUCT_W pNew = (PCOPYDATASTRUCT_W)(pMsgPacket + 1);
675	pMsgPacket->wParam = wParam;
676	pMsgPacket->lParam = (LPARAM)pNew;
677	pNew = pOrg;
678	if (pNew->cbData && pNew->lpData)
679	{
680	pNew->lpData = (LPVOID)(((unsigned)(pNew + 1) + 15) & ~15); //16byte align for safty.
681	//@todo what about a safe_memcpy?
682	memcpy(pNew->lpData, pOrg->lpData, pNew->cbData);
683	}
684
685	/* done! */
686	dprintf(("user32::oslibmsg::OSLibPackMessage - WM_COPYDATA: Packed down %d bytes at %#x (pMsgPacket)",
687	cb, pMsgPacket));
688	break;
689	}
690
691
692	/*
693	* Default packing
694	*/
695	default:
696	{
697	ULONG pid;
698
699	GetWindowThreadProcessId(hwndOdin, &pid);
700
701	//use shared or local memory depending on the target window
702	//(sfree can be used for any heap)
703	if(pid != GetCurrentProcessId()) {
704	pMsgPacket = (POSTMSG_PACKET *)_smalloc(sizeof(POSTMSG_PACKET));
705	}
706	else pMsgPacket = (POSTMSG_PACKET *)malloc(sizeof(POSTMSG_PACKET));
707
708	if (!pMsgPacket)
709	{
710	dprintf(("user32::oslibmsg::OSLibPackMessage - allocated packet structure is NULL"));
711	if (pRc)
712	{ // Can't find any better return code than 0 :/
713	*pRc = 0;
714	}
715	DebugInt3();
716	break;
717	}
718	pMsgPacket->wParam = wParam;
719	pMsgPacket->lParam = lParam;
720	}
721
722	}
723
724	return pMsgPacket;
725	}
726
727
728	/**
729	* Send an inter thread/proces message.
730	*
731	* @returns
732	* @param hwndWin32 Odin window handle.
733	* @param hwndOS2 OS/2 window handle
734	* @param msg Odin message id.
735	* @param wParam Message param.
736	* @param lParam Message param.
737	* @param fUnicode Unicode indicator.
738	*/
739	ULONG OSLibSendMessage(HWND hwndWin32, HWND hwndOS2, ULONG msg, ULONG wParam, ULONG lParam, BOOL fUnicode)
740	{
741	ULONG rc; /* return code on packing failure */
742	void * pvMsgPacket; /* packed message (shared memory) */
743
744	if(GetDesktopWindow() == hwndWin32) {
745	dprintf(("Ignore messages sent to the desktop window"));
746	return TRUE;
747	}
748
749	/*
750	* Call message packer.
751	*/
752	pvMsgPacket = OSLibPackMessage(hwndWin32, hwndOS2, msg, wParam, lParam, fUnicode, &rc);
753	if (!pvMsgPacket)
754	{
755	dprintf(("user32::oslibmsg::OSLibSendMessage - Failed to pack message !!"));
756	DebugInt3();
757	return rc;
758	}
759
760	return (ULONG)WinSendMsg(hwndOS2, WIN32APP_POSTMSG+msg, (MPARAM)((fUnicode) ? WIN32MSG_MAGICW : WIN32MSG_MAGICA), pvMsgPacket);
761	}
762	//******************************************************************************
763	//******************************************************************************
764	BOOL OSLibSendWinMessage(HWND hwnd, ULONG winmsg, ULONG extra /= 0/)
765	{
766	if (winmsg == WINWM_MOUSEWHEEL)
767	{
768	return (BOOL)WinSendMsg(Win32ToOS2Handle(hwnd), TranslateWinMsg(winmsg, TRUE),
769	0, MPFROM2SHORT(0, extra < 0 ? SB_LINEDOWN : SB_LINEUP));
770	}
771	return (BOOL)WinSendMsg(Win32ToOS2Handle(hwnd), TranslateWinMsg(winmsg, TRUE), 0, 0);
772	}
773	//******************************************************************************
774	//******************************************************************************
775	ULONG OSLibWinBroadcastMsg(ULONG msg, ULONG wParam, ULONG lParam, BOOL fSend)
776	{
777	#ifdef DEBUG
778	if (msg == WINWM_COPYDATA)
779	{
780	dprintf(("user32::oslibmsg::OSLibWinBroadcastMsg - WM_COPYDATA will not work outside this process !!!"));
781	DebugInt3();
782	}
783	#endif
784	return WinBroadcastMsg(HWND_DESKTOP, WIN32APP_POSTMSG+msg, (MPARAM)wParam, (MPARAM)lParam,
785	(fSend) ? BMSG_SEND : BMSG_POST);
786	}
787
788
789	/**
790	* Post a message.
791	*
792	* @returns Success indicator.
793	*
794	* @param hwndWin32 Odin window handle.
795	* @param hwndOS2 OS/2 window handle
796	* @param msg Odin message id.
797	* @param wParam Message param.
798	* @param lParam Message param.
799	* @param fUnicode Unicode indicator.
800	*/
801	BOOL OSLibPostMessage(HWND hwndWin32, HWND hwndOS2, ULONG msg, ULONG wParam, ULONG lParam, BOOL fUnicode)
802	{
803	void * pvMsgPacket; /* packed message (shared memory) */
804
805	if(GetDesktopWindow() == hwndWin32) {
806	dprintf(("Ignore messages posted to the desktop window"));
807	return TRUE;
808	}
809
810	/*
811	* Call message packer.
812	*/
813	pvMsgPacket = OSLibPackMessage(hwndWin32, hwndOS2, msg, wParam, lParam, fUnicode, NULL);
814	if (!pvMsgPacket)
815	{
816	dprintf(("user32::oslibmsg::OSLibPostMessage - Failed to pack message !!"));
817	DebugInt3();
818	return FALSE;
819	}
820
821	/*
822	* Post the message.
823	* Signal the receiver for if it's doing MsgWaitForMultipleObjects() at the time.
824	*/
825	TEB *teb = GetTEBFromThreadId(GetWindowThreadProcessId(hwndWin32, NULL));
826	BOOL ret = WinPostMsg(hwndOS2,
827	WIN32APP_POSTMSG+msg,
828	(MPARAM)((fUnicode) ? WIN32MSG_MAGICW : WIN32MSG_MAGICA),
829	pvMsgPacket);
830	if (teb && (teb->o.odin.dwWakeMask & QS_POSTMESSAGE_W))
831	{
832	//thread is blocked in MsgWaitForMultipleObjects waiting for
833	//posted messages
834	dprintf(("PostMessage: Wake up thread %x which is blocked in MsgWaitForMultipleObjects", teb->o.odin.threadId));
835	SetEvent(teb->o.odin.hPostMsgEvent);
836	}
837	return ret;
838	}
839	//******************************************************************************
840	//Direct posting of messages that must remain invisible to the win32 app
841	//******************************************************************************
842	BOOL OSLibPostMessageDirect(HWND hwnd, ULONG msg, ULONG wParam, ULONG lParam)
843	{
844	return WinPostMsg(hwnd, msg, (MPARAM)wParam, (MPARAM)lParam);
845	}
846	//******************************************************************************
847	//******************************************************************************
848	BOOL OSLibPostThreadMessage(ULONG threadid, UINT msg, WPARAM wParam, LPARAM lParam, BOOL fUnicode)
849	{
850	TEB *teb = GetTEBFromThreadId(threadid);
851	POSTMSG_PACKET packet = (POSTMSG_PACKET )_smalloc(sizeof(POSTMSG_PACKET));
852	BOOL ret;
853
854	if (NULL == packet)
855	{
856	dprintf(("user32::oslibmsg::OSLibPostMessage - allocated packet structure is NULL"));
857
858	DebugInt3();
859	// PH: we can provide a correct returncode
860	return FALSE;
861	}
862
863	if(teb == NULL) {
864	dprintf(("OSLibPostThreadMessage: thread %x not found!", threadid));
865	return FALSE;
866	}
867	dprintf(("PostThreadMessageA %x %x %x %x -> hmq %x", threadid, msg, wParam, lParam, teb->o.odin.hmq));
868	packet->wParam = wParam;
869	packet->lParam = lParam;
870
871	ret = WinPostQueueMsg((HMQ)teb->o.odin.hmq, WIN32APP_POSTMSG+msg,
872	(MPARAM)((fUnicode) ? WIN32MSG_MAGICW : WIN32MSG_MAGICA),
873	(MPARAM)packet);
874
875	if(ret == FALSE)
876	{
877	SetLastError(ERROR_INVALID_PARAMETER_W);
878	return FALSE;
879	}
880
881	if(teb->o.odin.dwWakeMask & QS_POSTMESSAGE_W) {
882	//thread is blocked in MsgWaitForMultipleObjects waiting for
883	//posted messages
884	dprintf(("PostMessage: Wake up thread %x which is blocked in MsgWaitForMultipleObjects", teb->o.odin.threadId));
885	SetEvent(teb->o.odin.hPostMsgEvent);
886	}
887
888	SetLastError(ERROR_SUCCESS_W);
889	return TRUE;
890	}
891	//******************************************************************************
892	//******************************************************************************
893	DWORD GetThreadMessageExtraInfo()
894	{
895	TEB *teb;
896
897	teb = GetThreadTEB();
898	if(teb)
899	{
900	return teb->o.odin.dwMsgExtraInfo;
901	}
902	dprintf(("GetThreadMessageExtraInfo: teb == NULL!!"));
903	return 0;
904	}
905	//******************************************************************************
906	//******************************************************************************
907	DWORD SetThreadMessageExtraInfo(DWORD lParam)
908	{
909	TEB *teb;
910
911	teb = GetThreadTEB();
912	if(teb)
913	{
914	teb->o.odin.dwMsgExtraInfo = lParam;
915	}
916	else dprintf(("SetThreadMessageExtraInfo: teb == NULL!!"));
917	return 0;
918	}
919	//******************************************************************************
920	//******************************************************************************

Note: See TracBrowser for help on using the repository browser.

Download in other formats: