ReactOS 0.4.15-dev-6054-gbddd8b0
msgqueue.c File Reference
#include <win32k.h>
Include dependency graph for msgqueue.c:

Go to the source code of this file.

Functions

 DBG_DEFAULT_CHANNEL (UserMsgQ)
 
NTSTATUS NTAPI MsqInitializeImpl (VOID)
 
PWND FASTCALL IntTopLevelWindowFromPoint (INT x, INT y)
 
PCURICON_OBJECT FASTCALL UserSetCursor (PCURICON_OBJECT NewCursor, BOOL ForceChange)
 
int UserShowCursor (BOOL bShow)
 
DWORD FASTCALL UserGetKeyState (DWORD dwKey)
 
static VOID UpdateKeyState (PUSER_MESSAGE_QUEUE MessageQueue, WORD wVk, BOOL bIsDown)
 
static VOID UpdateKeyStateFromMsg (PUSER_MESSAGE_QUEUE MessageQueue, MSG *msg)
 
WPARAM FASTCALL MsqGetDownKeyState (PUSER_MESSAGE_QUEUE MessageQueue)
 
HANDLE FASTCALL IntMsqSetWakeMask (DWORD WakeMask)
 
BOOL FASTCALL IntMsqClearWakeMask (VOID)
 
VOID FASTCALL MsqWakeQueue (PTHREADINFO pti, DWORD MessageBits, BOOL KeyEvent)
 
VOID FASTCALL ClearMsgBitsMask (PTHREADINFO pti, UINT MessageBits)
 
VOID FASTCALL MsqIncPaintCountQueue (PTHREADINFO pti)
 
VOID FASTCALL MsqDecPaintCountQueue (PTHREADINFO pti)
 
VOID FASTCALL MsqPostMouseMove (PTHREADINFO pti, MSG *Msg, LONG_PTR ExtraInfo)
 
VOID FASTCALL IntCoalesceMouseMove (PTHREADINFO pti)
 
VOID FASTCALL co_MsqInsertMouseMessage (MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
 
PUSER_MESSAGE FASTCALL MsqCreateMessage (LPMSG Msg)
 
VOID FASTCALL MsqDestroyMessage (PUSER_MESSAGE Message)
 
PUSER_SENT_MESSAGE FASTCALL AllocateUserMessage (BOOL KEvent)
 
VOID FASTCALL FreeUserMessage (PUSER_SENT_MESSAGE Message)
 
VOID APIENTRY MsqRemoveWindowMessagesFromQueue (PWND Window)
 
BOOLEAN FASTCALL co_MsqDispatchOneSentMessage (_In_ PTHREADINFO pti)
 
BOOL FASTCALL co_MsqSendMessageAsync (PTHREADINFO ptiReceiver, HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC CompletionCallback, ULONG_PTR CompletionCallbackContext, BOOL HasPackedLParam, INT HookMessage)
 
NTSTATUS FASTCALL co_MsqSendMessage (PTHREADINFO ptirec, HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uTimeout, BOOL Block, INT HookMessage, ULONG_PTR *uResult)
 
VOID FASTCALL MsqPostMessage (PTHREADINFO pti, MSG *Msg, BOOLEAN HardwareMessage, DWORD MessageBits, DWORD dwQEvent, LONG_PTR ExtraInfo)
 
VOID FASTCALL MsqPostQuitMessage (PTHREADINFO pti, ULONG ExitCode)
 
static void MsqSendParentNotify (PWND pwnd, WORD event, WORD idChild, POINT pt)
 
VOID FASTCALL IntTrackMouseMove (PWND pwndTrack, PDESKTOP pDesk, PMSG msg, USHORT hittest)
 
BOOL co_IntProcessMouseMessage (MSG *msg, BOOL *RemoveMessages, BOOL *NotForUs, LONG_PTR ExtraInfo, UINT first, UINT last)
 
BOOL co_IntProcessKeyboardMessage (MSG *Msg, BOOL *RemoveMessages)
 
BOOL co_IntProcessHardwareMessage (MSG *Msg, BOOL *RemoveMessages, BOOL *NotForUs, LONG_PTR ExtraInfo, UINT first, UINT last)
 
static INT FASTCALL filter_contains_hw_range (UINT first, UINT last)
 
static BOOL is_mouse_message (UINT message)
 
BOOL APIENTRY co_MsqPeekHardwareMessage (IN PTHREADINFO pti, IN BOOL Remove, IN PWND Window, IN UINT MsgFilterLow, IN UINT MsgFilterHigh, IN UINT QSflags, OUT MSG *pMsg)
 
BOOLEAN APIENTRY MsqPeekMessage (IN PTHREADINFO pti, IN BOOLEAN Remove, IN PWND Window, IN UINT MsgFilterLow, IN UINT MsgFilterHigh, IN UINT QSflags, OUT LONG_PTR *ExtraInfo, OUT DWORD *dwQEvent, OUT PMSG Message)
 
NTSTATUS FASTCALL co_MsqWaitForNewMessages (PTHREADINFO pti, PWND WndFilter, UINT MsgFilterMin, UINT MsgFilterMax)
 
BOOL FASTCALL MsqIsHung (PTHREADINFO pti, DWORD TimeOut)
 
BOOL FASTCALL IsThreadSuspended (PTHREADINFO pti)
 
VOID CALLBACK HungAppSysTimerProc (HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
 
BOOLEAN FASTCALL MsqInitializeMessageQueue (PTHREADINFO pti, PUSER_MESSAGE_QUEUE MessageQueue)
 
VOID FASTCALL MsqCleanupThreadMsgs (PTHREADINFO pti)
 
VOID FASTCALL MsqCleanupMessageQueue (PTHREADINFO pti)
 
PUSER_MESSAGE_QUEUE FASTCALL MsqCreateMessageQueue (PTHREADINFO pti)
 
VOID FASTCALL MsqDestroyMessageQueue (_In_ PTHREADINFO pti)
 
LPARAM FASTCALL MsqSetMessageExtraInfo (LPARAM lParam)
 
LPARAM FASTCALL MsqGetMessageExtraInfo (VOID)
 
BOOL FASTCALL co_MsqReplyMessage (LRESULT lResult)
 
HWND FASTCALL MsqSetStateWindow (PTHREADINFO pti, ULONG Type, HWND hWnd)
 
SHORT APIENTRY NtUserGetKeyState (INT key)
 
DWORD APIENTRY NtUserGetKeyboardState (LPBYTE lpKeyState)
 
BOOL APIENTRY NtUserSetKeyboardState (LPBYTE pKeyState)
 

Variables

static PPAGED_LOOKASIDE_LIST pgMessageLookasideList
 
static PPAGED_LOOKASIDE_LIST pgSendMsgLookasideList
 
INT PostMsgCount = 0
 
INT SendMsgCount = 0
 
PUSER_MESSAGE_QUEUE gpqCursor
 
ULONG_PTR gdwMouseMoveExtraInfo = 0
 
DWORD gdwMouseMoveTimeStamp = 0
 
LIST_ENTRY usmList
 

Function Documentation

◆ AllocateUserMessage()

PUSER_SENT_MESSAGE FASTCALL AllocateUserMessage ( BOOL  KEvent)

Definition at line 763 of file msgqueue.c.

764{
766
767 if(!(Message = ExAllocateFromPagedLookasideList(pgSendMsgLookasideList)))
768 {
769 ERR("AllocateUserMessage(): Not enough memory to allocate a message\n");
770 return NULL;
771 }
773
774 if (KEvent)
775 {
776 Message->pkCompletionEvent = &Message->CompletionEvent;
777
778 KeInitializeEvent(Message->pkCompletionEvent, NotificationEvent, FALSE);
779 }
780 SendMsgCount++;
781 TRACE("AUM pti %p msg %p\n",PsGetCurrentThreadWin32Thread(),Message);
782 return Message;
783}
#define ERR(fmt,...)
Definition: debug.h:110
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
static const WCHAR Message[]
Definition: register.c:74
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
static PPAGED_LOOKASIDE_LIST pgSendMsgLookasideList
Definition: msgqueue.c:17
INT SendMsgCount
Definition: msgqueue.c:19
@ NotificationEvent
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
#define TRACE(s)
Definition: solgame.cpp:4
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262

Referenced by co_IntSendMessageWithCallBack(), co_MsqSendMessage(), and co_MsqSendMessageAsync().

◆ ClearMsgBitsMask()

VOID FASTCALL ClearMsgBitsMask ( PTHREADINFO  pti,
UINT  MessageBits 
)

Definition at line 445 of file msgqueue.c.

446{
447 UINT ClrMask = 0;
448
449 if (MessageBits & QS_KEY)
450 {
451 if (--pti->nCntsQBits[QSRosKey] == 0) ClrMask |= QS_KEY;
452 }
453 if (MessageBits & QS_MOUSEMOVE)
454 { // Account for tracking mouse moves..
455 if (pti->nCntsQBits[QSRosMouseMove])
456 {
457 pti->nCntsQBits[QSRosMouseMove] = 0; // Throttle down count. Up to > 3:1 entries are ignored.
458 ClrMask |= QS_MOUSEMOVE;
459 }
460 }
461 if (MessageBits & QS_MOUSEBUTTON)
462 {
463 if (--pti->nCntsQBits[QSRosMouseButton] == 0) ClrMask |= QS_MOUSEBUTTON;
464 }
465 if (MessageBits & QS_POSTMESSAGE)
466 {
467 if (--pti->nCntsQBits[QSRosPostMessage] == 0) ClrMask |= QS_POSTMESSAGE;
468 }
469 if (MessageBits & QS_TIMER) // ReactOS hard coded.
470 { // Handle timer bits here.
471 if ( pti->cTimersReady )
472 {
473 if (--pti->cTimersReady == 0) ClrMask |= QS_TIMER;
474 }
475 }
476 if (MessageBits & QS_PAINT) // ReactOS hard coded.
477 { // Handle paint bits here.
478 if ( pti->cPaintsReady )
479 {
480 if (--pti->cPaintsReady == 0) ClrMask |= QS_PAINT;
481 }
482 }
483 if (MessageBits & QS_SENDMESSAGE)
484 {
485 if (--pti->nCntsQBits[QSRosSendMessage] == 0) ClrMask |= QS_SENDMESSAGE;
486 }
487 if (MessageBits & QS_HOTKEY)
488 {
489 if (--pti->nCntsQBits[QSRosHotKey] == 0) ClrMask |= QS_HOTKEY;
490 }
491 if (MessageBits & QS_EVENT)
492 {
493 if (--pti->nCntsQBits[QSRosEvent] == 0) ClrMask |= QS_EVENT;
494 }
495
496 pti->pcti->fsWakeBits &= ~ClrMask;
497 pti->pcti->fsChangeBits &= ~ClrMask;
498}
unsigned int UINT
Definition: ndis.h:50
DWORD nCntsQBits[QSIDCOUNTS]
Definition: win32.h:153
struct _CLIENTTHREADINFO * pcti
Definition: win32.h:91
UINT cTimersReady
Definition: win32.h:110
UINT cPaintsReady
Definition: win32.h:109
#define QS_EVENT
Definition: undocuser.h:97
@ QSRosMouseMove
Definition: win32.h:42
@ QSRosKey
Definition: win32.h:41
@ QSRosEvent
Definition: win32.h:47
@ QSRosHotKey
Definition: win32.h:46
@ QSRosSendMessage
Definition: win32.h:45
@ QSRosPostMessage
Definition: win32.h:44
@ QSRosMouseButton
Definition: win32.h:43
#define QS_KEY
Definition: winuser.h:868
#define QS_MOUSEMOVE
Definition: winuser.h:869
#define QS_SENDMESSAGE
Definition: winuser.h:874
#define QS_TIMER
Definition: winuser.h:872
#define QS_HOTKEY
Definition: winuser.h:875
#define QS_MOUSEBUTTON
Definition: winuser.h:870
#define QS_POSTMESSAGE
Definition: winuser.h:871
#define QS_PAINT
Definition: winuser.h:873

Referenced by co_IntPeekMessage(), co_MsqDispatchOneSentMessage(), co_MsqPeekHardwareMessage(), co_MsqSendMessage(), FindRemoveEventMsg(), MsqDecPaintCountQueue(), MsqPeekMessage(), MsqRemoveWindowMessagesFromQueue(), and PostTimerMessages().

◆ co_IntProcessHardwareMessage()

BOOL co_IntProcessHardwareMessage ( MSG Msg,
BOOL RemoveMessages,
BOOL NotForUs,
LONG_PTR  ExtraInfo,
UINT  first,
UINT  last 
)

Definition at line 1955 of file msgqueue.c.

1956{
1957 if ( IS_MOUSE_MESSAGE(Msg->message))
1958 {
1959 return co_IntProcessMouseMessage(Msg, RemoveMessages, NotForUs, ExtraInfo, first, last);
1960 }
1961 else if ( IS_KBD_MESSAGE(Msg->message))
1962 {
1963 return co_IntProcessKeyboardMessage(Msg, RemoveMessages);
1964 }
1965
1966 return TRUE;
1967}
struct @1609 Msg[]
#define TRUE
Definition: types.h:120
const GLint * first
Definition: glext.h:5794
POINT last
Definition: font.c:46
BOOL co_IntProcessKeyboardMessage(MSG *Msg, BOOL *RemoveMessages)
Definition: msgqueue.c:1766
BOOL co_IntProcessMouseMessage(MSG *msg, BOOL *RemoveMessages, BOOL *NotForUs, LONG_PTR ExtraInfo, UINT first, UINT last)
Definition: msgqueue.c:1472
#define IS_KBD_MESSAGE(message)
Definition: msgqueue.h:246
#define IS_MOUSE_MESSAGE(message)
Definition: msgqueue.h:242

Referenced by co_MsqPeekHardwareMessage().

◆ co_IntProcessKeyboardMessage()

BOOL co_IntProcessKeyboardMessage ( MSG Msg,
BOOL RemoveMessages 
)

Definition at line 1766 of file msgqueue.c.

1767{
1770 PWND pWnd;
1771 UINT ImmRet;
1772 BOOL Ret = TRUE;
1773 WPARAM wParam = Msg->wParam;
1775
1776 if (Msg->message == VK_PACKET)
1777 {
1778 pti->wchInjected = HIWORD(Msg->wParam);
1779 }
1780
1781 if (Msg->message == WM_KEYDOWN || Msg->message == WM_SYSKEYDOWN ||
1782 Msg->message == WM_KEYUP || Msg->message == WM_SYSKEYUP)
1783 {
1784 switch (Msg->wParam)
1785 {
1786 case VK_LSHIFT: case VK_RSHIFT:
1787 Msg->wParam = VK_SHIFT;
1788 break;
1789 case VK_LCONTROL: case VK_RCONTROL:
1790 Msg->wParam = VK_CONTROL;
1791 break;
1792 case VK_LMENU: case VK_RMENU:
1793 Msg->wParam = VK_MENU;
1794 break;
1795 }
1796 }
1797
1798 pWnd = ValidateHwndNoErr(Msg->hwnd);
1799 if (pWnd) UserRefObjectCo(pWnd, &Ref);
1800
1801 Event.message = Msg->message;
1802 Event.hwnd = Msg->hwnd;
1803 Event.time = Msg->time;
1804 Event.paramL = (Msg->wParam & 0xFF) | (HIWORD(Msg->lParam) << 8);
1805 Event.paramH = Msg->lParam & 0x7FFF;
1806 if (HIWORD(Msg->lParam) & 0x0100) Event.paramH |= 0x8000;
1808
1809 if (*RemoveMessages)
1810 {
1811 if ((Msg->message == WM_KEYDOWN) &&
1812 (Msg->hwnd != IntGetDesktopWindow()))
1813 {
1814 /* Handle F1 key by sending out WM_HELP message */
1815 if (Msg->wParam == VK_F1)
1816 {
1817 UserPostMessage( Msg->hwnd, WM_KEYF1, 0, 0 );
1818 }
1819 else if (Msg->wParam >= VK_BROWSER_BACK &&
1820 Msg->wParam <= VK_LAUNCH_APP2)
1821 {
1822 /* FIXME: Process keystate */
1823 co_IntSendMessage(Msg->hwnd, WM_APPCOMMAND, (WPARAM)Msg->hwnd, MAKELPARAM(0, (FAPPCOMMAND_KEY | (Msg->wParam - VK_BROWSER_BACK + 1))));
1824 }
1825 }
1826 else if (Msg->message == WM_KEYUP)
1827 {
1828 /* Handle VK_APPS key by posting a WM_CONTEXTMENU message */
1829 if (Msg->wParam == VK_APPS && pti->MessageQueue->MenuOwner == NULL)
1830 UserPostMessage( Msg->hwnd, WM_CONTEXTMENU, (WPARAM)Msg->hwnd, -1 );
1831 }
1832 }
1833
1835 if ( *RemoveMessages && Msg->message == WM_SYSKEYDOWN )
1836 {
1837 if ( HIWORD(Msg->lParam) & KF_ALTDOWN )
1838 {
1839 if ( Msg->wParam == VK_ESCAPE || Msg->wParam == VK_TAB ) // Alt-Tab/ESC Alt-Shift-Tab/ESC
1840 {
1841 WPARAM wParamTmp;
1842
1843 wParamTmp = UserGetKeyState(VK_SHIFT) & 0x8000 ? SC_PREVWINDOW : SC_NEXTWINDOW;
1844 TRACE("Send WM_SYSCOMMAND Alt-Tab/ESC Alt-Shift-Tab/ESC\n");
1845 co_IntSendMessage( Msg->hwnd, WM_SYSCOMMAND, wParamTmp, Msg->wParam );
1846
1848 Ret = FALSE;
1850 goto Exit;
1851 }
1852 }
1853 }
1854
1855 if ( *RemoveMessages && (Msg->message == WM_SYSKEYDOWN || Msg->message == WM_KEYDOWN) )
1856 {
1857 if (gdwLanguageToggleKey < 3)
1858 {
1859 if (IS_KEY_DOWN(gafAsyncKeyState, gdwLanguageToggleKey == 1 ? VK_LMENU : VK_CONTROL)) // L Alt 1 or Ctrl 2 .
1860 {
1861 if ( wParam == VK_LSHIFT ) gLanguageToggleKeyState = INPUTLANGCHANGE_FORWARD; // Left Alt - Left Shift, Next
1863 if ( wParam == VK_RSHIFT ) gLanguageToggleKeyState = INPUTLANGCHANGE_BACKWARD; // Left Alt - Right Shift, Previous
1864 }
1865 }
1866 }
1867
1869 if ( *RemoveMessages && (Msg->message == WM_SYSKEYUP || Msg->message == WM_KEYUP) )
1870 {
1871 // When initializing win32k: Reading from the registry hotkey combination
1872 // to switch the keyboard layout and store it to global variable.
1873 // Using this combination of hotkeys in this function
1874
1875 if ( gdwLanguageToggleKey < 3 &&
1877 {
1878 if ( Msg->wParam == VK_SHIFT && !(IS_KEY_DOWN(gafAsyncKeyState, VK_SHIFT)))
1879 {
1880 WPARAM wParamILR;
1881 PKL pkl = pti->KeyboardLayout;
1882
1883 if (pWnd) UserDerefObjectCo(pWnd);
1884
1886 if (!(pWnd = pti->MessageQueue->spwndFocus))
1887 {
1888 pWnd = pti->MessageQueue->spwndActive;
1889 }
1890 if (pWnd) UserRefObjectCo(pWnd, &Ref);
1891
1892 if (pkl != NULL && gLanguageToggleKeyState)
1893 {
1894 TRACE("Posting WM_INPUTLANGCHANGEREQUEST KeyState %d\n", gLanguageToggleKeyState );
1895
1896 wParamILR = gLanguageToggleKeyState;
1897 // If system character set and font signature send flag.
1898 if ( gSystemFS & pkl->dwFontSigs )
1899 {
1900 wParamILR |= INPUTLANGCHANGE_SYSCHARSET;
1901 }
1902
1904 WM_INPUTLANGCHANGEREQUEST,
1905 wParamILR,
1906 (LPARAM)pkl->hkl );
1907
1910 Ret = FALSE;
1912 goto Exit;
1913 }
1914 }
1915 }
1916 }
1917
1919 *RemoveMessages ? HC_ACTION : HC_NOREMOVE,
1920 LOWORD(Msg->wParam),
1921 Msg->lParam))
1922 {
1923 /* skip this message */
1926 LOWORD(Msg->wParam),
1927 Msg->lParam );
1928
1929 ERR("KeyboardMessage WH_KEYBOARD Call Hook return!\n");
1930
1931 *RemoveMessages = TRUE;
1932
1933 Ret = FALSE;
1934 }
1935
1936 if ( pWnd && Ret && *RemoveMessages && Msg->message == WM_KEYDOWN && !(pti->TIF_flags & TIF_DISABLEIME))
1937 {
1938 if ( (ImmRet = IntImmProcessKey(pti->MessageQueue, pWnd, Msg->message, Msg->wParam, Msg->lParam)) )
1939 {
1940 if ( ImmRet & (IPHK_HOTKEY|IPHK_SKIPTHISKEY) )
1941 {
1942 ImmRet = 0;
1943 }
1944 if ( ImmRet & IPHK_PROCESSBYIME )
1945 {
1946 Msg->wParam = VK_PROCESSKEY;
1947 }
1948 }
1949 }
1950Exit:
1951 if (pWnd) UserDerefObjectCo(pWnd);
1952 return Ret;
1953}
WPARAM wParam
Definition: combotst.c:138
#define ValidateHwndNoErr(hwnd)
Definition: precomp.h:84
unsigned int BOOL
Definition: ntddk_ex.h:94
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define TIF_DISABLEIME
Definition: ntuser.h:287
#define WM_KEYF1
Definition: msg.c:47
DWORD FASTCALL UserGetKeyState(DWORD dwKey)
Definition: msgqueue.c:221
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1102
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:40
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
#define LOWORD(l)
Definition: pedump.c:82
#define WM_CONTEXTMENU
Definition: richedit.h:64
static void Exit(void)
Definition: sock.c:1330
struct tagKL * KeyboardLayout
Definition: win32.h:90
FLONG TIF_flags
Definition: win32.h:95
WCHAR wchInjected
Definition: win32.h:139
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
Definition: object.h:4
Definition: ntuser.h:689
Definition: input.h:27
DWORD dwFontSigs
Definition: input.h:34
HKL hkl
Definition: input.h:32
#define HIWORD(l)
Definition: typedefs.h:247
#define IPHK_SKIPTHISKEY
Definition: undocuser.h:142
#define IPHK_HOTKEY
Definition: undocuser.h:139
#define IPHK_PROCESSBYIME
Definition: undocuser.h:140
HWND FASTCALL IntGetDesktopWindow(VOID)
Definition: desktop.c:1374
UINT FASTCALL IntImmProcessKey(PUSER_MESSAGE_QUEUE MessageQueue, PWND pWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: ime.c:570
DWORD gSystemFS
Definition: kbdlayout.c:24
BYTE gafAsyncKeyState[256 *2/8]
Definition: keyboard.c:13
DWORD gdwLanguageToggleKey
Definition: keyboard.c:19
#define IS_KEY_DOWN(ks, vk)
Definition: input.h:99
int gLanguageToggleKeyState
Definition: keyboard.c:18
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1346
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1446
LONG_PTR LPARAM
Definition: windef.h:208
UINT_PTR WPARAM
Definition: windef.h:207
#define HC_NOREMOVE
Definition: winuser.h:51
#define WH_KEYBOARD
Definition: winuser.h:32
#define WM_SYSCOMMAND
Definition: winuser.h:1731
#define VK_TAB
Definition: winuser.h:2189
#define VK_APPS
Definition: winuser.h:2227
#define MAKELPARAM(l, h)
Definition: winuser.h:3998
#define WM_KEYUP
Definition: winuser.h:1706
#define SC_PREVWINDOW
Definition: winuser.h:2581
#define KF_ALTDOWN
Definition: winuser.h:2439
#define WM_APPCOMMAND
Definition: winuser.h:1872
#define VK_CONTROL
Definition: winuser.h:2193
#define HC_ACTION
Definition: winuser.h:48
#define VK_RSHIFT
Definition: winuser.h:2273
#define VK_PROCESSKEY
Definition: winuser.h:2317
#define VK_LSHIFT
Definition: winuser.h:2272
#define WH_CBT
Definition: winuser.h:35
#define VK_LCONTROL
Definition: winuser.h:2274
#define VK_F1
Definition: winuser.h:2245
#define VK_RCONTROL
Definition: winuser.h:2275
#define SC_NEXTWINDOW
Definition: winuser.h:2580
#define VK_RMENU
Definition: winuser.h:2277
#define WM_SYSKEYUP
Definition: winuser.h:1710
#define VK_SHIFT
Definition: winuser.h:2192
#define WM_KEYDOWN
Definition: winuser.h:1705
#define VK_ESCAPE
Definition: winuser.h:2204
#define WM_SYSKEYDOWN
Definition: winuser.h:1709
#define WH_JOURNALRECORD
Definition: winuser.h:30
#define HCBT_KEYSKIPPED
Definition: winuser.h:62
#define VK_LMENU
Definition: winuser.h:2276
#define VK_MENU
Definition: winuser.h:2194

Referenced by co_IntProcessHardwareMessage().

◆ co_IntProcessMouseMessage()

BOOL co_IntProcessMouseMessage ( MSG msg,
BOOL RemoveMessages,
BOOL NotForUs,
LONG_PTR  ExtraInfo,
UINT  first,
UINT  last 
)

Definition at line 1472 of file msgqueue.c.

1473{
1474 MSG clk_msg;
1475 POINT pt;
1476 UINT message;
1477 USHORT hittest;
1480 BOOL eatMsg = FALSE;
1481
1482 PWND pwndMsg, pwndDesktop;
1483 PUSER_MESSAGE_QUEUE MessageQueue;
1484 PTHREADINFO pti;
1485 PSYSTEM_CURSORINFO CurInfo;
1486 PDESKTOP pDesk;
1487
1489 pwndDesktop = UserGetDesktopWindow();
1490 MessageQueue = pti->MessageQueue;
1491 CurInfo = IntGetSysCursorInfo();
1492 pwndMsg = ValidateHwndNoErr(msg->hwnd);
1493 clk_msg = MessageQueue->msgDblClk;
1494 pDesk = pwndDesktop->head.rpdesk;
1495
1496 /* find the window to dispatch this mouse message to */
1497 if (MessageQueue->spwndCapture)
1498 {
1499 hittest = HTCLIENT;
1500 pwndMsg = MessageQueue->spwndCapture;
1501 }
1502 else
1503 {
1504 /*
1505 Start with null window. See wine win.c:test_mouse_input:WM_COMMAND tests.
1506 */
1507 pwndMsg = co_WinPosWindowFromPoint( NULL, &msg->pt, &hittest, FALSE);
1508 }
1509
1510 TRACE("Got mouse message for %p, hittest: 0x%x\n", msg->hwnd, hittest);
1511
1512 // Null window or not the same "Hardware" message queue.
1513 if (pwndMsg == NULL || pwndMsg->head.pti->MessageQueue != MessageQueue)
1514 {
1515 // Crossing a boundary, so set cursor. See default message queue cursor.
1517 /* Remove and ignore the message */
1518 *RemoveMessages = TRUE;
1519 return FALSE;
1520 }
1521
1522 // Check to see if this is attached,
1523 if ( pwndMsg->head.pti != pti && // window thread is not current,
1524 MessageQueue->cThreads > 1 ) // and is attached...
1525 {
1526 // This is not for us and we should leave so the other thread can check for messages!!!
1527 *NotForUs = TRUE;
1528 *RemoveMessages = FALSE;
1529 return FALSE;
1530 }
1531
1532 if ( MessageQueue == gpqCursor ) // Cursor must use the same Queue!
1533 {
1534 IntTrackMouseMove(pwndMsg, pDesk, msg, hittest);
1535 }
1536 else
1537 {
1538 ERR("Not the same cursor!\n");
1539 }
1540
1541 msg->hwnd = UserHMGetHandle(pwndMsg);
1542
1543 pt = msg->pt;
1544 message = msg->message;
1545
1546 /* Note: windows has no concept of a non-client wheel message */
1547 if (message != WM_MOUSEWHEEL)
1548 {
1549 if (hittest != HTCLIENT)
1550 {
1552 msg->wParam = hittest; // Caution! This might break wParam check in DblClk.
1553 }
1554 else
1555 {
1556 /* coordinates don't get translated while tracking a menu */
1557 /* FIXME: should differentiate popups and top-level menus */
1558 if (!(MessageQueue->MenuOwner))
1559 {
1560 pt.x += pwndDesktop->rcClient.left - pwndMsg->rcClient.left;
1561 pt.y += pwndDesktop->rcClient.top - pwndMsg->rcClient.top;
1562 }
1563 }
1564 }
1565 msg->lParam = MAKELONG( pt.x, pt.y );
1566
1567 /* translate double clicks */
1568
1569 if ((msg->message == WM_LBUTTONDOWN) ||
1570 (msg->message == WM_RBUTTONDOWN) ||
1571 (msg->message == WM_MBUTTONDOWN) ||
1572 (msg->message == WM_XBUTTONDOWN))
1573 {
1574 BOOL update = *RemoveMessages;
1575
1576 /* translate double clicks -
1577 * note that ...MOUSEMOVEs can slip in between
1578 * ...BUTTONDOWN and ...BUTTONDBLCLK messages */
1579
1580 if ((MessageQueue->MenuOwner || MessageQueue->MoveSize) ||
1581 hittest != HTCLIENT ||
1582 (pwndMsg->pcls->style & CS_DBLCLKS))
1583 {
1584 if ((msg->message == clk_msg.message) &&
1585 (msg->hwnd == clk_msg.hwnd) &&
1586 // Only worry about XButton wParam.
1587 (msg->message != WM_XBUTTONDOWN || GET_XBUTTON_WPARAM(msg->wParam) == GET_XBUTTON_WPARAM(clk_msg.wParam)) &&
1588 ((msg->time - clk_msg.time) < (ULONG)gspv.iDblClickTime) &&
1589 (abs(msg->pt.x - clk_msg.pt.x) < UserGetSystemMetrics(SM_CXDOUBLECLK)/2) &&
1590 (abs(msg->pt.y - clk_msg.pt.y) < UserGetSystemMetrics(SM_CYDOUBLECLK)/2))
1591 {
1593 if (update)
1594 {
1595 MessageQueue->msgDblClk.message = 0; /* clear the double click conditions */
1596 update = FALSE;
1597 }
1598 }
1599 }
1600
1601 if (!((first == 0 && last == 0) || (message >= first || message <= last)))
1602 {
1603 TRACE("Message out of range!!!\n");
1604 return FALSE;
1605 }
1606
1607 /* update static double click conditions */
1608 if (update) MessageQueue->msgDblClk = *msg;
1609 }
1610 else
1611 {
1612 if (!((first == 0 && last == 0) || (message >= first || message <= last)))
1613 {
1614 TRACE("Message out of range!!!\n");
1615 return FALSE;
1616 }
1617
1618 // Update mouse move down keys.
1619 if (message == WM_MOUSEMOVE)
1620 {
1621 msg->wParam = MsqGetDownKeyState(MessageQueue);
1622 }
1623 }
1624
1626 {
1627 BOOL IsClkLck = FALSE;
1628
1629 if(msg->message == WM_LBUTTONUP)
1630 {
1631 IsClkLck = ((msg->time - CurInfo->ClickLockTime) >= gspv.dwMouseClickLockTime);
1632 if (IsClkLck && (!CurInfo->ClickLockActive))
1633 {
1634 CurInfo->ClickLockActive = TRUE;
1635 }
1636 }
1637 else if (msg->message == WM_LBUTTONDOWN)
1638 {
1639 if (CurInfo->ClickLockActive)
1640 {
1641 IsClkLck = TRUE;
1642 CurInfo->ClickLockActive = FALSE;
1643 }
1644
1645 CurInfo->ClickLockTime = msg->time;
1646 }
1647
1648 if(IsClkLck)
1649 {
1650 /* Remove and ignore the message */
1651 *RemoveMessages = TRUE;
1652 TRACE("Remove and ignore the message\n");
1653 return FALSE;
1654 }
1655 }
1656
1657 if (pti->TIF_flags & TIF_MSGPOSCHANGED)
1658 {
1659 pti->TIF_flags &= ~TIF_MSGPOSCHANGED;
1660 IntNotifyWinEvent(EVENT_OBJECT_LOCATIONCHANGE, NULL, OBJID_CLIENT, CHILDID_SELF, 0);
1661 }
1662
1663 /* message is accepted now (but still get dropped) */
1664
1665 event.message = msg->message;
1666 event.time = msg->time;
1667 event.hwnd = msg->hwnd;
1668 event.paramL = msg->pt.x;
1669 event.paramH = msg->pt.y;
1671
1672 hook.pt = msg->pt;
1673 hook.hwnd = msg->hwnd;
1674 hook.wHitTestCode = hittest;
1675 hook.dwExtraInfo = ExtraInfo;
1676 if (co_HOOK_CallHooks( WH_MOUSE, *RemoveMessages ? HC_ACTION : HC_NOREMOVE,
1677 message, (LPARAM)&hook ))
1678 {
1679 hook.pt = msg->pt;
1680 hook.hwnd = msg->hwnd;
1681 hook.wHitTestCode = hittest;
1682 hook.dwExtraInfo = ExtraInfo;
1684
1685 ERR("WH_MOUSE dropped mouse message!\n");
1686
1687 /* Remove and skip message */
1688 *RemoveMessages = TRUE;
1689 return FALSE;
1690 }
1691
1692 if ((hittest == (USHORT)HTERROR) || (hittest == (USHORT)HTNOWHERE))
1693 {
1694 co_IntSendMessage( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd, MAKELONG( hittest, msg->message ));
1695
1696 /* Remove and skip message */
1697 *RemoveMessages = TRUE;
1698 return FALSE;
1699 }
1700
1701 if ((*RemoveMessages == FALSE) || MessageQueue->spwndCapture)
1702 {
1703 /* Accept the message */
1704 msg->message = message;
1705 return TRUE;
1706 }
1707
1708 if ((msg->message == WM_LBUTTONDOWN) ||
1709 (msg->message == WM_RBUTTONDOWN) ||
1710 (msg->message == WM_MBUTTONDOWN) ||
1711 (msg->message == WM_XBUTTONDOWN))
1712 {
1713 /* Send the WM_PARENTNOTIFY,
1714 * note that even for double/nonclient clicks
1715 * notification message is still WM_L/M/RBUTTONDOWN.
1716 */
1717 MsqSendParentNotify(pwndMsg, msg->message, 0, msg->pt );
1718
1719 /* Activate the window if needed */
1720
1721 if (pwndMsg != MessageQueue->spwndActive)
1722 {
1723 PWND pwndTop = pwndMsg;
1724 pwndTop = IntGetNonChildAncestor(pwndTop);
1725
1726 TRACE("Mouse pti %p pwndMsg pti %p pwndTop pti %p\n",MessageQueue->ptiMouse,pwndMsg->head.pti,pwndTop->head.pti);
1727
1728 if (pwndTop && pwndTop != pwndDesktop)
1729 {
1730 LONG ret = co_IntSendMessage( msg->hwnd,
1732 (WPARAM)UserHMGetHandle(pwndTop),
1733 MAKELONG( hittest, msg->message));
1734 switch(ret)
1735 {
1737 eatMsg = TRUE;
1738 /* fall through */
1739 case MA_NOACTIVATE:
1740 break;
1741 case MA_ACTIVATEANDEAT:
1742 eatMsg = TRUE;
1743 /* fall through */
1744 case MA_ACTIVATE:
1745 case 0:
1746 if (!co_IntMouseActivateWindow( pwndTop )) eatMsg = TRUE;
1747 break;
1748 default:
1749 ERR( "unknown WM_MOUSEACTIVATE code %d\n", ret );
1750 break;
1751 }
1752 }
1753 }
1754 }
1755
1756 /* send the WM_SETCURSOR message */
1757
1758 /* Windows sends the normal mouse message as the message parameter
1759 in the WM_SETCURSOR message even if it's non-client mouse message */
1760 co_IntSendMessage( msg->hwnd, WM_SETCURSOR, (WPARAM)msg->hwnd, MAKELONG( hittest, msg->message ));
1761
1762 msg->message = message;
1763 return !eatMsg;
1764}
#define msg(x)
Definition: auth_time.c:54
@ hook
Definition: msg.h:42
#define SYSTEMCUR(func)
Definition: cursoricon.h:129
#define pt(x, y)
Definition: drawing.c:79
#define abs(i)
Definition: fconv.c:206
BOOL FASTCALL co_IntMouseActivateWindow(PWND Wnd)
Definition: focus.c:1250
struct _cl_event * event
Definition: glext.h:7739
#define TIF_MSGPOSCHANGED
Definition: ntuser.h:282
WPARAM FASTCALL MsqGetDownKeyState(PUSER_MESSAGE_QUEUE MessageQueue)
Definition: msgqueue.c:338
static void MsqSendParentNotify(PWND pwnd, WORD event, WORD idChild, POINT pt)
Definition: msgqueue.c:1394
PUSER_MESSAGE_QUEUE gpqCursor
Definition: msgqueue.c:20
VOID FASTCALL IntTrackMouseMove(PWND pwndTrack, PDESKTOP pDesk, PMSG msg, USHORT hittest)
Definition: msgqueue.c:1421
PWND APIENTRY co_WinPosWindowFromPoint(IN PWND ScopeWin, IN POINT *WinPoint, IN OUT USHORT *HitTest, IN BOOL Ignore)
Definition: winpos.c:2934
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
UINT style
Definition: ntuser.h:575
INT iDblClickTime
Definition: sysparams.h:90
DWORD dwMouseClickLockTime
Definition: sysparams.h:79
BOOL bMouseClickLock
Definition: sysparams.h:77
struct _DESKTOP * rpdesk
Definition: ntuser.h:194
PTHREADINFO ptiMouse
Definition: msgqueue.h:55
PCLS pcls
Definition: ntuser.h:715
THRDESKHEAD head
Definition: ntuser.h:690
RECT rcClient
Definition: ntuser.h:712
Definition: tftpd.h:60
LONG top
Definition: windef.h:307
LONG left
Definition: windef.h:306
#define WM_MOUSEWHEEL
Definition: treelist.c:96
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
#define MAKELONG(a, b)
Definition: typedefs.h:249
uint32_t ULONG
Definition: typedefs.h:59
int ret
PCURICON_OBJECT IntSystemSetCursor(PCURICON_OBJECT pcurNew)
Definition: cursoricon.c:230
PSYSTEM_CURSORINFO IntGetSysCursorInfo(VOID)
Definition: cursoricon.c:187
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1386
VOID FASTCALL IntNotifyWinEvent(DWORD Event, PWND pWnd, LONG idObject, LONG idChild, DWORD flags)
Definition: event.c:178
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:208
SPIVALUES gspv
Definition: sysparams.c:17
PWND FASTCALL IntGetNonChildAncestor(PWND pWnd)
Definition: window.c:351
#define OBJID_CLIENT
Definition: winable.h:19
#define CHILDID_SELF
Definition: winable.h:14
#define SM_CXDOUBLECLK
Definition: winuser.h:993
#define HTERROR
Definition: winuser.h:2462
#define WM_LBUTTONDBLCLK
Definition: winuser.h:1768
#define MA_ACTIVATE
Definition: winuser.h:2491
#define SM_CYDOUBLECLK
Definition: winuser.h:994
#define WM_MOUSEMOVE
Definition: winuser.h:1765
#define MA_NOACTIVATE
Definition: winuser.h:2493
#define CS_DBLCLKS
Definition: winuser.h:646
#define WM_LBUTTONDOWN
Definition: winuser.h:1766
#define WM_RBUTTONDOWN
Definition: winuser.h:1769
#define WM_NCMOUSEMOVE
Definition: winuser.h:1681
#define WH_MOUSE
Definition: winuser.h:37
#define HCBT_CLICKSKIPPED
Definition: winuser.h:61
#define HTCLIENT
Definition: winuser.h:2465
#define HTNOWHERE
Definition: winuser.h:2464
#define WM_MOUSEACTIVATE
Definition: winuser.h:1627
#define WM_LBUTTONUP
Definition: winuser.h:1767
#define MA_NOACTIVATEANDEAT
Definition: winuser.h:2494
#define WM_SETCURSOR
Definition: winuser.h:1626
#define WM_MBUTTONDOWN
Definition: winuser.h:1772
#define MA_ACTIVATEANDEAT
Definition: winuser.h:2492

Referenced by co_IntProcessHardwareMessage().

◆ co_MsqDispatchOneSentMessage()

BOOLEAN FASTCALL co_MsqDispatchOneSentMessage ( _In_ PTHREADINFO  pti)

Definition at line 873 of file msgqueue.c.

875{
878 BOOL Ret;
879 LRESULT Result = 0;
880
882
883 if (IsListEmpty(&pti->SentMessagesListHead))
884 {
885 return(FALSE);
886 }
887
888 /* remove it from the list of pending messages */
889 Entry = RemoveHeadList(&pti->SentMessagesListHead);
891
892 // Signal this message is being processed.
894
895 SaveMsg = pti->pusmCurrent;
896 pti->pusmCurrent = Message;
897
898 // Processing a message sent to it from another thread.
899 if ( ( Message->ptiSender && pti != Message->ptiSender) ||
900 ( Message->ptiCallBackSender && pti != Message->ptiCallBackSender ))
901 { // most likely, but, to be sure.
902 pti->pcti->CTI_flags |= CTI_INSENDMESSAGE; // Let the user know...
903 }
904
905 /* Now insert it to the global list of messages that can be removed Justin Case there's Trouble */
906 InsertTailList(&usmList, &Message->ListEntry);
907
908 ClearMsgBitsMask(pti, Message->QS_Flags);
909
910 if (Message->HookMessage == MSQ_ISHOOK)
911 { // Direct Hook Call processor
912 Result = co_CallHook( Message->Msg.message, // HookId
913 (INT)(INT_PTR)Message->Msg.hwnd, // Code
914 Message->Msg.wParam,
915 Message->Msg.lParam);
916 }
917 else if(Message->HookMessage == MSQ_INJECTMODULE)
918 {
919 Result = IntLoadHookModule(Message->Msg.message,
920 (HHOOK)Message->Msg.lParam,
921 Message->Msg.wParam);
922 }
923 else if ((Message->CompletionCallback) &&
924 (Message->ptiCallBackSender == pti))
925 { /* Call the callback routine */
926 if (Message->QS_Flags & QS_SMRESULT)
927 {
928 co_IntCallSentMessageCallback(Message->CompletionCallback,
929 Message->Msg.hwnd,
930 Message->Msg.message,
931 Message->CompletionCallbackContext,
932 Message->lResult);
933 /* Set callback to NULL to prevent reentry */
934 Message->CompletionCallback = NULL;
935 }
936 else
937 {
938 /* The message has not been processed yet, reinsert it. */
939 RemoveEntryList(&Message->ListEntry);
940 InsertTailList(&Message->ptiCallBackSender->SentMessagesListHead, &Message->ListEntry);
941 // List is occupied need to set the bit.
942 MsqWakeQueue(Message->ptiCallBackSender, QS_SENDMESSAGE, TRUE);
943 ERR("Callback Message not processed yet. Requeuing the message\n");
944 Ret = FALSE;
945 goto Exit;
946 }
947 }
948 else
949 { /* Call the window procedure. */
950 Result = co_IntSendMessage( Message->Msg.hwnd,
951 Message->Msg.message,
952 Message->Msg.wParam,
953 Message->Msg.lParam);
954 }
955
956 /* If the message is a callback, insert it in the callback senders MessageQueue */
957 if (Message->CompletionCallback)
958 {
959 if (Message->ptiCallBackSender)
960 {
961 Message->lResult = Result;
962 Message->QS_Flags |= QS_SMRESULT;
963
964 /* insert it in the callers message queue */
965 RemoveEntryList(&Message->ListEntry);
966 InsertTailList(&Message->ptiCallBackSender->SentMessagesListHead, &Message->ListEntry);
967 MsqWakeQueue(Message->ptiCallBackSender, QS_SENDMESSAGE, TRUE);
968 }
969 Ret = TRUE;
970 goto Exit;
971 }
972
973 // Retrieve the result from callback.
974 if (Message->QS_Flags & QS_SMRESULT)
975 {
976 Result = Message->lResult;
977 }
978
979 /* Let the sender know the result. */
980 Message->lResult = Result;
981
982 if (Message->HasPackedLParam)
983 {
984 if (Message->Msg.lParam)
985 ExFreePool((PVOID)Message->Msg.lParam);
986 }
987
988 // Clear busy signal.
989 Message->flags &= ~SMF_RECEIVERBUSY;
990
991 /* Notify the sender. */
992 if (Message->pkCompletionEvent != NULL)
993 {
994 KeSetEvent(Message->pkCompletionEvent, IO_NO_INCREMENT, FALSE);
995 }
996
997 /* free the message */
998 if (Message->flags & SMF_RECEIVERFREE)
999 {
1000 TRACE("Receiver Freeing Message %p\n",Message);
1002 }
1003
1004 Ret = TRUE;
1005Exit:
1006 /* do not hangup on the user if this is reentering */
1007 if (!SaveMsg) pti->pcti->CTI_flags &= ~CTI_INSENDMESSAGE;
1008 pti->pusmCurrent = SaveMsg;
1009
1010 return Ret;
1011}
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
#define InsertTailList(ListHead, Entry)
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define RemoveHeadList(ListHead)
Definition: env_spec_w32.h:964
#define CTI_INSENDMESSAGE
Definition: ntuser.h:162
#define ASSERT(a)
Definition: mode.c:44
VOID FASTCALL ClearMsgBitsMask(PTHREADINFO pti, UINT MessageBits)
Definition: msgqueue.c:445
VOID FASTCALL FreeUserMessage(PUSER_SENT_MESSAGE Message)
Definition: msgqueue.c:786
LIST_ENTRY usmList
Definition: msgqueue.c:23
VOID FASTCALL MsqWakeQueue(PTHREADINFO pti, DWORD MessageBits, BOOL KeyEvent)
Definition: msgqueue.c:412
#define MSQ_ISHOOK
Definition: msgqueue.h:5
#define SMF_RECEIVEDMESSAGE
Definition: msgqueue.h:41
#define MSQ_INJECTMODULE
Definition: msgqueue.h:6
#define SMF_RECEIVERBUSY
Definition: msgqueue.h:42
#define SMF_RECEIVERFREE
Definition: msgqueue.h:40
LRESULT APIENTRY co_CallHook(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:321
BOOL IntLoadHookModule(int iHookID, HHOOK hHook, BOOL Unload)
Definition: hook.c:30
base of all file and directory entries
Definition: entries.h:83
Definition: typedefs.h:120
int32_t INT_PTR
Definition: typedefs.h:64
int32_t INT
Definition: typedefs.h:58
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
#define QS_SMRESULT
Definition: undocuser.h:95
VOID APIENTRY co_IntCallSentMessageCallback(SENDASYNCPROC CompletionCallback, HWND hWnd, UINT Msg, ULONG_PTR CompletionCallbackContext, LRESULT Result)
Definition: callback.c:238
LONG_PTR LRESULT
Definition: windef.h:209
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define IO_NO_INCREMENT
Definition: iotypes.h:598

Referenced by co_IntPeekMessage(), and co_MsqSendMessage().

◆ co_MsqInsertMouseMessage()

VOID FASTCALL co_MsqInsertMouseMessage ( MSG Msg,
DWORD  flags,
ULONG_PTR  dwExtraInfo,
BOOL  Hook 
)

Definition at line 580 of file msgqueue.c.

581{
582 MSLLHOOKSTRUCT MouseHookData;
583// PDESKTOP pDesk;
584 PWND pwnd, pwndDesktop;
585 HDC hdcScreen;
586 PTHREADINFO pti;
587 PUSER_MESSAGE_QUEUE MessageQueue;
588 PSYSTEM_CURSORINFO CurInfo;
589
590 Msg->time = EngGetTickCount32();
591
592 MouseHookData.pt.x = LOWORD(Msg->lParam);
593 MouseHookData.pt.y = HIWORD(Msg->lParam);
594 switch (Msg->message)
595 {
596 case WM_MOUSEWHEEL:
597 MouseHookData.mouseData = MAKELONG(0, GET_WHEEL_DELTA_WPARAM(Msg->wParam));
598 break;
599 case WM_XBUTTONDOWN:
600 case WM_XBUTTONUP:
601 case WM_XBUTTONDBLCLK:
602 case WM_NCXBUTTONDOWN:
603 case WM_NCXBUTTONUP:
604 case WM_NCXBUTTONDBLCLK:
605 MouseHookData.mouseData = MAKELONG(0, HIWORD(Msg->wParam));
606 break;
607 default:
608 MouseHookData.mouseData = 0;
609 break;
610 }
611
612 MouseHookData.flags = flags; // LLMHF_INJECTED
613 MouseHookData.time = Msg->time;
614 MouseHookData.dwExtraInfo = dwExtraInfo;
615
616 /* If the hook procedure returned non zero, dont send the message */
617 if (Hook)
618 {
619 if (co_HOOK_CallHooks(WH_MOUSE_LL, HC_ACTION, Msg->message, (LPARAM) &MouseHookData))
620 return;
621 }
622
623 /* Get the desktop window */
624 pwndDesktop = UserGetDesktopWindow();
625 if (!pwndDesktop) return;
626// pDesk = pwndDesktop->head.rpdesk;
627
628 /* Check if the mouse is captured */
629 Msg->hwnd = IntGetCaptureWindow();
630 if (Msg->hwnd != NULL)
631 {
632 pwnd = UserGetWindowObject(Msg->hwnd);
633 }
634 else
635 {
636 pwnd = IntTopLevelWindowFromPoint(Msg->pt.x, Msg->pt.y);
637 if (pwnd) Msg->hwnd = pwnd->head.h;
638 }
639
640 hdcScreen = IntGetScreenDC();
641 CurInfo = IntGetSysCursorInfo();
642
643 /* Check if we found a window */
644 if (Msg->hwnd != NULL && pwnd != NULL)
645 {
646 pti = pwnd->head.pti;
647 MessageQueue = pti->MessageQueue;
648
649 if (MessageQueue->QF_flags & QF_INDESTROY)
650 {
651 ERR("Mouse is over a Window with a Dead Message Queue!\n");
652 return;
653 }
654
655 // Check to see if this is attached.
656 if ( pti != MessageQueue->ptiMouse &&
657 MessageQueue->cThreads > 1 )
658 {
659 // Set the send pti to the message queue mouse pti.
660 pti = MessageQueue->ptiMouse;
661 }
662
663 if (Msg->message == WM_MOUSEMOVE)
664 {
665 /* Check if cursor should be visible */
666 if(hdcScreen &&
667 MessageQueue->CursorObject &&
668 MessageQueue->iCursorLevel >= 0)
669 {
670 /* Check if shape has changed */
671 if(CurInfo->CurrentCursorObject != MessageQueue->CursorObject)
672 {
673 /* Call GDI to set the new screen cursor */
674 GreSetPointerShape(hdcScreen,
675 MessageQueue->CursorObject->hbmAlpha ?
676 NULL : MessageQueue->CursorObject->hbmMask,
677 MessageQueue->CursorObject->hbmAlpha ?
678 MessageQueue->CursorObject->hbmAlpha : MessageQueue->CursorObject->hbmColor,
679 MessageQueue->CursorObject->xHotspot,
680 MessageQueue->CursorObject->yHotspot,
681 gpsi->ptCursor.x,
682 gpsi->ptCursor.y,
683 MessageQueue->CursorObject->hbmAlpha ? SPS_ALPHA : 0);
684
685 } else
686 GreMovePointer(hdcScreen, Msg->pt.x, Msg->pt.y);
687 }
688 /* Check if we have to hide cursor */
689 else if (CurInfo->ShowingCursor >= 0)
690 GreMovePointer(hdcScreen, -1, -1);
691
692 /* Update global cursor info */
693 CurInfo->ShowingCursor = MessageQueue->iCursorLevel;
694 CurInfo->CurrentCursorObject = MessageQueue->CursorObject;
695 gpqCursor = MessageQueue;
696
697 /* Mouse move is a special case */
698 MessageQueue->QF_flags |= QF_MOUSEMOVED;
699 gdwMouseMoveExtraInfo = dwExtraInfo;
702 }
703 else
704 {
705 if (!IntGetCaptureWindow())
706 {
707 // ERR("ptiLastInput is set\n");
708 // ptiLastInput = pti; // Once this is set during Reboot or Shutdown, this prevents the exit window having foreground.
709 // Find all the Move Mouse calls and fix mouse set active focus issues......
710 }
711
712 // Post mouse move before posting mouse buttons, keep it in sync.
713 if (pti->MessageQueue->QF_flags & QF_MOUSEMOVED)
714 {
716 }
717
718 TRACE("Posting mouse message to hwnd=%p!\n", UserHMGetHandle(pwnd));
719 MsqPostMessage(pti, Msg, TRUE, QS_MOUSEBUTTON, 0, dwExtraInfo);
720 }
721 }
722 else if (hdcScreen)
723 {
724 /* always show cursor on background; FIXME: set default pointer */
725 GreMovePointer(hdcScreen, Msg->pt.x, Msg->pt.y);
726 CurInfo->ShowingCursor = 0;
727 }
728}
PSERVERINFO gpsi
Definition: imm.c:18
#define EngGetTickCount32()
Definition: eng.h:43
HWND FASTCALL IntGetCaptureWindow(VOID)
Definition: focus.c:34
GLbitfield flags
Definition: glext.h:7161
static HDC
Definition: imagelist.c:92
VOID FASTCALL IntCoalesceMouseMove(PTHREADINFO pti)
Definition: msgqueue.c:551
VOID FASTCALL MsqPostMessage(PTHREADINFO pti, MSG *Msg, BOOLEAN HardwareMessage, DWORD MessageBits, DWORD dwQEvent, LONG_PTR ExtraInfo)
Definition: msgqueue.c:1337
PWND FASTCALL IntTopLevelWindowFromPoint(INT x, INT y)
Definition: msgqueue.c:61
ULONG_PTR gdwMouseMoveExtraInfo
Definition: msgqueue.c:21
DWORD gdwMouseMoveTimeStamp
Definition: msgqueue.c:22
#define QF_INDESTROY
Definition: msgqueue.h:103
#define QF_MOUSEMOVED
Definition: msgqueue.h:99
HBITMAP hbmColor
Definition: cursoricon.h:20
HBITMAP hbmMask
Definition: cursoricon.h:19
HBITMAP hbmAlpha
Definition: cursoricon.h:21
PCURICON_OBJECT CurrentCursorObject
Definition: cursoricon.h:74
PCURICON_OBJECT CursorObject
Definition: msgqueue.h:89
ULONG_PTR dwExtraInfo
Definition: winuser.h:3811
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:122
ULONG NTAPI GreSetPointerShape(_In_ HDC hdc, _In_opt_ HBITMAP hbmMask, _In_opt_ HBITMAP hbmColor, _In_ LONG xHot, _In_ LONG yHot, _In_ LONG x, _In_ LONG y, _In_ FLONG fl)
Definition: mouse.c:703
VOID NTAPI GreMovePointer(_In_ HDC hdc, _In_ LONG x, _In_ LONG y)
Definition: mouse.c:799
HDC FASTCALL IntGetScreenDC(VOID)
Definition: winsta.c:371
#define SPS_ALPHA
Definition: winddi.h:4039
#define WH_MOUSE_LL
Definition: winuser.h:44

Referenced by co_UserDestroyWindow(), co_WinPosSetWindowPos(), IntDeactivateWindow(), UserAttachThreadInput(), UserDeleteW32Thread(), UserSendMouseInput(), and UserSetCursorPos().

◆ co_MsqPeekHardwareMessage()

BOOL APIENTRY co_MsqPeekHardwareMessage ( IN PTHREADINFO  pti,
IN BOOL  Remove,
IN PWND  Window,
IN UINT  MsgFilterLow,
IN UINT  MsgFilterHigh,
IN UINT  QSflags,
OUT MSG pMsg 
)

Definition at line 1997 of file msgqueue.c.

2004{
2005 BOOL AcceptMessage, NotForUs;
2006 PUSER_MESSAGE CurrentMessage;
2007 PLIST_ENTRY ListHead;
2008 MSG msg;
2009 ULONG_PTR idSave;
2010 DWORD QS_Flags;
2011 LONG_PTR ExtraInfo;
2012 BOOL Ret = FALSE;
2013 PUSER_MESSAGE_QUEUE MessageQueue = pti->MessageQueue;
2014
2015 if (!filter_contains_hw_range( MsgFilterLow, MsgFilterHigh )) return FALSE;
2016
2017 ListHead = MessageQueue->HardwareMessagesListHead.Flink;
2018
2019 if (IsListEmpty(ListHead)) return FALSE;
2020
2021 if (!MessageQueue->ptiSysLock)
2022 {
2023 MessageQueue->ptiSysLock = pti;
2024 pti->pcti->CTI_flags |= CTI_THREADSYSLOCK;
2025 }
2026
2027 if (MessageQueue->ptiSysLock != pti)
2028 {
2029 ERR("Thread Q is locked to ptiSysLock 0x%p pti 0x%p\n",MessageQueue->ptiSysLock,pti);
2030 return FALSE;
2031 }
2032
2033 while (ListHead != &MessageQueue->HardwareMessagesListHead)
2034 {
2035 CurrentMessage = CONTAINING_RECORD(ListHead, USER_MESSAGE, ListEntry);
2036 ListHead = ListHead->Flink;
2037
2038 if (MessageQueue->idSysPeek == (ULONG_PTR)CurrentMessage)
2039 {
2040 TRACE("Skip this message due to it is in play!\n");
2041 continue;
2042 }
2043/*
2044 MSDN:
2045 1: any window that belongs to the current thread, and any messages on the current thread's message queue whose hwnd value is NULL.
2046 2: retrieves only messages on the current thread's message queue whose hwnd value is NULL.
2047 3: handle to the window whose messages are to be retrieved.
2048 */
2049 if ( ( !Window || // 1
2050 ( Window == PWND_BOTTOM && CurrentMessage->Msg.hwnd == NULL ) || // 2
2051 ( Window != PWND_BOTTOM && Window->head.h == CurrentMessage->Msg.hwnd ) || // 3
2052 ( is_mouse_message(CurrentMessage->Msg.message) ) ) && // Null window for anything mouse.
2053 ( ( ( MsgFilterLow == 0 && MsgFilterHigh == 0 ) && CurrentMessage->QS_Flags & QSflags ) ||
2054 ( MsgFilterLow <= CurrentMessage->Msg.message && MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
2055 {
2056 idSave = MessageQueue->idSysPeek;
2057 MessageQueue->idSysPeek = (ULONG_PTR)CurrentMessage;
2058
2059 msg = CurrentMessage->Msg;
2060 ExtraInfo = CurrentMessage->ExtraInfo;
2061 QS_Flags = CurrentMessage->QS_Flags;
2062
2063 NotForUs = FALSE;
2064
2065 UpdateKeyStateFromMsg(MessageQueue, &msg);
2066 AcceptMessage = co_IntProcessHardwareMessage(&msg, &Remove, &NotForUs, ExtraInfo, MsgFilterLow, MsgFilterHigh);
2067
2068 if (Remove)
2069 {
2070 if (CurrentMessage->pti != NULL && (MessageQueue->idSysPeek == (ULONG_PTR)CurrentMessage))
2071 {
2072 MsqDestroyMessage(CurrentMessage);
2073 }
2074 ClearMsgBitsMask(pti, QS_Flags);
2075 }
2076
2077 MessageQueue->idSysPeek = idSave;
2078
2079 if (NotForUs)
2080 {
2081 Ret = FALSE;
2082 break;
2083 }
2084
2085 if (AcceptMessage)
2086 {
2087 *pMsg = msg;
2088 // Fix all but one wine win:test_GetMessagePos WM_TIMER tests. See PostTimerMessages.
2089 if (!RtlEqualMemory(&pti->ptLast, &msg.pt, sizeof(POINT)))
2090 {
2091 pti->TIF_flags |= TIF_MSGPOSCHANGED;
2092 }
2093 pti->timeLast = msg.time;
2094 pti->ptLast = msg.pt;
2095 MessageQueue->ExtraInfo = ExtraInfo;
2096 Ret = TRUE;
2097 break;
2098 }
2099 }
2100 }
2101
2102 MessageQueue->ptiSysLock = NULL;
2103 pti->pcti->CTI_flags &= ~CTI_THREADSYSLOCK;
2104 return Ret;
2105}
#define ULONG_PTR
Definition: config.h:101
unsigned long DWORD
Definition: ntddk_ex.h:95
#define PWND_BOTTOM
Definition: ntuser.h:764
#define CTI_THREADSYSLOCK
Definition: ntuser.h:161
#define RtlEqualMemory(a, b, c)
Definition: kdvm.h:18
VOID FASTCALL MsqDestroyMessage(PUSER_MESSAGE Message)
Definition: msgqueue.c:748
static BOOL is_mouse_message(UINT message)
Definition: msgqueue.c:1987
static VOID UpdateKeyStateFromMsg(PUSER_MESSAGE_QUEUE MessageQueue, MSG *msg)
Definition: msgqueue.c:265
static INT FASTCALL filter_contains_hw_range(UINT first, UINT last)
Definition: msgqueue.c:1971
BOOL co_IntProcessHardwareMessage(MSG *Msg, BOOL *RemoveMessages, BOOL *NotForUs, LONG_PTR ExtraInfo, UINT first, UINT last)
Definition: msgqueue.c:1955
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
Definition: window.c:28
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
ULONG_PTR idSysPeek
Definition: msgqueue.h:54
PTHREADINFO ptiSysLock
Definition: msgqueue.h:52
LIST_ENTRY HardwareMessagesListHead
Definition: msgqueue.h:59
uint32_t ULONG_PTR
Definition: typedefs.h:65
_In_ BOOLEAN Remove
Definition: psfuncs.h:110

Referenced by co_IntPeekMessage().

◆ co_MsqReplyMessage()

BOOL FASTCALL co_MsqReplyMessage ( LRESULT  lResult)

Definition at line 2530 of file msgqueue.c.

2531{
2533 PTHREADINFO pti;
2534
2536 Message = pti->pusmCurrent;
2537
2538 if (!Message) return FALSE;
2539
2540 if (Message->QS_Flags & QS_SMRESULT) return FALSE;
2541
2542 // SendMessageXxx || Callback msg and not a notify msg
2543 if (Message->ptiSender || Message->CompletionCallback)
2544 {
2545 Message->lResult = lResult;
2546 Message->QS_Flags |= QS_SMRESULT;
2547 // See co_MsqDispatchOneSentMessage, change bits already accounted for and cleared and this msg is going away..
2548 }
2549 return TRUE;
2550}
struct _USER_SENT_MESSAGE * pusmCurrent
Definition: win32.h:98

Referenced by NtUserCallOneParam().

◆ co_MsqSendMessage()

NTSTATUS FASTCALL co_MsqSendMessage ( PTHREADINFO  ptirec,
HWND  Wnd,
UINT  Msg,
WPARAM  wParam,
LPARAM  lParam,
UINT  uTimeout,
BOOL  Block,
INT  HookMessage,
ULONG_PTR uResult 
)

Definition at line 1056 of file msgqueue.c.

1065{
1066 PTHREADINFO pti;
1067 PUSER_SENT_MESSAGE SaveMsg, Message;
1068 NTSTATUS WaitStatus;
1071 PWND pWnd;
1072 BOOLEAN SwapStateEnabled;
1073 LRESULT Result = 0;
1074
1076 ASSERT(pti != ptirec);
1077 ASSERT(ptirec->pcti); // Send must have a client side to receive it!!!!
1078
1079 /* Don't send from or to a dying thread */
1080 if (pti->TIF_flags & TIF_INCLEANUP || ptirec->TIF_flags & TIF_INCLEANUP)
1081 {
1082 // Unless we are dying and need to tell our parents.
1083 if (pti->TIF_flags & TIF_INCLEANUP && !(ptirec->TIF_flags & TIF_INCLEANUP))
1084 {
1085 // Parent notify is the big one. Fire and forget!
1086 TRACE("Send message from dying thread %u\n", Msg);
1087 co_MsqSendMessageAsync(ptirec, Wnd, Msg, wParam, lParam, NULL, 0, FALSE, HookMessage);
1088 }
1089 if (uResult) *uResult = -1;
1090 TRACE("MsqSM: Msg %u Current pti %lu or Rec pti %lu\n", Msg, pti->TIF_flags & TIF_INCLEANUP, ptirec->TIF_flags & TIF_INCLEANUP);
1091 return STATUS_UNSUCCESSFUL;
1092 }
1093
1094 if (IsThreadSuspended(ptirec))
1095 {
1096 ERR("Sending to Suspended Thread Msg %lx\n",Msg);
1097 if (uResult) *uResult = -1;
1098 return STATUS_UNSUCCESSFUL;
1099 }
1100
1101 // Should we do the same for No Wait?
1102 if ( HookMessage == MSQ_NORMAL )
1103 {
1104 pWnd = ValidateHwndNoErr(Wnd);
1105
1106 // These can not cross International Border lines!
1107 if ( pti->ppi != ptirec->ppi && pWnd )
1108 {
1109 switch(Msg)
1110 {
1111 // Handle the special case when working with password transfers across bordering processes.
1112 case EM_GETLINE:
1113 case EM_SETPASSWORDCHAR:
1114 case WM_GETTEXT:
1115 // Look for edit controls setup for passwords.
1116 if ( gpsi->atomSysClass[ICLS_EDIT] == pWnd->pcls->atomClassName && // Use atomNVClassName.
1117 pWnd->style & ES_PASSWORD )
1118 {
1119 if (uResult) *uResult = -1;
1120 ERR("Running across the border without a passport!\n");
1122 return STATUS_UNSUCCESSFUL;
1123 }
1124 break;
1125 case WM_NOTIFY:
1126 if (uResult) *uResult = -1;
1127 ERR("Running across the border without a passport!\n");
1128 return STATUS_UNSUCCESSFUL;
1129 }
1130 }
1131
1132 // These can not cross State lines!
1133 if ( Msg == WM_CREATE || Msg == WM_NCCREATE )
1134 {
1135 if (uResult) *uResult = -1;
1136 ERR("Can not tell the other State we have Create!\n");
1137 return STATUS_UNSUCCESSFUL;
1138 }
1139 }
1140
1142 {
1143 ERR("MsqSendMessage(): Not enough memory to allocate a message\n");
1144 if (uResult) *uResult = -1;
1146 }
1147
1148 Timeout.QuadPart = Int32x32To64(-10000,uTimeout); // Pass SMTO test with a TO of 0x80000000.
1149 TRACE("Timeout val %lld\n",Timeout.QuadPart);
1150
1151 Message->Msg.hwnd = Wnd;
1152 Message->Msg.message = Msg;
1153 Message->Msg.wParam = wParam;
1154 Message->Msg.lParam = lParam;
1155 Message->ptiReceiver = ptirec;
1156 Message->ptiSender = pti;
1157 Message->HookMessage = HookMessage;
1158 Message->QS_Flags = QS_SENDMESSAGE;
1159
1160 SaveMsg = pti->pusmSent;
1161 pti->pusmSent = Message;
1162
1163 /* Queue it in the destination's message queue */
1164 InsertTailList(&ptirec->SentMessagesListHead, &Message->ListEntry);
1165
1167
1168 // First time in, turn off swapping of the stack.
1169 if (pti->cEnterCount == 0)
1170 {
1171 SwapStateEnabled = KeSetKernelStackSwapEnable(FALSE);
1172 }
1173 pti->cEnterCount++;
1174
1175 if (Block)
1176 {
1177 PVOID WaitObjects[2];
1178
1179 WaitObjects[0] = Message->pkCompletionEvent; // Wait 0
1180 WaitObjects[1] = ptirec->pEThread; // Wait 1
1181
1182 UserLeaveCo();
1183
1184 WaitStatus = KeWaitForMultipleObjects( 2,
1185 WaitObjects,
1186 WaitAny,
1188 UserMode,
1189 FALSE,
1190 (uTimeout ? &Timeout : NULL),
1191 NULL );
1192
1193 UserEnterCo();
1194
1195 if (WaitStatus == STATUS_TIMEOUT)
1196 {
1197 /* Look up if the message has not yet dispatched, if so
1198 make sure it can't pass a result and it must not set the completion event anymore */
1200 while (Entry != &ptirec->SentMessagesListHead)
1201 {
1203 {
1204 Message->pkCompletionEvent = NULL;
1205 RemoveEntryList(&Message->ListEntry);
1206 ClearMsgBitsMask(ptirec, Message->QS_Flags);
1207 InsertTailList(&usmList, &Message->ListEntry);
1208 break;
1209 }
1210 Entry = Entry->Flink;
1211 }
1212
1213 ERR("MsqSendMessage (blocked) timed out 1 Status %lx\n", WaitStatus);
1214 }
1215 // Receiving thread passed on and left us hanging with issues still pending.
1216 else if (WaitStatus == STATUS_WAIT_1)
1217 {
1218 ERR("Bk Receiving Thread woken up dead!\n");
1219 Message->flags |= SMF_RECEIVERDIED;
1220 }
1221
1222 while (co_MsqDispatchOneSentMessage(pti))
1223 ;
1224 }
1225 else
1226 {
1227 PVOID WaitObjects[3];
1228
1229 WaitObjects[0] = Message->pkCompletionEvent; // Wait 0
1230 WaitObjects[1] = pti->pEventQueueServer; // Wait 1
1231 WaitObjects[2] = ptirec->pEThread; // Wait 2
1232
1233 do
1234 {
1235 UserLeaveCo();
1236
1237 WaitStatus = KeWaitForMultipleObjects( 3,
1238 WaitObjects,
1239 WaitAny,
1241 UserMode,
1242 FALSE,
1243 (uTimeout ? &Timeout : NULL),
1244 NULL);
1245
1246 UserEnterCo();
1247
1248 if (WaitStatus == STATUS_TIMEOUT)
1249 {
1250 /* Look up if the message has not yet been dispatched, if so
1251 make sure it can't pass a result and it must not set the completion event anymore */
1253 while (Entry != &ptirec->SentMessagesListHead)
1254 {
1256 {
1257 Message->pkCompletionEvent = NULL;
1258 RemoveEntryList(&Message->ListEntry);
1259 ClearMsgBitsMask(ptirec, Message->QS_Flags);
1260 InsertTailList(&usmList, &Message->ListEntry);
1261 break;
1262 }
1263 Entry = Entry->Flink;
1264 }
1265
1266 ERR("MsqSendMessage timed out 2 Status %lx\n", WaitStatus);
1267 break;
1268 }
1269 // Receiving thread passed on and left us hanging with issues still pending.
1270 else if (WaitStatus == STATUS_WAIT_2)
1271 {
1272 ERR("NB Receiving Thread woken up dead!\n");
1273 Message->flags |= SMF_RECEIVERDIED;
1274 break;
1275 }
1276
1277 if (WaitStatus == STATUS_USER_APC) break;
1278
1279 while (co_MsqDispatchOneSentMessage(pti))
1280 ;
1281 } while (WaitStatus == STATUS_WAIT_1);
1282 }
1283
1284 // Count is nil, restore swapping of the stack.
1285 if (--pti->cEnterCount == 0 )
1286 {
1287 KeSetKernelStackSwapEnable(SwapStateEnabled);
1288 }
1289
1290 // Handle User APC
1291 if (WaitStatus == STATUS_USER_APC)
1292 {
1293 // The current thread is dying!
1294 TRACE("User APC\n");
1295
1296 // The Message will be on the Trouble list until Thread cleanup.
1297 Message->flags |= SMF_SENDERDIED;
1298
1300 ERR("User APC Returned\n"); // Should not see this message.
1301 }
1302
1303 // Force this thread to wake up for the next go around.
1305
1306 Result = Message->lResult;
1307
1308 // Determine whether this message is being processed or not.
1310 {
1311 Message->flags |= SMF_RECEIVERFREE;
1312 }
1313
1314 if (!(Message->flags & SMF_RECEIVERFREE))
1315 {
1316 TRACE("Sender Freeing Message %p ptirec %p bit %d list empty %d\n",Message,ptirec,!!(ptirec->pcti->fsChangeBits & QS_SENDMESSAGE),IsListEmpty(&ptirec->SentMessagesListHead));
1317 // Make it to this point, the message was received.
1319 }
1320
1321 pti->pusmSent = SaveMsg;
1322
1323 TRACE("MSM Allocation Count %d Status %lx Result %d\n",SendMsgCount,WaitStatus,Result);
1324
1325 if (WaitStatus != STATUS_TIMEOUT)
1326 {
1327 if (uResult)
1328 {
1329 *uResult = (STATUS_WAIT_0 == WaitStatus ? Result : 0);
1330 }
1331 }
1332
1333 return WaitStatus;
1334}
unsigned char BOOLEAN
LONG NTSTATUS
Definition: precomp.h:26
LPARAM lParam
Definition: combotst.c:139
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define ICLS_EDIT
Definition: ntuser.h:908
#define TIF_INCLEANUP
Definition: ntuser.h:262
BOOLEAN FASTCALL co_MsqDispatchOneSentMessage(_In_ PTHREADINFO pti)
Definition: msgqueue.c:873
BOOL FASTCALL IsThreadSuspended(PTHREADINFO pti)
Definition: msgqueue.c:2226
BOOL FASTCALL co_MsqSendMessageAsync(PTHREADINFO ptiReceiver, HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC CompletionCallback, ULONG_PTR CompletionCallbackContext, BOOL HasPackedLParam, INT HookMessage)
Definition: msgqueue.c:1014
PUSER_SENT_MESSAGE FASTCALL AllocateUserMessage(BOOL KEvent)
Definition: msgqueue.c:763
#define SMF_SENDERDIED
Definition: msgqueue.h:39
#define MSQ_NORMAL
Definition: msgqueue.h:4
#define SMF_RECEIVERDIED
Definition: msgqueue.h:38
#define UserMode
Definition: asm.h:35
#define Int32x32To64(a, b)
@ WaitAny
NTSTATUS NTAPI KeWaitForMultipleObjects(IN ULONG Count, IN PVOID Object[], IN WAIT_TYPE WaitType, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL, OUT PKWAIT_BLOCK WaitBlockArray OPTIONAL)
Definition: wait.c:586
#define STATUS_TIMEOUT
Definition: ntstatus.h:81
#define STATUS_WAIT_0
Definition: ntstatus.h:237
#define STATUS_WAIT_1
Definition: ntstatus.h:71
#define STATUS_USER_APC
Definition: ntstatus.h:78
#define STATUS_WAIT_2
Definition: ntstatus.h:72
#define ES_PASSWORD
Definition: pedump.c:670
static ULONG Timeout
Definition: ping.c:61
#define WM_NOTIFY
Definition: richedit.h:61
RTL_ATOM atomClassName
Definition: ntuser.h:563
PPROCESSINFO ppi
Definition: win32.h:88
INT cEnterCount
Definition: win32.h:135
struct _USER_SENT_MESSAGE * pusmSent
Definition: win32.h:97
PKEVENT pEventQueueServer
Definition: win32.h:125
LIST_ENTRY SentMessagesListHead
Definition: win32.h:100
DWORD style
Definition: ntuser.h:701
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1055
BOOLEAN NTAPI KeSetKernelStackSwapEnable(IN BOOLEAN Enable)
Definition: thrdobj.c:997
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define UserEnterCo
Definition: ntuser.h:8
#define UserLeaveCo
Definition: ntuser.h:9
VOID FASTCALL co_IntDeliverUserAPC(VOID)
Definition: callback.c:1157
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:28
#define WM_CREATE
Definition: winuser.h:1598
#define EM_SETPASSWORDCHAR
Definition: winuser.h:2004
#define WM_GETTEXT
Definition: winuser.h:1608
#define WM_NCCREATE
Definition: winuser.h:1673
#define EM_GETLINE
Definition: winuser.h:1981
@ UserRequest
Definition: ketypes.h:409

Referenced by co_IntCallLowLevelHook(), and co_IntSendMessageTimeoutSingle().

◆ co_MsqSendMessageAsync()

BOOL FASTCALL co_MsqSendMessageAsync ( PTHREADINFO  ptiReceiver,
HWND  hwnd,
UINT  Msg,
WPARAM  wParam,
LPARAM  lParam,
SENDASYNCPROC  CompletionCallback,
ULONG_PTR  CompletionCallbackContext,
BOOL  HasPackedLParam,
INT  HookMessage 
)

Definition at line 1014 of file msgqueue.c.

1023{
1024 PTHREADINFO ptiSender;
1026
1028 {
1029 ERR("MsqSendMessageAsync(): Not enough memory to allocate a message\n");
1030 return FALSE;
1031 }
1032
1033 ptiSender = PsGetCurrentThreadWin32Thread();
1034
1035 Message->Msg.hwnd = hwnd;
1036 Message->Msg.message = Msg;
1037 Message->Msg.wParam = wParam;
1038 Message->Msg.lParam = lParam;
1039 Message->pkCompletionEvent = NULL; // No event needed.
1040 Message->ptiReceiver = ptiReceiver;
1041 Message->ptiCallBackSender = ptiSender;
1042 Message->CompletionCallback = CompletionCallback;
1043 Message->CompletionCallbackContext = CompletionCallbackContext;
1044 Message->HookMessage = HookMessage;
1045 Message->HasPackedLParam = HasPackedLParam;
1046 Message->QS_Flags = QS_SENDMESSAGE;
1047 Message->flags = SMF_RECEIVERFREE;
1048
1049 InsertTailList(&ptiReceiver->SentMessagesListHead, &Message->ListEntry);
1050 MsqWakeQueue(ptiReceiver, QS_SENDMESSAGE, TRUE);
1051
1052 return TRUE;
1053}
const TCHAR * CompletionCallback(unsigned __int64 &rnIndex, const BOOL *pblnForward, const TCHAR *pszContext, const TCHAR *pszBegin)
Definition: Completion.cpp:439
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023

Referenced by co_MsqSendMessage(), IntHookModuleUnloaded(), and UserRegisterUserApiHook().

◆ co_MsqWaitForNewMessages()

NTSTATUS FASTCALL co_MsqWaitForNewMessages ( PTHREADINFO  pti,
PWND  WndFilter,
UINT  MsgFilterMin,
UINT  MsgFilterMax 
)

Definition at line 2165 of file msgqueue.c.

2167{
2169
2170 // Post mouse moves before waiting for messages.
2171 if (pti->MessageQueue->QF_flags & QF_MOUSEMOVED)
2172 {
2174 }
2175
2176 UserLeaveCo();
2177
2178 ZwYieldExecution(); // Let someone else run!
2179
2182 UserMode,
2183 FALSE,
2184 NULL );
2185 UserEnterCo();
2186 if ( ret == STATUS_USER_APC )
2187 {
2188 TRACE("MWFNW User APC\n");
2190 }
2191 return ret;
2192}
#define KeWaitForSingleObject(pEvt, foo, a, b, c)
Definition: env_spec_w32.h:478
NTSYSAPI NTSTATUS NTAPI ZwYieldExecution(VOID)
#define STATUS_SUCCESS
Definition: shellext.h:65

Referenced by co_IntGetPeekMessage(), and co_IntWaitMessage().

◆ DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL ( UserMsgQ  )

◆ filter_contains_hw_range()

static INT FASTCALL filter_contains_hw_range ( UINT  first,
UINT  last 
)
static

Definition at line 1971 of file msgqueue.c.

1972{
1973 /* hardware message ranges are (in numerical order):
1974 * WM_NCMOUSEFIRST .. WM_NCMOUSELAST
1975 * WM_KEYFIRST .. WM_KEYLAST
1976 * WM_MOUSEFIRST .. WM_MOUSELAST
1977 */
1978 if (!last) --last;
1979 if (last < WM_NCMOUSEFIRST) return 0;
1980 if (first > WM_NCMOUSELAST && last < WM_KEYFIRST) return 0;
1981 if (first > WM_KEYLAST && last < WM_MOUSEFIRST) return 0;
1982 if (first > WM_MOUSELAST) return 0;
1983 return 1;
1984}
#define WM_NCMOUSEFIRST
Definition: msgqueue.h:239
#define WM_NCMOUSELAST
Definition: msgqueue.h:240
#define WM_MOUSEFIRST
Definition: winuser.h:1764
#define WM_MOUSELAST
Definition: winuser.h:1791
#define WM_KEYFIRST
Definition: winuser.h:1704
#define WM_KEYLAST
Definition: winuser.h:1718

Referenced by co_MsqPeekHardwareMessage().

◆ FreeUserMessage()

VOID FASTCALL FreeUserMessage ( PUSER_SENT_MESSAGE  Message)

Definition at line 786 of file msgqueue.c.

787{
788 Message->pkCompletionEvent = NULL;
789
790 /* Remove it from the list */
791 RemoveEntryList(&Message->ListEntry);
792
793 ExFreeToPagedLookasideList(pgSendMsgLookasideList, Message);
794 SendMsgCount--;
795}

Referenced by co_MsqDispatchOneSentMessage(), co_MsqSendMessage(), MsqCleanupThreadMsgs(), and MsqRemoveWindowMessagesFromQueue().

◆ HungAppSysTimerProc()

VOID CALLBACK HungAppSysTimerProc ( HWND  hwnd,
UINT  uMsg,
UINT_PTR  idEvent,
DWORD  dwTime 
)

Definition at line 2239 of file msgqueue.c.

2240{
2242 TRACE("HungAppSysTimerProc\n");
2243 // Process list of windows that are hung and waiting.
2244}
VOID FASTCALL DoTheScreenSaver(VOID)
Definition: input.c:48

Referenced by StartTheTimers().

◆ IntCoalesceMouseMove()

VOID FASTCALL IntCoalesceMouseMove ( PTHREADINFO  pti)

Definition at line 551 of file msgqueue.c.

552{
553 MSG Msg;
554
555 // Force time stamp to update, keeping message time in sync.
556 if (gdwMouseMoveTimeStamp == 0)
557 {
559 }
560
561 // Build mouse move message.
562 Msg.hwnd = NULL;
563 Msg.message = WM_MOUSEMOVE;
564 Msg.wParam = 0;
565 Msg.lParam = MAKELONG(gpsi->ptCursor.x, gpsi->ptCursor.y);
567 Msg.pt = gpsi->ptCursor;
568
569 // Post the move.
571
572 // Zero the time stamp.
574
575 // Clear flag since the move was posted.
576 pti->MessageQueue->QF_flags &= ~QF_MOUSEMOVED;
577}
VOID FASTCALL MsqPostMouseMove(PTHREADINFO pti, MSG *Msg, LONG_PTR ExtraInfo)
Definition: msgqueue.c:518

Referenced by co_IntPeekMessage(), co_MsqInsertMouseMessage(), co_MsqWaitForNewMessages(), and ProcessKeyEvent().

◆ IntMsqClearWakeMask()

BOOL FASTCALL IntMsqClearWakeMask ( VOID  )

Definition at line 392 of file msgqueue.c.

393{
394 PTHREADINFO Win32Thread;
395
396 Win32Thread = PsGetCurrentThreadWin32Thread();
397 if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
398 return FALSE;
399 // Very hacky, but that is what they do.
400 Win32Thread->pcti->fsWakeBits = 0;
401
402 IdlePong();
403
404 return TRUE;
405}
VOID FASTCALL IdlePong(VOID)
Definition: message.c:557

Referenced by NtUserCallNoParam().

◆ IntMsqSetWakeMask()

HANDLE FASTCALL IntMsqSetWakeMask ( DWORD  WakeMask)

Definition at line 362 of file msgqueue.c.

363{
364 PTHREADINFO Win32Thread;
365 HANDLE MessageEventHandle;
366 DWORD dwFlags = HIWORD(WakeMask);
367
368 Win32Thread = PsGetCurrentThreadWin32Thread();
369 if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
370 return 0;
371
372// Win32Thread->pEventQueueServer; IntMsqSetWakeMask returns Win32Thread->hEventQueueClient
373 MessageEventHandle = Win32Thread->hEventQueueClient;
374
375 if (Win32Thread->pcti)
376 {
377 if ( (Win32Thread->pcti->fsChangeBits & LOWORD(WakeMask)) ||
378 ( (dwFlags & MWMO_INPUTAVAILABLE) && (Win32Thread->pcti->fsWakeBits & LOWORD(WakeMask)) ) )
379 {
380 ERR("Chg 0x%x Wake 0x%x Mask 0x%x\n",Win32Thread->pcti->fsChangeBits, Win32Thread->pcti->fsWakeBits, WakeMask);
381 KeSetEvent(Win32Thread->pEventQueueServer, IO_NO_INCREMENT, FALSE); // Wake it up!
382 return MessageEventHandle;
383 }
384 }
385
386 IdlePing();
387
388 return MessageEventHandle;
389}
HANDLE hEventQueueClient
Definition: win32.h:123
VOID FASTCALL IdlePing(VOID)
Definition: message.c:527
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
#define MWMO_INPUTAVAILABLE
Definition: winuser.h:904

Referenced by NtUserCallOneParam().

◆ IntTopLevelWindowFromPoint()

PWND FASTCALL IntTopLevelWindowFromPoint ( INT  x,
INT  y 
)

Definition at line 61 of file msgqueue.c.

62{
63 PWND pWnd, pwndDesktop;
64
65 /* Get the desktop window */
66 pwndDesktop = UserGetDesktopWindow();
67 if (!pwndDesktop)
68 return NULL;
69
70 /* Loop all top level windows */
71 for (pWnd = pwndDesktop->spwndChild;
72 pWnd != NULL;
73 pWnd = pWnd->spwndNext)
74 {
75 if (pWnd->state2 & WNDS2_INDESTROY || pWnd->state & WNDS_DESTROYED)
76 {
77 TRACE("The Window is in DESTROY!\n");
78 continue;
79 }
80
81 if ((pWnd->style & WS_VISIBLE) &&
83 IntPtInWindow(pWnd, x, y))
84 return pWnd;
85 }
86
87 /* Window has not been found */
88 return pwndDesktop;
89}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
#define WNDS_DESTROYED
Definition: ntuser.h:631
#define WNDS2_INDESTROY
Definition: ntuser.h:643
#define WS_VISIBLE
Definition: pedump.c:620
#define WS_EX_TRANSPARENT
Definition: pedump.c:649
DWORD ExStyle
Definition: ntuser.h:699
DWORD state2
Definition: ntuser.h:697
struct _WND * spwndChild
Definition: ntuser.h:709
DWORD state
Definition: ntuser.h:696
struct _WND * spwndNext
Definition: ntuser.h:706
FORCEINLINE BOOL IntPtInWindow(PWND pwnd, INT x, INT y)
Definition: winpos.h:30
#define WS_EX_LAYERED
Definition: winuser.h:389

Referenced by co_MsqInsertMouseMessage(), UserSetCursor(), and UserShowCursor().

◆ IntTrackMouseMove()

VOID FASTCALL IntTrackMouseMove ( PWND  pwndTrack,
PDESKTOP  pDesk,
PMSG  msg,
USHORT  hittest 
)

Definition at line 1421 of file msgqueue.c.

1422{
1423// PWND pwndTrack = IntChildrenWindowFromPoint(pwndMsg, msg->pt.x, msg->pt.y);
1424// hittest = (USHORT)GetNCHitEx(pwndTrack, msg->pt); /// @todo WTF is this???
1425
1426 if ( pDesk->spwndTrack != pwndTrack || // Change with tracking window or
1427 msg->message != WM_MOUSEMOVE || // Mouse click changes or
1428 pDesk->htEx != hittest) // Change in current hit test states.
1429 {
1430 TRACE("ITMM: Track Mouse Move!\n");
1431
1432 /* Handle only the changing window track and mouse move across a border. */
1433 if ( pDesk->spwndTrack != pwndTrack ||
1434 (pDesk->htEx == HTCLIENT) ^ (hittest == HTCLIENT) )
1435 {
1436 TRACE("ITMM: Another Wnd %d or Across Border %d\n",
1437 pDesk->spwndTrack != pwndTrack,(pDesk->htEx == HTCLIENT) ^ (hittest == HTCLIENT));
1438
1439 if ( pDesk->dwDTFlags & DF_TME_LEAVE )
1442 0, 0);
1443
1444 if ( pDesk->dwDTFlags & DF_TME_HOVER )
1446
1447 /* Clear the flags to sign a change. */
1448 pDesk->dwDTFlags &= ~(DF_TME_LEAVE|DF_TME_HOVER);
1449 }
1450 /* Set the Track window and hit test. */
1451 pDesk->spwndTrack = pwndTrack;
1452 pDesk->htEx = hittest;
1453 }
1454
1455 /* Reset, Same Track window, Hover set and Mouse Clicks or Clobbered Hover box. */
1456 if ( pDesk->spwndTrack == pwndTrack &&
1457 ( msg->message != WM_MOUSEMOVE || !RECTL_bPointInRect(&pDesk->rcMouseHover, msg->pt.x, msg->pt.y)) &&
1458 pDesk->dwDTFlags & DF_TME_HOVER )
1459 {
1460 TRACE("ITMM: Reset Hover points!\n");
1461 // Restart timer for the hover period.
1463 // Reset desktop mouse hover from the system default hover rectangle.
1465 msg->pt.x - gspv.iMouseHoverWidth / 2,
1466 msg->pt.y - gspv.iMouseHoverHeight / 2,
1467 msg->pt.x + gspv.iMouseHoverWidth / 2,
1468 msg->pt.y + gspv.iMouseHoverHeight / 2);
1469 }
1470}
#define WM_MOUSELEAVE
Definition: commctrl.h:4975
DWORD dwMouseHoverTime
Definition: desktop.h:34
PWND spwndTrack
Definition: desktop.h:31
DWORD htEx
Definition: desktop.h:32
RECT rcMouseHover
Definition: desktop.h:33
DWORD dwDTFlags
Definition: desktop.h:12
INT iMouseHoverWidth
Definition: sysparams.h:85
INT iMouseHoverHeight
Definition: sysparams.h:86
FORCEINLINE VOID RECTL_vSetRect(_Out_ RECTL *prcl, _In_ LONG left, _In_ LONG top, _In_ LONG right, _In_ LONG bottom)
Definition: rect.h:5
FORCEINLINE BOOL RECTL_bPointInRect(_In_ const RECTL *prcl, _In_ INT x, _In_ INT y)
Definition: rect.h:52
#define DF_TME_LEAVE
Definition: desktop.h:48
#define DF_TME_HOVER
Definition: desktop.h:47
VOID CALLBACK SystemTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
Definition: timer.c:280
BOOL FASTCALL IntKillTimer(PWND Window, UINT_PTR IDEvent, BOOL SystemTimer)
Definition: timer.c:573
UINT_PTR FASTCALL IntSetTimer(PWND Window, UINT_PTR IDEvent, UINT Elapse, TIMERPROC TimerFunc, INT Type)
Definition: timer.c:177
#define TMRF_SYSTEM
Definition: timer.h:20
#define ID_EVENT_SYSTIMER_MOUSEHOVER
Definition: timer.h:27
#define WM_NCMOUSELEAVE
Definition: winuser.h:1832

Referenced by co_IntProcessMouseMessage().

◆ is_mouse_message()

static BOOL is_mouse_message ( UINT  message)
inlinestatic

Definition at line 1987 of file msgqueue.c.

1988{
1989 return ( //( message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST ) || This seems to break tests...
1991 ( message >= WM_XBUTTONDOWN && message <= WM_XBUTTONDBLCLK ) ||
1994}
#define WM_RBUTTONDBLCLK
Definition: winuser.h:1771
#define WM_MBUTTONDBLCLK
Definition: winuser.h:1774

Referenced by co_MsqPeekHardwareMessage().

◆ IsThreadSuspended()

BOOL FASTCALL IsThreadSuspended ( PTHREADINFO  pti)

Definition at line 2226 of file msgqueue.c.

2227{
2228 if (pti->pEThread)
2229 {
2230 BOOL Ret = TRUE;
2231 if (!(pti->pEThread->Tcb.SuspendCount) && !PsGetThreadFreezeCount(pti->pEThread)) Ret = FALSE;
2232 return Ret;
2233 }
2234 return FALSE;
2235}
ULONG NTAPI PsGetThreadFreezeCount(IN PETHREAD Thread)
Definition: thread.c:685

Referenced by co_MsqSendMessage(), and UpdateThreadWindows().

◆ MsqCleanupMessageQueue()

VOID FASTCALL MsqCleanupMessageQueue ( PTHREADINFO  pti)

Definition at line 2379 of file msgqueue.c.

2380{
2381 PUSER_MESSAGE_QUEUE MessageQueue;
2382 PLIST_ENTRY CurrentEntry;
2383 PUSER_MESSAGE CurrentMessage;
2384
2385 MessageQueue = pti->MessageQueue;
2386 MessageQueue->cThreads--;
2387
2388 if (MessageQueue->cThreads)
2389 {
2390 if (MessageQueue->ptiSysLock == pti) MessageQueue->ptiSysLock = NULL;
2391 }
2392
2393 if (MessageQueue->cThreads == 0)
2394 {
2395 /* cleanup posted messages */
2396 while (!IsListEmpty(&MessageQueue->HardwareMessagesListHead))
2397 {
2398 CurrentEntry = MessageQueue->HardwareMessagesListHead.Flink;
2399 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
2400 ERR("MQ Cleanup Post Messages %p\n",CurrentMessage);
2401 MsqDestroyMessage(CurrentMessage);
2402 }
2403 }
2404
2405 if (MessageQueue->CursorObject)
2406 {
2407 PCURICON_OBJECT pCursor = MessageQueue->CursorObject;
2408
2409 /* Change to another cursor if we going to dereference current one
2410 Note: we can't use UserSetCursor because it uses current thread
2411 message queue instead of queue given for cleanup */
2412 if (IntGetSysCursorInfo()->CurrentCursorObject == pCursor)
2413 {
2414 HDC hdcScreen;
2415
2416 /* Get the screen DC */
2417 hdcScreen = IntGetScreenDC();
2418 if (hdcScreen)
2419 GreMovePointer(hdcScreen, -1, -1);
2421 }
2422
2423 TRACE("DereferenceObject pCursor\n");
2424 UserDereferenceObject(pCursor);
2425 }
2426
2427 if (gpqForeground == MessageQueue)
2428 {
2430 }
2431 if (gpqForegroundPrev == MessageQueue)
2432 {
2434 }
2435 if (gpqCursor == MessageQueue)
2436 {
2437 gpqCursor = NULL;
2438 }
2439}
PUSER_MESSAGE_QUEUE gpqForeground
Definition: focus.c:13
PUSER_MESSAGE_QUEUE gpqForegroundPrev
Definition: focus.c:14
VOID FASTCALL IntSetFocusMessageQueue(PUSER_MESSAGE_QUEUE NewQueue)
Definition: desktop.c:1319
BOOL FASTCALL UserDereferenceObject(PVOID Object)
Definition: object.c:644

Referenced by MsqDestroyMessageQueue().

◆ MsqCleanupThreadMsgs()

VOID FASTCALL MsqCleanupThreadMsgs ( PTHREADINFO  pti)

Definition at line 2267 of file msgqueue.c.

2268{
2269 PLIST_ENTRY CurrentEntry;
2270 PUSER_MESSAGE CurrentMessage;
2271 PUSER_SENT_MESSAGE CurrentSentMessage;
2272
2273 TRACE("MsqCleanupThreadMsgs %p\n",pti);
2274
2275 // Clear it all out.
2276 if (pti->pcti)
2277 {
2278 pti->pcti->fsWakeBits = 0;
2279 pti->pcti->fsChangeBits = 0;
2280 }
2281
2282 pti->nCntsQBits[QSRosKey] = 0;
2283 pti->nCntsQBits[QSRosMouseMove] = 0;
2284 pti->nCntsQBits[QSRosMouseButton] = 0;
2285 pti->nCntsQBits[QSRosPostMessage] = 0;
2286 pti->nCntsQBits[QSRosSendMessage] = 0;
2287 pti->nCntsQBits[QSRosHotKey] = 0;
2288 pti->nCntsQBits[QSRosEvent] = 0;
2289
2290 /* cleanup posted messages */
2291 while (!IsListEmpty(&pti->PostedMessagesListHead))
2292 {
2293 CurrentEntry = pti->PostedMessagesListHead.Flink;
2294 CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
2295 ERR("Thread Cleanup Post Messages %p\n",CurrentMessage);
2296 if (CurrentMessage->dwQEvent)
2297 {
2298 if (CurrentMessage->dwQEvent == POSTEVENT_NWE)
2299 {
2300 ExFreePoolWithTag( (PVOID)CurrentMessage->ExtraInfo, TAG_HOOK);
2301 }
2302 }
2303 MsqDestroyMessage(CurrentMessage);
2304 }
2305
2306 /* remove the messages that have not yet been dispatched */
2307 while (!IsListEmpty(&pti->SentMessagesListHead))
2308 {
2309 CurrentEntry = pti->SentMessagesListHead.Flink;
2310 CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE, ListEntry);
2311
2312 ERR("Thread Cleanup Sent Messages %p\n",CurrentSentMessage);
2313
2314 /* wake the sender's thread */
2315 if (CurrentSentMessage->pkCompletionEvent != NULL)
2316 {
2317 KeSetEvent(CurrentSentMessage->pkCompletionEvent, IO_NO_INCREMENT, FALSE);
2318 }
2319
2320 if (CurrentSentMessage->HasPackedLParam)
2321 {
2322 if (CurrentSentMessage->Msg.lParam)
2323 ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
2324 }
2325
2326 /* free the message */
2327 FreeUserMessage(CurrentSentMessage);
2328 }
2329
2330 // Process Trouble Message List
2331 if (!IsListEmpty(&usmList))
2332 {
2333 CurrentEntry = usmList.Flink;
2334 while (CurrentEntry != &usmList)
2335 {
2336 CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE, ListEntry);
2337 CurrentEntry = CurrentEntry->Flink;
2338
2339 TRACE("Found troubled messages %p on the list\n",CurrentSentMessage);
2340
2341 if ( pti == CurrentSentMessage->ptiReceiver )
2342 {
2343 if (CurrentSentMessage->HasPackedLParam)
2344 {
2345 if (CurrentSentMessage->Msg.lParam)
2346 ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
2347 }
2348
2349 /* free the message */
2350 FreeUserMessage(CurrentSentMessage);
2351 }
2352 else if ( pti == CurrentSentMessage->ptiSender ||
2353 pti == CurrentSentMessage->ptiCallBackSender )
2354 {
2355 // Determine whether this message is being processed or not.
2356 if ((CurrentSentMessage->flags & (SMF_RECEIVERBUSY|SMF_RECEIVEDMESSAGE)) != SMF_RECEIVEDMESSAGE)
2357 {
2358 CurrentSentMessage->flags |= SMF_RECEIVERFREE;
2359 }
2360
2361 if (!(CurrentSentMessage->flags & SMF_RECEIVERFREE))
2362 {
2363
2364 if (CurrentSentMessage->HasPackedLParam)
2365 {
2366 if (CurrentSentMessage->Msg.lParam)
2367 ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
2368 }
2369
2370 /* free the message */
2371 FreeUserMessage(CurrentSentMessage);
2372 }
2373 }
2374 }
2375 }
2376}
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
#define POSTEVENT_NWE
Definition: msgqueue.h:125
LIST_ENTRY PostedMessagesListHead
Definition: win32.h:137
LONG_PTR ExtraInfo
Definition: msgqueue.h:13
DWORD dwQEvent
Definition: msgqueue.h:14
BOOL HasPackedLParam
Definition: msgqueue.h:34
PTHREADINFO ptiReceiver
Definition: msgqueue.h:29
PTHREADINFO ptiCallBackSender
Definition: msgqueue.h:31
PKEVENT pkCompletionEvent
Definition: msgqueue.h:25
PTHREADINFO ptiSender
Definition: msgqueue.h:28
#define TAG_HOOK
Definition: tags.h:5

Referenced by UserDeleteW32Thread().

◆ MsqCreateMessage()

PUSER_MESSAGE FASTCALL MsqCreateMessage ( LPMSG  Msg)

Definition at line 731 of file msgqueue.c.

732{
734
735 Message = ExAllocateFromPagedLookasideList(pgMessageLookasideList);
736 if (!Message)
737 {
738 return NULL;
739 }
740
741 RtlZeroMemory(Message, sizeof(*Message));
742 RtlMoveMemory(&Message->Msg, Msg, sizeof(MSG));
743 PostMsgCount++;
744 return Message;
745}
INT PostMsgCount
Definition: msgqueue.c:18
static PPAGED_LOOKASIDE_LIST pgMessageLookasideList
Definition: msgqueue.c:16
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264

Referenced by MsqPostMessage().

◆ MsqCreateMessageQueue()

PUSER_MESSAGE_QUEUE FASTCALL MsqCreateMessageQueue ( PTHREADINFO  pti)

Definition at line 2442 of file msgqueue.c.

2443{
2444 PUSER_MESSAGE_QUEUE MessageQueue;
2445
2446 MessageQueue = ExAllocatePoolWithTag(NonPagedPool,
2447 sizeof(*MessageQueue),
2448 USERTAG_Q);
2449
2450 if (!MessageQueue)
2451 {
2452 return NULL;
2453 }
2454
2455 RtlZeroMemory(MessageQueue, sizeof(*MessageQueue));
2456 /* hold at least one reference until it'll be destroyed */
2457 IntReferenceMessageQueue(MessageQueue);
2458 /* initialize the queue */
2459 if (!MsqInitializeMessageQueue(pti, MessageQueue))
2460 {
2461 IntDereferenceMessageQueue(MessageQueue);
2462 return NULL;
2463 }
2464
2465 return MessageQueue;
2466}
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define NonPagedPool
Definition: env_spec_w32.h:307
BOOLEAN FASTCALL MsqInitializeMessageQueue(PTHREADINFO pti, PUSER_MESSAGE_QUEUE MessageQueue)
Definition: msgqueue.c:2247
#define IntReferenceMessageQueue(MsgQueue)
Definition: msgqueue.h:217
#define IntDereferenceMessageQueue(MsgQueue)
Definition: msgqueue.h:220
#define USERTAG_Q
Definition: tags.h:269

Referenced by InitThreadCallback(), and UserAttachThreadInput().

◆ MsqDecPaintCountQueue()

VOID FASTCALL MsqDecPaintCountQueue ( PTHREADINFO  pti)

◆ MsqDestroyMessage()

VOID FASTCALL MsqDestroyMessage ( PUSER_MESSAGE  Message)

Definition at line 748 of file msgqueue.c.

749{
750 TRACE("Post Destroy %d\n",PostMsgCount);
751 if (Message->pti == NULL)
752 {
753 ERR("Double Free Message\n");
754 return;
755 }
756 RemoveEntryList(&Message->ListEntry);
757 Message->pti = NULL;
758 ExFreeToPagedLookasideList(pgMessageLookasideList, Message);
759 PostMsgCount--;
760}

Referenced by co_MsqPeekHardwareMessage(), FindRemoveEventMsg(), MsqCleanupMessageQueue(), MsqCleanupThreadMsgs(), MsqPeekMessage(), and MsqRemoveWindowMessagesFromQueue().

◆ MsqDestroyMessageQueue()

VOID FASTCALL MsqDestroyMessageQueue ( _In_ PTHREADINFO  pti)

Definition at line 2469 of file msgqueue.c.

2470{
2471 PDESKTOP desk;
2472 PUSER_MESSAGE_QUEUE MessageQueue = pti->MessageQueue;
2473
2474 NT_ASSERT(MessageQueue != NULL);
2475 MessageQueue->QF_flags |= QF_INDESTROY;
2476
2477 /* remove the message queue from any desktops */
2478 if ((desk = InterlockedExchangePointer((PVOID*)&MessageQueue->Desktop, 0)))
2479 {
2481 IntDereferenceMessageQueue(MessageQueue);
2482 }
2483
2484 /* clean it up */
2486
2487 /* decrease the reference counter, if it hits zero, the queue will be freed */
2489 IntDereferenceMessageQueue(MessageQueue);
2490}
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
VOID FASTCALL MsqCleanupMessageQueue(PTHREADINFO pti)
Definition: msgqueue.c:2379
struct _USER_MESSAGE_QUEUE * ActiveMessageQueue
Definition: desktop.h:38
struct _DESKTOP * Desktop
Definition: msgqueue.h:50
#define _PRAGMA_WARNING_SUPPRESS(x)
Definition: suppress.h:28
#define __WARNING_USING_UNINIT_VAR
Definition: suppress.h:31
#define NT_ASSERT
Definition: rtlfuncs.h:3310

Referenced by UserAttachThreadInput(), and UserDeleteW32Thread().

◆ MsqGetDownKeyState()

WPARAM FASTCALL MsqGetDownKeyState ( PUSER_MESSAGE_QUEUE  MessageQueue)

Definition at line 338 of file msgqueue.c.

339{
340 WPARAM ret = 0;
341
343 {
344 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_RBUTTON)) ret |= MK_LBUTTON;
345 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_LBUTTON)) ret |= MK_RBUTTON;
346 }
347 else
348 {
349 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_LBUTTON)) ret |= MK_LBUTTON;
350 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_RBUTTON)) ret |= MK_RBUTTON;
351 }
352
353 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_MBUTTON)) ret |= MK_MBUTTON;
354 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_SHIFT)) ret |= MK_SHIFT;
355 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_CONTROL)) ret |= MK_CONTROL;
356 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_XBUTTON1)) ret |= MK_XBUTTON1;
357 if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_XBUTTON2)) ret |= MK_XBUTTON2;
358 return ret;
359}
BOOL bMouseBtnSwap
Definition: sysparams.h:82
BYTE afKeyState[256 *2/8]
Definition: msgqueue.h:84
#define MK_RBUTTON
Definition: winuser.h:2358
#define MK_SHIFT
Definition: winuser.h:2359
#define VK_RBUTTON
Definition: winuser.h:2181
#define VK_MBUTTON
Definition: winuser.h:2183
#define MK_MBUTTON
Definition: winuser.h:2361
#define MK_CONTROL
Definition: winuser.h:2360
#define MK_LBUTTON
Definition: winuser.h:2357
#define VK_LBUTTON
Definition: winuser.h:2180

Referenced by co_IntProcessMouseMessage(), and SystemTimerProc().

◆ MsqGetMessageExtraInfo()

LPARAM FASTCALL MsqGetMessageExtraInfo ( VOID  )

Definition at line 2513 of file msgqueue.c.

2514{
2515 PTHREADINFO pti;
2516 PUSER_MESSAGE_QUEUE MessageQueue;
2517
2519 MessageQueue = pti->MessageQueue;
2520 if(!MessageQueue)
2521 {
2522 return 0;
2523 }
2524
2525 return MessageQueue->ExtraInfo;
2526}

Referenced by NtUserGetThreadState().

◆ MsqIncPaintCountQueue()

VOID FASTCALL MsqIncPaintCountQueue ( PTHREADINFO  pti)

Definition at line 501 of file msgqueue.c.

502{
503 pti->cPaintsReady++;
505}

Referenced by IntInvalidateWindows().

◆ MsqInitializeImpl()

NTSTATUS NTAPI MsqInitializeImpl ( VOID  )

Definition at line 30 of file msgqueue.c.

31{
32 // Setup Post Messages
35 return STATUS_NO_MEMORY;
37 NULL,
38 NULL,
39 0,
40 sizeof(USER_MESSAGE),
42 256);
43 // Setup Send Messages
46 return STATUS_NO_MEMORY;
48 NULL,
49 NULL,
50 0,
51 sizeof(USER_SENT_MESSAGE),
53 16);
54
56
57 return(STATUS_SUCCESS);
58}
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
VOID NTAPI ExInitializePagedLookasideList(IN PPAGED_LOOKASIDE_LIST Lookaside, IN PALLOCATE_FUNCTION Allocate OPTIONAL, IN PFREE_FUNCTION Free OPTIONAL, IN ULONG Flags, IN SIZE_T Size, IN ULONG Tag, IN USHORT Depth)
Definition: lookas.c:270
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
#define TAG_USRMSG
Definition: tags.h:8
struct LOOKASIDE_ALIGN _PAGED_LOOKASIDE_LIST PAGED_LOOKASIDE_LIST

Referenced by DriverEntry().

◆ MsqInitializeMessageQueue()

BOOLEAN FASTCALL MsqInitializeMessageQueue ( PTHREADINFO  pti,
PUSER_MESSAGE_QUEUE  MessageQueue 
)

Definition at line 2247 of file msgqueue.c.

2248{
2249 InitializeListHead(&MessageQueue->HardwareMessagesListHead); // Keep here!
2250 MessageQueue->spwndFocus = NULL;
2251 MessageQueue->iCursorLevel = 0;
2252 MessageQueue->CursorObject = SYSTEMCUR(WAIT); // See test_initial_cursor.
2253 if (MessageQueue->CursorObject)
2254 {
2255 TRACE("Default cursor hcur %p\n",UserHMGetHandle(MessageQueue->CursorObject));
2256 UserReferenceObject(MessageQueue->CursorObject);
2257 }
2259 MessageQueue->ptiMouse = pti;
2260 MessageQueue->ptiKeyboard = pti;
2261 MessageQueue->cThreads++;
2262
2263 return TRUE;
2264}
#define WAIT
Definition: listbox.c:36
PTHREADINFO ptiKeyboard
Definition: msgqueue.h:56
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
VOID FASTCALL UserReferenceObject(PVOID obj)
Definition: object.c:731

Referenced by MsqCreateMessageQueue().

◆ MsqIsHung()

BOOL FASTCALL MsqIsHung ( PTHREADINFO  pti,
DWORD  TimeOut 
)

Definition at line 2195 of file msgqueue.c.

2196{
2197 DWORD dwTimeStamp = EngGetTickCount32();
2198 if (dwTimeStamp - pti->pcti->timeLastRead > TimeOut &&
2199 !(pti->pcti->fsWakeMask & QS_INPUT) &&
2200 !PsGetThreadFreezeCount(pti->pEThread) &&
2201 !(pti->ppi->W32PF_flags & W32PF_APPSTARTING))
2202 {
2203 TRACE("\nMsqIsHung(pti %p, TimeOut %lu)\n"
2204 "pEThread %p, ThreadsProcess %p, ImageFileName '%s'\n"
2205 "dwTimeStamp = %lu\n"
2206 "pti->pcti->timeLastRead = %lu\n"
2207 "pti->timeLast = %lu\n"
2208 "PsGetThreadFreezeCount(pti->pEThread) = %lu\n",
2209 pti, TimeOut,
2210 pti->pEThread,
2211 pti->pEThread ? pti->pEThread->ThreadsProcess : NULL,
2212 (pti->pEThread && pti->pEThread->ThreadsProcess)
2213 ? pti->pEThread->ThreadsProcess->ImageFileName : "(None)",
2214 dwTimeStamp,
2215 pti->pcti->timeLastRead,
2216 pti->timeLast,
2217 PsGetThreadFreezeCount(pti->pEThread));
2218
2219 return TRUE;
2220 }
2221
2222 return FALSE;
2223}
LONG timeLast
Definition: win32.h:102
#define W32PF_APPSTARTING
Definition: win32.h:10
#define QS_INPUT
Definition: winuser.h:893

Referenced by co_IntSendMessageTimeoutSingle(), IntMakeHungWindowGhosted(), NtUserQueryWindow(), and UpdateThreadWindows().

◆ MsqPeekMessage()

BOOLEAN APIENTRY MsqPeekMessage ( IN PTHREADINFO  pti,
IN BOOLEAN  Remove,
IN PWND  Window,
IN UINT  MsgFilterLow,
IN UINT  MsgFilterHigh,
IN UINT  QSflags,
OUT LONG_PTR ExtraInfo,
OUT DWORD dwQEvent,
OUT PMSG  Message 
)

Definition at line 2108 of file msgqueue.c.

2117{
2118 PUSER_MESSAGE CurrentMessage;
2119 PLIST_ENTRY ListHead;
2120 DWORD QS_Flags;
2121 BOOL Ret = FALSE;
2122
2123 ListHead = pti->PostedMessagesListHead.Flink;
2124
2125 if (IsListEmpty(ListHead)) return FALSE;
2126
2127 while(ListHead != &pti->PostedMessagesListHead)
2128 {
2129 CurrentMessage = CONTAINING_RECORD(ListHead, USER_MESSAGE, ListEntry);
2130 ListHead = ListHead->Flink;
2131/*
2132 MSDN:
2133 1: any window that belongs to the current thread, and any messages on the current thread's message queue whose hwnd value is NULL.
2134 2: retrieves only messages on the current thread's message queue whose hwnd value is NULL.
2135 3: handle to the window whose messages are to be retrieved.
2136 */
2137 if ( ( !Window || // 1
2138 ( Window == PWND_BOTTOM && CurrentMessage->Msg.hwnd == NULL ) || // 2
2139 ( Window != PWND_BOTTOM && Window->head.h == CurrentMessage->Msg.hwnd ) ) && // 3
2140 ( ( ( MsgFilterLow == 0 && MsgFilterHigh == 0 ) && CurrentMessage->QS_Flags & QSflags ) ||
2141 ( MsgFilterLow <= CurrentMessage->Msg.message && MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
2142 {
2143 *Message = CurrentMessage->Msg;
2144 *ExtraInfo = CurrentMessage->ExtraInfo;
2145 QS_Flags = CurrentMessage->QS_Flags;
2146 if (dwQEvent) *dwQEvent = CurrentMessage->dwQEvent;
2147
2148 if (Remove)
2149 {
2150 if (CurrentMessage->pti != NULL)
2151 {
2152 MsqDestroyMessage(CurrentMessage);
2153 }
2154 ClearMsgBitsMask(pti, QS_Flags);
2155 }
2156 Ret = TRUE;
2157 break;
2158 }
2159 }
2160
2161 return Ret;
2162}
PTHREADINFO pti
Definition: msgqueue.h:15
DWORD QS_Flags
Definition: msgqueue.h:12

Referenced by co_IntPeekMessage().

◆ MsqPostMessage()

VOID FASTCALL MsqPostMessage ( PTHREADINFO  pti,
MSG Msg,
BOOLEAN  HardwareMessage,
DWORD  MessageBits,
DWORD  dwQEvent,
LONG_PTR  ExtraInfo 
)

Definition at line 1337 of file msgqueue.c.

1343{
1345 PUSER_MESSAGE_QUEUE MessageQueue;
1346
1347 MessageQueue = pti->MessageQueue;
1348
1349 if ((pti->TIF_flags & TIF_INCLEANUP) || (MessageQueue->QF_flags & QF_INDESTROY))
1350 {
1351 ERR("Post Msg; Thread or Q is Dead!\n");
1352 return;
1353 }
1354
1356 if (!Message)
1357 return;
1358
1359 if (Msg->message == WM_HOTKEY)
1360 MessageBits |= QS_HOTKEY;
1361
1362 Message->dwQEvent = dwQEvent;
1363 Message->ExtraInfo = ExtraInfo;
1364 Message->QS_Flags = MessageBits;
1365 Message->pti = pti;
1366
1367 if (!HardwareMessage)
1368 {
1369 InsertTailList(&pti->PostedMessagesListHead, &Message->ListEntry);
1370 }
1371 else
1372 {
1373 InsertTailList(&MessageQueue->HardwareMessagesListHead, &Message->ListEntry);
1374 }
1375
1376 MsqWakeQueue(pti, MessageBits, TRUE);
1377 TRACE("Post Message %d\n", PostMsgCount);
1378}
PUSER_MESSAGE FASTCALL MsqCreateMessage(LPMSG Msg)
Definition: msgqueue.c:731
#define WM_HOTKEY
Definition: winuser.h:1869

Referenced by co_IntSetForegroundAndFocusWindow(), co_IntSetForegroundMessageQueue(), co_MsqInsertMouseMessage(), IntCallLowLevelEvent(), IntTranslateKbdMessage(), MsqPostMouseMove(), NtUserCallTwoParam(), PostTimerMessages(), ProcessKeyEvent(), UserPostMessage(), and UserPostThreadMessage().

◆ MsqPostMouseMove()

VOID FASTCALL MsqPostMouseMove ( PTHREADINFO  pti,
MSG Msg,
LONG_PTR  ExtraInfo 
)

Definition at line 518 of file msgqueue.c.

519{
521 PLIST_ENTRY ListHead;
522 PUSER_MESSAGE_QUEUE MessageQueue = pti->MessageQueue;
523
524 ListHead = &MessageQueue->HardwareMessagesListHead;
525
526 // Do nothing if empty.
527 if (!IsListEmpty(ListHead->Flink))
528 {
529 // Look at the end of the list,
530 Message = CONTAINING_RECORD(ListHead->Blink, USER_MESSAGE, ListEntry);
531
532 // If the mouse move message is existing on the list,
533 if (Message->Msg.message == WM_MOUSEMOVE)
534 {
535 // Overwrite the message with updated data!
536 Message->Msg = *Msg;
537
539 return;
540 }
541 }
542
543 MsqPostMessage(pti, Msg, TRUE, QS_MOUSEMOVE, 0, ExtraInfo);
544}
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122

Referenced by IntCoalesceMouseMove().

◆ MsqPostQuitMessage()

VOID FASTCALL MsqPostQuitMessage ( PTHREADINFO  pti,
ULONG  ExitCode 
)

Definition at line 1381 of file msgqueue.c.

1382{
1383 pti->QuitPosted = TRUE;
1384 pti->exitCode = ExitCode;
1386}
INT exitCode
Definition: win32.h:107
BOOLEAN QuitPosted
Definition: win32.h:105
#define QS_ALLPOSTMESSAGE
Definition: winuser.h:876

Referenced by NtUserCallOneParam().

◆ MsqRemoveWindowMessagesFromQueue()

VOID APIENTRY MsqRemoveWindowMessagesFromQueue ( PWND  Window)

Definition at line 798 of file msgqueue.c.

799{
800 PTHREADINFO pti;
801 PUSER_SENT_MESSAGE SentMessage;
802 PUSER_MESSAGE PostedMessage;
803 PLIST_ENTRY CurrentEntry, ListHead;
804
805 ASSERT(Window);
806
807 pti = Window->head.pti;
808
809 /* remove the posted messages for this window */
810 CurrentEntry = pti->PostedMessagesListHead.Flink;
811 ListHead = &pti->PostedMessagesListHead;
812 while (CurrentEntry != ListHead)
813 {
814 PostedMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
815
816 if (PostedMessage->Msg.hwnd == Window->head.h)
817 {
818 if (PostedMessage->Msg.message == WM_QUIT && pti->QuitPosted == 0)
819 {
820 pti->QuitPosted = 1;
821 pti->exitCode = PostedMessage->Msg.wParam;
822 }
823 ClearMsgBitsMask(pti, PostedMessage->QS_Flags);
824 MsqDestroyMessage(PostedMessage);
825 CurrentEntry = pti->PostedMessagesListHead.Flink;
826 }
827 else
828 {
829 CurrentEntry = CurrentEntry->Flink;
830 }
831 }
832
833 /* remove the sent messages for this window */
834 CurrentEntry = pti->SentMessagesListHead.Flink;
835 ListHead = &pti->SentMessagesListHead;
836 while (CurrentEntry != ListHead)
837 {
838 SentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE, ListEntry);
839
840 if(SentMessage->Msg.hwnd == Window->head.h)
841 {
842 ERR("Remove Window Messages %p From Sent Queue\n",SentMessage);
843#if 0 // Should mark these as invalid and allow the rest clean up, so far no harm by just commenting out. See CORE-9210.
844 ClearMsgBitsMask(pti, SentMessage->QS_Flags);
845
846 /* wake the sender's thread */
847 if (SentMessage->pkCompletionEvent != NULL)
848 {
850 }
851
852 if (SentMessage->HasPackedLParam)
853 {
854 if (SentMessage->Msg.lParam)
855 ExFreePool((PVOID)SentMessage->Msg.lParam);
856 }
857
858 /* free the message */
859 FreeUserMessage(SentMessage);
860
861 CurrentEntry = pti->SentMessagesListHead.Flink;
862#endif
863 CurrentEntry = CurrentEntry->Flink;
864 }
865 else
866 {
867 CurrentEntry = CurrentEntry->Flink;
868 }
869 }
870}
#define WM_QUIT
Definition: winuser.h:1613

Referenced by co_UserFreeWindow().

◆ MsqSendParentNotify()

static void MsqSendParentNotify ( PWND  pwnd,
WORD  event,
WORD  idChild,
POINT  pt 
)
static

Definition at line 1394 of file msgqueue.c.

1395{
1396 PWND pwndDesktop = UserGetDesktopWindow();
1397
1398 /* pt has to be in the client coordinates of the parent window */
1399 pt.x += pwndDesktop->rcClient.left - pwnd->rcClient.left;
1400 pt.y += pwndDesktop->rcClient.top - pwnd->rcClient.top;
1401
1402 for (;;)
1403 {
1404 PWND pwndParent;
1405
1406 if (!(pwnd->style & WS_CHILD)) break;
1407 if (pwnd->ExStyle & WS_EX_NOPARENTNOTIFY) break;
1408 if (!(pwndParent = IntGetParent(pwnd))) break;
1409 if (pwndParent == pwndDesktop) break;
1410 pt.x += pwnd->rcClient.left - pwndParent->rcClient.left;
1411 pt.y += pwnd->rcClient.top - pwndParent->rcClient.top;
1412
1413 pwnd = pwndParent;
1415 MAKEWPARAM( event, idChild ), MAKELPARAM( pt.x, pt.y ) );
1416 }
1417}
#define WS_CHILD
Definition: pedump.c:617
#define WS_EX_NOPARENTNOTIFY
Definition: pedump.c:646
PWND FASTCALL IntGetParent(PWND Wnd)
Definition: window.c:204
#define MAKEWPARAM(l, h)
Definition: winuser.h:3999
#define WM_PARENTNOTIFY
Definition: winuser.h:1793

Referenced by co_IntProcessMouseMessage().

◆ MsqSetMessageExtraInfo()

LPARAM FASTCALL MsqSetMessageExtraInfo ( LPARAM  lParam)

Definition at line 2493 of file msgqueue.c.

2494{
2495 LPARAM Ret;
2496 PTHREADINFO pti;
2497 PUSER_MESSAGE_QUEUE MessageQueue;
2498
2500 MessageQueue = pti->MessageQueue;
2501 if(!MessageQueue)
2502 {
2503 return 0;
2504 }
2505
2506 Ret = MessageQueue->ExtraInfo;
2507 MessageQueue->ExtraInfo = lParam;
2508
2509 return Ret;
2510}

Referenced by NtUserCallOneParam().

◆ MsqSetStateWindow()

HWND FASTCALL MsqSetStateWindow ( PTHREADINFO  pti,
ULONG  Type,
HWND  hWnd 
)

Definition at line 2553 of file msgqueue.c.

2554{
2555 HWND Prev;
2556 PUSER_MESSAGE_QUEUE MessageQueue;
2557
2558 MessageQueue = pti->MessageQueue;
2559
2560 switch(Type)
2561 {
2562 case MSQ_STATE_CAPTURE:
2563 Prev = MessageQueue->spwndCapture ? UserHMGetHandle(MessageQueue->spwndCapture) : 0;
2564 MessageQueue->spwndCapture = ValidateHwndNoErr(hWnd);
2565 return Prev;
2566 case MSQ_STATE_ACTIVE:
2567 Prev = MessageQueue->spwndActive ? UserHMGetHandle(MessageQueue->spwndActive) : 0;
2568 MessageQueue->spwndActive = ValidateHwndNoErr(hWnd);
2569 return Prev;
2570 case MSQ_STATE_FOCUS:
2571 Prev = MessageQueue->spwndFocus ? UserHMGetHandle(MessageQueue->spwndFocus) : 0;
2572 MessageQueue->spwndFocus = ValidateHwndNoErr(hWnd);
2573 return Prev;
2575 Prev = MessageQueue->MenuOwner;
2576 MessageQueue->MenuOwner = hWnd;
2577 return Prev;
2578 case MSQ_STATE_MOVESIZE:
2579 Prev = MessageQueue->MoveSize;
2580 MessageQueue->MoveSize = hWnd;
2581 return Prev;
2582 case MSQ_STATE_CARET:
2583 Prev = MessageQueue->CaretInfo.hWnd;
2584 MessageQueue->CaretInfo.hWnd = hWnd;
2585 return Prev;
2586 }
2587
2588 return NULL;
2589}
Type
Definition: Type.h:7
HWND hWnd
Definition: settings.c:17
#define MSQ_STATE_CARET
Definition: ntuser.h:3709
#define MSQ_STATE_MOVESIZE
Definition: ntuser.h:3708
#define MSQ_STATE_CAPTURE
Definition: ntuser.h:3704
#define MSQ_STATE_FOCUS
Definition: ntuser.h:3706
#define MSQ_STATE_ACTIVE
Definition: ntuser.h:3705
#define MSQ_STATE_MENUOWNER
Definition: ntuser.h:3707
THRDCARETINFO CaretInfo
Definition: msgqueue.h:92

Referenced by co_UserSetCapture(), DefWndDoSizeMove(), IntTrackPopupMenuEx(), MENU_DoNextMenu(), MENU_InitTracking(), MENU_TrackMenu(), and NtUserCallTwoParam().

◆ MsqWakeQueue()

VOID FASTCALL MsqWakeQueue ( PTHREADINFO  pti,
DWORD  MessageBits,
BOOL  KeyEvent 
)

Definition at line 412 of file msgqueue.c.

413{
415
416 Queue = pti->MessageQueue;
417
418 if (Queue->QF_flags & QF_INDESTROY)
419 {
420 ERR("This Message Queue is in Destroy!\n");
421 }
422 pti->pcti->fsWakeBits |= MessageBits;
423 pti->pcti->fsChangeBits |= MessageBits;
424
425 // Start bit accounting to help clear the main set of bits.
426 if (MessageBits & QS_KEY)
427 {
428 pti->nCntsQBits[QSRosKey]++;
429 }
430 if (MessageBits & QS_MOUSE)
431 {
432 if (MessageBits & QS_MOUSEMOVE) pti->nCntsQBits[QSRosMouseMove]++;
433 if (MessageBits & QS_MOUSEBUTTON) pti->nCntsQBits[QSRosMouseButton]++;
434 }
435 if (MessageBits & QS_POSTMESSAGE) pti->nCntsQBits[QSRosPostMessage]++;
436 if (MessageBits & QS_SENDMESSAGE) pti->nCntsQBits[QSRosSendMessage]++;
437 if (MessageBits & QS_HOTKEY) pti->nCntsQBits[QSRosHotKey]++;
438 if (MessageBits & QS_EVENT) pti->nCntsQBits[QSRosEvent]++;
439
440 if (KeyEvent)
442}
_Must_inspect_result_ _In_ WDFDEVICE _In_ PIRP _In_ WDFQUEUE Queue
Definition: wdfdevice.h:2225
#define QS_MOUSE
Definition: winuser.h:886

Referenced by co_IntSendMessageWithCallBack(), co_MsqDispatchOneSentMessage(), co_MsqInsertMouseMessage(), co_MsqSendMessage(), co_MsqSendMessageAsync(), MsqIncPaintCountQueue(), MsqPostMessage(), MsqPostMouseMove(), MsqPostQuitMessage(), and ProcessTimers().

◆ NtUserGetKeyboardState()

DWORD APIENTRY NtUserGetKeyboardState ( LPBYTE  lpKeyState)

Definition at line 2609 of file msgqueue.c.

2610{
2611 DWORD i, ret = TRUE;
2612 PTHREADINFO pti;
2613 PUSER_MESSAGE_QUEUE MessageQueue;
2614
2616
2618 MessageQueue = pti->MessageQueue;
2619
2620 _SEH2_TRY
2621 {
2622 /* Probe and copy key state to an array */
2623 ProbeForWrite(lpKeyState, 256 * sizeof(BYTE), 1);
2624 for (i = 0; i < 256; ++i)
2625 {
2626 lpKeyState[i] = 0;
2627 if (IS_KEY_DOWN(MessageQueue->afKeyState, i))
2628 lpKeyState[i] |= KS_DOWN_BIT;
2629 if (IS_KEY_LOCKED(MessageQueue->afKeyState, i))
2630 lpKeyState[i] |= KS_LOCK_BIT;
2631 }
2632 }
2634 {
2636 ret = FALSE;
2637 }
2638 _SEH2_END;
2639
2640 UserLeave();
2641
2642 return ret;
2643}
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
#define _SEH2_END
Definition: filesup.c:22
#define _SEH2_TRY
Definition: filesup.c:19
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:254
VOID FASTCALL UserEnterShared(VOID)
Definition: ntuser.c:238
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:159
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:34
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:37
#define KS_DOWN_BIT
Definition: input.h:54
#define KS_LOCK_BIT
Definition: input.h:55
#define IS_KEY_LOCKED(ks, vk)
Definition: input.h:100
unsigned char BYTE
Definition: xxhash.c:193

Referenced by GetKeyboardState().

◆ NtUserGetKeyState()

SHORT APIENTRY NtUserGetKeyState ( INT  key)

Definition at line 2593 of file msgqueue.c.

2594{
2595 DWORD Ret;
2596
2598
2599 Ret = UserGetKeyState(key);
2600
2601 UserLeave();
2602
2603 return (SHORT)Ret;
2604}
short SHORT
Definition: pedump.c:59
Definition: copy.c:22

Referenced by GetKeyState().

◆ NtUserSetKeyboardState()

BOOL APIENTRY NtUserSetKeyboardState ( LPBYTE  pKeyState)

Definition at line 2647 of file msgqueue.c.

2648{
2649 UINT i;
2650 BOOL bRet = TRUE;
2651 PTHREADINFO pti;
2652 PUSER_MESSAGE_QUEUE MessageQueue;
2653
2655
2657 MessageQueue = pti->MessageQueue;
2658
2659 _SEH2_TRY
2660 {
2661 ProbeForRead(pKeyState, 256 * sizeof(BYTE), 1);
2662 for (i = 0; i < 256; ++i)
2663 {
2664 SET_KEY_DOWN(MessageQueue->afKeyState, i, pKeyState[i] & KS_DOWN_BIT);
2665 SET_KEY_LOCKED(MessageQueue->afKeyState, i, pKeyState[i] & KS_LOCK_BIT);
2666 }
2667 }
2669 {
2671 bRet = FALSE;
2672 }
2673 _SEH2_END;
2674
2675 UserLeave();
2676
2677 return bRet;
2678}
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:245
#define SET_KEY_DOWN(ks, vk, down)
Definition: input.h:101
#define SET_KEY_LOCKED(ks, vk, down)
Definition: input.h:104

Referenced by SetKeyboardState().

◆ UpdateKeyState()

static VOID UpdateKeyState ( PUSER_MESSAGE_QUEUE  MessageQueue,
WORD  wVk,
BOOL  bIsDown 
)
static

Definition at line 246 of file msgqueue.c.

247{
248 TRACE("UpdateKeyState wVk: %u, bIsDown: %d\n", wVk, bIsDown);
249
250 if (bIsDown)
251 {
252 /* If it's first key down event, xor lock bit */
253 if (!IS_KEY_DOWN(MessageQueue->afKeyState, wVk))
254 SET_KEY_LOCKED(MessageQueue->afKeyState, wVk, !IS_KEY_LOCKED(MessageQueue->afKeyState, wVk));
255
256 SET_KEY_DOWN(MessageQueue->afKeyState, wVk, TRUE);
257 MessageQueue->afKeyRecentDown[wVk / 8] |= (1 << (wVk % 8));
258 }
259 else
260 SET_KEY_DOWN(MessageQueue->afKeyState, wVk, FALSE);
261}
BYTE afKeyRecentDown[256/8]
Definition: msgqueue.h:83

Referenced by UpdateKeyStateFromMsg().

◆ UpdateKeyStateFromMsg()

static VOID UpdateKeyStateFromMsg ( PUSER_MESSAGE_QUEUE  MessageQueue,
MSG msg 
)
static

Definition at line 265 of file msgqueue.c.

266{
267 UCHAR key;
268 BOOL down = FALSE;
269
270 TRACE("UpdateKeyStateFromMsg message:%u\n", msg->message);
271
272 switch (msg->message)
273 {
274 case WM_LBUTTONDOWN:
275 down = TRUE;
276 /* fall through */
277 case WM_LBUTTONUP:
278 UpdateKeyState(MessageQueue, VK_LBUTTON, down);
279 break;
280 case WM_MBUTTONDOWN:
281 down = TRUE;
282 /* fall through */
283 case WM_MBUTTONUP:
284 UpdateKeyState(MessageQueue, VK_MBUTTON, down);
285 break;
286 case WM_RBUTTONDOWN:
287 down = TRUE;
288 /* fall through */
289 case WM_RBUTTONUP:
290 UpdateKeyState(MessageQueue, VK_RBUTTON, down);
291 break;
292 case WM_XBUTTONDOWN:
293 down = TRUE;
294 /* fall through */
295 case WM_XBUTTONUP:
296 if (msg->wParam == XBUTTON1)
297 UpdateKeyState(MessageQueue, VK_XBUTTON1, down);
298 else if (msg->wParam == XBUTTON2)
299 UpdateKeyState(MessageQueue, VK_XBUTTON2, down);
300 break;
301 case WM_KEYDOWN:
302 case WM_SYSKEYDOWN:
303 down = TRUE;
304 /* fall through */
305 case WM_KEYUP:
306 case WM_SYSKEYUP:
307 key = (UCHAR)msg->wParam;
308 UpdateKeyState(MessageQueue, key, down);
309 switch(key)
310 {
311 case VK_LCONTROL:
312 case VK_RCONTROL:
313 down = IS_KEY_DOWN(MessageQueue->afKeyState, VK_LCONTROL) || IS_KEY_DOWN(MessageQueue->afKeyState, VK_RCONTROL);
314 UpdateKeyState(MessageQueue, VK_CONTROL, down);
315 break;
316 case VK_LMENU:
317 case VK_RMENU:
318 down = IS_KEY_DOWN(MessageQueue->afKeyState, VK_LMENU) || IS_KEY_DOWN(MessageQueue->afKeyState, VK_RMENU);
319 UpdateKeyState(MessageQueue, VK_MENU, down);
320 break;
321 case VK_LSHIFT:
322 case VK_RSHIFT:
323 down = IS_KEY_DOWN(MessageQueue->afKeyState, VK_LSHIFT) || IS_KEY_DOWN(MessageQueue->afKeyState, VK_RSHIFT);
324 UpdateKeyState(MessageQueue, VK_SHIFT, down);
325 break;
326 }
327 break;
328 }
329}
#define down(mutex)
Definition: glue.h:29
static VOID UpdateKeyState(PUSER_MESSAGE_QUEUE MessageQueue, WORD wVk, BOOL bIsDown)
Definition: msgqueue.c:246
#define WM_RBUTTONUP
Definition: winuser.h:1770
#define WM_MBUTTONUP
Definition: winuser.h:1773
unsigned char UCHAR
Definition: xmlstorage.h:181

Referenced by co_MsqPeekHardwareMessage().

◆ UserGetKeyState()

DWORD FASTCALL UserGetKeyState ( DWORD  dwKey)

Definition at line 221 of file msgqueue.c.

222{
223 DWORD dwRet = 0;
224 PTHREADINFO pti;
225 PUSER_MESSAGE_QUEUE MessageQueue;
226
228 MessageQueue = pti->MessageQueue;
229
230 if (dwKey < 0x100)
231 {
232 if (IS_KEY_DOWN(MessageQueue->afKeyState, dwKey))
233 dwRet |= 0xFF80; // If down, windows returns 0xFF80.
234 if (IS_KEY_LOCKED(MessageQueue->afKeyState, dwKey))
235 dwRet |= 0x1;
236 }
237 else
238 {
240 }
241 return dwRet;
242}
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101

Referenced by co_IntProcessKeyboardMessage(), co_IntTranslateAccelerator(), IntDefWindowProc(), MENU_InitPopup(), and NtUserGetKeyState().

◆ UserSetCursor()

PCURICON_OBJECT FASTCALL UserSetCursor ( PCURICON_OBJECT  NewCursor,
BOOL  ForceChange 
)

Definition at line 93 of file msgqueue.c.

96{
97 PCURICON_OBJECT OldCursor;
98 HDC hdcScreen;
99 PTHREADINFO pti;
100 PUSER_MESSAGE_QUEUE MessageQueue;
101 PWND pWnd;
102
104 MessageQueue = pti->MessageQueue;
105
106 OldCursor = MessageQueue->CursorObject;
107
108 /* Check if cursors are different */
109 if (OldCursor == NewCursor)
110 return OldCursor;
111
112 /* Update cursor for this message queue */
113 MessageQueue->CursorObject = NewCursor;
114
115 /* If cursor is not visible we have nothing to do */
116 if (MessageQueue->iCursorLevel < 0)
117 return OldCursor;
118
119 // Fixes the error message "Not the same cursor!".
120 if (gpqCursor == NULL)
121 {
122 gpqCursor = MessageQueue;
123 }
124
125 /* Update cursor if this message queue controls it */
126 pWnd = IntTopLevelWindowFromPoint(gpsi->ptCursor.x, gpsi->ptCursor.y);
127 if (pWnd && pWnd->head.pti->MessageQueue == MessageQueue)
128 {
129 /* Get the screen DC */
130 if (!(hdcScreen = IntGetScreenDC()))
131 {
132 return NULL;
133 }
134
135 if (NewCursor)
136 {
137 /* Call GDI to set the new screen cursor */
138 PCURICON_OBJECT CursorFrame = NewCursor;
139 if(NewCursor->CURSORF_flags & CURSORF_ACON)
140 {
141 FIXME("Should animate the cursor, using only the first frame now.\n");
142 CursorFrame = ((PACON)NewCursor)->aspcur[0];
143 }
144 GreSetPointerShape(hdcScreen,
145 CursorFrame->hbmAlpha ? NULL : NewCursor->hbmMask,
146 CursorFrame->hbmAlpha ? NewCursor->hbmAlpha : NewCursor->hbmColor,
147 CursorFrame->xHotspot,
148 CursorFrame->yHotspot,
149 gpsi->ptCursor.x,
150 gpsi->ptCursor.y,
151 CursorFrame->hbmAlpha ? SPS_ALPHA : 0);
152 }
153 else /* Note: OldCursor != NewCursor so we have to hide cursor */
154 {
155 /* Remove the cursor */
156 GreMovePointer(hdcScreen, -1, -1);
157 TRACE("Removing pointer!\n");
158 }
160 }
161
162 /* Return the old cursor */
163 return OldCursor;
164}
#define FIXME(fmt,...)
Definition: debug.h:111
struct tagACON * PACON
#define CURSORF_ACON
Definition: ntuser.h:1197
ULONG CURSORF_flags
Definition: cursoricon.h:16

Referenced by DefWndDoSizeMove(), DesktopWindowProc(), IntSystemSetCursor(), NtUserSetCursor(), and UserChangeDisplaySettings().

◆ UserShowCursor()

int UserShowCursor ( BOOL  bShow)

Definition at line 168 of file msgqueue.c.

169{
170 HDC hdcScreen;
171 PTHREADINFO pti;
172 PUSER_MESSAGE_QUEUE MessageQueue;
173 PWND pWnd;
174
175 if (!(hdcScreen = IntGetScreenDC()))
176 {
177 return -1; /* No mouse */
178 }
179
181 MessageQueue = pti->MessageQueue;
182
183 /* Update counter */
184 MessageQueue->iCursorLevel += bShow ? 1 : -1;
185 pti->iCursorLevel += bShow ? 1 : -1;
186
187 /* Check for trivial cases */
188 if ((bShow && MessageQueue->iCursorLevel != 0) ||
189 (!bShow && MessageQueue->iCursorLevel != -1))
190 {
191 /* Note: w don't update global info here because it is used only
192 internally to check if cursor is visible */
193 return MessageQueue->iCursorLevel;
194 }
195
196 /* Check if cursor is above window owned by this MessageQueue */
197 pWnd = IntTopLevelWindowFromPoint(gpsi->ptCursor.x, gpsi->ptCursor.y);
198 if (pWnd && pWnd->head.pti->MessageQueue == MessageQueue)
199 {
200 if (bShow)
201 {
202 /* Show the pointer */
203 GreMovePointer(hdcScreen, gpsi->ptCursor.x, gpsi->ptCursor.y);
204 TRACE("Showing pointer!\n");
205 }
206 else
207 {
208 /* Remove the pointer */
209 GreMovePointer(hdcScreen, -1, -1);
210 TRACE("Removing pointer!\n");
211 }
212
213 /* Update global info */
215 }
216
217 return MessageQueue->iCursorLevel;
218}
INT iCursorLevel
Definition: win32.h:127

Referenced by DefWndDoSizeMove(), and NtUserCallOneParam().

Variable Documentation

◆ gdwMouseMoveExtraInfo

ULONG_PTR gdwMouseMoveExtraInfo = 0

Definition at line 21 of file msgqueue.c.

Referenced by co_MsqInsertMouseMessage(), and IntCoalesceMouseMove().

◆ gdwMouseMoveTimeStamp

DWORD gdwMouseMoveTimeStamp = 0

Definition at line 22 of file msgqueue.c.

Referenced by co_MsqInsertMouseMessage(), and IntCoalesceMouseMove().

◆ gpqCursor

◆ pgMessageLookasideList

PPAGED_LOOKASIDE_LIST pgMessageLookasideList
static

Definition at line 16 of file msgqueue.c.

Referenced by MsqCreateMessage(), MsqDestroyMessage(), and MsqInitializeImpl().

◆ pgSendMsgLookasideList

PPAGED_LOOKASIDE_LIST pgSendMsgLookasideList
static

Definition at line 17 of file msgqueue.c.

Referenced by AllocateUserMessage(), FreeUserMessage(), and MsqInitializeImpl().

◆ PostMsgCount

INT PostMsgCount = 0

Definition at line 18 of file msgqueue.c.

Referenced by MsqCreateMessage(), MsqDestroyMessage(), and MsqPostMessage().

◆ SendMsgCount

INT SendMsgCount = 0

Definition at line 19 of file msgqueue.c.

Referenced by AllocateUserMessage(), co_MsqSendMessage(), and FreeUserMessage().

◆ usmList