Context Navigation

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

Visit:

Last change on this file since 9944 was 9944, checked in by sandervl, 22 years ago
PF: changes for handling Ctrl-Break
File size: 39.9 KB

Line
1	/* $Id: oslibmsgtranslate.cpp,v 1.106 2003-03-27 13:54:18 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	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
643	return TRUE;
644
645	winMsg->message = 0;
646	winMsg->wParam = 0;
647	winMsg->lParam = 0;
648	goto msgdone;
649	}
650	goto dummymessage;
651	}
652
653	case WM_CHAR_SPECIAL_ALTGRCONTROL:
654	{
655	// special char message from the keyboard hook
656	dprintf(("PM: WM_CHAR_SPECIAL_ALTGRCONTROL"));
657	// NO BREAK! FALLTHRU CASE!
658	}
659
660	case WM_CHAR_SPECIAL:
661	{
662	// @@@PH
663	// special char message from the keyboard hook
664	if(os2Msg->msg == WM_CHAR_SPECIAL) {
665	dprintf(("PM: WM_CHAR_SPECIAL"));
666	}
667	// NO BREAK! FALLTHRU CASE!
668	}
669
670	case WM_CHAR:
671	{
672	ULONG repeatCount=0;
673	ULONG virtualKey=0;
674	ULONG keyFlags=0;
675	USHORT scanCode=0;
676	ULONG flags = SHORT1FROMMP(os2Msg->mp1);
677	BOOL keyWasPressed;
678	BOOL numPressed = (BOOL)(WinGetKeyState(HWND_DESKTOP,VK_NUMLOCK) & 1);
679	char c;
680	USHORT usPMScanCode = CHAR4FROMMP(os2Msg->mp1);
681
682	teb->o.odin.fTranslated = FALSE;
683	repeatCount = CHAR3FROMMP(os2Msg->mp1);
684	scanCode = CHAR4FROMMP(os2Msg->mp1);
685	keyWasPressed = ((SHORT1FROMMP (os2Msg->mp1) & KC_PREVDOWN) == KC_PREVDOWN);
686
687	dprintf(("PM: WM_CHAR: %x %x rep=%d scancode=%x num=%d", SHORT1FROMMP(os2Msg->mp2), SHORT2FROMMP(os2Msg->mp2), repeatCount, scanCode, numPressed));
688	dprintf(("PM: WM_CHAR: hwnd %x flags %x mp1 %x, mp2 %x, time=%08xh", win32wnd->getWindowHandle(), flags, os2Msg->mp1, os2Msg->mp2, os2Msg->time));
689
690	BOOL fWinExtended;
691	BYTE bWinVKey;
692	WORD wWinScan;
693
694	if (scanCode==0) goto dummymessage;
695
696	KeyTranslatePMScanToWinVKey(usPMScanCode,
697	FALSE,
698	&bWinVKey,
699	&wWinScan,
700	&fWinExtended);
701	winMsg->wParam = bWinVKey;
702	winMsg->lParam = repeatCount & 0x0FFFF; // bit 0-15, repeatcount
703	winMsg->lParam \|= (wWinScan & 0x1FF) << 16; // bit 16-23, scancode + bit 15 extended
704
705	// Set the extended bit when appropriate
706	if (fWinExtended)
707	winMsg->lParam = winMsg->lParam \| WIN_KEY_EXTENDED;
708
709	//PF When we press shift we enable non-numeric functions of Numpad
710	if ((!numPressed \|\| (flags & KC_SHIFT)) && (scanCode >= PMSCAN_PAD7) && (scanCode <= PMSCAN_PADPERIOD))
711	winMsg->wParam = ConvertNumPadKey(scanCode);
712
713	//@PF This looks ugly but this is just what we have in win32 both in win98/win2k
714	//what happens is that lParam is tweaked in win32 to contain some illegal codes
715	//I simply reproduce here all situation. Absolute values can be kept because
716	//Break scancode can be acheived only by pressing Ctrl-Break combination
717	if ((usPMScanCode == PMSCAN_BREAK) && !(flags & KC_KEYUP) && (flags & KC_CTRL)
718	&& (fMsgRemoved && !(teb->o.odin.fTranslated)))
719	{
720	MSG extramsg;
721	memcpy(&extramsg, winMsg, sizeof(MSG));
722	// adjust our WM_CHAR code
723	extramsg.lParam = 0x01460001;
724
725	//After SetFocus(0), all keystrokes are converted in WM_SYS*
726	extramsg.message = (fIgnoreKeystrokes) ? WINWM_SYSCHAR : WINWM_CHAR;
727
728	setThreadQueueExtraCharMessage(teb, &extramsg);
729	// and finally adjust our WM_KEYDOWN code
730	winMsg->lParam = 0x01460001;
731	}
732
733	if (!(flags & KC_ALT))
734	{
735	//
736	// the Alt key is not pressed
737	// or no more pressed
738	//
739	if (flags & KC_KEYUP)
740	{
741	// check for a lonesome ALT key ...
742	// SvL: Only Left Alt; AltGr generates a WM_KEYUP when released
743	if ( (flags & KC_LONEKEY) &&
744	(winMsg->wParam == VK_LMENU_W) )
745	{
746	winMsg->message = WINWM_SYSKEYUP;
747	// held ALT-key when current key is released
748	// generates additional flag 0x2000000
749	// Note: PM seems to do this differently,
750	// KC_ALT is already reset
751	}
752	else
753	{
754	// send WM_KEYUP message
755	winMsg->message = WINWM_KEYUP;
756	}
757	winMsg->lParam \|= WIN_KEY_PREVSTATE; // bit 30, previous state, always 1 for a WM_KEYUP message
758	winMsg->lParam \|= 1 << 31; // bit 31, transition state, always 1 for WM_KEYUP
759	}
760	else
761	{ // send WM_KEYDOWN message
762	winMsg->message = WINWM_KEYDOWN;
763
764	if (keyWasPressed)
765	winMsg->lParam \|= WIN_KEY_PREVSTATE; // bit 30, previous state, 1 means key was pressed
766
767	//Shift-Enter and possibly others need to have special handling
768	if (flags & KC_SHIFT)
769	{
770	if(fMsgRemoved && !(teb->o.odin.fTranslated))
771	{
772	dprintf(("PM: KC_SHIFT: %x",winMsg->wParam));
773	if (winMsg->wParam == VK_RETURN_W)
774	{
775	MSG extramsg;
776	memcpy(&extramsg, winMsg, sizeof(MSG));
777
778	//After SetFocus(0), all keystrokes are converted in WM_SYS*
779	extramsg.message = (fIgnoreKeystrokes) ? WINWM_SYSCHAR : WINWM_CHAR;
780
781	// insert message into the queue
782	setThreadQueueExtraCharMessage(teb, &extramsg);
783	winMsg->lParam &= 0x3FFFFFFF;
784	}
785	} // else ???
786	} // KC_SHIFT
787	else
788	{
789	// in case we handle Enter directly through PMKBDHOOK
790	if ((os2Msg->msg == WM_CHAR_SPECIAL) && (winMsg->wParam == VK_RETURN_W)
791	&& (fMsgRemoved && !(teb->o.odin.fTranslated)))
792	{
793	MSG extramsg;
794	memcpy(&extramsg, winMsg, sizeof(MSG));
795
796	//After SetFocus(0), all keystrokes are converted in WM_SYS*
797	extramsg.message = (fIgnoreKeystrokes) ? WINWM_SYSCHAR : WINWM_CHAR;
798
799	// insert message into the queue
800	setThreadQueueExtraCharMessage(teb, &extramsg);
801	}
802	}
803	}
804	// if right alt is down, then we need to set the alt down bit too
805	// except for the fake Ctrl WM_CHAR sent for AltGr emulation
806	if (os2Msg->msg != WM_CHAR_SPECIAL_ALTGRCONTROL &&
807	(WinGetKeyState(HWND_DESKTOP, VK_ALTGRAF) & 0x8000))
808	{
809	winMsg->lParam \|= WIN_KEY_ALTHELD;
810	}
811	}
812	else
813	{
814	//
815	// the Alt key is pressed
816	//
817	if (flags & KC_KEYUP)
818	{
819	//@@PF Note that without pmkbdhook there will not be correct message for Alt-Enter
820	winMsg->message = WINWM_SYSKEYUP;
821	winMsg->lParam \|= WIN_KEY_PREVSTATE;
822	// No ALTHELD for Alt itself ;)
823	winMsg->lParam \|= WIN_KEY_ALTHELD;
824	winMsg->lParam \|= 1 << 31; // bit 31, transition state, always 1 for WM_KEYUP
825	}
826	else
827	{
828	// send WM_SYSKEYDOWN message
829	winMsg->message = WINWM_SYSKEYDOWN;
830	if (keyWasPressed)
831	winMsg->lParam \|= WIN_KEY_PREVSTATE; // bit 30, previous state, 1 means key was pressed
832
833	// pressed ALT-key generates additional flag 0x2000000
834	// if the current window has keyboard focus
835	winMsg->lParam \|= WIN_KEY_ALTHELD;
836	}
837	}
838	#if 0
839	//
840	// AltGr needs special handling
841	//
842	// AltGr -> WM_KEYDOWN (VK_CONTROL), WM_KEYDOWN (VK_MENU)
843	// WM_SYSKEYUP (VK_CONTROL)
844	// WM_KEYUP (VK_MENU)
845	//
846	// Ctrl+AltGr -> WM_KEYDOWN (VK_CONTROL), WM_KEYUP (VK_CONTROL)
847	// WM_KEYDOWN (VK_MENU)
848	// WM_KEYUP (VK_MENU)
849	// WM_KEYUP (VK_CONTROL)
850	//
851	// AltGr+Ctrl -> WM_KEYDOWN (VK_CONTROL), WM_KEYDOWN (VK_MENU)
852	// WM_KEYDOWN (VK_CONTROL)
853	// WM_SYSKEYUP (VK_CONTROL)
854	// WM_SYSKEYUP (VK_CONTROL)
855	// WM_KEYUP (VK_MENU)
856	//
857	// AltGr down -> if Ctrl down, send WM_KEYUP (VK_CONTROL)
858	// endif
859	// Send WM_KEYDOWN (VK_CONTROL)
860	// Send WM_KEYDOWN (VK_MENU)
861	// AltGr up -> if !(Ctrl down before AltGr was pressed \|\| Ctrl up)
862	// Send WM_SYSKEYUP (VK_CONTROL)
863	// endif
864	// Send WM_KEYDOWN (VK_MENU)
865	//
866	if(winMsg->wParam == VK_MENU_W && (winMsg->lParam & WIN_KEY_EXTENDED))
867	{//AltGr
868	if(GetKeyState(VK_CONTROL_W) & 0x8000)
869	{//Ctrl key pressed, send WM_KEYUP
870
871	}
872	}
873	#endif
874
875	//After SetFocus(0), all keystrokes are converted in WM_SYS*
876	if(fIgnoreKeystrokes) {
877	if(winMsg->message == WINWM_KEYDOWN) {
878	winMsg->message = WINWM_SYSKEYDOWN;
879	}
880	else
881	if(winMsg->message == WINWM_KEYUP) {
882	winMsg->message = WINWM_SYSKEYUP;
883	}
884	}
885	break;
886	}
887
888	case WM_TIMER:
889	//Why was this check here????
890	// if (os2Msg->mp2)
891	// {
892	BOOL sys;
893	ULONG id;
894
895	if (TIMER_GetTimerInfo(os2Msg->hwnd,(ULONG)os2Msg->mp1,&sys,&id))
896	{
897	winMsg->wParam = (WPARAM)id;
898	winMsg->message= (sys) ? WINWM_SYSTIMER : WINWM_TIMER;
899	break;
900	}
901	// }
902	goto dummymessage; //for caret blinking
903
904	case WM_SETWINDOWPARAMS:
905	{
906	WNDPARAMS wndParams = (WNDPARAMS )os2Msg->mp1;
907
908	if(wndParams->fsStatus & WPM_TEXT) {
909	winMsg->message = WINWM_SETTEXT;
910	winMsg->lParam = (LPARAM)wndParams->pszText;
911	break;
912	}
913	goto dummymessage;
914	}
915
916	#if 0
917	case WM_QUERYWINDOWPARAMS:
918	{
919	PWNDPARAMS wndpars = (PWNDPARAMS)mp1;
920	ULONG textlen;
921	PSZ wintext;
922
923	if(wndpars->fsStatus & (WPM_CCHTEXT \| WPM_TEXT))
924	{
925	if(wndpars->fsStatus & WPM_CCHTEXT)
926	wndpars->cchText = win32wnd->MsgGetTextLength();
927	if(wndpars->fsStatus & WPM_TEXT)
928	wndpars->pszText = win32wnd->MsgGetText();
929
930	wndpars->fsStatus = 0;
931	wndpars->cbCtlData = 0;
932	wndpars->cbPresParams = 0;
933	goto dummymessage;
934	}
935	}
936	#endif
937
938	case WM_PAINT:
939	{
940	if(win32wnd->IsWindowIconic()) {
941	winMsg->message = WINWM_PAINTICON;
942	}
943	else winMsg->message = WINWM_PAINT;
944	break;
945	}
946
947	case WM_CONTEXTMENU:
948	winMsg->message = WINWM_CONTEXTMENU;
949	winMsg->wParam = win32wnd->getWindowHandle();
950	winMsg->lParam = MAKELONG(winMsg->pt.x,winMsg->pt.y);
951	break;
952
953	case WM_RENDERFMT:
954	winMsg->message = WINWM_RENDERFORMAT;
955	winMsg->wParam = (UINT) os2Msg->mp1;
956	break;
957
958	case WM_RENDERALLFMTS:
959	winMsg->message = WINWM_RENDERALLFORMATS;
960	break;
961
962	case WM_DESTROYCLIPBOARD:
963	winMsg->message = WINWM_DESTROYCLIPBOARD;
964	break;
965
966	case WM_DRAWCLIPBOARD:
967	winMsg->message = WINWM_DRAWCLIPBOARD;
968	break;
969
970	case WM_HSCROLL:
971	case WM_VSCROLL:
972	//PF For win32 we support only vertical scrolling for WM_MOUSEWHEEL
973	if (os2Msg->msg == WM_VSCROLL)
974	{
975	POINT CursorPoint;
976	winMsg->message = WINWM_MOUSEWHEEL;
977	if (OSLibWinQueryPointerPos(&CursorPoint))
978	mapScreenPoint((OSLIBPOINT*)&CursorPoint);
979
980	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEDOWN)
981	winMsg->wParam = MAKELONG(GetMouseKeyState(), -WHEEL_DELTA/OS2_WHEEL_CORRECTION);
982	else
983	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEUP)
984	winMsg->wParam = MAKELONG(GetMouseKeyState(), WHEEL_DELTA/OS2_WHEEL_CORRECTION);
985	else
986	winMsg->wParam = MAKELONG(GetMouseKeyState(), 0);
987
988	winMsg->lParam = MAKELONG(CursorPoint.x, CursorPoint.y);
989
990	dprintf(("WM_MOUSEWHEEL message delta %d at (%d,%d)",HIWORD(winMsg->wParam),CursorPoint.x, CursorPoint.y));
991	if (fMsgRemoved == MSG_REMOVE)
992	{
993	MSLLHOOKSTRUCT hook;
994
995	hook.pt.x = os2Msg->ptl.x & 0xFFFF;
996	hook.pt.y = mapScreenY(os2Msg->ptl.y);
997	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEDOWN)
998	hook.mouseData = MAKELONG(GetMouseKeyState(), -WHEEL_DELTA/OS2_WHEEL_CORRECTION);
999	else
1000	if (SHORT2FROMMP(os2Msg->mp2) == SB_LINEUP)
1001	hook.mouseData = MAKELONG(GetMouseKeyState(), WHEEL_DELTA/OS2_WHEEL_CORRECTION);
1002	else goto dummymessage; // IBM driver produces other messages as well sometimes
1003
1004	hook.flags = LLMHF_INJECTED;
1005	hook.time = winMsg->time;
1006	hook.dwExtraInfo = 0;
1007	if(HOOK_CallHooksW( WH_MOUSE_LL, HC_ACTION, WINWM_MOUSEWHEEL, (LPARAM)&hook))
1008	goto dummymessage; //hook swallowed message
1009	}
1010	break;
1011	}
1012	goto dummymessage; //eat this message
1013	break;
1014
1015	case WM_INITMENU:
1016	case WM_MENUSELECT:
1017	case WM_MENUEND:
1018	case WM_NEXTMENU:
1019	case WM_SYSCOLORCHANGE:
1020	case WM_SYSVALUECHANGED:
1021	case WM_SETSELECTION:
1022	case WM_PPAINT:
1023	case WM_PSETFOCUS:
1024	case WM_PSYSCOLORCHANGE:
1025	case WM_PSIZE:
1026	case WM_PACTIVATE:
1027	case WM_PCONTROL:
1028	case WM_HELP:
1029	case WM_APPTERMINATENOTIFY:
1030	case WM_PRESPARAMCHANGED:
1031	case WM_DRAWITEM:
1032	case WM_MEASUREITEM:
1033	case WM_CONTROLPOINTER:
1034	case WM_QUERYDLGCODE:
1035	case WM_SUBSTITUTESTRING:
1036	case WM_MATCHMNEMONIC:
1037	case WM_SAVEAPPLICATION:
1038	case WM_SEMANTICEVENT:
1039	default:
1040	dummymessage:
1041	dprintf2(("dummy message %x %x %x %x", os2Msg->hwnd, os2Msg->msg, os2Msg->mp1, os2Msg->mp2));
1042	winMsg->message = 0;
1043	winMsg->wParam = 0;
1044	winMsg->lParam = 0;
1045	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
1046	return FALSE;
1047	}
1048	msgdone:
1049	if(win32wnd) RELEASE_WNDOBJ(win32wnd);
1050	return TRUE;
1051	}
1052	//******************************************************************************
1053	//******************************************************************************
1054	BOOL OSLibWinTranslateMessage(MSG *msg)
1055	{
1056	TEB *teb;
1057	MSG extramsg;
1058	BOOL numPressed = (BOOL)(WinGetKeyState(HWND_DESKTOP,VK_NUMLOCK) & 1);
1059	teb = GetThreadTEB();
1060	if(!teb)
1061	return FALSE;
1062
1063	UCHAR ucPMScanCode = CHAR4FROMMP(teb->o.odin.os2msg.mp1);
1064	ULONG fl = SHORT1FROMMP(teb->o.odin.os2msg.mp1);
1065
1066
1067	//NOTE: These actually need to be posted so that the next message retrieved by GetMessage contains
1068	// the newly generated WM_CHAR message.
1069	if(!teb->o.odin.fTranslated &&
1070	teb->o.odin.os2msg.msg == WM_CHAR &&
1071	!((SHORT1FROMMP(teb->o.odin.os2msg.mp1) & KC_KEYUP) == KC_KEYUP))
1072	{
1073	//TranslatedMessage was called before DispatchMessage, so queue WM_CHAR message
1074	memcpy(&extramsg, msg, sizeof(MSG));
1075	extramsg.wParam = SHORT1FROMMP(teb->o.odin.os2msg.mp2);
1076	extramsg.lParam = 0;
1077
1078	// ESCAPE generates a WM_CHAR under windows, so take
1079	// special care for this here.
1080	switch (ucPMScanCode)
1081	{
1082	case PMSCAN_ESC:
1083	extramsg.wParam = VK_ESCAPE_W;
1084	fl \|= KC_CHAR;
1085	break;
1086	}
1087
1088	// PF With NumLock off do not generate any WM_CHAR messages at all
1089	// PADMINUS,PADPLUS fall in range of PAD7..PADPERIOD but they should generate WM_CHAR
1090	// other PAD(X) buttons miss that range at all and thus generate WM_CHAR
1091	if (!numPressed && (ucPMScanCode != PMSCAN_PADMINUS) && (ucPMScanCode != PMSCAN_PADPLUS) &&
1092	(ucPMScanCode >= PMSCAN_PAD7) && (ucPMScanCode <= PMSCAN_PADPERIOD))
1093	return FALSE;
1094
1095	if(!(fl & KC_CHAR) && msg->message < WINWM_SYSKEYDOWN)
1096	{
1097	return FALSE;
1098	}
1099
1100	//the KC_COMPOSITE flag might be set; in that case this key will
1101	//be combined with the previous dead key, so we must use the scancode
1102	//(e.g. ^ on german keyboards)
1103	if((fl & (KC_VIRTUALKEY\|KC_COMPOSITE)) == KC_VIRTUALKEY)
1104	{
1105	if(msg->wParam)
1106	{
1107	if ((msg->wParam >= VK_NUMPAD0_W) &&
1108	(msg->wParam <= VK_NUMPAD9_W))
1109	extramsg.wParam = msg->wParam - 0x30;
1110	else
1111	if (msg->wParam == VK_DECIMAL_W)
1112	extramsg.wParam = VK_DELETE_W;
1113	else
1114	/* PM Sends Bogus Things when pressing Shift+NUMAsterisk */
1115	if (msg->wParam != VK_MULTIPLY_W)
1116	extramsg.wParam = msg->wParam;
1117	}
1118	else
1119	extramsg.wParam = SHORT2FROMMP(teb->o.odin.os2msg.mp2);
1120	}
1121
1122
1123	//After SetFocus(0), all keystrokes are converted in WM_SYS*
1124	if(msg->message >= WINWM_SYSKEYDOWN \|\| fIgnoreKeystrokes)
1125	extramsg.message = WINWM_SYSCHAR;
1126	else
1127	extramsg.message = WINWM_CHAR;
1128
1129	if(fl & KC_DEADKEY)
1130	extramsg.message++; //WM_DEADCHAR/WM_SYSDEADCHAR
1131
1132
1133	extramsg.lParam = msg->lParam & 0x00FFFFFF;
1134	if ((fl & KC_ALT) \|\| (msg->lParam & WIN_KEY_ALTHELD))
1135	extramsg.lParam \|= WIN_KEY_ALTHELD;
1136	if(fl & KC_PREVDOWN)
1137	extramsg.lParam \|= WIN_KEY_PREVSTATE;
1138	if(fl & KC_KEYUP)
1139	extramsg.lParam \|= (1<<31);
1140
1141	// insert message into the queue
1142	setThreadQueueExtraCharMessage(teb, &extramsg);
1143	return TRUE;
1144	}
1145	return FALSE;
1146	}
1147	//******************************************************************************
1148	//******************************************************************************
1149

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

Download in other formats: