Context Navigation

source: trunk/src/user32/oslibmsgtranslate.cpp@ 10010

Visit:

Last change on this file since 10010 was 9950, checked in by sandervl, 22 years ago
Fix for multiple WM_CHAR_SPECIAL_CONSOLE_BREAK
File size: 39.8 KB

Line
1	/* $Id: oslibmsgtranslate.cpp,v 1.107 2003-03-28 11:49:01 sandervl Exp $ */
2	/*
3	* Window message translation functions for OS/2
4	*
5	*
6	* Copyright 1998-1999 Sander van Leeuwen (sandervl@xs4all.nl)
7	* Copyright 1999 Daniela Engert (dani@ngrt.de)
8	* Copyright 1999 Rene Pronk (R.Pronk@twi.tudelft.nl)
9	*
10	* Project Odin Software License can be found in LICENSE.TXT
11	*
12	* TODO: Extra msgs: which messages must be put into the queue and which can be sent directly?
13	* (According to the docs TranslateMessage really inserts a msg in the queue)
14	* TODO: Filter translation isn't correct for posted messages
15	*
16	*/
17	#define INCL_WIN
18	#define INCL_PM
19	#define INCL_DOSPROCESS
20	#include <os2wrap.h>
21	#include <string.h>
22	#include <misc.h>
23	#include <winconst.h>
24	#include <win32api.h>
25	#include "oslibmsg.h"
26	#include <winuser32.h>
27	#include "win32wdesktop.h"
28	#include "oslibutil.h"
29	#include "timer.h"
30	#include <thread.h>
31	#include <wprocess.h>
32	#include "pmwindow.h"
33	#include "oslibwin.h"
34	#include "winmouse.h"
35	#include <pmkbdhk.h>
36	#include <pmscan.h>
37	#include <winscan.h>
38	#include <winkeyboard.h>
39	#include "hook.h"
40	#include "user32api.h"
41
42
43	#define DBG_LOCALLOG DBG_oslibmsgtranslate
44	#include "dbglocal.h"
45
46	static BOOL fGenerateDoubleClick = FALSE;
47	static MSG doubleClickMsg = {0};
48
49	//For wheel mouse translation
50	#define WHEEL_DELTA 120
51	#define OS2_WHEEL_CORRECTION 1
52	//PF Correction is different for different mouse drivers. For now no correction
53	//is ok because lots of Odin controls rely on minimum delta. However in future
54	//we will possibly detect mouse driver and use correction if speed will be
55	//too high or too low.
56
57	//******************************************************************************
58	//******************************************************************************
59	BOOL setThreadQueueExtraCharMessage(TEB* teb, MSG* pExtraMsg)
60	{
61	// check if the single slot is occupied already
62	if (teb->o.odin.fTranslated == TRUE)
63	// there's still an already translated message to be processed
64	return FALSE;
65	teb->o.odin.fTranslated = TRUE;
66	memcpy(&teb->o.odin.msgWCHAR, pExtraMsg, sizeof(MSG));
67	return TRUE;
68	}
69
70	//******************************************************************************
71	//******************************************************************************
72	ULONG ConvertNumPadKey(ULONG pmScan)
73	{
74	ULONG ret;
75	BYTE winKey;
76
77	switch (pmScan)
78	{
79	case PMSCAN_PAD7: ret = PMSCAN_HOME; break;
80	case PMSCAN_PAD8: ret = PMSCAN_UP; break;
81	case PMSCAN_PAD9: ret = PMSCAN_PAGEUP; break;
82	case PMSCAN_PAD4: ret = PMSCAN_LEFT; break;
83	case PMSCAN_PAD6: ret = PMSCAN_RIGHT; break;
84	case PMSCAN_PAD1: ret = PMSCAN_END; break;
85	case PMSCAN_PAD2: ret = PMSCAN_DOWN; break;
86	case PMSCAN_PAD3: ret = PMSCAN_PAGEDOWN; break;
87	case PMSCAN_PAD0: ret = PMSCAN_INSERT; break;
88	case PMSCAN_PADPERIOD: ret = PMSCAN_DELETE; break;
89	default:
90	ret = pmScan;
91	}
92
93	KeyTranslatePMScanToWinVKey(ret, FALSE, (PBYTE)&winKey, NULL, NULL);
94	return winKey;
95
96	}
97	//******************************************************************************
98	//******************************************************************************
99	ULONG GetMouseKeyState()
100	{
101	ULONG keystate = 0;
102
103	if(WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) & 0x8000)
104	keystate \|= MK_LBUTTON_W;
105	if(WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & 0x8000)
106	keystate \|= MK_RBUTTON_W;
107	if(WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) & 0x8000)
108	keystate \|= MK_MBUTTON_W;
109	if(WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000)
110	keystate \|= MK_SHIFT_W;
111	if(WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000)
112	keystate \|= MK_CONTROL_W;
113
114	return keystate;
115	}
116	//******************************************************************************
117	//******************************************************************************
118	LONG IsNCMouseMsg(Win32BaseWindow *win32wnd)
119	{
120	return ((win32wnd->getLastHitTestVal() != HTCLIENT_W) && (WinQueryCapture(HWND_DESKTOP) != win32wnd->getOS2WindowHandle()));
121	}
122	//******************************************************************************
123	//******************************************************************************
124	void OSLibSetMenuDoubleClick(BOOL fSet)
125	{
126	fGenerateDoubleClick = fSet;
127	}
128	//******************************************************************************
129	//******************************************************************************
130	BOOL OS2ToWinMsgTranslate(void pTeb, QMSG os2Msg, MSG *winMsg, BOOL isUnicode, BOOL fMsgRemoved)
131	{
132	Win32BaseWindow *win32wnd = 0;
133	OSLIBPOINT point, ClientPoint;
134	POSTMSG_PACKET *packet;
135	TEB teb = (TEB )pTeb;
136	BOOL fWasDisabled = FALSE;
137	BOOL fIsFrame = FALSE;
138	int i;
139
140	memset(winMsg, 0, sizeof(MSG));
141	win32wnd = Win32BaseWindow::GetWindowFromOS2Handle(os2Msg->hwnd);
142	if(!win32wnd) {
143	win32wnd = Win32BaseWindow::GetWindowFromOS2FrameHandle(os2Msg->hwnd);
144	if(win32wnd) {
145	fIsFrame = TRUE;
146	}
147	}
148
149	//PostThreadMessage posts WIN32APP_POSTMSG msg without window handle
150	//Realplayer starts a timer with hwnd 0 & proc 0; check this here
151	if(win32wnd == 0 && (os2Msg->msg != WM_CREATE && os2Msg->msg != WM_QUIT && os2Msg->msg != WM_TIMER && os2Msg->msg < WIN32APP_POSTMSG))
152	{
153	goto dummymessage; //not a win32 client window
154	}
155	winMsg->time = os2Msg->time;
156	//CB: PM bug or undocumented feature? ptl.x highword is set!
157	winMsg->pt.x = os2Msg->ptl.x & 0xFFFF;
158	winMsg->pt.y = mapScreenY(os2Msg->ptl.y);
159
160	if(win32wnd) //==0 for WM_CREATE/WM_QUIT
161	winMsg->hwnd = win32wnd->getWindowHandle();
162
163	if(os2Msg->msg >= WIN32APP_POSTMSG) {
164	packet = (POSTMSG_PACKET *)os2Msg->mp2;
165	if(packet && ((ULONG)os2Msg->mp1 == WIN32MSG_MAGICA \|\| (ULONG)os2Msg->mp1 == WIN32MSG_MAGICW)) {
166	winMsg->message = os2Msg->msg - WIN32APP_POSTMSG;
167	winMsg->wParam = packet->wParam;
168	winMsg->lParam = packet->lParam;
169	if(fMsgRemoved == MSG_REMOVE) free(packet); //free the shared memory here
170	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
171	return TRUE;
172	}
173	else {//broadcasted message (no packet present)
174	winMsg->message = os2Msg->msg - WIN32APP_POSTMSG;
175	winMsg->wParam = (UINT)os2Msg->mp1;
176	winMsg->lParam = (DWORD)os2Msg->mp2;
177	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
178	return TRUE;
179	}
180	goto dummymessage;
181	}
182
183	switch(os2Msg->msg)
184	{
185	//OS/2 msgs
186	case WM_CREATE:
187	{
188	if(teb->o.odin.newWindow == 0) {
189	DebugInt3();
190	goto dummymessage;
191	}
192
193	win32wnd = (Win32BaseWindow *)teb->o.odin.newWindow;
194	win32wnd->addRef();
195
196	winMsg->message = WINWM_CREATE;
197	winMsg->hwnd = win32wnd->getWindowHandle();
198	winMsg->wParam = 0;
199	winMsg->lParam = (LPARAM)win32wnd->tmpcs;
200	break;
201	}
202
203	case WM_QUIT:
204	winMsg->message = WINWM_QUIT;
205	if (fMsgRemoved && win32wnd && (ULONG)os2Msg->mp2 != 0) {
206	// mp2 != 0 -> sent by window list; be nice and close
207	// the window first
208	win32wnd->MsgClose();
209	}
210	break;
211
212	case WM_CLOSE:
213	winMsg->message = WINWM_CLOSE;
214	break;
215
216	case WM_DESTROY:
217	winMsg->message = WINWM_DESTROY;
218	break;
219
220	case WM_ENABLE:
221	winMsg->message = WINWM_ENABLE;
222	winMsg->wParam = SHORT1FROMMP(os2Msg->mp1);
223	break;
224
225	case WM_SHOW:
226	winMsg->message = WINWM_SHOWWINDOW;
227	winMsg->wParam = SHORT1FROMMP(os2Msg->mp1);
228	break;
229
230	case WM_REALIZEPALETTE:
231	winMsg->message = WINWM_PALETTECHANGED;
232	break;
233
234	case WM_WINDOWPOSCHANGED:
235	{
236	PSWP pswp = (PSWP)os2Msg->mp1;
237	SWP swpOld = *(pswp + 1);
238	HWND hParent = NULLHANDLE;
239	LONG yDelta = pswp->cy - swpOld.cy;
240	LONG xDelta = pswp->cx - swpOld.cx;
241
242	if(!fIsFrame) goto dummymessage;
243
244	if ((pswp->fl & (SWP_SIZE \| SWP_MOVE \| SWP_ZORDER)) == 0) goto dummymessage;
245
246	if(pswp->fl & (SWP_MOVE \| SWP_SIZE)) {
247	if (win32wnd->isChild()) {
248	if(win32wnd->getParent()) {
249	hParent = win32wnd->getParent()->getOS2WindowHandle();
250	}
251	else goto dummymessage; //parent has just been destroyed
252	}
253	}
254	if(win32wnd->getParent()) {
255	OSLibMapSWPtoWINDOWPOS(pswp, &teb->o.odin.wp, &swpOld, win32wnd->getParent()->getClientHeight(),
256	win32wnd->getOS2WindowHandle());
257	}
258	else OSLibMapSWPtoWINDOWPOS(pswp, &teb->o.odin.wp, &swpOld, OSLibQueryScreenHeight(), win32wnd->getOS2WindowHandle());
259
260	if (!win32wnd->CanReceiveSizeMsgs()) goto dummymessage;
261
262	if(pswp->fl & (SWP_MOVE \| SWP_SIZE))
263	{
264	teb->o.odin.wp.hwnd = win32wnd->getWindowHandle();
265	if ((pswp->fl & SWP_ZORDER) && (pswp->hwndInsertBehind > HWND_BOTTOM))
266	{
267	Win32BaseWindow *wndAfter = Win32BaseWindow::GetWindowFromOS2Handle(pswp->hwndInsertBehind);
268	if(wndAfter) {
269	teb->o.odin.wp.hwndInsertAfter = wndAfter->getWindowHandle();
270	RELEASE_WNDOBJ(wndAfter);
271	}
272	else teb->o.odin.wp.hwndInsertAfter = HWND_TOP_W;
273	}
274	}
275	winMsg->message = WINWM_WINDOWPOSCHANGED;
276	winMsg->lParam = (LPARAM)&teb->o.odin.wp;
277	break;
278	}
279
280	case WM_ACTIVATE:
281	{
282	HWND hwndActivate = (HWND)os2Msg->mp2;
283	BOOL fMinimized = FALSE;
284
285	hwndActivate = OS2ToWin32Handle(hwndActivate);
286	if(hwndActivate == 0) {
287	//another (non-win32) application's window
288	//set to desktop window handle
289	hwndActivate = windowDesktop->getWindowHandle();
290	}
291
292	if(win32wnd->getStyle() & WS_MINIMIZE_W)
293	{
294	fMinimized = TRUE;
295	}
296
297	winMsg->message = WINWM_ACTIVATE;
298	winMsg->wParam = MAKELONG((SHORT1FROMMP(os2Msg->mp1)) ? WA_ACTIVE_W : WA_INACTIVE_W, fMinimized);
299	winMsg->lParam = (LPARAM)hwndActivate;
300	break;
301	}
302
303	case WM_SETFOCUS:
304	{
305	HWND hwndFocus = (HWND)os2Msg->mp1;
306
307	if(WinQueryWindowULong(hwndFocus, OFFSET_WIN32PM_MAGIC) != WIN32PM_MAGIC) {
308	//another (non-win32) application's window
309	//set to NULL (allowed according to win32 SDK) to avoid problems
310	hwndFocus = NULL;
311	}
312	else hwndFocus = OS2ToWin32Handle(hwndFocus);
313
314	if((ULONG)os2Msg->mp2 == TRUE) {
315	winMsg->message = WINWM_SETFOCUS;
316	winMsg->wParam = (WPARAM)hwndFocus;
317	}
318	else {
319	//If SetFocus(0) was called, then the window has already received
320	//a WM_KILLFOCUS; don't send another one
321	if(!fIgnoreKeystrokes) {
322	winMsg->message = WINWM_KILLFOCUS;
323	winMsg->wParam = (WPARAM)hwndFocus;
324	}
325	else {
326	dprintf(("Window has already received a WM_KILLFOCUS (SetFocus(0)); ignore"));
327	goto dummymessage;
328	}
329	}
330	break;
331	}
332
333	//**************************************************************************
334	//Mouse messages (OS/2 Window coordinates -> Win32 coordinates relative to screen
335	//**************************************************************************
336	case WM_BUTTON1DOWN:
337	case WM_BUTTON1UP:
338	case WM_BUTTON1DBLCLK:
339	case WM_BUTTON2DOWN:
340	case WM_BUTTON2UP:
341	case WM_BUTTON2DBLCLK:
342	case WM_BUTTON3DOWN:
343	case WM_BUTTON3UP:
344	case WM_BUTTON3DBLCLK:
345	{
346	//WM_NCBUTTON is posted when the cursor is in a non-client area of the window
347
348	dprintf(("MsgButton %x (%x) %d at (%d,%d) time %x", winMsg->hwnd, os2Msg->hwnd, WINWM_NCLBUTTONDOWN + (os2Msg->msg - WM_BUTTON1DOWN), winMsg->pt.x, winMsg->pt.y, winMsg->time));
349
350	HWND hwnd;
351
352	DisableLogging();
353	if(GetCapture() != winMsg->hwnd)
354	{
355	hwnd = WindowFromPoint(winMsg->pt);
356	if(win32wnd->getWindowHandle() != hwnd) {
357	RELEASE_WNDOBJ(win32wnd);
358	win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
359	if(win32wnd == NULL) {
360	DebugInt3();
361	EnableLogging();
362	goto dummymessage;
363	}
364	winMsg->hwnd = hwnd;
365	}
366	}
367
368	//if a window is disabled, its parent receives the mouse messages
369	if(!IsWindowEnabled(win32wnd->getWindowHandle())) {
370	if(win32wnd->getParent()) {
371	Win32BaseWindow *parent = win32wnd->getParent();;
372	if(parent) parent->addRef();
373	RELEASE_WNDOBJ(win32wnd);
374	win32wnd = parent;
375	}
376	fWasDisabled = TRUE;
377	}
378
379	if(IsNCMouseMsg(win32wnd)) {
380	winMsg->message = WINWM_NCLBUTTONDOWN + (os2Msg->msg - WM_BUTTON1DOWN);
381	winMsg->wParam = win32wnd->getLastHitTestVal();
382	winMsg->lParam = MAKELONG(winMsg->pt.x, winMsg->pt.y); //screen coordinates
383	}
384	else {
385	ClientPoint.x = winMsg->pt.x;
386	ClientPoint.y = winMsg->pt.y;
387	MapWindowPoints(0, win32wnd->getWindowHandle(), (LPPOINT)&ClientPoint, 1);
388	winMsg->message = WINWM_LBUTTONDOWN + (os2Msg->msg - WM_BUTTON1DOWN);
389	winMsg->wParam = GetMouseKeyState();
390	winMsg->lParam = MAKELONG(ClientPoint.x, ClientPoint.y); //client coordinates
391	}
392	EnableLogging();
393
394	if(fWasDisabled) {
395	if(win32wnd) {
396	winMsg->hwnd = win32wnd->getWindowHandle();
397	}
398	else goto dummymessage; //don't send mouse messages to disabled windows
399	}
400
401	DisableLogging();
402	if ((winMsg->message == WINWM_LBUTTONDOWN) \|\|
403	(winMsg->message == WINWM_RBUTTONDOWN) \|\|
404	(winMsg->message == WINWM_MBUTTONDOWN) \|\|
405	(winMsg->message == WINWM_NCLBUTTONDOWN) \|\|
406	(winMsg->message == WINWM_NCRBUTTONDOWN) \|\|
407	(winMsg->message == WINWM_NCMBUTTONDOWN))
408	{
409	if(fGenerateDoubleClick && doubleClickMsg.message == winMsg->message &&
410	winMsg->time - doubleClickMsg.time < GetDoubleClickTime() &&
411	(abs(winMsg->pt.x - doubleClickMsg.pt.x) < GetSystemMetrics(SM_CXDOUBLECLK_W)/2) &&
412	(abs(winMsg->pt.y - doubleClickMsg.pt.y) < GetSystemMetrics(SM_CYDOUBLECLK_W)/2))
413	{
414	dprintf(("single -> double click"));
415	if(winMsg->message >= WINWM_LBUTTONDOWN) {
416	winMsg->message += (WINWM_LBUTTONDBLCLK - WINWM_LBUTTONDOWN);
417	}
418	else winMsg->message += (WINWM_LBUTTONDBLCLK - WINWM_NCLBUTTONDOWN);
419	if(fMsgRemoved) doubleClickMsg.message = 0;
420	}
421	else {
422	dprintf(("save for double click"));
423	if(fMsgRemoved) {
424	doubleClickMsg = *winMsg;
425	if(doubleClickMsg.message >= WINWM_NCLBUTTONDOWN && doubleClickMsg.message <= WINWM_NCMBUTTONDOWN) {
426	doubleClickMsg.message += (WINWM_LBUTTONDOWN - WINWM_NCLBUTTONDOWN);
427	}
428	}
429	}
430	}
431	EnableLogging();
432
433	if(fMsgRemoved == MSG_REMOVE)
434	{
435	MSLLHOOKSTRUCT hook;
436	ULONG msg;
437
438	if(winMsg->message >= WINWM_NCLBUTTONDOWN && winMsg->message <= WINWM_NCMBUTTONDBLCLK) {
439	msg = winMsg->message - WINWM_NCLBUTTONDOWN + WINWM_LBUTTONDOWN;
440	}
441	else msg = winMsg->message;
442
443	if(msg == WINWM_LBUTTONDBLCLK) {
444	msg = WINWM_LBUTTONDOWN;
445	}
446	else
447	if(msg == WINWM_RBUTTONDBLCLK) {
448	msg = WINWM_RBUTTONDOWN;
449	}
450	else
451	if(msg == WINWM_MBUTTONDBLCLK) {
452	msg = WINWM_MBUTTONDOWN;
453	}
454
455	hook.pt.x = os2Msg->ptl.x & 0xFFFF;
456	hook.pt.y = mapScreenY(os2Msg->ptl.y);
457	hook.mouseData = 0; //todo: XBUTTON1/2 (XP feature) or wheel data
458	hook.flags = 0; //todo: injected (LLMHF_INJECTED)
459	hook.time = winMsg->time;
460	hook.dwExtraInfo = 0;
461
462	if(HOOK_CallHooksW( WH_MOUSE_LL, HC_ACTION, msg, (LPARAM)&hook)) {
463	goto dummymessage; //hook swallowed message
464	}
465	}
466	break;
467	}
468
469	case WM_BUTTON2CLICK:
470	case WM_BUTTON1CLICK:
471	case WM_BUTTON3CLICK:
472	goto dummymessage;
473
474	case WM_BUTTON2MOTIONSTART:
475	case WM_BUTTON2MOTIONEND:
476	case WM_BUTTON1MOTIONSTART:
477	case WM_BUTTON1MOTIONEND:
478	case WM_BUTTON3MOTIONSTART:
479	case WM_BUTTON3MOTIONEND:
480	//no break; translate to WM_MOUSEMOVE
481	//Some applications (e.g. Unreal) retrieve all mouse messages
482	//when a mouse button is pressed and don't expect WM_NULL
483
484	case WM_MOUSEMOVE:
485	{
486	//WM_NCMOUSEMOVE is posted when the cursor moves into a non-client area of the window
487
488	HWND hwnd;
489
490	dprintf2(("WM_MOUSEMOVE (%d,%d)", winMsg->pt.x, winMsg->pt.y));
491	DisableLogging();
492	if(GetCapture() != winMsg->hwnd)
493	{
494	hwnd = WindowFromPoint(winMsg->pt);
495	if(win32wnd->getWindowHandle() != hwnd) {
496	RELEASE_WNDOBJ(win32wnd);
497	win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
498	if(win32wnd == NULL) {
499	DebugInt3();
500	EnableLogging();
501	goto dummymessage;
502	}
503	winMsg->hwnd = hwnd;
504	}
505	}
506
507	//if a window is disabled, its parent receives the mouse messages
508	if(!IsWindowEnabled(win32wnd->getWindowHandle())) {
509	if(win32wnd->getParent()) {
510	Win32BaseWindow *parent = win32wnd->getParent();;
511	if(parent) parent->addRef();
512	RELEASE_WNDOBJ(win32wnd);
513	win32wnd = parent;
514	}
515	fWasDisabled = TRUE;
516	}
517	if(IsNCMouseMsg(win32wnd))
518	{
519	winMsg->message = WINWM_NCMOUSEMOVE;
520	winMsg->wParam = (WPARAM)win32wnd->getLastHitTestVal();
521	winMsg->lParam = MAKELONG(winMsg->pt.x,winMsg->pt.y);
522	}
523	else
524	{
525	ClientPoint.x = winMsg->pt.x;
526	ClientPoint.y = winMsg->pt.y;
527	MapWindowPoints(0, win32wnd->getWindowHandle(), (LPPOINT)&ClientPoint, 1);
528
529	winMsg->message = WINWM_MOUSEMOVE;
530	winMsg->wParam = GetMouseKeyState();
531	winMsg->lParam = MAKELONG(ClientPoint.x, ClientPoint.y); //client coordinates
532	}
533	EnableLogging();
534	if(fWasDisabled) {
535	if(win32wnd) {
536	winMsg->hwnd = win32wnd->getWindowHandle();
537	}
538	else {
539	goto dummymessage; //don't send mouse messages to disabled windows
540	}
541	}
542	if(fMsgRemoved == MSG_REMOVE)
543	{
544	MSLLHOOKSTRUCT hook;
545
546	hook.pt.x = os2Msg->ptl.x & 0xFFFF;
547	hook.pt.y = mapScreenY(os2Msg->ptl.y);
548	hook.mouseData = 0;
549	hook.flags = 0; //todo: injected (LLMHF_INJECTED)
550	hook.time = winMsg->time;
551	hook.dwExtraInfo = 0;
552
553	if(HOOK_CallHooksW( WH_MOUSE_LL, HC_ACTION, winMsg->message, (LPARAM)&hook)) {
554	goto dummymessage; //hook swallowed message
555	}
556	}
557	break;
558	}
559
560	case WM_CONTROL:
561	goto dummymessage;
562
563	case WM_COMMAND:
564	if(SHORT1FROMMP(os2Msg->mp2) == CMDSRC_MENU) {
565	winMsg->message = WINWM_COMMAND;
566	winMsg->wParam = (WPARAM)SHORT1FROMMP(os2Msg->mp1); //id
567	break;
568	}
569	//todo controls
570	goto dummymessage;
571
572	case WM_SYSCOMMAND:
573	{
574	ULONG x = 0, y = 0;
575	ULONG win32sc;
576
577	if(SHORT2FROMMP(os2Msg->mp2) == TRUE) {//syscommand caused by mouse action
578	POINTL pointl;
579	WinQueryPointerPos(HWND_DESKTOP, &pointl);
580	x = pointl.x;
581	y = mapScreenY(y);
582	}
583	switch(SHORT1FROMMP(os2Msg->mp1)) {
584	case SC_MOVE:
585	win32sc = SC_MOVE_W;
586	break;
587	case SC_CLOSE:
588	{
589	//FALSE -> keyboard operation = user pressed Alt-F4 -> close app
590	//TRUE -> user clicked on close button -> close window
591	if(SHORT2FROMMP(os2Msg->mp2) == FALSE)
592	{
593	HWND hwnd = win32wnd->GetTopParent();
594	if(win32wnd->getWindowHandle() != hwnd) {
595	RELEASE_WNDOBJ(win32wnd);
596	win32wnd = Win32BaseWindow::GetWindowFromHandle(hwnd);
597	if(win32wnd == NULL) {
598	DebugInt3();
599	goto dummymessage;
600	}
601	winMsg->hwnd = hwnd;
602	}
603	}
604	win32sc = SC_CLOSE_W;
605	break;
606	}
607	case SC_MAXIMIZE:
608	win32sc = SC_MAXIMIZE_W;
609	break;
610	case SC_MINIMIZE:
611	win32sc = SC_MINIMIZE_W;
612	break;
613	case SC_NEXTFRAME:
614	case SC_NEXTWINDOW:
615	win32sc = SC_NEXTWINDOW_W;
616	break;
617	case SC_RESTORE:
618	win32sc = SC_RESTORE_W;
619	break;
620	case SC_TASKMANAGER:
621	win32sc = SC_TASKLIST_W;
622	break;
623	default:
624	dprintf(("Unknown/unsupported SC command %d", SHORT1FROMMP(os2Msg->mp1)));
625	goto dummymessage;
626	}
627	winMsg->message= WINWM_SYSCOMMAND;
628	winMsg->wParam = (WPARAM)win32sc;
629	winMsg->lParam = MAKELONG((USHORT)x, (USHORT)y);
630	break;
631	}
632
633	case WM_CHAR_SPECIAL_CONSOLE_BREAK:
634	{
635	dprintf(("PM: WM_CHAR_SPECIAL_CONSOLE_BREAK for %x", winMsg->hwnd));
636	if(fMsgRemoved)
637	{
638	GenerateConsoleCtrlEvent(CTRL_BREAK_EVENT_W,0);
639	// It is our internal message, do not work with it more, its function
640	// is over, otherwise it will return FALSE and will be dispatched,
641	// and retranslated once again.
642
643	winMsg->message = 0;
644	winMsg->wParam = 0;
645	winMsg->lParam = 0;
646	goto msgdone;
647	}
648	goto dummymessage;
649	}
650
651	case WM_CHAR_SPECIAL_ALTGRCONTROL:
652	{
653	// special char message from the keyboard hook
654	dprintf(("PM: WM_CHAR_SPECIAL_ALTGRCONTROL"));
655	// NO BREAK! FALLTHRU CASE!
656	}
657
658	case WM_CHAR_SPECIAL:
659	{
660	// @@@PH
661	// special char message from the keyboard hook
662	if(os2Msg->msg == WM_CHAR_SPECIAL) {
663	dprintf(("PM: WM_CHAR_SPECIAL"));
664	}
665	// NO BREAK! FALLTHRU CASE!
666	}
667
668	case WM_CHAR:
669	{
670	ULONG repeatCount=0;
671	ULONG virtualKey=0;
672	ULONG keyFlags=0;
673	USHORT scanCode=0;
674	ULONG flags = SHORT1FROMMP(os2Msg->mp1);
675	BOOL keyWasPressed;
676	BOOL numPressed = (BOOL)(WinGetKeyState(HWND_DESKTOP,VK_NUMLOCK) & 1);
677	char c;
678	USHORT usPMScanCode = CHAR4FROMMP(os2Msg->mp1);
679
680	teb->o.odin.fTranslated = FALSE;
681	repeatCount = CHAR3FROMMP(os2Msg->mp1);
682	scanCode = CHAR4FROMMP(os2Msg->mp1);
683	keyWasPressed = ((SHORT1FROMMP (os2Msg->mp1) & KC_PREVDOWN) == KC_PREVDOWN);
684
685	dprintf(("PM: WM_CHAR: %x %x rep=%d scancode=%x num=%d", SHORT1FROMMP(os2Msg->mp2), SHORT2FROMMP(os2Msg->mp2), repeatCount, scanCode, numPressed));
686	dprintf(("PM: WM_CHAR: hwnd %x flags %x mp1 %x, mp2 %x, time=%08xh", win32wnd->getWindowHandle(), flags, os2Msg->mp1, os2Msg->mp2, os2Msg->time));
687
688	BOOL fWinExtended;
689	BYTE bWinVKey;
690	WORD wWinScan;
691
692	if (scanCode==0) goto dummymessage;
693
694	KeyTranslatePMScanToWinVKey(usPMScanCode,
695	FALSE,
696	&bWinVKey,
697	&wWinScan,
698	&fWinExtended);
699	winMsg->wParam = bWinVKey;
700	winMsg->lParam = repeatCount & 0x0FFFF; // bit 0-15, repeatcount
701	winMsg->lParam \|= (wWinScan & 0x1FF) << 16; // bit 16-23, scancode + bit 15 extended
702
703	// Set the extended bit when appropriate
704	if (fWinExtended)
705	winMsg->lParam = winMsg->lParam \| WIN_KEY_EXTENDED;
706
707	//PF When we press shift we enable non-numeric functions of Numpad
708	if ((!numPressed \|\| (flags & KC_SHIFT)) && (scanCode >= PMSCAN_PAD7) && (scanCode <= PMSCAN_PADPERIOD))
709	winMsg->wParam = ConvertNumPadKey(scanCode);
710
711	//@PF This looks ugly but this is just what we have in win32 both in win98/win2k
712	//what happens is that lParam is tweaked in win32 to contain some illegal codes
713	//I simply reproduce here all situation. Absolute values can be kept because
714	//Break scancode can be acheived only by pressing Ctrl-Break combination
715	if ((usPMScanCode == PMSCAN_BREAK) && !(flags & KC_KEYUP) && (flags & KC_CTRL)
716	&& (fMsgRemoved && !(teb->o.odin.fTranslated)))
717	{
718	MSG extramsg;
719	memcpy(&extramsg, winMsg, sizeof(MSG));
720	// adjust our WM_CHAR code
721	extramsg.lParam = 0x01460001;
722
723	//After SetFocus(0), all keystrokes are converted in WM_SYS*
724	extramsg.message = (fIgnoreKeystrokes) ? WINWM_SYSCHAR : WINWM_CHAR;
725
726	setThreadQueueExtraCharMessage(teb, &extramsg);
727	// and finally adjust our WM_KEYDOWN code
728	winMsg->lParam = 0x01460001;
729	}
730
731	if (!(flags & KC_ALT))
732	{
733	//
734	// the Alt key is not pressed
735	// or no more pressed
736	//
737	if (flags & KC_KEYUP)
738	{
739	// check for a lonesome ALT key ...
740	// SvL: Only Left Alt; AltGr generates a WM_KEYUP when released
741	if ( (flags & KC_LONEKEY) &&
742	(winMsg->wParam == VK_LMENU_W) )
743	{
744	winMsg->message = WINWM_SYSKEYUP;
745	// held ALT-key when current key is released
746	// generates additional flag 0x2000000
747	// Note: PM seems to do this differently,
748	// KC_ALT is already reset
749	}
750	else
751	{
752	// send WM_KEYUP message
753	winMsg->message = WINWM_KEYUP;
754	}
755	winMsg->lParam \|= WIN_KEY_PREVSTATE; // bit 30, previous state, always 1 for a WM_KEYUP message
756	winMsg->lParam \|= 1 << 31; // bit 31, transition state, always 1 for WM_KEYUP
757	}
758	else
759	{ // send WM_KEYDOWN message
760	winMsg->message = WINWM_KEYDOWN;
761
762	if (keyWasPressed)
763	winMsg->lParam \|= WIN_KEY_PREVSTATE; // bit 30, previous state, 1 means key was pressed
764
765	//Shift-Enter and possibly others need to have special handling
766	if (flags & KC_SHIFT)
767	{
768	if(fMsgRemoved && !(teb->o.odin.fTranslated))
769	{
770	dprintf(("PM: KC_SHIFT: %x",winMsg->wParam));
771	if (winMsg->wParam == VK_RETURN_W)
772	{
773	MSG extramsg;
774	memcpy(&extramsg, winMsg, sizeof(MSG));
775
776	//After SetFocus(0), all keystrokes are converted in WM_SYS*
777	extramsg.message = (fIgnoreKeystrokes) ? WINWM_SYSCHAR : WINWM_CHAR;
778
779	// insert message into the queue
780	setThreadQueueExtraCharMessage(teb, &extramsg);
781	winMsg->lParam &= 0x3FFFFFFF;
782	}
783	} // else ???
784	} // KC_SHIFT
785	else
786	{
787	// in case we handle Enter directly through PMKBDHOOK
788	if ((os2Msg->msg == WM_CHAR_SPECIAL) && (winMsg->wParam == VK_RETURN_W)
789	&& (fMsgRemoved && !(teb->o.odin.fTranslated)))
790	{
791	MSG extramsg;
792	memcpy(&extramsg, winMsg, sizeof(MSG));
793
794	//After SetFocus(0), all keystrokes are converted in WM_SYS*
795	extramsg.message = (fIgnoreKeystrokes) ? WINWM_SYSCHAR : WINWM_CHAR;
796
797	// insert message into the queue
798	setThreadQueueExtraCharMessage(teb, &extramsg);
799	}
800	}
801	}
802	// if right alt is down, then we need to set the alt down bit too
803	// except for the fake Ctrl WM_CHAR sent for AltGr emulation
804	if (os2Msg->msg != WM_CHAR_SPECIAL_ALTGRCONTROL &&
805	(WinGetKeyState(HWND_DESKTOP, VK_ALTGRAF) & 0x8000))
806	{
807	winMsg->lParam \|= WIN_KEY_ALTHELD;
808	}
809	}
810	else
811	{
812	//
813	// the Alt key is pressed
814	//
815	if (flags & KC_KEYUP)
816	{
817	//@@PF Note that without pmkbdhook there will not be correct message for Alt-Enter
818	winMsg->message = WINWM_SYSKEYUP;
819	winMsg->lParam \|= WIN_KEY_PREVSTATE;
820	// No ALTHELD for Alt itself ;)
821	winMsg->lParam \|= WIN_KEY_ALTHELD;
822	winMsg->lParam \|= 1 << 31; // bit 31, transition state, always 1 for WM_KEYUP
823	}
824	else
825	{
826	// send WM_SYSKEYDOWN message
827	winMsg->message = WINWM_SYSKEYDOWN;
828	if (keyWasPressed)
829	winMsg->lParam \|= WIN_KEY_PREVSTATE; // bit 30, previous state, 1 means key was pressed
830
831	// pressed ALT-key generates additional flag 0x2000000
832	// if the current window has keyboard focus
833	winMsg->lParam \|= WIN_KEY_ALTHELD;
834	}
835	}
836	#if 0
837	//
838	// AltGr needs special handling
839	//
840	// AltGr -> WM_KEYDOWN (VK_CONTROL), WM_KEYDOWN (VK_MENU)
841	// WM_SYSKEYUP (VK_CONTROL)
842	// WM_KEYUP (VK_MENU)
843	//
844	// Ctrl+AltGr -> WM_KEYDOWN (VK_CONTROL), WM_KEYUP (VK_CONTROL)
845	// WM_KEYDOWN (VK_MENU)
846	// WM_KEYUP (VK_MENU)
847	// WM_KEYUP (VK_CONTROL)
848	//
849	// AltGr+Ctrl -> WM_KEYDOWN (VK_CONTROL), WM_KEYDOWN (VK_MENU)
850	// WM_KEYDOWN (VK_CONTROL)
851	// WM_SYSKEYUP (VK_CONTROL)
852	// WM_SYSKEYUP (VK_CONTROL)
853	// WM_KEYUP (VK_MENU)
854	//
855	// AltGr down -> if Ctrl down, send WM_KEYUP (VK_CONTROL)
856	// endif
857	// Send WM_KEYDOWN (VK_CONTROL)
858	// Send WM_KEYDOWN (VK_MENU)
859	// AltGr up -> if !(Ctrl down before AltGr was pressed \|\| Ctrl up)
860	// Send WM_SYSKEYUP (VK_CONTROL)
861	// endif
862	// Send WM_KEYDOWN (VK_MENU)
863	//
864	if(winMsg->wParam == VK_MENU_W && (winMsg->lParam & WIN_KEY_EXTENDED))
865	{//AltGr
866	if(GetKeyState(VK_CONTROL_W) & 0x8000)
867	{//Ctrl key pressed, send WM_KEYUP
868
869	}
870	}
871	#endif
872
873	//After SetFocus(0), all keystrokes are converted in WM_SYS*
874	if(fIgnoreKeystrokes) {
875	if(winMsg->message == WINWM_KEYDOWN) {
876	winMsg->message = WINWM_SYSKEYDOWN;
877	}
878	else
879	if(winMsg->message == WINWM_KEYUP) {
880	winMsg->message = WINWM_SYSKEYUP;
881	}
882	}
883	break;
884	}
885
886	case WM_TIMER:
887	//Why was this check here????
888	// if (os2Msg->mp2)
889	// {
890	BOOL sys;
891	ULONG id;
892
893	if (TIMER_GetTimerInfo(os2Msg->hwnd,(ULONG)os2Msg->mp1,&sys,&id))
894	{
895	winMsg->wParam = (WPARAM)id;
896	winMsg->message= (sys) ? WINWM_SYSTIMER : WINWM_TIMER;
897	break;
898	}
899	// }
900	goto dummymessage; //for caret blinking
901
902	case WM_SETWINDOWPARAMS:
903	{
904	WNDPARAMS wndParams = (WNDPARAMS )os2Msg->mp1;
905
906	if(wndParams->fsStatus & WPM_TEXT) {
907	winMsg->message = WINWM_SETTEXT;
908	winMsg->lParam = (LPARAM)wndParams->pszText;
909	break;
910	}
911	goto dummymessage;
912	}
913
914	#if 0
915	case WM_QUERYWINDOWPARAMS:
916	{
917	PWNDPARAMS wndpars = (PWNDPARAMS)mp1;
918	ULONG textlen;
919	PSZ wintext;
920
921	if(wndpars->fsStatus & (WPM_CCHTEXT \| WPM_TEXT))
922	{
923	if(wndpars->fsStatus & WPM_CCHTEXT)
924	wndpars->cchText = win32wnd->MsgGetTextLength();
925	if(wndpars->fsStatus & WPM_TEXT)
926	wndpars->pszText = win32wnd->MsgGetText();
927
928	wndpars->fsStatus = 0;
929	wndpars->cbCtlData = 0;
930	wndpars->cbPresParams = 0;
931	goto dummymessage;
932	}
933	}
934	#endif
935
936	case WM_PAINT:
937	{
938	if(win32wnd->IsWindowIconic()) {
939	winMsg->message = WINWM_PAINTICON;
940	}
941	else winMsg->message = WINWM_PAINT;
942	break;
943	}
944
945	case WM_CONTEXTMENU:
946	winMsg->message = WINWM_CONTEXTMENU;
947	winMsg->wParam = win32wnd->getWindowHandle();
948	winMsg->lParam = MAKELONG(winMsg->pt.x,winMsg->pt.y);
949	break;
950
951	case WM_RENDERFMT:
952	winMsg->message = WINWM_RENDERFORMAT;
953	winMsg->wParam = (UINT) os2Msg->mp1;
954	break;
955
956	case WM_RENDERALLFMTS:
957	winMsg->message = WINWM_RENDERALLFORMATS;
958	break;
959
960	case WM_DESTROYCLIPBOARD:
961	winMsg->message = WINWM_DESTROYCLIPBOARD;
962	break;
963
964	case WM_DRAWCLIPBOARD:
965	winMsg->message = WINWM_DRAWCLIPBOARD;
966	break;
967
968	case WM_HSCROLL:
969	case WM_VSCROLL:
970	//PF For win32 we support only vertical scrolling for WM_MOUSEWHEEL
971	if (os2Msg->msg == WM_VSCROLL)
972	{
973	POINT CursorPoint;
974	winMsg->message = WINWM_MOUSEWHEEL;
975	if (OSLibWinQueryPointerPos(&CursorPoint))
976	mapScreenPoint((OSLIBPOINT*)&CursorPoint);
977
978	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEDOWN)
979	winMsg->wParam = MAKELONG(GetMouseKeyState(), -WHEEL_DELTA/OS2_WHEEL_CORRECTION);
980	else
981	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEUP)
982	winMsg->wParam = MAKELONG(GetMouseKeyState(), WHEEL_DELTA/OS2_WHEEL_CORRECTION);
983	else
984	winMsg->wParam = MAKELONG(GetMouseKeyState(), 0);
985
986	winMsg->lParam = MAKELONG(CursorPoint.x, CursorPoint.y);
987
988	dprintf(("WM_MOUSEWHEEL message delta %d at (%d,%d)",HIWORD(winMsg->wParam),CursorPoint.x, CursorPoint.y));
989	if (fMsgRemoved == MSG_REMOVE)
990	{
991	MSLLHOOKSTRUCT hook;
992
993	hook.pt.x = os2Msg->ptl.x & 0xFFFF;
994	hook.pt.y = mapScreenY(os2Msg->ptl.y);
995	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEDOWN)
996	hook.mouseData = MAKELONG(GetMouseKeyState(), -WHEEL_DELTA/OS2_WHEEL_CORRECTION);
997	else
998	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEUP)
999	hook.mouseData = MAKELONG(GetMouseKeyState(), WHEEL_DELTA/OS2_WHEEL_CORRECTION);
1000	else goto dummymessage; // IBM driver produces other messages as well sometimes
1001
1002	hook.flags = LLMHF_INJECTED;
1003	hook.time = winMsg->time;
1004	hook.dwExtraInfo = 0;
1005	if(HOOK_CallHooksW( WH_MOUSE_LL, HC_ACTION, WINWM_MOUSEWHEEL, (LPARAM)&hook))
1006	goto dummymessage; //hook swallowed message
1007	}
1008	break;
1009	}
1010	goto dummymessage; //eat this message
1011	break;
1012
1013	case WM_INITMENU:
1014	case WM_MENUSELECT:
1015	case WM_MENUEND:
1016	case WM_NEXTMENU:
1017	case WM_SYSCOLORCHANGE:
1018	case WM_SYSVALUECHANGED:
1019	case WM_SETSELECTION:
1020	case WM_PPAINT:
1021	case WM_PSETFOCUS:
1022	case WM_PSYSCOLORCHANGE:
1023	case WM_PSIZE:
1024	case WM_PACTIVATE:
1025	case WM_PCONTROL:
1026	case WM_HELP:
1027	case WM_APPTERMINATENOTIFY:
1028	case WM_PRESPARAMCHANGED:
1029	case WM_DRAWITEM:
1030	case WM_MEASUREITEM:
1031	case WM_CONTROLPOINTER:
1032	case WM_QUERYDLGCODE:
1033	case WM_SUBSTITUTESTRING:
1034	case WM_MATCHMNEMONIC:
1035	case WM_SAVEAPPLICATION:
1036	case WM_SEMANTICEVENT:
1037	default:
1038	dummymessage:
1039	dprintf2(("dummy message %x %x %x %x", os2Msg->hwnd, os2Msg->msg, os2Msg->mp1, os2Msg->mp2));
1040	winMsg->message = 0;
1041	winMsg->wParam = 0;
1042	winMsg->lParam = 0;
1043	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
1044	return FALSE;
1045	}
1046	msgdone:
1047	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
1048	return TRUE;
1049	}
1050	//******************************************************************************
1051	//******************************************************************************
1052	BOOL OSLibWinTranslateMessage(MSG *msg)
1053	{
1054	TEB *teb;
1055	MSG extramsg;
1056	BOOL numPressed = (BOOL)(WinGetKeyState(HWND_DESKTOP,VK_NUMLOCK) & 1);
1057	teb = GetThreadTEB();
1058	if(!teb)
1059	return FALSE;
1060
1061	UCHAR ucPMScanCode = CHAR4FROMMP(teb->o.odin.os2msg.mp1);
1062	ULONG fl = SHORT1FROMMP(teb->o.odin.os2msg.mp1);
1063
1064
1065	//NOTE: These actually need to be posted so that the next message retrieved by GetMessage contains
1066	// the newly generated WM_CHAR message.
1067	if(!teb->o.odin.fTranslated &&
1068	teb->o.odin.os2msg.msg == WM_CHAR &&
1069	!((SHORT1FROMMP(teb->o.odin.os2msg.mp1) & KC_KEYUP) == KC_KEYUP))
1070	{
1071	//TranslatedMessage was called before DispatchMessage, so queue WM_CHAR message
1072	memcpy(&extramsg, msg, sizeof(MSG));
1073	extramsg.wParam = SHORT1FROMMP(teb->o.odin.os2msg.mp2);
1074	extramsg.lParam = 0;
1075
1076	// ESCAPE generates a WM_CHAR under windows, so take
1077	// special care for this here.
1078	switch (ucPMScanCode)
1079	{
1080	case PMSCAN_ESC:
1081	extramsg.wParam = VK_ESCAPE_W;
1082	fl \|= KC_CHAR;
1083	break;
1084	}
1085
1086	// PF With NumLock off do not generate any WM_CHAR messages at all
1087	// PADMINUS,PADPLUS fall in range of PAD7..PADPERIOD but they should generate WM_CHAR
1088	// other PAD(X) buttons miss that range at all and thus generate WM_CHAR
1089	if (!numPressed && (ucPMScanCode != PMSCAN_PADMINUS) && (ucPMScanCode != PMSCAN_PADPLUS) &&
1090	(ucPMScanCode >= PMSCAN_PAD7) && (ucPMScanCode <= PMSCAN_PADPERIOD))
1091	return FALSE;
1092
1093	if(!(fl & KC_CHAR) && msg->message < WINWM_SYSKEYDOWN)
1094	{
1095	return FALSE;
1096	}
1097
1098	//the KC_COMPOSITE flag might be set; in that case this key will
1099	//be combined with the previous dead key, so we must use the scancode
1100	//(e.g. ^ on german keyboards)
1101	if((fl & (KC_VIRTUALKEY\|KC_COMPOSITE)) == KC_VIRTUALKEY)
1102	{
1103	if(msg->wParam)
1104	{
1105	if ((msg->wParam >= VK_NUMPAD0_W) &&
1106	(msg->wParam <= VK_NUMPAD9_W))
1107	extramsg.wParam = msg->wParam - 0x30;
1108	else
1109	if (msg->wParam == VK_DECIMAL_W)
1110	extramsg.wParam = VK_DELETE_W;
1111	else
1112	/* PM Sends Bogus Things when pressing Shift+NUMAsterisk */
1113	if (msg->wParam != VK_MULTIPLY_W)
1114	extramsg.wParam = msg->wParam;
1115	}
1116	else
1117	extramsg.wParam = SHORT2FROMMP(teb->o.odin.os2msg.mp2);
1118	}
1119
1120
1121	//After SetFocus(0), all keystrokes are converted in WM_SYS*
1122	if(msg->message >= WINWM_SYSKEYDOWN \|\| fIgnoreKeystrokes)
1123	extramsg.message = WINWM_SYSCHAR;
1124	else
1125	extramsg.message = WINWM_CHAR;
1126
1127	if(fl & KC_DEADKEY)
1128	extramsg.message++; //WM_DEADCHAR/WM_SYSDEADCHAR
1129
1130
1131	extramsg.lParam = msg->lParam & 0x00FFFFFF;
1132	if ((fl & KC_ALT) \|\| (msg->lParam & WIN_KEY_ALTHELD))
1133	extramsg.lParam \|= WIN_KEY_ALTHELD;
1134	if(fl & KC_PREVDOWN)
1135	extramsg.lParam \|= WIN_KEY_PREVSTATE;
1136	if(fl & KC_KEYUP)
1137	extramsg.lParam \|= (1<<31);
1138
1139	// insert message into the queue
1140	setThreadQueueExtraCharMessage(teb, &extramsg);
1141	return TRUE;
1142	}
1143	return FALSE;
1144	}
1145	//******************************************************************************
1146	//******************************************************************************
1147

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

Download in other formats: