[WIN32K]
[reactos.git] / reactos / subsystems / win32 / win32k / ntuser / msgqueue.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: Message queues
5 * FILE: subsystems/win32/win32k/ntuser/msgqueue.c
6 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 Alexandre Julliard
8 Maarten Lankhorst
9 */
10
11 #include <win32k.h>
12 DBG_DEFAULT_CHANNEL(UserMsgQ);
13
14 /* GLOBALS *******************************************************************/
15
16 static PAGED_LOOKASIDE_LIST MessageLookasideList;
17 MOUSEMOVEPOINT MouseHistoryOfMoves[64];
18 INT gcur_count = 0;
19
20 /* FUNCTIONS *****************************************************************/
21
22 INIT_FUNCTION
23 NTSTATUS
24 NTAPI
25 MsqInitializeImpl(VOID)
26 {
27 ExInitializePagedLookasideList(&MessageLookasideList,
28 NULL,
29 NULL,
30 0,
31 sizeof(USER_MESSAGE),
32 TAG_USRMSG,
33 256);
34
35 return(STATUS_SUCCESS);
36 }
37
38 PWND FASTCALL
39 IntChildrenWindowFromPoint(PWND pWndTop, INT x, INT y)
40 {
41 PWND pWnd, pWndChild;
42
43 if (!(pWndTop->style & WS_VISIBLE)) return NULL;
44 if ((pWndTop->style & WS_DISABLED)) return NULL;
45 if (!IntPtInWindow(pWndTop, x, y)) return NULL;
46
47 if (x - pWndTop->rcClient.left < pWndTop->rcClient.right &&
48 y - pWndTop->rcClient.top < pWndTop->rcClient.bottom )
49 {
50 for (pWnd = pWndTop->spwndChild;
51 pWnd != NULL;
52 pWnd = pWnd->spwndNext)
53 {
54 if (pWnd->state2 & WNDS2_INDESTROY || pWnd->state & WNDS_DESTROYED )
55 {
56 TRACE("The Window is in DESTROY!\n");
57 continue;
58 }
59
60 pWndChild = IntChildrenWindowFromPoint(pWnd, x, y);
61
62 if (pWndChild)
63 {
64 return pWndChild;
65 }
66 }
67 }
68 return pWndTop;
69 }
70
71 PWND FASTCALL
72 IntTopLevelWindowFromPoint(INT x, INT y)
73 {
74 PWND pWnd, pwndDesktop;
75
76 /* Get the desktop window */
77 pwndDesktop = UserGetDesktopWindow();
78 if (!pwndDesktop)
79 return NULL;
80
81 /* Loop all top level windows */
82 for (pWnd = pwndDesktop->spwndChild;
83 pWnd != NULL;
84 pWnd = pWnd->spwndNext)
85 {
86 if (pWnd->state2 & WNDS2_INDESTROY || pWnd->state & WNDS_DESTROYED)
87 {
88 TRACE("The Window is in DESTROY!\n");
89 continue;
90 }
91
92 if ((pWnd->style & WS_VISIBLE) && IntPtInWindow(pWnd, x, y))
93 return pWnd;
94 }
95
96 /* Window has not been found */
97 return NULL;
98 }
99
100 PCURICON_OBJECT
101 FASTCALL
102 UserSetCursor(
103 PCURICON_OBJECT NewCursor,
104 BOOL ForceChange)
105 {
106 PCURICON_OBJECT OldCursor;
107 HDC hdcScreen;
108 PTHREADINFO pti;
109 PUSER_MESSAGE_QUEUE MessageQueue;
110 PWND pWnd;
111
112 pti = PsGetCurrentThreadWin32Thread();
113 MessageQueue = pti->MessageQueue;
114
115 /* Get the screen DC */
116 if(!(hdcScreen = IntGetScreenDC()))
117 {
118 return (HCURSOR)0;
119 }
120
121 OldCursor = MessageQueue->CursorObject;
122
123 /* Check if cursors are different */
124 if (OldCursor == NewCursor)
125 return OldCursor;
126
127 /* Update cursor for this message queue */
128 MessageQueue->CursorObject = NewCursor;
129
130 /* If cursor is not visible we have nothing to do */
131 if (MessageQueue->ShowingCursor < 0)
132 return OldCursor;
133
134 /* Update cursor if this message queue controls it */
135 pWnd = IntTopLevelWindowFromPoint(gpsi->ptCursor.x, gpsi->ptCursor.y);
136 if (pWnd && pWnd->head.pti->MessageQueue == MessageQueue)
137 {
138 if (NewCursor)
139 {
140 /* Call GDI to set the new screen cursor */
141 GreSetPointerShape(hdcScreen,
142 NewCursor->IconInfo.hbmMask,
143 NewCursor->IconInfo.hbmColor,
144 NewCursor->IconInfo.xHotspot,
145 NewCursor->IconInfo.yHotspot,
146 gpsi->ptCursor.x,
147 gpsi->ptCursor.y);
148 }
149 else /* Note: OldCursor != NewCursor so we have to hide cursor */
150 {
151 /* Remove the cursor */
152 GreMovePointer(hdcScreen, -1, -1);
153 TRACE("Removing pointer!\n");
154 }
155 IntGetSysCursorInfo()->CurrentCursorObject = NewCursor;
156 }
157
158 /* Return the old cursor */
159 return OldCursor;
160 }
161
162 /* Called from NtUserCallOneParam with Routine ONEPARAM_ROUTINE_SHOWCURSOR
163 * User32 macro NtUserShowCursor */
164 int UserShowCursor(BOOL bShow)
165 {
166 HDC hdcScreen;
167 PTHREADINFO pti;
168 PUSER_MESSAGE_QUEUE MessageQueue;
169 PWND pWnd;
170
171 if (!(hdcScreen = IntGetScreenDC()))
172 {
173 return -1; /* No mouse */
174 }
175
176 pti = PsGetCurrentThreadWin32Thread();
177 MessageQueue = pti->MessageQueue;
178
179 /* Update counter */
180 MessageQueue->ShowingCursor += bShow ? 1 : -1;
181
182 /* Check for trivial cases */
183 if ((bShow && MessageQueue->ShowingCursor != 0) ||
184 (!bShow && MessageQueue->ShowingCursor != -1))
185 {
186 /* Note: w don't update global info here because it is used only
187 internally to check if cursor is visible */
188 return MessageQueue->ShowingCursor;
189 }
190
191 /* Check if cursor is above window owned by this MessageQueue */
192 pWnd = IntTopLevelWindowFromPoint(gpsi->ptCursor.x, gpsi->ptCursor.y);
193 if (pWnd && pWnd->head.pti->MessageQueue == MessageQueue)
194 {
195 if (bShow)
196 {
197 /* Show the pointer */
198 GreMovePointer(hdcScreen, gpsi->ptCursor.x, gpsi->ptCursor.y);
199 TRACE("Showing pointer!\n");
200 }
201 else
202 {
203 /* Remove the pointer */
204 GreMovePointer(hdcScreen, -1, -1);
205 TRACE("Removing pointer!\n");
206 }
207
208 /* Update global info */
209 IntGetSysCursorInfo()->ShowingCursor = MessageQueue->ShowingCursor;
210 }
211
212 return MessageQueue->ShowingCursor;
213 }
214
215 DWORD FASTCALL UserGetKeyState(DWORD key)
216 {
217 DWORD ret = 0;
218 PTHREADINFO pti;
219 PUSER_MESSAGE_QUEUE MessageQueue;
220
221 pti = PsGetCurrentThreadWin32Thread();
222 MessageQueue = pti->MessageQueue;
223
224 if (key < 0x100)
225 {
226 ret = (DWORD)MessageQueue->KeyState[key];
227 if (MessageQueue->KeyState[key] & KS_DOWN_BIT)
228 ret |= 0xFF80; // If down, windows returns 0xFF80.
229 if (MessageQueue->KeyState[key] & KS_LOCK_BIT)
230 ret |= 0x1;
231 }
232 else
233 {
234 EngSetLastError(ERROR_INVALID_PARAMETER);
235 }
236 return ret;
237 }
238
239 /* change the input key state for a given key */
240 static void set_input_key_state( PUSER_MESSAGE_QUEUE MessageQueue, UCHAR key, BOOL down )
241 {
242 TRACE("set_input_key_state key:%d, down:%d\n", key, down);
243
244 if (down)
245 {
246 if (!(MessageQueue->KeyState[key] & KS_DOWN_BIT))
247 {
248 MessageQueue->KeyState[key] ^= KS_LOCK_BIT;
249 }
250 MessageQueue->KeyState[key] |= KS_DOWN_BIT;
251 }
252 else
253 {
254 MessageQueue->KeyState[key] &= ~KS_DOWN_BIT;
255 }
256 }
257
258 /* update the input key state for a keyboard message */
259 static void update_input_key_state( PUSER_MESSAGE_QUEUE MessageQueue, MSG* msg )
260 {
261 UCHAR key;
262 BOOL down = 0;
263
264 TRACE("update_input_key_state message:%d\n", msg->message);
265
266 switch (msg->message)
267 {
268 case WM_LBUTTONDOWN:
269 down = 1;
270 /* fall through */
271 case WM_LBUTTONUP:
272 set_input_key_state( MessageQueue, VK_LBUTTON, down );
273 break;
274 case WM_MBUTTONDOWN:
275 down = 1;
276 /* fall through */
277 case WM_MBUTTONUP:
278 set_input_key_state( MessageQueue, VK_MBUTTON, down );
279 break;
280 case WM_RBUTTONDOWN:
281 down = 1;
282 /* fall through */
283 case WM_RBUTTONUP:
284 set_input_key_state( MessageQueue, VK_RBUTTON, down );
285 break;
286 case WM_XBUTTONDOWN:
287 down = 1;
288 /* fall through */
289 case WM_XBUTTONUP:
290 if (msg->wParam == XBUTTON1)
291 set_input_key_state( MessageQueue, VK_XBUTTON1, down );
292 else if (msg->wParam == XBUTTON2)
293 set_input_key_state( MessageQueue, VK_XBUTTON2, down );
294 break;
295 case WM_KEYDOWN:
296 case WM_SYSKEYDOWN:
297 down = 1;
298 /* fall through */
299 case WM_KEYUP:
300 case WM_SYSKEYUP:
301 key = (UCHAR)msg->wParam;
302 set_input_key_state( MessageQueue, key, down );
303 switch(key)
304 {
305 case VK_LCONTROL:
306 case VK_RCONTROL:
307 down = (MessageQueue->KeyState[VK_LCONTROL] | MessageQueue->KeyState[VK_RCONTROL]) & KS_DOWN_BIT;
308 set_input_key_state( MessageQueue, VK_CONTROL, down );
309 break;
310 case VK_LMENU:
311 case VK_RMENU:
312 down = (MessageQueue->KeyState[VK_LMENU] | MessageQueue->KeyState[VK_RMENU]) & KS_DOWN_BIT;
313 set_input_key_state( MessageQueue, VK_MENU, down );
314 break;
315 case VK_LSHIFT:
316 case VK_RSHIFT:
317 down = (MessageQueue->KeyState[VK_LSHIFT] | MessageQueue->KeyState[VK_RSHIFT]) & KS_DOWN_BIT;
318 set_input_key_state( MessageQueue, VK_SHIFT, down );
319 break;
320 }
321 break;
322 }
323 }
324
325 HANDLE FASTCALL
326 IntMsqSetWakeMask(DWORD WakeMask)
327 {
328 PTHREADINFO Win32Thread;
329 PUSER_MESSAGE_QUEUE MessageQueue;
330 HANDLE MessageEventHandle;
331 DWORD dwFlags = HIWORD(WakeMask);
332
333 Win32Thread = PsGetCurrentThreadWin32Thread();
334 if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
335 return 0;
336
337 MessageQueue = Win32Thread->MessageQueue;
338 // Win32Thread->pEventQueueServer; IntMsqSetWakeMask returns Win32Thread->hEventQueueClient
339 MessageEventHandle = MessageQueue->NewMessagesHandle;
340
341 if (Win32Thread->pcti)
342 {
343 if ( (Win32Thread->pcti->fsChangeBits & LOWORD(WakeMask)) ||
344 ( (dwFlags & MWMO_INPUTAVAILABLE) && (Win32Thread->pcti->fsWakeBits & LOWORD(WakeMask)) ) )
345 {
346 ERR("Chg 0x%x Wake 0x%x Mask 0x%x\n",Win32Thread->pcti->fsChangeBits, Win32Thread->pcti->fsWakeBits, WakeMask);
347 KeSetEvent(MessageQueue->NewMessages, IO_NO_INCREMENT, FALSE); // Wake it up!
348 return MessageEventHandle;
349 }
350 }
351
352 IdlePing();
353
354 return MessageEventHandle;
355 }
356
357 BOOL FASTCALL
358 IntMsqClearWakeMask(VOID)
359 {
360 PTHREADINFO Win32Thread;
361
362 Win32Thread = PsGetCurrentThreadWin32Thread();
363 if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
364 return FALSE;
365 // Very hacky, but that is what they do.
366 Win32Thread->pcti->fsWakeBits = 0;
367
368 IdlePong();
369
370 return TRUE;
371 }
372
373 /*
374 Due to the uncertainty of knowing what was set in our multilevel message queue,
375 and even if the bits are all cleared. The same as cTimers/cPaintsReady.
376 I think this is the best solution... (jt) */
377 VOID FASTCALL
378 MsqWakeQueue(PUSER_MESSAGE_QUEUE Queue, DWORD MessageBits, BOOL KeyEvent)
379 {
380 PTHREADINFO pti;
381
382 pti = Queue->Thread->Tcb.Win32Thread;
383 pti->pcti->fsWakeBits |= MessageBits;
384 pti->pcti->fsChangeBits |= MessageBits;
385
386 // Start bit accounting to help clear the main set of bits.
387 if (MessageBits & QS_KEY) Queue->nCntsQBits[QSRosKey]++;
388 if (MessageBits & QS_MOUSEMOVE) Queue->nCntsQBits[QSRosMouseMove]++;
389 if (MessageBits & QS_MOUSEBUTTON) Queue->nCntsQBits[QSRosMouseButton]++;
390 if (MessageBits & QS_POSTMESSAGE) Queue->nCntsQBits[QSRosPostMessage]++;
391 if (MessageBits & QS_SENDMESSAGE) Queue->nCntsQBits[QSRosSendMessage]++;
392 if (MessageBits & QS_HOTKEY) Queue->nCntsQBits[QSRosHotKey]++;
393
394 if (KeyEvent)
395 KeSetEvent(Queue->NewMessages, IO_NO_INCREMENT, FALSE);
396 }
397
398 VOID FASTCALL
399 ClearMsgBitsMask(PUSER_MESSAGE_QUEUE Queue, UINT MessageBits)
400 {
401 PTHREADINFO pti;
402 UINT ClrMask = 0;
403
404 pti = Queue->Thread->Tcb.Win32Thread;
405
406 if (MessageBits & QS_KEY)
407 {
408 if (--Queue->nCntsQBits[QSRosKey] == 0) ClrMask |= QS_KEY;
409 }
410 if (MessageBits & QS_MOUSEMOVE) // ReactOS hard coded.
411 { // Account for tracking mouse moves..
412 if (--Queue->nCntsQBits[QSRosMouseMove] == 0) ClrMask |= QS_MOUSEMOVE;
413 // Handle mouse move bits here.
414 if (Queue->MouseMoved) ClrMask |= QS_MOUSEMOVE;
415 }
416 if (MessageBits & QS_MOUSEBUTTON)
417 {
418 if (--Queue->nCntsQBits[QSRosMouseButton] == 0) ClrMask |= QS_MOUSEBUTTON;
419 }
420 if (MessageBits & QS_POSTMESSAGE)
421 {
422 if (--Queue->nCntsQBits[QSRosPostMessage] == 0) ClrMask |= QS_POSTMESSAGE;
423 }
424 if (MessageBits & QS_TIMER) // ReactOS hard coded.
425 { // Handle timer bits here.
426 if ( pti->cTimersReady )
427 {
428 if (--pti->cTimersReady == 0) ClrMask |= QS_TIMER;
429 }
430 }
431 if (MessageBits & QS_PAINT) // ReactOS hard coded.
432 { // Handle paint bits here.
433 if ( pti->cPaintsReady )
434 {
435 if (--pti->cPaintsReady == 0) ClrMask |= QS_PAINT;
436 }
437 }
438 if (MessageBits & QS_SENDMESSAGE)
439 {
440 if (--Queue->nCntsQBits[QSRosSendMessage] == 0) ClrMask |= QS_SENDMESSAGE;
441 }
442 if (MessageBits & QS_HOTKEY)
443 {
444 if (--Queue->nCntsQBits[QSRosHotKey] == 0) ClrMask |= QS_HOTKEY;
445 }
446
447 pti->pcti->fsWakeBits &= ~ClrMask;
448 pti->pcti->fsChangeBits &= ~ClrMask;
449 }
450
451 VOID FASTCALL
452 MsqIncPaintCountQueue(PUSER_MESSAGE_QUEUE Queue)
453 {
454 PTHREADINFO pti;
455 pti = Queue->Thread->Tcb.Win32Thread;
456 pti->cPaintsReady++;
457 MsqWakeQueue(Queue, QS_PAINT, TRUE);
458 }
459
460 VOID FASTCALL
461 MsqDecPaintCountQueue(PUSER_MESSAGE_QUEUE Queue)
462 {
463 ClearMsgBitsMask(Queue, QS_PAINT);
464 }
465
466 VOID FASTCALL
467 MsqPostMouseMove(PUSER_MESSAGE_QUEUE MessageQueue, MSG* Msg)
468 {
469 MessageQueue->MouseMoveMsg = *Msg;
470 MessageQueue->MouseMoved = TRUE;
471 MsqWakeQueue(MessageQueue, QS_MOUSEMOVE, TRUE);
472 }
473
474 VOID FASTCALL
475 co_MsqInsertMouseMessage(MSG* Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
476 {
477 LARGE_INTEGER LargeTickCount;
478 MSLLHOOKSTRUCT MouseHookData;
479 PDESKTOP pDesk;
480 PWND pwnd, pwndDesktop;
481 HDC hdcScreen;
482 PSYSTEM_CURSORINFO CurInfo;
483
484 KeQueryTickCount(&LargeTickCount);
485 Msg->time = MsqCalculateMessageTime(&LargeTickCount);
486
487 MouseHookData.pt.x = LOWORD(Msg->lParam);
488 MouseHookData.pt.y = HIWORD(Msg->lParam);
489 switch (Msg->message)
490 {
491 case WM_MOUSEWHEEL:
492 MouseHookData.mouseData = MAKELONG(0, GET_WHEEL_DELTA_WPARAM(Msg->wParam));
493 break;
494 case WM_XBUTTONDOWN:
495 case WM_XBUTTONUP:
496 case WM_XBUTTONDBLCLK:
497 case WM_NCXBUTTONDOWN:
498 case WM_NCXBUTTONUP:
499 case WM_NCXBUTTONDBLCLK:
500 MouseHookData.mouseData = MAKELONG(0, HIWORD(Msg->wParam));
501 break;
502 default:
503 MouseHookData.mouseData = 0;
504 break;
505 }
506
507 MouseHookData.flags = flags; // LLMHF_INJECTED
508 MouseHookData.time = Msg->time;
509 MouseHookData.dwExtraInfo = dwExtraInfo;
510
511 /* If the hook procedure returned non zero, dont send the message */
512 if (Hook)
513 {
514 if (co_HOOK_CallHooks(WH_MOUSE_LL, HC_ACTION, Msg->message, (LPARAM) &MouseHookData))
515 return;
516 }
517
518 /* Get the desktop window */
519 pwndDesktop = UserGetDesktopWindow();
520 if (!pwndDesktop) return;
521 pDesk = pwndDesktop->head.rpdesk;
522
523 /* Check if the mouse is captured */
524 Msg->hwnd = IntGetCaptureWindow();
525 if (Msg->hwnd != NULL)
526 {
527 pwnd = UserGetWindowObject(Msg->hwnd);
528 }
529 else
530 {
531 pwnd = IntTopLevelWindowFromPoint(Msg->pt.x, Msg->pt.y);
532 if (pwnd) Msg->hwnd = pwnd->head.h;
533 }
534
535 if (pwnd)
536 {
537 /* If we a re tracking the mouse and it moves to another top level window */
538 if(pDesk->spwndTrack &&
539 UserGetAncestor(pDesk->spwndTrack, GA_ROOT) != pwnd)
540 {
541 /* Generate a WM_MOUSELEAVE message */
542 if ( pDesk->dwDTFlags & DF_TME_LEAVE )
543 {
544 MSG msgMouseLeave;
545
546 TRACE("co_MsqInsertMouseMessage: generating WM_MOUSELEAVE\n");
547
548 msgMouseLeave.hwnd = UserHMGetHandle(pDesk->spwndTrack);
549 msgMouseLeave.message = WM_MOUSELEAVE;
550 msgMouseLeave.pt = Msg->pt;
551 msgMouseLeave.time = Msg->time;
552 msgMouseLeave.lParam = msgMouseLeave.wParam = 0;
553
554 MsqPostMessage(pwnd->head.pti->MessageQueue, Msg, TRUE, QS_MOUSE);
555 }
556
557 /* Stop tracking */
558 if ( pDesk->dwDTFlags & DF_TME_HOVER )
559 {
560 IntKillTimer(pDesk->spwndTrack, ID_EVENT_SYSTIMER_MOUSEHOVER, TRUE);
561 }
562
563 pDesk->spwndTrack = NULL;
564 pDesk->htEx = 0;
565 }
566 }
567
568 hdcScreen = IntGetScreenDC();
569 CurInfo = IntGetSysCursorInfo();
570
571 /* Check if we found a window */
572 if (Msg->hwnd != NULL && pwnd != NULL)
573 {
574 if (Msg->message == WM_MOUSEMOVE)
575 {
576 PUSER_MESSAGE_QUEUE MessageQueue = pwnd->head.pti->MessageQueue;
577
578 /* Check if cursor should be visible */
579 if(hdcScreen &&
580 MessageQueue->CursorObject &&
581 MessageQueue->ShowingCursor >= 0)
582 {
583 /* Check if shape has changed */
584 if(CurInfo->CurrentCursorObject != MessageQueue->CursorObject)
585 {
586 /* Call GDI to set the new screen cursor */
587 GreSetPointerShape(hdcScreen,
588 MessageQueue->CursorObject->IconInfo.hbmMask,
589 MessageQueue->CursorObject->IconInfo.hbmColor,
590 MessageQueue->CursorObject->IconInfo.xHotspot,
591 MessageQueue->CursorObject->IconInfo.yHotspot,
592 gpsi->ptCursor.x,
593 gpsi->ptCursor.y);
594 } else
595 GreMovePointer(hdcScreen, Msg->pt.x, Msg->pt.y);
596 }
597 /* Check if w have to hide cursor */
598 else if (CurInfo->ShowingCursor >= 0)
599 GreMovePointer(hdcScreen, -1, -1);
600
601 /* Update global cursor info */
602 CurInfo->ShowingCursor = MessageQueue->ShowingCursor;
603 CurInfo->CurrentCursorObject = MessageQueue->CursorObject;
604
605 /* Mouse move is a special case */
606 MsqPostMouseMove(MessageQueue, Msg);
607 }
608 else
609 {
610 TRACE("Posting mouse message to hwnd=0x%x!\n", UserHMGetHandle(pwnd));
611 MsqPostMessage(pwnd->head.pti->MessageQueue, Msg, TRUE, QS_MOUSEBUTTON);
612 }
613 }
614 else if (hdcScreen)
615 {
616 /* always show cursor on background; FIXME: set default pointer */
617 GreMovePointer(hdcScreen, Msg->pt.x, Msg->pt.y);
618 CurInfo->ShowingCursor = 0;
619 }
620
621 /* Do GetMouseMovePointsEx FIFO. */
622 MouseHistoryOfMoves[gcur_count].x = Msg->pt.x;
623 MouseHistoryOfMoves[gcur_count].y = Msg->pt.y;
624 MouseHistoryOfMoves[gcur_count].time = Msg->time;
625 MouseHistoryOfMoves[gcur_count].dwExtraInfo = dwExtraInfo;
626 if (++gcur_count == ARRAYSIZE(MouseHistoryOfMoves))
627 gcur_count = 0; // 0 - 63 is 64, FIFO forwards.
628 }
629
630 //
631 // Note: Only called from input.c.
632 //
633 VOID FASTCALL
634 co_MsqPostKeyboardMessage(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL bInjected)
635 {
636 PUSER_MESSAGE_QUEUE FocusMessageQueue;
637 MSG Msg;
638 LARGE_INTEGER LargeTickCount;
639 KBDLLHOOKSTRUCT KbdHookData;
640
641 TRACE("MsqPostKeyboardMessage(uMsg 0x%x, wParam 0x%x, lParam 0x%x)\n",
642 uMsg, wParam, lParam);
643
644 // Condition may arise when calling MsqPostMessage and waiting for an event.
645 ASSERT(UserIsEntered());
646
647 FocusMessageQueue = IntGetFocusMessageQueue();
648
649 Msg.hwnd = 0;
650
651 if (FocusMessageQueue && (FocusMessageQueue->FocusWindow != (HWND)0))
652 Msg.hwnd = FocusMessageQueue->FocusWindow;
653
654 Msg.message = uMsg;
655 Msg.wParam = wParam;
656 Msg.lParam = lParam;
657
658 KeQueryTickCount(&LargeTickCount);
659 Msg.time = MsqCalculateMessageTime(&LargeTickCount);
660
661 /* We can't get the Msg.pt point here since we don't know thread
662 (and thus the window station) the message will end up in yet. */
663
664 KbdHookData.vkCode = Msg.wParam;
665 KbdHookData.scanCode = (Msg.lParam >> 16) & 0xff;
666 KbdHookData.flags = 0;
667 if (Msg.lParam & 0x01000000)
668 KbdHookData.flags |= LLKHF_EXTENDED;
669 if (Msg.lParam & 0x20000000)
670 KbdHookData.flags |= LLKHF_ALTDOWN;
671 if (Msg.lParam & 0x80000000)
672 KbdHookData.flags |= LLKHF_UP;
673 if (bInjected)
674 KbdHookData.flags |= LLKHF_INJECTED;
675 KbdHookData.time = Msg.time;
676 KbdHookData.dwExtraInfo = 0;
677 if (co_HOOK_CallHooks(WH_KEYBOARD_LL, HC_ACTION, Msg.message, (LPARAM) &KbdHookData))
678 {
679 ERR("Kbd msg %d wParam %d lParam 0x%08x dropped by WH_KEYBOARD_LL hook\n",
680 Msg.message, Msg.wParam, Msg.lParam);
681 return;
682 }
683
684 if (FocusMessageQueue == NULL)
685 {
686 TRACE("No focus message queue\n");
687 return;
688 }
689
690 if (FocusMessageQueue->FocusWindow != (HWND)0)
691 {
692 Msg.hwnd = FocusMessageQueue->FocusWindow;
693 TRACE("Msg.hwnd = %x\n", Msg.hwnd);
694
695 FocusMessageQueue->Desktop->pDeskInfo->LastInputWasKbd = TRUE;
696
697 Msg.pt = gpsi->ptCursor;
698 MsqPostMessage(FocusMessageQueue, &Msg, TRUE, QS_KEY);
699 }
700 else
701 {
702 TRACE("Invalid focus window handle\n");
703 }
704
705 return;
706 }
707
708 VOID FASTCALL
709 MsqPostHotKeyMessage(PVOID Thread, HWND hWnd, WPARAM wParam, LPARAM lParam)
710 {
711 PWND Window;
712 PTHREADINFO Win32Thread;
713 MSG Mesg;
714 LARGE_INTEGER LargeTickCount;
715 NTSTATUS Status;
716 INT id;
717 DWORD Type;
718
719 Status = ObReferenceObjectByPointer (Thread,
720 THREAD_ALL_ACCESS,
721 PsThreadType,
722 KernelMode);
723 if (!NT_SUCCESS(Status))
724 return;
725
726 Win32Thread = ((PETHREAD)Thread)->Tcb.Win32Thread;
727 if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
728 {
729 ObDereferenceObject ((PETHREAD)Thread);
730 return;
731 }
732
733 Window = IntGetWindowObject(hWnd);
734 if (!Window)
735 {
736 ObDereferenceObject ((PETHREAD)Thread);
737 return;
738 }
739
740 id = wParam; // Check for hot keys unrelated to the hot keys set by RegisterHotKey.
741
742 Mesg.hwnd = hWnd;
743 Mesg.message = id != IDHOT_REACTOS ? WM_HOTKEY : WM_SYSCOMMAND;
744 Mesg.wParam = id != IDHOT_REACTOS ? wParam : SC_HOTKEY;
745 Mesg.lParam = id != IDHOT_REACTOS ? lParam : (LPARAM)hWnd;
746 Type = id != IDHOT_REACTOS ? QS_HOTKEY : QS_POSTMESSAGE;
747 KeQueryTickCount(&LargeTickCount);
748 Mesg.time = MsqCalculateMessageTime(&LargeTickCount);
749 Mesg.pt = gpsi->ptCursor;
750 MsqPostMessage(Window->head.pti->MessageQueue, &Mesg, FALSE, Type);
751 UserDereferenceObject(Window);
752 ObDereferenceObject (Thread);
753
754 }
755
756 PUSER_MESSAGE FASTCALL
757 MsqCreateMessage(LPMSG Msg)
758 {
759 PUSER_MESSAGE Message;
760
761 Message = ExAllocateFromPagedLookasideList(&MessageLookasideList);
762 if (!Message)
763 {
764 return NULL;
765 }
766
767 RtlMoveMemory(&Message->Msg, Msg, sizeof(MSG));
768
769 return Message;
770 }
771
772 VOID FASTCALL
773 MsqDestroyMessage(PUSER_MESSAGE Message)
774 {
775 ExFreeToPagedLookasideList(&MessageLookasideList, Message);
776 }
777
778 BOOLEAN FASTCALL
779 co_MsqDispatchOneSentMessage(PUSER_MESSAGE_QUEUE MessageQueue)
780 {
781 PUSER_SENT_MESSAGE SaveMsg, Message;
782 PLIST_ENTRY Entry;
783 PTHREADINFO pti;
784 LRESULT Result = 0;
785
786 if (IsListEmpty(&MessageQueue->SentMessagesListHead))
787 {
788 return(FALSE);
789 }
790
791 /* remove it from the list of pending messages */
792 Entry = RemoveHeadList(&MessageQueue->SentMessagesListHead);
793 Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
794
795 pti = MessageQueue->Thread->Tcb.Win32Thread;
796
797 SaveMsg = pti->pusmCurrent;
798 pti->pusmCurrent = Message;
799
800 // Processing a message sent to it from another thread.
801 if ( ( Message->SenderQueue && MessageQueue != Message->SenderQueue) ||
802 ( Message->CallBackSenderQueue && MessageQueue != Message->CallBackSenderQueue ))
803 { // most likely, but, to be sure.
804 pti->pcti->CTI_flags |= CTI_INSENDMESSAGE; // Let the user know...
805 }
806
807 /* insert it to the list of messages that are currently dispatched by this
808 message queue */
809 InsertTailList(&MessageQueue->LocalDispatchingMessagesHead,
810 &Message->ListEntry);
811
812 ClearMsgBitsMask(MessageQueue, Message->QS_Flags);
813
814 if (Message->HookMessage == MSQ_ISHOOK)
815 { // Direct Hook Call processor
816 Result = co_CallHook( Message->Msg.message, // HookId
817 (INT)(INT_PTR)Message->Msg.hwnd, // Code
818 Message->Msg.wParam,
819 Message->Msg.lParam);
820 }
821 else if (Message->HookMessage == MSQ_ISEVENT)
822 { // Direct Event Call processor
823 Result = co_EVENT_CallEvents( Message->Msg.message,
824 Message->Msg.hwnd,
825 Message->Msg.wParam,
826 Message->Msg.lParam);
827 }
828 else if(Message->HookMessage == MSQ_INJECTMODULE)
829 {
830 Result = IntLoadHookModule(Message->Msg.message,
831 (HHOOK)Message->Msg.lParam,
832 Message->Msg.wParam);
833 }
834 else if ((Message->CompletionCallback)
835 && (Message->CallBackSenderQueue == MessageQueue))
836 { /* Call the callback routine */
837 if (Message->QS_Flags & QS_SMRESULT)
838 {
839 co_IntCallSentMessageCallback(Message->CompletionCallback,
840 Message->Msg.hwnd,
841 Message->Msg.message,
842 Message->CompletionCallbackContext,
843 Message->lResult);
844 /* Set callback to NULL to prevent reentry */
845 Message->CompletionCallback = NULL;
846 }
847 else
848 {
849 /* The message has not been processed yet, reinsert it. */
850 RemoveEntryList(&Message->ListEntry);
851 InsertTailList(&Message->CallBackSenderQueue->SentMessagesListHead, &Message->ListEntry);
852 TRACE("Callback Message not processed yet. Requeuing the message\n");
853 return (FALSE);
854 }
855 }
856 else
857 { /* Call the window procedure. */
858 Result = co_IntSendMessage( Message->Msg.hwnd,
859 Message->Msg.message,
860 Message->Msg.wParam,
861 Message->Msg.lParam);
862 }
863
864 /* remove the message from the local dispatching list, because it doesn't need
865 to be cleaned up on thread termination anymore */
866 RemoveEntryList(&Message->ListEntry);
867
868 /* If the message is a callback, insert it in the callback senders MessageQueue */
869 if (Message->CompletionCallback)
870 {
871 if (Message->CallBackSenderQueue)
872 {
873 Message->lResult = Result;
874 Message->QS_Flags |= QS_SMRESULT;
875
876 /* insert it in the callers message queue */
877 InsertTailList(&Message->CallBackSenderQueue->SentMessagesListHead, &Message->ListEntry);
878 MsqWakeQueue(Message->CallBackSenderQueue, QS_SENDMESSAGE, TRUE);
879 IntDereferenceMessageQueue(Message->CallBackSenderQueue);
880 }
881 return (TRUE);
882 }
883
884 /* remove the message from the dispatching list if needed, so lock the sender's message queue */
885 if (Message->SenderQueue)
886 {
887 if (Message->DispatchingListEntry.Flink != NULL)
888 {
889 /* only remove it from the dispatching list if not already removed by a timeout */
890 RemoveEntryList(&Message->DispatchingListEntry);
891 }
892 }
893 /* still keep the sender's message queue locked, so the sender can't exit the
894 MsqSendMessage() function (if timed out) */
895
896 if (Message->QS_Flags & QS_SMRESULT)
897 {
898 Result = Message->lResult;
899 }
900
901 /* Let the sender know the result. */
902 if (Message->Result != NULL)
903 {
904 *Message->Result = Result;
905 }
906
907 if (Message->HasPackedLParam == TRUE)
908 {
909 if (Message->Msg.lParam)
910 ExFreePool((PVOID)Message->Msg.lParam);
911 }
912
913 /* Notify the sender. */
914 if (Message->CompletionEvent != NULL)
915 {
916 KeSetEvent(Message->CompletionEvent, IO_NO_INCREMENT, FALSE);
917 }
918
919 /* if the message has a sender */
920 if (Message->SenderQueue)
921 {
922 /* dereference our and the sender's message queue */
923 IntDereferenceMessageQueue(Message->SenderQueue);
924 IntDereferenceMessageQueue(MessageQueue);
925 }
926
927 /* free the message */
928 ExFreePoolWithTag(Message, TAG_USRMSG);
929
930 /* do not hangup on the user if this is reentering */
931 if (!SaveMsg) pti->pcti->CTI_flags &= ~CTI_INSENDMESSAGE;
932 pti->pusmCurrent = SaveMsg;
933
934 return(TRUE);
935 }
936
937 VOID APIENTRY
938 MsqRemoveWindowMessagesFromQueue(PVOID pWindow)
939 {
940 PUSER_SENT_MESSAGE SentMessage;
941 PUSER_MESSAGE PostedMessage;
942 PUSER_MESSAGE_QUEUE MessageQueue;
943 PLIST_ENTRY CurrentEntry, ListHead;
944 PWND Window = pWindow;
945
946 ASSERT(Window);
947
948 MessageQueue = Window->head.pti->MessageQueue;
949 ASSERT(MessageQueue);
950
951 /* remove the posted messages for this window */
952 CurrentEntry = MessageQueue->PostedMessagesListHead.Flink;
953 ListHead = &MessageQueue->PostedMessagesListHead;
954 while (CurrentEntry != ListHead)
955 {
956 PostedMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
957 ListEntry);
958 if (PostedMessage->Msg.hwnd == Window->head.h)
959 {
960 RemoveEntryList(&PostedMessage->ListEntry);
961 ClearMsgBitsMask(MessageQueue, PostedMessage->QS_Flags);
962 MsqDestroyMessage(PostedMessage);
963 CurrentEntry = MessageQueue->PostedMessagesListHead.Flink;
964 }
965 else
966 {
967 CurrentEntry = CurrentEntry->Flink;
968 }
969 }
970
971 /* remove the sent messages for this window */
972 CurrentEntry = MessageQueue->SentMessagesListHead.Flink;
973 ListHead = &MessageQueue->SentMessagesListHead;
974 while (CurrentEntry != ListHead)
975 {
976 SentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
977 ListEntry);
978 if(SentMessage->Msg.hwnd == Window->head.h)
979 {
980 TRACE("Notify the sender and remove a message from the queue that had not been dispatched\n");
981
982 RemoveEntryList(&SentMessage->ListEntry);
983 ClearMsgBitsMask(MessageQueue, SentMessage->QS_Flags);
984
985 /* if it is a callback and this queue is not the sender queue, dereference queue */
986 if ((SentMessage->CompletionCallback) && (SentMessage->CallBackSenderQueue != MessageQueue))
987 {
988 IntDereferenceMessageQueue(SentMessage->CallBackSenderQueue);
989 }
990 /* Only if the message has a sender was the queue referenced */
991 if ((SentMessage->SenderQueue)
992 && (SentMessage->DispatchingListEntry.Flink != NULL))
993 {
994 RemoveEntryList(&SentMessage->DispatchingListEntry);
995 }
996
997 /* wake the sender's thread */
998 if (SentMessage->CompletionEvent != NULL)
999 {
1000 KeSetEvent(SentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
1001 }
1002
1003 if (SentMessage->HasPackedLParam == TRUE)
1004 {
1005 if (SentMessage->Msg.lParam)
1006 ExFreePool((PVOID)SentMessage->Msg.lParam);
1007 }
1008
1009 /* if the message has a sender */
1010 if (SentMessage->SenderQueue)
1011 {
1012 /* dereference our and the sender's message queue */
1013 IntDereferenceMessageQueue(MessageQueue);
1014 IntDereferenceMessageQueue(SentMessage->SenderQueue);
1015 }
1016
1017 /* free the message */
1018 ExFreePoolWithTag(SentMessage, TAG_USRMSG);
1019
1020 CurrentEntry = MessageQueue->SentMessagesListHead.Flink;
1021 }
1022 else
1023 {
1024 CurrentEntry = CurrentEntry->Flink;
1025 }
1026 }
1027 }
1028
1029 BOOL FASTCALL
1030 co_MsqSendMessageAsync(PTHREADINFO ptiReceiver,
1031 HWND hwnd,
1032 UINT Msg,
1033 WPARAM wParam,
1034 LPARAM lParam,
1035 SENDASYNCPROC CompletionCallback,
1036 ULONG_PTR CompletionCallbackContext,
1037 BOOL HasPackedLParam,
1038 INT HookMessage)
1039 {
1040
1041 PTHREADINFO ptiSender;
1042 PUSER_SENT_MESSAGE Message;
1043
1044 if(!(Message = ExAllocatePoolWithTag(NonPagedPool, sizeof(USER_SENT_MESSAGE), TAG_USRMSG)))
1045 {
1046 ERR("MsqSendMessage(): Not enough memory to allocate a message");
1047 return FALSE;
1048 }
1049
1050 ptiSender = PsGetCurrentThreadWin32Thread();
1051
1052 IntReferenceMessageQueue(ptiReceiver->MessageQueue);
1053 /* Take reference on this MessageQueue if its a callback. It will be released
1054 when message is processed or removed from target hwnd MessageQueue */
1055 if (CompletionCallback)
1056 IntReferenceMessageQueue(ptiSender->MessageQueue);
1057
1058 Message->Msg.hwnd = hwnd;
1059 Message->Msg.message = Msg;
1060 Message->Msg.wParam = wParam;
1061 Message->Msg.lParam = lParam;
1062 Message->CompletionEvent = NULL;
1063 Message->Result = 0;
1064 Message->lResult = 0;
1065 Message->SenderQueue = NULL;
1066 Message->CallBackSenderQueue = ptiSender->MessageQueue;
1067 Message->DispatchingListEntry.Flink = NULL;
1068 Message->CompletionCallback = CompletionCallback;
1069 Message->CompletionCallbackContext = CompletionCallbackContext;
1070 Message->HookMessage = HookMessage;
1071 Message->HasPackedLParam = HasPackedLParam;
1072 Message->QS_Flags = QS_SENDMESSAGE;
1073
1074 InsertTailList(&ptiReceiver->MessageQueue->SentMessagesListHead, &Message->ListEntry);
1075 MsqWakeQueue(ptiReceiver->MessageQueue, QS_SENDMESSAGE, TRUE);
1076 IntDereferenceMessageQueue(ptiReceiver->MessageQueue);
1077
1078 return TRUE;
1079 }
1080
1081 NTSTATUS FASTCALL
1082 co_MsqSendMessage(PUSER_MESSAGE_QUEUE MessageQueue,
1083 HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam,
1084 UINT uTimeout, BOOL Block, INT HookMessage,
1085 ULONG_PTR *uResult)
1086 {
1087 PTHREADINFO pti, ptirec;
1088 PUSER_SENT_MESSAGE Message;
1089 KEVENT CompletionEvent;
1090 NTSTATUS WaitStatus;
1091 PUSER_MESSAGE_QUEUE ThreadQueue;
1092 LARGE_INTEGER Timeout;
1093 PLIST_ENTRY Entry;
1094 LRESULT Result = 0; //// Result could be trashed. ////
1095
1096 if(!(Message = ExAllocatePoolWithTag(PagedPool, sizeof(USER_SENT_MESSAGE), TAG_USRMSG)))
1097 {
1098 ERR("MsqSendMessage(): Not enough memory to allocate a message");
1099 return STATUS_INSUFFICIENT_RESOURCES;
1100 }
1101
1102 KeInitializeEvent(&CompletionEvent, NotificationEvent, FALSE);
1103
1104 pti = PsGetCurrentThreadWin32Thread();
1105 ThreadQueue = pti->MessageQueue;
1106 ptirec = MessageQueue->Thread->Tcb.Win32Thread;
1107 ASSERT(ThreadQueue != MessageQueue);
1108 ASSERT(ptirec->pcti); // Send must have a client side to receive it!!!!
1109
1110 /* Don't send from or to a dying thread */
1111 if (pti->TIF_flags & TIF_INCLEANUP || ptirec->TIF_flags & TIF_INCLEANUP)
1112 {
1113 *uResult = -1;
1114 return STATUS_TIMEOUT;
1115 }
1116
1117 Timeout.QuadPart = (LONGLONG) uTimeout * (LONGLONG) -10000;
1118
1119 /* FIXME - increase reference counter of sender's message queue here */
1120
1121 Message->Msg.hwnd = Wnd;
1122 Message->Msg.message = Msg;
1123 Message->Msg.wParam = wParam;
1124 Message->Msg.lParam = lParam;
1125 Message->CompletionEvent = &CompletionEvent;
1126 Message->Result = &Result;
1127 Message->lResult = 0;
1128 Message->QS_Flags = 0;
1129 Message->SenderQueue = ThreadQueue;
1130 Message->CallBackSenderQueue = NULL;
1131 IntReferenceMessageQueue(ThreadQueue);
1132 Message->CompletionCallback = NULL;
1133 Message->CompletionCallbackContext = 0;
1134 Message->HookMessage = HookMessage;
1135 Message->HasPackedLParam = FALSE;
1136
1137 IntReferenceMessageQueue(MessageQueue);
1138
1139 /* add it to the list of pending messages */
1140 InsertTailList(&ThreadQueue->DispatchingMessagesHead, &Message->DispatchingListEntry);
1141
1142 /* queue it in the destination's message queue */
1143 InsertTailList(&MessageQueue->SentMessagesListHead, &Message->ListEntry);
1144
1145 Message->QS_Flags = QS_SENDMESSAGE;
1146 MsqWakeQueue(MessageQueue, QS_SENDMESSAGE, TRUE);
1147
1148 /* we can't access the Message anymore since it could have already been deleted! */
1149
1150 if(Block)
1151 {
1152 UserLeaveCo();
1153
1154 /* don't process messages sent to the thread */
1155 WaitStatus = KeWaitForSingleObject(&CompletionEvent, UserRequest, UserMode,
1156 FALSE, (uTimeout ? &Timeout : NULL));
1157
1158 UserEnterCo();
1159
1160 if(WaitStatus == STATUS_TIMEOUT)
1161 {
1162 /* look up if the message has not yet dispatched, if so
1163 make sure it can't pass a result and it must not set the completion event anymore */
1164 Entry = MessageQueue->SentMessagesListHead.Flink;
1165 while (Entry != &MessageQueue->SentMessagesListHead)
1166 {
1167 if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry)
1168 == Message)
1169 {
1170 /* we can access Message here, it's secure because the message queue is locked
1171 and the message is still hasn't been dispatched */
1172 Message->CompletionEvent = NULL;
1173 Message->Result = NULL;
1174 break;
1175 }
1176 Entry = Entry->Flink;
1177 }
1178
1179 /* remove from the local dispatching list so the other thread knows,
1180 it can't pass a result and it must not set the completion event anymore */
1181 Entry = ThreadQueue->DispatchingMessagesHead.Flink;
1182 while (Entry != &ThreadQueue->DispatchingMessagesHead)
1183 {
1184 if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, DispatchingListEntry)
1185 == Message)
1186 {
1187 /* we can access Message here, it's secure because the sender's message is locked
1188 and the message has definitely not yet been destroyed, otherwise it would
1189 have been removed from this list by the dispatching routine right after
1190 dispatching the message */
1191 Message->CompletionEvent = NULL;
1192 Message->Result = NULL;
1193 RemoveEntryList(&Message->DispatchingListEntry);
1194 Message->DispatchingListEntry.Flink = NULL;
1195 break;
1196 }
1197 Entry = Entry->Flink;
1198 }
1199
1200 TRACE("MsqSendMessage (blocked) timed out 1\n");
1201 }
1202 while (co_MsqDispatchOneSentMessage(ThreadQueue))
1203 ;
1204 }
1205 else
1206 {
1207 PVOID WaitObjects[2];
1208
1209 WaitObjects[0] = &CompletionEvent;
1210 WaitObjects[1] = ThreadQueue->NewMessages;
1211 do
1212 {
1213 UserLeaveCo();
1214
1215 WaitStatus = KeWaitForMultipleObjects(2, WaitObjects, WaitAny, UserRequest,
1216 UserMode, FALSE, (uTimeout ? &Timeout : NULL), NULL);
1217
1218 UserEnterCo();
1219
1220 if(WaitStatus == STATUS_TIMEOUT)
1221 {
1222 /* look up if the message has not yet been dispatched, if so
1223 make sure it can't pass a result and it must not set the completion event anymore */
1224 Entry = MessageQueue->SentMessagesListHead.Flink;
1225 while (Entry != &MessageQueue->SentMessagesListHead)
1226 {
1227 if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry)
1228 == Message)
1229 {
1230 /* we can access Message here, it's secure because the message queue is locked
1231 and the message is still hasn't been dispatched */
1232 Message->CompletionEvent = NULL;
1233 Message->Result = NULL;
1234 break;
1235 }
1236 Entry = Entry->Flink;
1237 }
1238
1239 /* remove from the local dispatching list so the other thread knows,
1240 it can't pass a result and it must not set the completion event anymore */
1241 Entry = ThreadQueue->DispatchingMessagesHead.Flink;
1242 while (Entry != &ThreadQueue->DispatchingMessagesHead)
1243 {
1244 if ((PUSER_SENT_MESSAGE) CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, DispatchingListEntry)
1245 == Message)
1246 {
1247 /* we can access Message here, it's secure because the sender's message is locked
1248 and the message has definitely not yet been destroyed, otherwise it would
1249 have been removed from this list by the dispatching routine right after
1250 dispatching the message */
1251 Message->CompletionEvent = NULL;
1252 Message->Result = NULL;
1253 RemoveEntryList(&Message->DispatchingListEntry);
1254 Message->DispatchingListEntry.Flink = NULL;
1255 break;
1256 }
1257 Entry = Entry->Flink;
1258 }
1259
1260 TRACE("MsqSendMessage timed out 2\n");
1261 break;
1262 }
1263 while (co_MsqDispatchOneSentMessage(ThreadQueue))
1264 ;
1265 }
1266 while (NT_SUCCESS(WaitStatus) && STATUS_WAIT_0 != WaitStatus);
1267 }
1268
1269 if(WaitStatus != STATUS_TIMEOUT)
1270 *uResult = (STATUS_WAIT_0 == WaitStatus ? Result : -1);
1271
1272 return WaitStatus;
1273 }
1274
1275 VOID FASTCALL
1276 MsqPostMessage(PUSER_MESSAGE_QUEUE MessageQueue, MSG* Msg, BOOLEAN HardwareMessage,
1277 DWORD MessageBits)
1278 {
1279 PUSER_MESSAGE Message;
1280
1281 if(!(Message = MsqCreateMessage(Msg)))
1282 {
1283 return;
1284 }
1285
1286 if(!HardwareMessage)
1287 {
1288 InsertTailList(&MessageQueue->PostedMessagesListHead,
1289 &Message->ListEntry);
1290 }
1291 else
1292 {
1293 InsertTailList(&MessageQueue->HardwareMessagesListHead,
1294 &Message->ListEntry);
1295
1296 update_input_key_state( MessageQueue, Msg );
1297 }
1298
1299 Message->QS_Flags = MessageBits;
1300 MsqWakeQueue(MessageQueue, MessageBits, (MessageBits & QS_TIMER ? FALSE : TRUE));
1301 }
1302
1303 VOID FASTCALL
1304 MsqPostQuitMessage(PUSER_MESSAGE_QUEUE MessageQueue, ULONG ExitCode)
1305 {
1306 MessageQueue->QuitPosted = TRUE;
1307 MessageQueue->QuitExitCode = ExitCode;
1308 MsqWakeQueue(MessageQueue, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE, TRUE);
1309 }
1310
1311 /***********************************************************************
1312 * MsqSendParentNotify
1313 *
1314 * Send a WM_PARENTNOTIFY to all ancestors of the given window, unless
1315 * the window has the WS_EX_NOPARENTNOTIFY style.
1316 */
1317 static void MsqSendParentNotify( PWND pwnd, WORD event, WORD idChild, POINT pt )
1318 {
1319 PWND pwndDesktop = UserGetWindowObject(IntGetDesktopWindow());
1320
1321 /* pt has to be in the client coordinates of the parent window */
1322 pt.x += pwndDesktop->rcClient.left - pwnd->rcClient.left;
1323 pt.y += pwndDesktop->rcClient.top - pwnd->rcClient.top;
1324
1325 for (;;)
1326 {
1327 PWND pwndParent;
1328
1329 if (!(pwnd->style & WS_CHILD)) break;
1330 if (pwnd->ExStyle & WS_EX_NOPARENTNOTIFY) break;
1331 if (!(pwndParent = IntGetParent(pwnd))) break;
1332 if (pwndParent == pwndDesktop) break;
1333 pt.x += pwnd->rcClient.left - pwndParent->rcClient.left;
1334 pt.y += pwnd->rcClient.top - pwndParent->rcClient.top;
1335
1336 pwnd = pwndParent;
1337 co_IntSendMessage( UserHMGetHandle(pwnd), WM_PARENTNOTIFY,
1338 MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
1339 }
1340 }
1341
1342 BOOL co_IntProcessMouseMessage(MSG* msg, BOOL* RemoveMessages, UINT first, UINT last)
1343 {
1344 MSG clk_msg;
1345 POINT pt;
1346 UINT message;
1347 USHORT hittest;
1348 EVENTMSG event;
1349 MOUSEHOOKSTRUCT hook;
1350 BOOL eatMsg;
1351
1352 PWND pwndMsg, pwndDesktop;
1353 PUSER_MESSAGE_QUEUE MessageQueue;
1354 PTHREADINFO pti;
1355 PSYSTEM_CURSORINFO CurInfo;
1356 PDESKTOP pDesk;
1357 DECLARE_RETURN(BOOL);
1358
1359 pti = PsGetCurrentThreadWin32Thread();
1360 pwndDesktop = UserGetDesktopWindow();
1361 MessageQueue = pti->MessageQueue;
1362 CurInfo = IntGetSysCursorInfo();
1363 pwndMsg = UserGetWindowObject(msg->hwnd);
1364 clk_msg = MessageQueue->msgDblClk;
1365 pDesk = pwndDesktop->head.rpdesk;
1366
1367 /* find the window to dispatch this mouse message to */
1368 if (MessageQueue->CaptureWindow)
1369 {
1370 hittest = HTCLIENT;
1371 pwndMsg = IntGetWindowObject(MessageQueue->CaptureWindow);
1372 }
1373 else
1374 {
1375 pwndMsg = co_WinPosWindowFromPoint(pwndMsg, &msg->pt, &hittest);
1376 }
1377
1378 TRACE("Got mouse message for 0x%x, hittest: 0x%x\n", msg->hwnd, hittest );
1379
1380 if (pwndMsg == NULL || pwndMsg->head.pti != pti)
1381 {
1382 /* Remove and ignore the message */
1383 *RemoveMessages = TRUE;
1384 RETURN(FALSE);
1385 }
1386
1387 /* If we a re tracking the mouse and it moves to another window */
1388 if(pDesk->spwndTrack &&
1389 pDesk->spwndTrack != pwndMsg &&
1390 msg->message != WM_MOUSELEAVE)
1391 {
1392 /* Generate a WM_MOUSELEAVE message */
1393 if ( pDesk->dwDTFlags & DF_TME_LEAVE )
1394 {
1395 MSG msgMouseLeave;
1396
1397 TRACE("co_IntProcessMouseMessage: generating WM_MOUSELEAVE\n");
1398
1399 msgMouseLeave.hwnd = UserHMGetHandle(pDesk->spwndTrack);
1400 msgMouseLeave.message = WM_MOUSELEAVE;
1401 msgMouseLeave.pt = msg->pt;
1402 msgMouseLeave.time = msg->time;
1403 msgMouseLeave.lParam = msgMouseLeave.wParam = 0;
1404
1405 MsqPostMessage(pwndMsg->head.pti->MessageQueue,
1406 &msgMouseLeave,
1407 TRUE,
1408 QS_MOUSE);
1409 }
1410
1411 /* Stop tracking */
1412 if ( pDesk->dwDTFlags & DF_TME_HOVER )
1413 {
1414 IntKillTimer(pDesk->spwndTrack, ID_EVENT_SYSTIMER_MOUSEHOVER, TRUE);
1415 }
1416
1417 pDesk->spwndTrack = NULL;
1418 pDesk->htEx = 0;
1419 }
1420
1421 if(pDesk->spwndTrack)
1422 {
1423 pDesk->htEx = hittest;
1424 }
1425
1426 msg->hwnd = UserHMGetHandle(pwndMsg);
1427
1428 #if 0
1429 if (!check_hwnd_filter( msg, hwnd_filter )) RETURN(FALSE);
1430 #endif
1431
1432 pt = msg->pt;
1433 message = msg->message;
1434 /* Note: windows has no concept of a non-client wheel message */
1435 if (message != WM_MOUSEWHEEL)
1436 {
1437 if (hittest != HTCLIENT)
1438 {
1439 message += WM_NCMOUSEMOVE - WM_MOUSEMOVE;
1440 msg->wParam = hittest;
1441 }
1442 else
1443 {
1444 /* coordinates don't get translated while tracking a menu */
1445 /* FIXME: should differentiate popups and top-level menus */
1446 if (!(MessageQueue->MenuOwner))
1447 {
1448 pt.x += pwndDesktop->rcClient.left - pwndMsg->rcClient.left;
1449 pt.y += pwndDesktop->rcClient.top - pwndMsg->rcClient.top;
1450 }
1451 }
1452 }
1453 msg->lParam = MAKELONG( pt.x, pt.y );
1454
1455 /* translate double clicks */
1456
1457 if ((msg->message == WM_LBUTTONDOWN) ||
1458 (msg->message == WM_RBUTTONDOWN) ||
1459 (msg->message == WM_MBUTTONDOWN) ||
1460 (msg->message == WM_XBUTTONDOWN))
1461 {
1462 BOOL update = *RemoveMessages;
1463
1464 /* translate double clicks -
1465 * note that ...MOUSEMOVEs can slip in between
1466 * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
1467
1468 if ((MessageQueue->MenuOwner || MessageQueue->MoveSize) ||
1469 hittest != HTCLIENT ||
1470 (pwndMsg->pcls->style & CS_DBLCLKS))
1471 {
1472 if ((msg->message == clk_msg.message) &&
1473 (msg->hwnd == clk_msg.hwnd) &&
1474 (msg->wParam == clk_msg.wParam) &&
1475 (msg->time - clk_msg.time < gspv.iDblClickTime) &&
1476 (abs(msg->pt.x - clk_msg.pt.x) < UserGetSystemMetrics(SM_CXDOUBLECLK)/2) &&
1477 (abs(msg->pt.y - clk_msg.pt.y) < UserGetSystemMetrics(SM_CYDOUBLECLK)/2))
1478 {
1479 message += (WM_LBUTTONDBLCLK - WM_LBUTTONDOWN);
1480 if (update)
1481 {
1482 MessageQueue->msgDblClk.message = 0; /* clear the double click conditions */
1483 update = FALSE;
1484 }
1485 }
1486 }
1487
1488 if (!((first == 0 && last == 0) || (message >= first || message <= last)))
1489 {
1490 TRACE("Message out of range!!!\n");
1491 RETURN(FALSE);
1492 }
1493
1494 /* update static double click conditions */
1495 if (update) MessageQueue->msgDblClk = *msg;
1496 }
1497 else
1498 {
1499 if (!((first == 0 && last == 0) || (message >= first || message <= last)))
1500 {
1501 TRACE("Message out of range!!!\n");
1502 RETURN(FALSE);
1503 }
1504 }
1505
1506 if(gspv.bMouseClickLock)
1507 {
1508 BOOL IsClkLck = FALSE;
1509
1510 if(msg->message == WM_LBUTTONUP)
1511 {
1512 IsClkLck = ((msg->time - CurInfo->ClickLockTime) >= gspv.dwMouseClickLockTime);
1513 if (IsClkLck && (!CurInfo->ClickLockActive))
1514 {
1515 CurInfo->ClickLockActive = TRUE;
1516 }
1517 }
1518 else if (msg->message == WM_LBUTTONDOWN)
1519 {
1520 if (CurInfo->ClickLockActive)
1521 {
1522 IsClkLck = TRUE;
1523 CurInfo->ClickLockActive = FALSE;
1524 }
1525
1526 CurInfo->ClickLockTime = msg->time;
1527 }
1528
1529 if(IsClkLck)
1530 {
1531 /* Remove and ignore the message */
1532 *RemoveMessages = TRUE;
1533 RETURN(FALSE);
1534 }
1535 }
1536
1537 /* message is accepted now (but may still get dropped) */
1538
1539 event.message = msg->message;
1540 event.time = msg->time;
1541 event.hwnd = msg->hwnd;
1542 event.paramL = msg->pt.x;
1543 event.paramH = msg->pt.y;
1544 co_HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&event );
1545
1546 hook.pt = msg->pt;
1547 hook.hwnd = msg->hwnd;
1548 hook.wHitTestCode = hittest;
1549 hook.dwExtraInfo = 0/*extra_info*/;
1550 if (co_HOOK_CallHooks( WH_MOUSE, *RemoveMessages ? HC_ACTION : HC_NOREMOVE,
1551 message, (LPARAM)&hook ))
1552 {
1553 hook.pt = msg->pt;
1554 hook.hwnd = msg->hwnd;
1555 hook.wHitTestCode = hittest;
1556 hook.dwExtraInfo = 0/*extra_info*/;
1557 co_HOOK_CallHooks( WH_CBT, HCBT_CLICKSKIPPED, message, (LPARAM)&hook );
1558
1559 ERR("WH_MOUSE dorpped mouse message!\n");
1560
1561 /* Remove and skip message */
1562 *RemoveMessages = TRUE;
1563 RETURN(FALSE);
1564 }
1565
1566 if ((hittest == HTERROR) || (hittest == HTNOWHERE))
1567 {
1568 co_IntSendMessage( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd,
1569 MAKELONG( hittest, msg->message ));
1570
1571 /* Remove and skip message */
1572 *RemoveMessages = TRUE;
1573 RETURN(FALSE);
1574 }
1575
1576 if ((*RemoveMessages == FALSE) || MessageQueue->CaptureWindow)
1577 {
1578 /* Accept the message */
1579 msg->message = message;
1580 RETURN(TRUE);
1581 }
1582
1583 eatMsg = FALSE;
1584
1585 if ((msg->message == WM_LBUTTONDOWN) ||
1586 (msg->message == WM_RBUTTONDOWN) ||
1587 (msg->message == WM_MBUTTONDOWN) ||
1588 (msg->message == WM_XBUTTONDOWN))
1589 {
1590 /* Send the WM_PARENTNOTIFY,
1591 * note that even for double/nonclient clicks
1592 * notification message is still WM_L/M/RBUTTONDOWN.
1593 */
1594 MsqSendParentNotify(pwndMsg, msg->message, 0, msg->pt );
1595
1596 /* Activate the window if needed */
1597
1598 if (msg->hwnd != UserGetForegroundWindow())
1599 {
1600 PWND pwndTop = pwndMsg;
1601 while (pwndTop)
1602 {
1603 if ((pwndTop->style & (WS_POPUP|WS_CHILD)) != WS_CHILD) break;
1604 pwndTop = IntGetParent( pwndTop );
1605 }
1606
1607 if (pwndTop && pwndTop != pwndDesktop)
1608 {
1609 LONG ret = co_IntSendMessage( msg->hwnd,
1610 WM_MOUSEACTIVATE,
1611 (WPARAM)UserHMGetHandle(pwndTop),
1612 MAKELONG( hittest, msg->message));
1613 switch(ret)
1614 {
1615 case MA_NOACTIVATEANDEAT:
1616 eatMsg = TRUE;
1617 /* fall through */
1618 case MA_NOACTIVATE:
1619 break;
1620 case MA_ACTIVATEANDEAT:
1621 eatMsg = TRUE;
1622 /* fall through */
1623 case MA_ACTIVATE:
1624 case 0:
1625 if(!co_IntMouseActivateWindow(pwndMsg)) eatMsg = TRUE;
1626 break;
1627 default:
1628 ERR( "unknown WM_MOUSEACTIVATE code %d\n", ret );
1629 break;
1630 }
1631 }
1632 }
1633 }
1634
1635 /* send the WM_SETCURSOR message */
1636
1637 /* Windows sends the normal mouse message as the message parameter
1638 in the WM_SETCURSOR message even if it's non-client mouse message */
1639 co_IntSendMessage( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd, MAKELONG( hittest, msg->message ));
1640
1641 msg->message = message;
1642 RETURN(!eatMsg);
1643
1644 CLEANUP:
1645 if(pwndMsg)
1646 UserDereferenceObject(pwndMsg);
1647
1648 END_CLEANUP;
1649 }
1650
1651 BOOL co_IntProcessKeyboardMessage(MSG* Msg, BOOL* RemoveMessages)
1652 {
1653 EVENTMSG Event;
1654
1655 if (Msg->message == WM_KEYDOWN || Msg->message == WM_SYSKEYDOWN ||
1656 Msg->message == WM_KEYUP || Msg->message == WM_SYSKEYUP)
1657 {
1658 switch (Msg->wParam)
1659 {
1660 case VK_LSHIFT: case VK_RSHIFT:
1661 Msg->wParam = VK_SHIFT;
1662 break;
1663 case VK_LCONTROL: case VK_RCONTROL:
1664 Msg->wParam = VK_CONTROL;
1665 break;
1666 case VK_LMENU: case VK_RMENU:
1667 Msg->wParam = VK_MENU;
1668 break;
1669 }
1670 }
1671
1672 Event.message = Msg->message;
1673 Event.hwnd = Msg->hwnd;
1674 Event.time = Msg->time;
1675 Event.paramL = (Msg->wParam & 0xFF) | (HIWORD(Msg->lParam) << 8);
1676 Event.paramH = Msg->lParam & 0x7FFF;
1677 if (HIWORD(Msg->lParam) & 0x0100) Event.paramH |= 0x8000;
1678 co_HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&Event);
1679
1680 if (co_HOOK_CallHooks( WH_KEYBOARD,
1681 *RemoveMessages ? HC_ACTION : HC_NOREMOVE,
1682 LOWORD(Msg->wParam),
1683 Msg->lParam))
1684 {
1685 /* skip this message */
1686 co_HOOK_CallHooks( WH_CBT,
1687 HCBT_KEYSKIPPED,
1688 LOWORD(Msg->wParam),
1689 Msg->lParam );
1690 ERR("KeyboardMessage WH_CBT Call Hook return!\n");
1691 return FALSE;
1692 }
1693 return TRUE;
1694 }
1695
1696 BOOL co_IntProcessHardwareMessage(MSG* Msg, BOOL* RemoveMessages, UINT first, UINT last)
1697 {
1698 if ( IS_MOUSE_MESSAGE(Msg->message))
1699 {
1700 return co_IntProcessMouseMessage(Msg, RemoveMessages, first, last);
1701 }
1702 else if ( IS_KBD_MESSAGE(Msg->message))
1703 {
1704 return co_IntProcessKeyboardMessage(Msg, RemoveMessages);
1705 }
1706
1707 return TRUE;
1708 }
1709
1710 BOOL APIENTRY
1711 co_MsqPeekMouseMove(IN PUSER_MESSAGE_QUEUE MessageQueue,
1712 IN BOOL Remove,
1713 IN PWND Window,
1714 IN UINT MsgFilterLow,
1715 IN UINT MsgFilterHigh,
1716 OUT MSG* pMsg)
1717 {
1718 BOOL AcceptMessage;
1719 MSG msg;
1720
1721 if(!(MessageQueue->MouseMoved))
1722 return FALSE;
1723
1724 msg = MessageQueue->MouseMoveMsg;
1725
1726 AcceptMessage = co_IntProcessMouseMessage(&msg, &Remove, MsgFilterLow, MsgFilterHigh);
1727
1728 if(AcceptMessage)
1729 *pMsg = msg;
1730
1731 if(Remove)
1732 {
1733 ClearMsgBitsMask(MessageQueue, QS_MOUSEMOVE);
1734 MessageQueue->MouseMoved = FALSE;
1735 }
1736
1737 return AcceptMessage;
1738 }
1739
1740 /* check whether a message filter contains at least one potential hardware message */
1741 static INT FASTCALL
1742 filter_contains_hw_range( UINT first, UINT last )
1743 {
1744 /* hardware message ranges are (in numerical order):
1745 * WM_NCMOUSEFIRST .. WM_NCMOUSELAST
1746 * WM_KEYFIRST .. WM_KEYLAST
1747 * WM_MOUSEFIRST .. WM_MOUSELAST
1748 */
1749 if (!last) --last;
1750 if (last < WM_NCMOUSEFIRST) return 0;
1751 if (first > WM_NCMOUSELAST && last < WM_KEYFIRST) return 0;
1752 if (first > WM_KEYLAST && last < WM_MOUSEFIRST) return 0;
1753 if (first > WM_MOUSELAST) return 0;
1754 return 1;
1755 }
1756
1757 BOOL APIENTRY
1758 co_MsqPeekHardwareMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
1759 IN BOOL Remove,
1760 IN PWND Window,
1761 IN UINT MsgFilterLow,
1762 IN UINT MsgFilterHigh,
1763 IN UINT QSflags,
1764 OUT MSG* pMsg)
1765 {
1766
1767 BOOL AcceptMessage;
1768 PUSER_MESSAGE CurrentMessage;
1769 PLIST_ENTRY ListHead, CurrentEntry = NULL;
1770 MSG msg;
1771
1772 if (!filter_contains_hw_range( MsgFilterLow, MsgFilterHigh )) return FALSE;
1773
1774 ListHead = &MessageQueue->HardwareMessagesListHead;
1775 CurrentEntry = ListHead->Flink;
1776
1777 if (IsListEmpty(CurrentEntry)) return FALSE;
1778
1779 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1780 ListEntry);
1781 do
1782 {
1783 if (IsListEmpty(CurrentEntry)) break;
1784 if (!CurrentMessage) break;
1785 CurrentEntry = CurrentMessage->ListEntry.Flink;
1786 /*
1787 MSDN:
1788 1: any window that belongs to the current thread, and any messages on the current thread's message queue whose hwnd value is NULL.
1789 2: retrieves only messages on the current thread's message queue whose hwnd value is NULL.
1790 3: handle to the window whose messages are to be retrieved.
1791 */
1792 if ( ( !Window || // 1
1793 ( Window == HWND_BOTTOM && CurrentMessage->Msg.hwnd == NULL ) || // 2
1794 ( Window != HWND_BOTTOM && Window->head.h == CurrentMessage->Msg.hwnd ) ) && // 3
1795 ( ( ( MsgFilterLow == 0 && MsgFilterHigh == 0 ) && CurrentMessage->QS_Flags & QSflags ) ||
1796 ( MsgFilterLow <= CurrentMessage->Msg.message && MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
1797 {
1798 msg = CurrentMessage->Msg;
1799
1800 AcceptMessage = co_IntProcessHardwareMessage(&msg, &Remove, MsgFilterLow, MsgFilterHigh);
1801
1802 if (Remove)
1803 {
1804 update_input_key_state(MessageQueue, &msg);
1805 RemoveEntryList(&CurrentMessage->ListEntry);
1806 ClearMsgBitsMask(MessageQueue, CurrentMessage->QS_Flags);
1807 MsqDestroyMessage(CurrentMessage);
1808 }
1809
1810 if (AcceptMessage)
1811 {
1812 *pMsg = msg;
1813 return TRUE;
1814 }
1815 }
1816 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1817 ListEntry);
1818 }
1819 while(CurrentEntry != ListHead);
1820
1821 return FALSE;
1822 }
1823
1824 BOOLEAN APIENTRY
1825 MsqPeekMessage(IN PUSER_MESSAGE_QUEUE MessageQueue,
1826 IN BOOLEAN Remove,
1827 IN PWND Window,
1828 IN UINT MsgFilterLow,
1829 IN UINT MsgFilterHigh,
1830 IN UINT QSflags,
1831 OUT PMSG Message)
1832 {
1833 PLIST_ENTRY CurrentEntry;
1834 PUSER_MESSAGE CurrentMessage;
1835 PLIST_ENTRY ListHead;
1836
1837 CurrentEntry = MessageQueue->PostedMessagesListHead.Flink;
1838 ListHead = &MessageQueue->PostedMessagesListHead;
1839
1840 if (IsListEmpty(CurrentEntry)) return FALSE;
1841
1842 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1843 ListEntry);
1844 do
1845 {
1846 if (IsListEmpty(CurrentEntry)) break;
1847 if (!CurrentMessage) break;
1848 CurrentEntry = CurrentEntry->Flink;
1849 /*
1850 MSDN:
1851 1: any window that belongs to the current thread, and any messages on the current thread's message queue whose hwnd value is NULL.
1852 2: retrieves only messages on the current thread's message queue whose hwnd value is NULL.
1853 3: handle to the window whose messages are to be retrieved.
1854 */
1855 if ( ( !Window || // 1
1856 ( Window == HWND_BOTTOM && CurrentMessage->Msg.hwnd == NULL ) || // 2
1857 ( Window != HWND_BOTTOM && Window->head.h == CurrentMessage->Msg.hwnd ) ) && // 3
1858 ( ( ( MsgFilterLow == 0 && MsgFilterHigh == 0 ) && CurrentMessage->QS_Flags & QSflags ) ||
1859 ( MsgFilterLow <= CurrentMessage->Msg.message && MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
1860 {
1861 *Message = CurrentMessage->Msg;
1862
1863 if (Remove)
1864 {
1865 RemoveEntryList(&CurrentMessage->ListEntry);
1866 ClearMsgBitsMask(MessageQueue, CurrentMessage->QS_Flags);
1867 MsqDestroyMessage(CurrentMessage);
1868 }
1869 return(TRUE);
1870 }
1871 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1872 ListEntry);
1873 }
1874 while (CurrentEntry != ListHead);
1875
1876 return(FALSE);
1877 }
1878
1879 NTSTATUS FASTCALL
1880 co_MsqWaitForNewMessages(PUSER_MESSAGE_QUEUE MessageQueue, PWND WndFilter,
1881 UINT MsgFilterMin, UINT MsgFilterMax)
1882 {
1883 NTSTATUS ret;
1884 UserLeaveCo();
1885 ret = KeWaitForSingleObject( MessageQueue->NewMessages,
1886 UserRequest,
1887 UserMode,
1888 FALSE,
1889 NULL );
1890 UserEnterCo();
1891 return ret;
1892 }
1893
1894 BOOL FASTCALL
1895 MsqIsHung(PUSER_MESSAGE_QUEUE MessageQueue)
1896 {
1897 LARGE_INTEGER LargeTickCount;
1898
1899 KeQueryTickCount(&LargeTickCount);
1900 return ((LargeTickCount.u.LowPart - MessageQueue->LastMsgRead) > MSQ_HUNG);
1901 }
1902
1903 VOID
1904 CALLBACK
1905 HungAppSysTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
1906 {
1907 DoTheScreenSaver();
1908 TRACE("HungAppSysTimerProc\n");
1909 // Process list of windows that are hung and waiting.
1910 }
1911
1912 BOOLEAN FASTCALL
1913 MsqInitializeMessageQueue(struct _ETHREAD *Thread, PUSER_MESSAGE_QUEUE MessageQueue)
1914 {
1915 LARGE_INTEGER LargeTickCount;
1916 NTSTATUS Status;
1917
1918 MessageQueue->Thread = Thread;
1919 MessageQueue->CaretInfo = (PTHRDCARETINFO)(MessageQueue + 1);
1920 InitializeListHead(&MessageQueue->PostedMessagesListHead);
1921 InitializeListHead(&MessageQueue->SentMessagesListHead);
1922 InitializeListHead(&MessageQueue->HardwareMessagesListHead);
1923 InitializeListHead(&MessageQueue->DispatchingMessagesHead);
1924 InitializeListHead(&MessageQueue->LocalDispatchingMessagesHead);
1925 MessageQueue->QuitPosted = FALSE;
1926 MessageQueue->QuitExitCode = 0;
1927 KeQueryTickCount(&LargeTickCount);
1928 MessageQueue->LastMsgRead = LargeTickCount.u.LowPart;
1929 MessageQueue->FocusWindow = NULL;
1930 MessageQueue->NewMessagesHandle = NULL;
1931 MessageQueue->ShowingCursor = 0;
1932 MessageQueue->CursorObject = NULL;
1933 RtlCopyMemory(MessageQueue->KeyState, gafAsyncKeyState, sizeof(gafAsyncKeyState));
1934
1935 Status = ZwCreateEvent(&MessageQueue->NewMessagesHandle, EVENT_ALL_ACCESS,
1936 NULL, SynchronizationEvent, FALSE);
1937 if (!NT_SUCCESS(Status))
1938 {
1939 return FALSE;
1940 }
1941
1942 Status = ObReferenceObjectByHandle(MessageQueue->NewMessagesHandle, 0,
1943 ExEventObjectType, KernelMode,
1944 (PVOID*)&MessageQueue->NewMessages, NULL);
1945 if (!NT_SUCCESS(Status))
1946 {
1947 ZwClose(MessageQueue->NewMessagesHandle);
1948 MessageQueue->NewMessagesHandle = NULL;
1949 return FALSE;
1950 }
1951
1952 return TRUE;
1953 }
1954
1955 VOID FASTCALL
1956 MsqCleanupMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
1957 {
1958 PLIST_ENTRY CurrentEntry;
1959 PUSER_MESSAGE CurrentMessage;
1960 PUSER_SENT_MESSAGE CurrentSentMessage;
1961 PTHREADINFO pti;
1962
1963 pti = MessageQueue->Thread->Tcb.Win32Thread;
1964
1965
1966 /* cleanup posted messages */
1967 while (!IsListEmpty(&MessageQueue->PostedMessagesListHead))
1968 {
1969 CurrentEntry = RemoveHeadList(&MessageQueue->PostedMessagesListHead);
1970 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE,
1971 ListEntry);
1972 MsqDestroyMessage(CurrentMessage);
1973 }
1974
1975 /* remove the messages that have not yet been dispatched */
1976 while (!IsListEmpty(&MessageQueue->SentMessagesListHead))
1977 {
1978 CurrentEntry = RemoveHeadList(&MessageQueue->SentMessagesListHead);
1979 CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
1980 ListEntry);
1981
1982 /* if it is a callback and this queue is not the sender queue, dereference queue */
1983 if ((CurrentSentMessage->CompletionCallback) && (CurrentSentMessage->CallBackSenderQueue != MessageQueue))
1984 {
1985 IntDereferenceMessageQueue(CurrentSentMessage->CallBackSenderQueue);
1986 }
1987
1988 TRACE("Notify the sender and remove a message from the queue that had not been dispatched\n");
1989 /* Only if the message has a sender was the message in the DispatchingList */
1990 if ((CurrentSentMessage->SenderQueue)
1991 && (CurrentSentMessage->DispatchingListEntry.Flink != NULL))
1992 {
1993 RemoveEntryList(&CurrentSentMessage->DispatchingListEntry);
1994 }
1995
1996 /* wake the sender's thread */
1997 if (CurrentSentMessage->CompletionEvent != NULL)
1998 {
1999 KeSetEvent(CurrentSentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
2000 }
2001
2002 if (CurrentSentMessage->HasPackedLParam == TRUE)
2003 {
2004 if (CurrentSentMessage->Msg.lParam)
2005 ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
2006 }
2007
2008 /* if the message has a sender */
2009 if (CurrentSentMessage->SenderQueue)
2010 {
2011 /* dereference our and the sender's message queue */
2012 IntDereferenceMessageQueue(MessageQueue);
2013 IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
2014 }
2015
2016 /* free the message */
2017 ExFreePool(CurrentSentMessage);
2018 }
2019
2020 /* notify senders of dispatching messages. This needs to be cleaned up if e.g.
2021 ExitThread() was called in a SendMessage() umode callback */
2022 while (!IsListEmpty(&MessageQueue->LocalDispatchingMessagesHead))
2023 {
2024 CurrentEntry = RemoveHeadList(&MessageQueue->LocalDispatchingMessagesHead);
2025 CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
2026 ListEntry);
2027
2028 /* if it is a callback and this queue is not the sender queue, dereference queue */
2029 if ((CurrentSentMessage->CompletionCallback) && (CurrentSentMessage->CallBackSenderQueue != MessageQueue))
2030 {
2031 IntDereferenceMessageQueue(CurrentSentMessage->CallBackSenderQueue);
2032 }
2033
2034 /* remove the message from the dispatching list */
2035 if(CurrentSentMessage->DispatchingListEntry.Flink != NULL)
2036 {
2037 RemoveEntryList(&CurrentSentMessage->DispatchingListEntry);
2038 }
2039
2040 TRACE("Notify the sender, the thread has been terminated while dispatching a message!\n");
2041
2042 /* wake the sender's thread */
2043 if (CurrentSentMessage->CompletionEvent != NULL)
2044 {
2045 KeSetEvent(CurrentSentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
2046 }
2047
2048 if (CurrentSentMessage->HasPackedLParam == TRUE)
2049 {
2050 if (CurrentSentMessage->Msg.lParam)
2051 ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
2052 }
2053
2054 /* if the message has a sender */
2055 if (CurrentSentMessage->SenderQueue)
2056 {
2057 /* dereference our and the sender's message queue */
2058 IntDereferenceMessageQueue(MessageQueue);
2059 IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
2060 }
2061
2062 /* free the message */
2063 ExFreePool(CurrentSentMessage);
2064 }
2065
2066 /* tell other threads not to bother returning any info to us */
2067 while (! IsListEmpty(&MessageQueue->DispatchingMessagesHead))
2068 {
2069 CurrentEntry = RemoveHeadList(&MessageQueue->DispatchingMessagesHead);
2070 CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE,
2071 DispatchingListEntry);
2072 CurrentSentMessage->CompletionEvent = NULL;
2073 CurrentSentMessage->Result = NULL;
2074
2075 /* do NOT dereference our message queue as it might get attempted to be
2076 locked later */
2077 }
2078
2079 // Clear it all out.
2080 if(pti->pcti)
2081 {
2082 pti->pcti->fsWakeBits = 0;
2083 pti->pcti->fsChangeBits = 0;
2084 }
2085
2086 MessageQueue->nCntsQBits[QSRosKey] = 0;
2087 MessageQueue->nCntsQBits[QSRosMouseMove] = 0;
2088 MessageQueue->nCntsQBits[QSRosMouseButton] = 0;
2089 MessageQueue->nCntsQBits[QSRosPostMessage] = 0;
2090 MessageQueue->nCntsQBits[QSRosSendMessage] = 0;
2091 MessageQueue->nCntsQBits[QSRosHotKey] = 0;
2092
2093 if (MessageQueue->CursorObject)
2094 {
2095 PCURICON_OBJECT pCursor = MessageQueue->CursorObject;
2096
2097 /* Change to another cursor if we going to dereference current one
2098 Note: we can't use UserSetCursor because it uses current thread
2099 message queue instead of queue given for cleanup */
2100 if (IntGetSysCursorInfo()->CurrentCursorObject == pCursor)
2101 {
2102 HDC hdcScreen;
2103
2104 /* Get the screen DC */
2105 hdcScreen = IntGetScreenDC();
2106 if (hdcScreen)
2107 GreMovePointer(hdcScreen, -1, -1);
2108 IntGetSysCursorInfo()->CurrentCursorObject = NULL;
2109 }
2110
2111 UserDereferenceObject(pCursor);
2112 }
2113
2114 }
2115
2116 PUSER_MESSAGE_QUEUE FASTCALL
2117 MsqCreateMessageQueue(struct _ETHREAD *Thread)
2118 {
2119 PUSER_MESSAGE_QUEUE MessageQueue;
2120
2121 MessageQueue = (PUSER_MESSAGE_QUEUE)ExAllocatePoolWithTag(NonPagedPool,
2122 sizeof(USER_MESSAGE_QUEUE) + sizeof(THRDCARETINFO),
2123 USERTAG_Q);
2124
2125 if (!MessageQueue)
2126 {
2127 return NULL;
2128 }
2129
2130 RtlZeroMemory(MessageQueue, sizeof(USER_MESSAGE_QUEUE) + sizeof(THRDCARETINFO));
2131 /* hold at least one reference until it'll be destroyed */
2132 IntReferenceMessageQueue(MessageQueue);
2133 /* initialize the queue */
2134 if (!MsqInitializeMessageQueue(Thread, MessageQueue))
2135 {
2136 IntDereferenceMessageQueue(MessageQueue);
2137 return NULL;
2138 }
2139
2140 return MessageQueue;
2141 }
2142
2143 VOID FASTCALL
2144 MsqDestroyMessageQueue(PUSER_MESSAGE_QUEUE MessageQueue)
2145 {
2146 PDESKTOP desk;
2147
2148 MessageQueue->QF_flags |= QF_INDESTROY;
2149
2150 /* remove the message queue from any desktops */
2151 if ((desk = InterlockedExchangePointer((PVOID*)&MessageQueue->Desktop, 0)))
2152 {
2153 (void)InterlockedExchangePointer((PVOID*)&desk->ActiveMessageQueue, 0);
2154 IntDereferenceMessageQueue(MessageQueue);
2155 }
2156
2157 /* clean it up */
2158 MsqCleanupMessageQueue(MessageQueue);
2159
2160 if (MessageQueue->NewMessagesHandle != NULL)
2161 ZwClose(MessageQueue->NewMessagesHandle);
2162 MessageQueue->NewMessagesHandle = NULL;
2163 /* decrease the reference counter, if it hits zero, the queue will be freed */
2164 IntDereferenceMessageQueue(MessageQueue);
2165 }
2166
2167 LPARAM FASTCALL
2168 MsqSetMessageExtraInfo(LPARAM lParam)
2169 {
2170 LPARAM Ret;
2171 PTHREADINFO pti;
2172 PUSER_MESSAGE_QUEUE MessageQueue;
2173
2174 pti = PsGetCurrentThreadWin32Thread();
2175 MessageQueue = pti->MessageQueue;
2176 if(!MessageQueue)
2177 {
2178 return 0;
2179 }
2180
2181 Ret = MessageQueue->ExtraInfo;
2182 MessageQueue->ExtraInfo = lParam;
2183
2184 return Ret;
2185 }
2186
2187 LPARAM FASTCALL
2188 MsqGetMessageExtraInfo(VOID)
2189 {
2190 PTHREADINFO pti;
2191 PUSER_MESSAGE_QUEUE MessageQueue;
2192
2193 pti = PsGetCurrentThreadWin32Thread();
2194 MessageQueue = pti->MessageQueue;
2195 if(!MessageQueue)
2196 {
2197 return 0;
2198 }
2199
2200 return MessageQueue->ExtraInfo;
2201 }
2202
2203 // ReplyMessage is called by the thread receiving the window message.
2204 BOOL FASTCALL
2205 co_MsqReplyMessage( LRESULT lResult )
2206 {
2207 PUSER_SENT_MESSAGE Message;
2208 PTHREADINFO pti;
2209
2210 pti = PsGetCurrentThreadWin32Thread();
2211 Message = pti->pusmCurrent;
2212
2213 if (!Message) return FALSE;
2214
2215 if (Message->QS_Flags & QS_SMRESULT) return FALSE;
2216
2217 // SendMessageXxx || Callback msg and not a notify msg
2218 if (Message->SenderQueue || Message->CompletionCallback)
2219 {
2220 Message->lResult = lResult;
2221 Message->QS_Flags |= QS_SMRESULT;
2222 // See co_MsqDispatchOneSentMessage, change bits already accounted for and cleared and this msg is going away..
2223 }
2224 return TRUE;
2225 }
2226
2227 HWND FASTCALL
2228 MsqSetStateWindow(PUSER_MESSAGE_QUEUE MessageQueue, ULONG Type, HWND hWnd)
2229 {
2230 HWND Prev;
2231
2232 switch(Type)
2233 {
2234 case MSQ_STATE_CAPTURE:
2235 Prev = MessageQueue->CaptureWindow;
2236 MessageQueue->CaptureWindow = hWnd;
2237 return Prev;
2238 case MSQ_STATE_ACTIVE:
2239 Prev = MessageQueue->ActiveWindow;
2240 MessageQueue->ActiveWindow = hWnd;
2241 return Prev;
2242 case MSQ_STATE_FOCUS:
2243 Prev = MessageQueue->FocusWindow;
2244 MessageQueue->FocusWindow = hWnd;
2245 return Prev;
2246 case MSQ_STATE_MENUOWNER:
2247 Prev = MessageQueue->MenuOwner;
2248 MessageQueue->MenuOwner = hWnd;
2249 return Prev;
2250 case MSQ_STATE_MOVESIZE:
2251 Prev = MessageQueue->MoveSize;
2252 MessageQueue->MoveSize = hWnd;
2253 return Prev;
2254 case MSQ_STATE_CARET:
2255 ASSERT(MessageQueue->CaretInfo);
2256 Prev = MessageQueue->CaretInfo->hWnd;
2257 MessageQueue->CaretInfo->hWnd = hWnd;
2258 return Prev;
2259 }
2260
2261 return NULL;
2262 }
2263
2264 SHORT
2265 APIENTRY
2266 NtUserGetKeyState(INT key)
2267 {
2268 DWORD Ret;
2269
2270 UserEnterExclusive();
2271
2272 Ret = UserGetKeyState(key);
2273
2274 UserLeave();
2275
2276 return Ret;
2277 }
2278
2279
2280 DWORD
2281 APIENTRY
2282 NtUserGetKeyboardState(LPBYTE lpKeyState)
2283 {
2284 DWORD ret = TRUE;
2285 PTHREADINFO pti;
2286 PUSER_MESSAGE_QUEUE MessageQueue;
2287
2288 UserEnterShared();
2289
2290 pti = PsGetCurrentThreadWin32Thread();
2291 MessageQueue = pti->MessageQueue;
2292
2293 _SEH2_TRY
2294 {
2295 ProbeForWrite(lpKeyState,sizeof(MessageQueue->KeyState) ,1);
2296 RtlCopyMemory(lpKeyState,MessageQueue->KeyState,sizeof(MessageQueue->KeyState));
2297 }
2298 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2299 {
2300 SetLastNtError(_SEH2_GetExceptionCode());
2301 ret = FALSE;
2302 }
2303 _SEH2_END;
2304
2305 UserLeave();
2306
2307 return ret;
2308 }
2309
2310 BOOL
2311 APIENTRY
2312 NtUserSetKeyboardState(LPBYTE lpKeyState)
2313 {
2314 DWORD ret = TRUE;
2315 PTHREADINFO pti;
2316 PUSER_MESSAGE_QUEUE MessageQueue;
2317
2318 UserEnterExclusive();
2319
2320 pti = PsGetCurrentThreadWin32Thread();
2321 MessageQueue = pti->MessageQueue;
2322
2323 _SEH2_TRY
2324 {
2325 ProbeForRead(lpKeyState,sizeof(MessageQueue->KeyState) ,1);
2326 RtlCopyMemory(MessageQueue->KeyState,lpKeyState,sizeof(MessageQueue->KeyState));
2327 }
2328 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
2329 {
2330 SetLastNtError(_SEH2_GetExceptionCode());
2331 ret = FALSE;
2332 }
2333 _SEH2_END;
2334
2335 UserLeave();
2336
2337 return ret;
2338 }
2339
2340 /* EOF */