msgqueue.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_USER_MESSAGE
struct	_USER_SENT_MESSAGE
struct	_USER_MESSAGE_QUEUE

Macros
#define	MSQ_HUNG   5000
#define	MSQ_NORMAL   0
#define	MSQ_ISHOOK   1
#define	MSQ_INJECTMODULE   2
#define	SMF_RECEIVERDIED   0x00000002
#define	SMF_SENDERDIED   0x00000004
#define	SMF_RECEIVERFREE   0x00000008
#define	SMF_RECEIVEDMESSAGE   0x00000010
#define	SMF_RECEIVERBUSY   0x00004000
#define	QF_UPDATEKEYSTATE   0x00000001
#define	QF_FMENUSTATUSBREAK   0x00000004
#define	QF_FMENUSTATUS   0x00000008
#define	QF_FF10STATUS   0x00000010
#define	QF_MOUSEMOVED   0x00000020
#define	QF_ACTIVATIONCHANGE   0x00000040
#define	QF_TABSWITCHING   0x00000080
#define	QF_KEYSTATERESET   0x00000100
#define	QF_INDESTROY   0x00000200
#define	QF_LOCKNOREMOVE   0x00000400
#define	QF_FOCUSNULLSINCEACTIVE   0x00000800
#define	QF_DIALOGACTIVE   0x00004000
#define	QF_EVENTDEACTIVATEREMOVED   0x00008000
#define	QF_TRACKMOUSELEAVE   0x00020000
#define	QF_TRACKMOUSEHOVER   0x00040000
#define	QF_TRACKMOUSEFIRING   0x00080000
#define	QF_CAPTURELOCKED   0x00100000
#define	QF_ACTIVEWNDTRACKING   0x00200000
#define	POSTEVENT_DAW   4
#define	POSTEVENT_SAW   5
#define	POSTEVENT_NWE   14
#define	POSTEVENT_NONE   0xFFFF
#define	IntReferenceMessageQueue(MsgQueue)    InterlockedIncrement(&(MsgQueue)->References)
#define	IntDereferenceMessageQueue(MsgQueue)
#define	IS_BTN_MESSAGE(message, code)
#define	WM_NCMOUSEFIRST   WM_NCMOUSEMOVE
#define	WM_NCMOUSELAST   (WM_NCMOUSEFIRST+(WM_MOUSELAST-WM_MOUSEFIRST))
#define	IS_MOUSE_MESSAGE(message)
#define	IS_KBD_MESSAGE(message)    (message >= WM_KEYFIRST && message <= WM_KEYLAST)

Typedefs
typedef struct _USER_MESSAGE	USER_MESSAGE
typedef struct _USER_MESSAGE *	PUSER_MESSAGE
typedef struct _USER_SENT_MESSAGE	USER_SENT_MESSAGE
typedef struct _USER_SENT_MESSAGE *	PUSER_SENT_MESSAGE
typedef struct _USER_MESSAGE_QUEUE	USER_MESSAGE_QUEUE
typedef struct _USER_MESSAGE_QUEUE *	PUSER_MESSAGE_QUEUE

Enumerations
enum	internal_event_message { WM_ASYNC_SHOWWINDOW = 0x80000000 , WM_ASYNC_SETWINDOWPOS , WM_ASYNC_SETACTIVEWINDOW , WM_ASYNC_DESTROYWINDOW }

Functions
BOOL FASTCALL	MsqIsHung (PTHREADINFO pti, DWORD TimeOut)
VOID CALLBACK	HungAppSysTimerProc (HWND, UINT, UINT_PTR, DWORD)
NTSTATUS FASTCALL	co_MsqSendMessage (PTHREADINFO ptirec, HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uTimeout, BOOL Block, INT HookMessage, ULONG_PTR *uResult)
PUSER_MESSAGE FASTCALL	MsqCreateMessage (LPMSG Msg)
VOID FASTCALL	MsqDestroyMessage (PUSER_MESSAGE Message)
VOID FASTCALL	MsqPostMessage (PTHREADINFO, MSG *, BOOLEAN, DWORD, DWORD, LONG_PTR)
VOID FASTCALL	MsqPostQuitMessage (PTHREADINFO pti, ULONG ExitCode)
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)
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 FASTCALL	MsqInitializeMessageQueue (PTHREADINFO, PUSER_MESSAGE_QUEUE)
PUSER_MESSAGE_QUEUE FASTCALL	MsqCreateMessageQueue (PTHREADINFO)
VOID FASTCALL	MsqCleanupThreadMsgs (PTHREADINFO)
VOID FASTCALL	MsqDestroyMessageQueue (_In_ PTHREADINFO pti)
	CODE_SEG ("INIT") NTSTATUS NTAPI MsqInitializeImpl(VOID)
BOOLEAN FASTCALL	co_MsqDispatchOneSentMessage (_In_ PTHREADINFO pti)
NTSTATUS FASTCALL	co_MsqWaitForNewMessages (PTHREADINFO pti, PWND WndFilter, UINT MsgFilterMin, UINT MsgFilterMax)
VOID FASTCALL	MsqIncPaintCountQueue (PTHREADINFO)
VOID FASTCALL	MsqDecPaintCountQueue (PTHREADINFO)
LRESULT FASTCALL	co_IntSendMessage (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT FASTCALL	co_IntPostOrSendMessage (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT FASTCALL	co_IntSendMessageTimeout (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uFlags, UINT uTimeout, ULONG_PTR *uResult)
BOOL FASTCALL	UserSendNotifyMessage (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT FASTCALL	co_IntSendMessageNoWait (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
LRESULT FASTCALL	co_IntSendMessageWithCallBack (HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC CompletionCallback, ULONG_PTR CompletionCallbackContext, ULONG_PTR *uResult)
BOOL FASTCALL	co_MsqSendMessageAsync (PTHREADINFO ptiReceiver, HWND hwnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC CompletionCallback, ULONG_PTR CompletionCallbackContext, BOOL HasPackedLParam, INT HookMessage)
VOID FASTCALL	IntCoalesceMouseMove (PTHREADINFO)
LRESULT FASTCALL	IntDispatchMessage (MSG *Msg)
BOOL FASTCALL	IntTranslateKbdMessage (LPMSG lpMsg, UINT flags)
VOID FASTCALL	co_MsqInsertMouseMessage (MSG *Msg, DWORD flags, ULONG_PTR dwExtraInfo, BOOL Hook)
BOOL FASTCALL	MsqIsClkLck (LPMSG Msg, BOOL Remove)
BOOL FASTCALL	MsqIsDblClk (LPMSG Msg, BOOL Remove)
HWND FASTCALL	MsqSetStateWindow (PTHREADINFO pti, ULONG Type, HWND hWnd)
BOOL APIENTRY	IntInitMessagePumpHook (VOID)
BOOL APIENTRY	IntUninitMessagePumpHook (VOID)
LPARAM FASTCALL	MsqSetMessageExtraInfo (LPARAM lParam)
LPARAM FASTCALL	MsqGetMessageExtraInfo (VOID)
VOID APIENTRY	MsqRemoveWindowMessagesFromQueue (PWND pWindow)
HANDLE FASTCALL	IntMsqSetWakeMask (DWORD WakeMask)
BOOL FASTCALL	IntMsqClearWakeMask (VOID)
VOID FASTCALL	IdlePing (VOID)
VOID FASTCALL	IdlePong (VOID)
BOOL FASTCALL	co_MsqReplyMessage (LRESULT)
VOID FASTCALL	MsqWakeQueue (PTHREADINFO, DWORD, BOOL)
VOID FASTCALL	ClearMsgBitsMask (PTHREADINFO, UINT)
BOOL FASTCALL	IntCallMsgFilter (LPMSG, INT)
WPARAM FASTCALL	MsqGetDownKeyState (PUSER_MESSAGE_QUEUE)
BOOL FASTCALL	IsThreadSuspended (PTHREADINFO)
PUSER_SENT_MESSAGE FASTCALL	AllocateUserMessage (BOOL)
VOID FASTCALL	FreeUserMessage (PUSER_SENT_MESSAGE)
int	UserShowCursor (BOOL bShow)
PCURICON_OBJECT FASTCALL	UserSetCursor (PCURICON_OBJECT NewCursor, BOOL ForceChange)
DWORD APIENTRY	IntGetQueueStatus (DWORD)
UINT	lParamMemorySize (UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL APIENTRY	co_IntGetPeekMessage (PMSG pMsg, HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax, UINT RemoveMsg, BOOL bGMSG)
BOOL FASTCALL	UserPostThreadMessage (PTHREADINFO pti, UINT Msg, WPARAM wParam, LPARAM lParam)
BOOL FASTCALL	co_IntWaitMessage (PWND Window, UINT MsgFilterMin, UINT MsgFilterMax)

Variables
LIST_ENTRY	usmList

Macro Definition Documentation

IntDereferenceMessageQueue

#define IntDereferenceMessageQueue

(

MsgQueue

)

Value:

  do { \
    if(InterlockedDecrement(&(MsgQueue)->References) == 0) \
    { \
      TRACE("Free message queue 0x%p\n", (MsgQueue)); \
      ExFreePoolWithTag((MsgQueue), USERTAG_Q); \
    } \
  } while(0)

Definition at line 220 of file msgqueue.h.

IntReferenceMessageQueue

#define IntReferenceMessageQueue

(

MsgQueue

)

InterlockedIncrement(&(MsgQueue)->References)

Definition at line 217 of file msgqueue.h.

IS_BTN_MESSAGE

#define IS_BTN_MESSAGE	(		message,
			code
	)

Value:

  ((message) == WM_LBUTTON##code || \
   (message) == WM_MBUTTON##code || \
   (message) == WM_RBUTTON##code || \
   (message) == WM_XBUTTON##code || \
   (message) == WM_NCLBUTTON##code || \
   (message) == WM_NCMBUTTON##code || \
   (message) == WM_NCRBUTTON##code || \
   (message) == WM_NCXBUTTON##code )

Definition at line 229 of file msgqueue.h.

IS_KBD_MESSAGE

#define IS_KBD_MESSAGE

(

message

)

(message >= WM_KEYFIRST && message <= WM_KEYLAST)

Definition at line 246 of file msgqueue.h.

IS_MOUSE_MESSAGE

#define IS_MOUSE_MESSAGE

(

message

)

Value:

    ((message >= WM_NCMOUSEFIRST && message <= WM_NCMOUSELAST) || \
            (message >= WM_MOUSEFIRST && message <= WM_MOUSELAST))

Definition at line 242 of file msgqueue.h.

MSQ_HUNG

#define MSQ_HUNG   5000

Definition at line 3 of file msgqueue.h.

MSQ_INJECTMODULE

#define MSQ_INJECTMODULE   2

Definition at line 6 of file msgqueue.h.

MSQ_ISHOOK

#define MSQ_ISHOOK   1

Definition at line 5 of file msgqueue.h.

MSQ_NORMAL

#define MSQ_NORMAL   0

Definition at line 4 of file msgqueue.h.

POSTEVENT_DAW

#define POSTEVENT_DAW   4

Definition at line 123 of file msgqueue.h.

POSTEVENT_NONE

#define POSTEVENT_NONE   0xFFFF

Definition at line 126 of file msgqueue.h.

POSTEVENT_NWE

#define POSTEVENT_NWE   14

Definition at line 125 of file msgqueue.h.

POSTEVENT_SAW

#define POSTEVENT_SAW   5

Definition at line 124 of file msgqueue.h.

QF_ACTIVATIONCHANGE

#define QF_ACTIVATIONCHANGE   0x00000040

Definition at line 100 of file msgqueue.h.

QF_ACTIVEWNDTRACKING

#define QF_ACTIVEWNDTRACKING   0x00200000

Definition at line 112 of file msgqueue.h.

QF_CAPTURELOCKED

#define QF_CAPTURELOCKED   0x00100000

Definition at line 111 of file msgqueue.h.

QF_DIALOGACTIVE

#define QF_DIALOGACTIVE   0x00004000

Definition at line 106 of file msgqueue.h.

QF_EVENTDEACTIVATEREMOVED

#define QF_EVENTDEACTIVATEREMOVED   0x00008000

Definition at line 107 of file msgqueue.h.

QF_FF10STATUS

#define QF_FF10STATUS   0x00000010

Definition at line 98 of file msgqueue.h.

QF_FMENUSTATUS

#define QF_FMENUSTATUS   0x00000008

Definition at line 97 of file msgqueue.h.

QF_FMENUSTATUSBREAK

#define QF_FMENUSTATUSBREAK   0x00000004

Definition at line 96 of file msgqueue.h.

QF_FOCUSNULLSINCEACTIVE

#define QF_FOCUSNULLSINCEACTIVE   0x00000800

Definition at line 105 of file msgqueue.h.

QF_INDESTROY

#define QF_INDESTROY   0x00000200

Definition at line 103 of file msgqueue.h.

QF_KEYSTATERESET

#define QF_KEYSTATERESET   0x00000100

Definition at line 102 of file msgqueue.h.

QF_LOCKNOREMOVE

#define QF_LOCKNOREMOVE   0x00000400

Definition at line 104 of file msgqueue.h.

QF_MOUSEMOVED

#define QF_MOUSEMOVED   0x00000020

Definition at line 99 of file msgqueue.h.

QF_TABSWITCHING

#define QF_TABSWITCHING   0x00000080

Definition at line 101 of file msgqueue.h.

QF_TRACKMOUSEFIRING

#define QF_TRACKMOUSEFIRING   0x00080000

Definition at line 110 of file msgqueue.h.

QF_TRACKMOUSEHOVER

#define QF_TRACKMOUSEHOVER   0x00040000

Definition at line 109 of file msgqueue.h.

QF_TRACKMOUSELEAVE

#define QF_TRACKMOUSELEAVE   0x00020000

Definition at line 108 of file msgqueue.h.

QF_UPDATEKEYSTATE

#define QF_UPDATEKEYSTATE   0x00000001

Definition at line 95 of file msgqueue.h.

SMF_RECEIVEDMESSAGE

#define SMF_RECEIVEDMESSAGE   0x00000010

Definition at line 41 of file msgqueue.h.

SMF_RECEIVERBUSY

#define SMF_RECEIVERBUSY   0x00004000

Definition at line 42 of file msgqueue.h.

SMF_RECEIVERDIED

#define SMF_RECEIVERDIED   0x00000002

Definition at line 38 of file msgqueue.h.

SMF_RECEIVERFREE

#define SMF_RECEIVERFREE   0x00000008

Definition at line 40 of file msgqueue.h.

SMF_SENDERDIED

#define SMF_SENDERDIED   0x00000004

Definition at line 39 of file msgqueue.h.

WM_NCMOUSEFIRST

#define WM_NCMOUSEFIRST   WM_NCMOUSEMOVE

Definition at line 239 of file msgqueue.h.

WM_NCMOUSELAST

#define WM_NCMOUSELAST   (WM_NCMOUSEFIRST+(WM_MOUSELAST-WM_MOUSEFIRST))

Definition at line 240 of file msgqueue.h.

Typedef Documentation

PUSER_MESSAGE

typedef struct _USER_MESSAGE * PUSER_MESSAGE

PUSER_MESSAGE_QUEUE

typedef struct _USER_MESSAGE_QUEUE * PUSER_MESSAGE_QUEUE

PUSER_SENT_MESSAGE

typedef struct _USER_SENT_MESSAGE * PUSER_SENT_MESSAGE

USER_MESSAGE

typedef struct _USER_MESSAGE USER_MESSAGE

USER_MESSAGE_QUEUE

typedef struct _USER_MESSAGE_QUEUE USER_MESSAGE_QUEUE

USER_SENT_MESSAGE

typedef struct _USER_SENT_MESSAGE USER_SENT_MESSAGE

Enumeration Type Documentation

internal_event_message

enum internal_event_message

Enumerator
WM_ASYNC_SHOWWINDOW
WM_ASYNC_SETWINDOWPOS
WM_ASYNC_SETACTIVEWINDOW
WM_ASYNC_DESTROYWINDOW

Definition at line 115 of file msgqueue.h.

{
    WM_ASYNC_SHOWWINDOW = 0x80000000,
    WM_ASYNC_SETWINDOWPOS,
    WM_ASYNC_SETACTIVEWINDOW,
    WM_ASYNC_DESTROYWINDOW
};

Function Documentation

AllocateUserMessage()

PUSER_SENT_MESSAGE FASTCALL AllocateUserMessage

(

BOOL

KEvent

)

Definition at line 763 of file msgqueue.c.

{
   PUSER_SENT_MESSAGE Message;
 
   if(!(Message = ExAllocateFromPagedLookasideList(pgSendMsgLookasideList)))
   {
       ERR("AllocateUserMessage(): Not enough memory to allocate a message\n");
       return NULL;
   }
   RtlZeroMemory(Message, sizeof(USER_SENT_MESSAGE));
 
   if (KEvent)
   {
      Message->pkCompletionEvent = &Message->CompletionEvent;
 
      KeInitializeEvent(Message->pkCompletionEvent, NotificationEvent, FALSE);
   }
   SendMsgCount++;
   TRACE("AUM pti %p msg %p\n",PsGetCurrentThreadWin32Thread(),Message);
   return Message;
}

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.

{
   UINT ClrMask = 0;
 
   if (MessageBits & QS_KEY)
   {
      if (--pti->nCntsQBits[QSRosKey] == 0) ClrMask |= QS_KEY;
   }
   if (MessageBits & QS_MOUSEMOVE)
   {  // Account for tracking mouse moves..
      if (pti->nCntsQBits[QSRosMouseMove])
      {
         pti->nCntsQBits[QSRosMouseMove] = 0; // Throttle down count. Up to > 3:1 entries are ignored.
         ClrMask |= QS_MOUSEMOVE;
      }
   }
   if (MessageBits & QS_MOUSEBUTTON)
   {
      if (--pti->nCntsQBits[QSRosMouseButton] == 0) ClrMask |= QS_MOUSEBUTTON;
   }
   if (MessageBits & QS_POSTMESSAGE)
   {
      if (--pti->nCntsQBits[QSRosPostMessage] == 0) ClrMask |= QS_POSTMESSAGE;
   }
   if (MessageBits & QS_TIMER) // ReactOS hard coded.
   {  // Handle timer bits here.
      if ( pti->cTimersReady )
      {
         if (--pti->cTimersReady == 0) ClrMask |= QS_TIMER;
      }
   }
   if (MessageBits & QS_PAINT) // ReactOS hard coded.
   {  // Handle paint bits here.
      if ( pti->cPaintsReady )
      {
         if (--pti->cPaintsReady == 0) ClrMask |= QS_PAINT;
      }
   }
   if (MessageBits & QS_SENDMESSAGE)
   {
      if (--pti->nCntsQBits[QSRosSendMessage] == 0) ClrMask |= QS_SENDMESSAGE;
   }
   if (MessageBits & QS_HOTKEY)
   {
      if (--pti->nCntsQBits[QSRosHotKey] == 0) ClrMask |= QS_HOTKEY;
   }
   if (MessageBits & QS_EVENT)
   {
      if (--pti->nCntsQBits[QSRosEvent] == 0) ClrMask |= QS_EVENT;
   }
 
   pti->pcti->fsWakeBits &= ~ClrMask;
   pti->pcti->fsChangeBits &= ~ClrMask;
}

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

co_IntGetPeekMessage()

BOOL APIENTRY co_IntGetPeekMessage	(	PMSG	pMsg,
		HWND	hWnd,
		UINT	MsgFilterMin,
		UINT	MsgFilterMax,
		UINT	RemoveMsg,
		BOOL	bGMSG
	)

Definition at line 1176 of file message.c.

{
    PWND Window;
    PTHREADINFO pti;
    BOOL Present = FALSE;
    NTSTATUS Status;
    LONG_PTR ExtraInfo = 0;
 
    if ( hWnd == HWND_TOPMOST || hWnd == HWND_BROADCAST )
        hWnd = HWND_BOTTOM;
 
    /* Validate input */
    if (hWnd && hWnd != HWND_BOTTOM)
    {
        if (!(Window = UserGetWindowObject(hWnd)))
        {
            if (bGMSG)
                return -1;
            else
                return FALSE;
        }
    }
    else
    {
        Window = (PWND)hWnd;
    }
 
    if (MsgFilterMax < MsgFilterMin)
    {
        MsgFilterMin = 0;
        MsgFilterMax = 0;
    }
 
    if (bGMSG)
    {
       RemoveMsg |= ((GetWakeMask( MsgFilterMin, MsgFilterMax ))<< 16);
    }
 
    pti = PsGetCurrentThreadWin32Thread();
    pti->pClientInfo->cSpins++; // Bump up the spin count.
 
    do
    {
        Present = co_IntPeekMessage( pMsg,
                                     Window,
                                     MsgFilterMin,
                                     MsgFilterMax,
                                     RemoveMsg,
                                     &ExtraInfo,
                                     bGMSG );
        if (Present)
        {
           if ( pMsg->message != WM_DEVICECHANGE || (pMsg->wParam & 0x8000) )
           {
               /* GetMessage or PostMessage must never get messages that contain pointers */
               ASSERT(FindMsgMemory(pMsg->message) == NULL);
           }
 
           if ( pMsg->message >= WM_DDE_FIRST && pMsg->message <= WM_DDE_LAST )
           {
              if (!IntDdeGetMessageHook(pMsg, ExtraInfo))
              {
                 TRACE("DDE Get return ERROR\n");
                 continue;
              }
           }
 
           if (pMsg->message != WM_PAINT && pMsg->message != WM_QUIT)
           {
              if (!RtlEqualMemory(&pti->ptLast, &pMsg->pt, sizeof(POINT)))
              {
                 pti->TIF_flags |= TIF_MSGPOSCHANGED;
              }
              pti->timeLast = pMsg->time;
              pti->ptLast   = pMsg->pt;
           }
 
           // The WH_GETMESSAGE hook enables an application to monitor messages about to
           // be returned by the GetMessage or PeekMessage function.
 
           co_HOOK_CallHooks( WH_GETMESSAGE, HC_ACTION, RemoveMsg & PM_REMOVE, (LPARAM)pMsg);
 
           if ( bGMSG || pMsg->message == WM_PAINT) break;
        }
 
        if ( bGMSG )
        {
            Status = co_MsqWaitForNewMessages( pti,
                                               Window,
                                               MsgFilterMin,
                                               MsgFilterMax);
           if ( !NT_SUCCESS(Status) ||
                Status == STATUS_USER_APC ||
                Status == STATUS_TIMEOUT )
           {
              Present = -1;
              break;
           }
        }
        else
        {
           if (!(RemoveMsg & PM_NOYIELD))
           {
              IdlePing();
              // Yield this thread!
              UserLeave();
              ZwYieldExecution();
              UserEnterExclusive();
              // Fall through to exit.
              IdlePong();
           }
           break;
        }
    }
    while( bGMSG && !Present );
 
    // Been spinning, time to swap vinyl...
    if (pti->pClientInfo->cSpins >= 100)
    {
       // Clear the spin cycle to fix the mix.
       pti->pClientInfo->cSpins = 0;
       //if (!(pti->TIF_flags & TIF_SPINNING)) // FIXME: Need to swap vinyl...
    }
    return Present;
}

Referenced by DefWndDoSizeMove(), DefWndStartSizeMove(), DesktopThreadMain(), MENU_SuspendPopup(), MENU_TrackMenu(), NC_DoButton(), NC_HandleNCRButtonDown(), NtUserDragDetect(), NtUserGetMessage(), NtUserPeekMessage(), and NtUserWaitForInputIdle().

co_IntPostOrSendMessage()

LRESULT FASTCALL co_IntPostOrSendMessage	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

co_IntSendMessage()

LRESULT FASTCALL co_IntSendMessage	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1445 of file message.c.

{
    ULONG_PTR Result = 0;
 
    if (co_IntSendMessageTimeout(hWnd, Msg, wParam, lParam, SMTO_NORMAL, 0, &Result))
    {
        return (LRESULT)Result;
    }
    return 0;
}

Referenced by co_IntDoSendMessage(), co_IntPaintWindows(), co_IntProcessKeyboardMessage(), co_IntProcessMouseMessage(), co_IntSendActivateMessages(), co_IntSendDeactivateMessages(), co_IntSetForegroundMessageQueue(), co_IntSetWindowLongPtr(), co_IntTranslateAccelerator(), co_IntUpdateWindows(), co_MsqDispatchOneSentMessage(), co_UserActivateKbl(), co_UserActivateKeyboardLayout(), co_UserCreateWindowEx(), co_UserFreeWindow(), co_UserSetCapture(), co_WinPosDoNCCALCSize(), co_WinPosDoWinPosChanging(), co_WinPosGetMinMaxInfo(), co_WinPosSearchChildren(), co_WinPosShowWindow(), DefWndDoSizeMove(), DefWndHandleSysCommand(), DefWndHandleWindowPosChanged(), DefWndPrint(), DefWndStartSizeMove(), ForceNCPaintErase(), GetControlColor(), IntActivateWindow(), IntBeginPaint(), IntCheckImeShowStatus(), IntClientShutdown(), IntDeactivateWindow(), IntDefWindowProc(), IntEnableWindow(), IntFlashWindowEx(), IntFocusSetInputContext(), IntImeWindowPosChanged(), IntImmActivateLayout(), IntScrollWindowEx(), IntSendDestroyMsg(), IntSendFocusMessages(), IntSendMessageToUI(), IntSendNCPaint(), IntSendOpenStatusNotify(), IntSendParentNotify(), IntShowOwnedPopups(), IntTrackPopupMenuEx(), MENU_CalcItemSize(), MENU_DoNextMenu(), MENU_DrawBitmapItem(), MENU_DrawMenuItem(), MENU_ExitTracking(), MENU_FindItemByKey(), MENU_GetBitmapItemSize(), MENU_HideSubPopups(), MENU_InitTracking(), MENU_SelectItem(), MENU_ShowSubPopup(), MENU_TrackMenu(), MsqSendParentNotify(), NC_DoButton(), NC_DoNCPaint(), NC_HandleNCLButtonDblClk(), NC_HandleNCLButtonDown(), NC_HandleNCRButtonDown(), NtUserChangeClipboardChain(), NtUserGetClipboardData(), NtUserGetComboBoxInfo(), NtUserGetListBoxInfo(), NtUserGetMenuBarInfo(), UserClipboardRelease(), UserEmptyClipboard(), and UserPaintCaption().

co_IntSendMessageNoWait()

LRESULT FASTCALL co_IntSendMessageNoWait	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1709 of file message.c.

{
    ULONG_PTR Result = 0;
    return co_IntSendMessageWithCallBack(hWnd,
                                         Msg,
                                         wParam,
                                         lParam,
                                         NULL,
                                         0,
                                         &Result);
}

Referenced by co_WinPosGetNonClientSize(), co_WinPosMinMaximize(), co_WinPosSendSizeMove(), co_WinPosSetWindowPos(), co_WinPosShowWindow(), IntEndDeferWindowPosEx(), IntSendSyncPaint(), IntSetWindowPlacement(), NtUserSetClipboardViewer(), NtUserShowWindowAsync(), UserClipboardRelease(), UserCloseClipboard(), and UserSendNotifyMessage().

co_IntSendMessageTimeout()

LRESULT FASTCALL co_IntSendMessageTimeout	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		UINT	uFlags,
		UINT	uTimeout,
		ULONG_PTR *	uResult
	)

Definition at line 1653 of file message.c.

{
    PWND DesktopWindow;
    HWND *Children;
    HWND *Child;
 
    if (hWnd != HWND_BROADCAST && hWnd != HWND_TOPMOST)
    {
        return co_IntSendMessageTimeoutSingle(hWnd, Msg, wParam, lParam, uFlags, uTimeout, uResult);
    }
 
    if (!is_message_broadcastable(Msg)) return TRUE;
 
    DesktopWindow = UserGetDesktopWindow();
    if (NULL == DesktopWindow)
    {
       EngSetLastError(ERROR_INTERNAL_ERROR);
       return 0;
    }
 
    if (hWnd != HWND_TOPMOST)
    {
       /* Send message to the desktop window too! */
       co_IntSendMessageTimeoutSingle(DesktopWindow->head.h, Msg, wParam, lParam, uFlags, uTimeout, uResult);
    }
 
    Children = IntWinListChildren(DesktopWindow);
    if (NULL == Children)
    {
        return 0;
    }
 
    for (Child = Children; NULL != *Child; Child++)
    {
        PWND pwnd = UserGetWindowObject(*Child);
        if (!pwnd) continue;
 
        if ( pwnd->fnid == FNID_MENU ||
             pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_SWITCH] )
           continue;
 
        co_IntSendMessageTimeoutSingle(*Child, Msg, wParam, lParam, uFlags, uTimeout, uResult);
    }
 
    ExFreePoolWithTag(Children, USERTAG_WINDOWLIST);
 
    return (LRESULT) TRUE;
}

Referenced by co_IntDoSendMessage(), co_IntSendMessage(), NtUserMessageCall(), UserChangeDisplaySettings(), and UserSystemParametersInfo().

co_IntSendMessageWithCallBack()

LRESULT FASTCALL co_IntSendMessageWithCallBack	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam,
		SENDASYNCPROC	CompletionCallback,
		ULONG_PTR	CompletionCallbackContext,
		ULONG_PTR *	uResult
	)

Definition at line 1731 of file message.c.

{
    ULONG_PTR Result;
    PWND Window = NULL;
    PMSGMEMORY MsgMemoryEntry;
    INT lParamBufferSize;
    LPARAM lParamPacked;
    PTHREADINFO Win32Thread, ptiSendTo = NULL;
    DECLARE_RETURN(LRESULT);
    USER_REFERENCE_ENTRY Ref;
    PUSER_SENT_MESSAGE Message;
    BOOL DoCallBack = TRUE;
 
    if (!(Window = UserGetWindowObject(hWnd)))
    {
        TRACE("SendMessageWithCallBack: Invalid handle 0x%p\n",hWnd);
        RETURN(FALSE);
    }
 
    UserRefObjectCo(Window, &Ref);
 
    if (Window->state & WNDS_DESTROYED)
    {
        /* FIXME: last error? */
        ERR("Attempted to send message to window %p that is being destroyed\n", hWnd);
        RETURN(FALSE);
    }
 
    Win32Thread = PsGetCurrentThreadWin32Thread();
 
    if (Win32Thread == NULL || Win32Thread->TIF_flags & TIF_INCLEANUP)
        RETURN(FALSE);
 
    ptiSendTo = IntSendTo(Window, Win32Thread, Msg);
 
    if (Msg & 0x80000000 &&
        !ptiSendTo)
    {
        if (Win32Thread->TIF_flags & TIF_INCLEANUP) RETURN(FALSE);
 
        TRACE("SMWCB: Internal Message\n");
        Result = (ULONG_PTR)handle_internal_message(Window, Msg, wParam, lParam);
        if (uResult) *uResult = Result;
        RETURN(TRUE);
    }
 
    /* See if this message type is present in the table */
    MsgMemoryEntry = FindMsgMemory(Msg);
    if (NULL == MsgMemoryEntry)
    {
        lParamBufferSize = -1;
    }
    else
    {
        lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
        if (!lParamBufferSize) lParamBufferSize = -1;
    }
 
    if (!NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, !!ptiSendTo)))
    {
        ERR("Failed to pack message parameters\n");
        RETURN(FALSE);
    }
 
    /* If it can be sent now, then send it. */
    if (!ptiSendTo)
    {
        if (Win32Thread->TIF_flags & TIF_INCLEANUP)
        {
            UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE);
            /* Never send messages to exiting threads */
            RETURN(FALSE);
        }
 
        IntCallWndProc(Window, hWnd, Msg, wParam, lParam);
 
        if (Window->state & WNDS_SERVERSIDEWINDOWPROC)
        {
           TRACE("SMWCB: Server Side Window Procedure\n");
           switch(Window->fnid)
           {
              case FNID_DESKTOP:
                DoCallBack = !DesktopWindowProc(Window, Msg, wParam, lParamPacked, (LRESULT*)&Result);
                break;
              case FNID_MESSAGEWND:
                DoCallBack = !UserMessageWindowProc(Window, Msg, wParam, lParam, (LRESULT*)&Result);
                break;
              case FNID_MENU:
                DoCallBack = !PopupMenuWndProc(Window, Msg, wParam, lParam, (LRESULT*)&Result);
                break;
           }
        }
 
        if (DoCallBack)
        Result = (ULONG_PTR)co_IntCallWindowProc(Window->lpfnWndProc,
                                                 !Window->Unicode,
                                                 hWnd,
                                                 Msg,
                                                 wParam,
                                                 lParamPacked,
                                                 lParamBufferSize);
        if(uResult)
        {
            *uResult = Result;
        }
 
        IntCallWndProcRet(Window, hWnd, Msg, wParam, lParam, (LRESULT *)uResult);
 
        if (CompletionCallback)
        {
            co_IntCallSentMessageCallback(CompletionCallback,
                                          hWnd,
                                          Msg,
                                          CompletionCallbackContext,
                                          Result);
        }
    }
 
    if (!ptiSendTo)
    {
        if (!NT_SUCCESS(UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE)))
        {
            ERR("Failed to unpack message parameters\n");
        }
        RETURN(TRUE);
    }
 
    if(!(Message = AllocateUserMessage(FALSE)))
    {
        ERR("Failed to allocate message\n");
        RETURN(FALSE);
    }
 
    Message->Msg.hwnd = hWnd;
    Message->Msg.message = Msg;
    Message->Msg.wParam = wParam;
    Message->Msg.lParam = lParamPacked;
    Message->pkCompletionEvent = NULL; // No event needed.
    Message->lResult = 0;
    Message->QS_Flags = 0;
    Message->ptiReceiver = ptiSendTo;
    Message->ptiSender = NULL;
    Message->ptiCallBackSender = Win32Thread;
    Message->CompletionCallback = CompletionCallback;
    Message->CompletionCallbackContext = CompletionCallbackContext;
    Message->HookMessage = MSQ_NORMAL;
    Message->HasPackedLParam = (lParamBufferSize > 0);
    Message->QS_Flags = QS_SENDMESSAGE;
    Message->flags = SMF_RECEIVERFREE;
 
    if (Msg & 0x80000000) // Higher priority event message!
        InsertHeadList(&ptiSendTo->SentMessagesListHead, &Message->ListEntry);
    else
        InsertTailList(&ptiSendTo->SentMessagesListHead, &Message->ListEntry);
    MsqWakeQueue(ptiSendTo, QS_SENDMESSAGE, TRUE);
 
    RETURN(TRUE);
 
CLEANUP:
    if (Window) UserDerefObjectCo(Window);
    END_CLEANUP;
}

Referenced by co_IntSendMessageNoWait(), IntFocusSetInputContext(), and NtUserMessageCall().

co_IntWaitMessage()

BOOL FASTCALL co_IntWaitMessage	(	PWND	Window,
		UINT	MsgFilterMin,
		UINT	MsgFilterMax
	)

Definition at line 1130 of file message.c.

{
    PTHREADINFO pti;
    NTSTATUS Status = STATUS_SUCCESS;
    MSG Msg;
    LONG_PTR ExtraInfo = 0;
 
    pti = PsGetCurrentThreadWin32Thread();
 
    do
    {
        if ( co_IntPeekMessage( &Msg,       // Dont reenter!
                                 Window,
                                 MsgFilterMin,
                                 MsgFilterMax,
                                 MAKELONG( PM_NOREMOVE, GetWakeMask( MsgFilterMin, MsgFilterMax)),
                                 &ExtraInfo,
                                 TRUE ) )   // act like GetMessage.
        {
            return TRUE;
        }
 
        /* Nothing found. Wait for new messages. */
        Status = co_MsqWaitForNewMessages( pti,
                                           Window,
                                           MsgFilterMin,
                                           MsgFilterMax);
        if (!NT_SUCCESS(Status))
        {
            SetLastNtError(Status);
            ERR("Exit co_IntWaitMessage on error!\n");
            return FALSE;
        }
        if (Status == STATUS_USER_APC || Status == STATUS_TIMEOUT)
        {
           return FALSE;
        }
    }
    while ( TRUE );
 
    return FALSE;
}

Referenced by MENU_TrackMenu(), NtUserDragDetect(), and NtUserWaitMessage().

co_MsqDispatchOneSentMessage()

BOOLEAN FASTCALL co_MsqDispatchOneSentMessage

(

_In_ PTHREADINFO

pti

)

Definition at line 873 of file msgqueue.c.

{
   PUSER_SENT_MESSAGE SaveMsg, Message;
   PLIST_ENTRY Entry;
   BOOL Ret;
   LRESULT Result = 0;
 
   ASSERT(pti == PsGetCurrentThreadWin32Thread());
 
   if (IsListEmpty(&pti->SentMessagesListHead))
   {
      return(FALSE);
   }
 
   /* remove it from the list of pending messages */
   Entry = RemoveHeadList(&pti->SentMessagesListHead);
   Message = CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry);
 
   // Signal this message is being processed.
   Message->flags |= SMF_RECEIVERBUSY|SMF_RECEIVEDMESSAGE;
 
   SaveMsg = pti->pusmCurrent;
   pti->pusmCurrent = Message;
 
   // Processing a message sent to it from another thread.
   if ( ( Message->ptiSender && pti != Message->ptiSender) ||
        ( Message->ptiCallBackSender && pti != Message->ptiCallBackSender ))
   {  // most likely, but, to be sure.
      pti->pcti->CTI_flags |= CTI_INSENDMESSAGE; // Let the user know...
   }
 
   /* Now insert it to the global list of messages that can be removed Justin Case there's Trouble */
   InsertTailList(&usmList, &Message->ListEntry);
 
   ClearMsgBitsMask(pti, Message->QS_Flags);
 
   if (Message->HookMessage == MSQ_ISHOOK)
   {  // Direct Hook Call processor
      Result = co_CallHook( Message->Msg.message,           // HookId
                           (INT)(INT_PTR)Message->Msg.hwnd, // Code
                            Message->Msg.wParam,
                            Message->Msg.lParam);
   }
   else if(Message->HookMessage == MSQ_INJECTMODULE)
   {
       Result = IntLoadHookModule(Message->Msg.message,
                                  (HHOOK)Message->Msg.lParam,
                                  Message->Msg.wParam);
   }
   else if ((Message->CompletionCallback) &&
            (Message->ptiCallBackSender == pti))
   {   /* Call the callback routine */
      if (Message->QS_Flags & QS_SMRESULT)
      {
         co_IntCallSentMessageCallback(Message->CompletionCallback,
                                       Message->Msg.hwnd,
                                       Message->Msg.message,
                                       Message->CompletionCallbackContext,
                                       Message->lResult);
         /* Set callback to NULL to prevent reentry */
         Message->CompletionCallback = NULL;
      }
      else
      {
         /* The message has not been processed yet, reinsert it. */
         RemoveEntryList(&Message->ListEntry);
         InsertTailList(&Message->ptiCallBackSender->SentMessagesListHead, &Message->ListEntry);
         // List is occupied need to set the bit.
         MsqWakeQueue(Message->ptiCallBackSender, QS_SENDMESSAGE, TRUE);
         ERR("Callback Message not processed yet. Requeuing the message\n"); 
         Ret = FALSE;
         goto Exit;
      }
   }
   else
   {  /* Call the window procedure. */
      Result = co_IntSendMessage( Message->Msg.hwnd,
                                  Message->Msg.message,
                                  Message->Msg.wParam,
                                  Message->Msg.lParam);
   }
 
   /* If the message is a callback, insert it in the callback senders MessageQueue */
   if (Message->CompletionCallback)
   {
      if (Message->ptiCallBackSender)
      {
         Message->lResult = Result;
         Message->QS_Flags |= QS_SMRESULT;
 
         /* insert it in the callers message queue */
         RemoveEntryList(&Message->ListEntry);
         InsertTailList(&Message->ptiCallBackSender->SentMessagesListHead, &Message->ListEntry);
         MsqWakeQueue(Message->ptiCallBackSender, QS_SENDMESSAGE, TRUE);
      }
      Ret = TRUE;
      goto Exit;
   }
 
   // Retrieve the result from callback.
   if (Message->QS_Flags & QS_SMRESULT)
   {
      Result = Message->lResult;
   }
 
   /* Let the sender know the result. */
   Message->lResult = Result;
 
   if (Message->HasPackedLParam)
   {
      if (Message->Msg.lParam)
         ExFreePool((PVOID)Message->Msg.lParam);
   }
 
   // Clear busy signal.
   Message->flags &= ~SMF_RECEIVERBUSY;
 
   /* Notify the sender. */
   if (Message->pkCompletionEvent != NULL)
   {
      KeSetEvent(Message->pkCompletionEvent, IO_NO_INCREMENT, FALSE);
   }
 
   /* free the message */
   if (Message->flags & SMF_RECEIVERFREE)
   {
      TRACE("Receiver Freeing Message %p\n",Message);
      FreeUserMessage(Message);
   }
 
   Ret = TRUE;
Exit:
   /* do not hangup on the user if this is reentering */
   if (!SaveMsg) pti->pcti->CTI_flags &= ~CTI_INSENDMESSAGE;
   pti->pusmCurrent = SaveMsg;
 
   return Ret;
}

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.

{
   MSLLHOOKSTRUCT MouseHookData;
//   PDESKTOP pDesk;
   PWND pwnd, pwndDesktop;
   HDC hdcScreen;
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE MessageQueue;
   PSYSTEM_CURSORINFO CurInfo;
 
   Msg->time = EngGetTickCount32();
 
   MouseHookData.pt.x = LOWORD(Msg->lParam);
   MouseHookData.pt.y = HIWORD(Msg->lParam);
   switch (Msg->message)
   {
      case WM_MOUSEWHEEL:
         MouseHookData.mouseData = MAKELONG(0, GET_WHEEL_DELTA_WPARAM(Msg->wParam));
         break;
      case WM_XBUTTONDOWN:
      case WM_XBUTTONUP:
      case WM_XBUTTONDBLCLK:
      case WM_NCXBUTTONDOWN:
      case WM_NCXBUTTONUP:
      case WM_NCXBUTTONDBLCLK:
         MouseHookData.mouseData = MAKELONG(0, HIWORD(Msg->wParam));
         break;
      default:
         MouseHookData.mouseData = 0;
         break;
   }
 
   MouseHookData.flags = flags; // LLMHF_INJECTED
   MouseHookData.time = Msg->time;
   MouseHookData.dwExtraInfo = dwExtraInfo;
 
   /* If the hook procedure returned non zero, dont send the message */
   if (Hook)
   {
      if (co_HOOK_CallHooks(WH_MOUSE_LL, HC_ACTION, Msg->message, (LPARAM) &MouseHookData))
         return;
   }
 
   /* Get the desktop window */
   pwndDesktop = UserGetDesktopWindow();
   if (!pwndDesktop) return;
//   pDesk = pwndDesktop->head.rpdesk;
 
   /* Check if the mouse is captured */
   Msg->hwnd = IntGetCaptureWindow();
   if (Msg->hwnd != NULL)
   {
       pwnd = UserGetWindowObject(Msg->hwnd);
   }
   else
   {
       pwnd = IntTopLevelWindowFromPoint(Msg->pt.x, Msg->pt.y);
       if (pwnd) Msg->hwnd = pwnd->head.h;
   }
 
   hdcScreen = IntGetScreenDC();
   CurInfo = IntGetSysCursorInfo();
 
   /* Check if we found a window */
   if (Msg->hwnd != NULL && pwnd != NULL)
   {
       pti = pwnd->head.pti;
       MessageQueue = pti->MessageQueue;
 
       if (MessageQueue->QF_flags & QF_INDESTROY)
       {
          ERR("Mouse is over a Window with a Dead Message Queue!\n");
          return;
       }
 
       // Check to see if this is attached.
       if ( pti != MessageQueue->ptiMouse &&
            MessageQueue->cThreads > 1 )
       {
          // Set the send pti to the message queue mouse pti.
          pti = MessageQueue->ptiMouse;
       }
 
       if (Msg->message == WM_MOUSEMOVE)
       {
          /* Check if cursor should be visible */
           if(hdcScreen &&
              MessageQueue->CursorObject &&
              MessageQueue->iCursorLevel >= 0)
           {
               /* Check if shape has changed */
               if(CurInfo->CurrentCursorObject != MessageQueue->CursorObject)
               {
                   /* Call GDI to set the new screen cursor */
                    GreSetPointerShape(hdcScreen,
                                       MessageQueue->CursorObject->hbmAlpha ?
                                           NULL : MessageQueue->CursorObject->hbmMask,
                                       MessageQueue->CursorObject->hbmAlpha ?
                                           MessageQueue->CursorObject->hbmAlpha : MessageQueue->CursorObject->hbmColor,
                                       MessageQueue->CursorObject->xHotspot,
                                       MessageQueue->CursorObject->yHotspot,
                                       gpsi->ptCursor.x,
                                       gpsi->ptCursor.y,
                                       MessageQueue->CursorObject->hbmAlpha ? SPS_ALPHA : 0);
 
               } else
                   GreMovePointer(hdcScreen, Msg->pt.x, Msg->pt.y);
           }
           /* Check if we have to hide cursor */
           else if (CurInfo->ShowingCursor >= 0)
               GreMovePointer(hdcScreen, -1, -1);
 
           /* Update global cursor info */
           CurInfo->ShowingCursor = MessageQueue->iCursorLevel;
           CurInfo->CurrentCursorObject = MessageQueue->CursorObject;
           gpqCursor = MessageQueue;
 
           /* Mouse move is a special case */
           MessageQueue->QF_flags |= QF_MOUSEMOVED;
           gdwMouseMoveExtraInfo = dwExtraInfo;
           gdwMouseMoveTimeStamp = Msg->time;
           MsqWakeQueue(pti, QS_MOUSEMOVE, TRUE);
       }
       else
       {
           if (!IntGetCaptureWindow())
           {
             // ERR("ptiLastInput is set\n");
             // ptiLastInput = pti; // Once this is set during Reboot or Shutdown, this prevents the exit window having foreground.
             // Find all the Move Mouse calls and fix mouse set active focus issues......
           }
 
           // Post mouse move before posting mouse buttons, keep it in sync.
           if (pti->MessageQueue->QF_flags & QF_MOUSEMOVED)
           {
              IntCoalesceMouseMove(pti);
           }
 
           TRACE("Posting mouse message to hwnd=%p!\n", UserHMGetHandle(pwnd));
           MsqPostMessage(pti, Msg, TRUE, QS_MOUSEBUTTON, 0, dwExtraInfo);
       }
   }
   else if (hdcScreen)
   {
       /* always show cursor on background; FIXME: set default pointer */
       GreMovePointer(hdcScreen, Msg->pt.x, Msg->pt.y);
       CurInfo->ShowingCursor = 0;
   }
}

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.

{
   BOOL AcceptMessage, NotForUs;
   PUSER_MESSAGE CurrentMessage;
   PLIST_ENTRY ListHead;
   MSG msg;
   ULONG_PTR idSave;
   DWORD QS_Flags;
   LONG_PTR ExtraInfo;
   BOOL Ret = FALSE;
   PUSER_MESSAGE_QUEUE MessageQueue = pti->MessageQueue;
 
   if (!filter_contains_hw_range( MsgFilterLow, MsgFilterHigh )) return FALSE;
 
   ListHead = MessageQueue->HardwareMessagesListHead.Flink;
 
   if (IsListEmpty(ListHead)) return FALSE;
 
   if (!MessageQueue->ptiSysLock)
   {
      MessageQueue->ptiSysLock = pti;
      pti->pcti->CTI_flags |= CTI_THREADSYSLOCK;
   }
 
   if (MessageQueue->ptiSysLock != pti)
   {
      ERR("Thread Q is locked to ptiSysLock 0x%p pti 0x%p\n",MessageQueue->ptiSysLock,pti);
      return FALSE;
   }
 
   while (ListHead != &MessageQueue->HardwareMessagesListHead)
   {
      CurrentMessage = CONTAINING_RECORD(ListHead, USER_MESSAGE, ListEntry);
      ListHead = ListHead->Flink;
 
      if (MessageQueue->idSysPeek == (ULONG_PTR)CurrentMessage)
      {
         TRACE("Skip this message due to it is in play!\n");
         continue;
      }
/*
 MSDN:
 1: any window that belongs to the current thread, and any messages on the current thread's message queue whose hwnd value is NULL.
 2: retrieves only messages on the current thread's message queue whose hwnd value is NULL.
 3: handle to the window whose messages are to be retrieved.
 */
      if ( ( !Window || // 1
            ( Window == PWND_BOTTOM && CurrentMessage->Msg.hwnd == NULL ) || // 2
            ( Window != PWND_BOTTOM && Window->head.h == CurrentMessage->Msg.hwnd ) || // 3
            ( is_mouse_message(CurrentMessage->Msg.message) ) ) && // Null window for anything mouse.
            ( ( ( MsgFilterLow == 0 && MsgFilterHigh == 0 ) && CurrentMessage->QS_Flags & QSflags ) ||
              ( MsgFilterLow <= CurrentMessage->Msg.message && MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
      {
         idSave = MessageQueue->idSysPeek;
         MessageQueue->idSysPeek = (ULONG_PTR)CurrentMessage;
 
         msg = CurrentMessage->Msg;
         ExtraInfo = CurrentMessage->ExtraInfo;
         QS_Flags = CurrentMessage->QS_Flags;
 
         NotForUs = FALSE;
 
         UpdateKeyStateFromMsg(MessageQueue, &msg);
         AcceptMessage = co_IntProcessHardwareMessage(&msg, &Remove, &NotForUs, ExtraInfo, MsgFilterLow, MsgFilterHigh);
 
         if (Remove)
         {
             if (CurrentMessage->pti != NULL && (MessageQueue->idSysPeek == (ULONG_PTR)CurrentMessage))
             {
                MsqDestroyMessage(CurrentMessage);
             }
             ClearMsgBitsMask(pti, QS_Flags);
         }
 
         MessageQueue->idSysPeek = idSave;
 
         if (NotForUs)
         {
            Ret = FALSE;
            break;
         }
 
         if (AcceptMessage)
         {
            *pMsg = msg;
            // Fix all but one wine win:test_GetMessagePos WM_TIMER tests. See PostTimerMessages.
            if (!RtlEqualMemory(&pti->ptLast, &msg.pt, sizeof(POINT)))
            {
               pti->TIF_flags |= TIF_MSGPOSCHANGED;
            }
            pti->timeLast = msg.time;
            pti->ptLast   = msg.pt;
            MessageQueue->ExtraInfo = ExtraInfo;
            Ret = TRUE;
            break;
         }
      }
   }
 
   MessageQueue->ptiSysLock = NULL;
   pti->pcti->CTI_flags &= ~CTI_THREADSYSLOCK;
   return Ret;
}

Referenced by co_IntPeekMessage().

co_MsqReplyMessage()

BOOL FASTCALL co_MsqReplyMessage

(

LRESULT

lResult

)

Definition at line 2530 of file msgqueue.c.

{
   PUSER_SENT_MESSAGE Message;
   PTHREADINFO pti;
 
   pti = PsGetCurrentThreadWin32Thread();
   Message = pti->pusmCurrent;
 
   if (!Message) return FALSE;
 
   if (Message->QS_Flags & QS_SMRESULT) return FALSE;
 
   //     SendMessageXxx  || Callback msg and not a notify msg
   if (Message->ptiSender || Message->CompletionCallback)
   {
      Message->lResult = lResult;
      Message->QS_Flags |= QS_SMRESULT;
   // See co_MsqDispatchOneSentMessage, change bits already accounted for and cleared and this msg is going away..
   }
   return TRUE;
}

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.

{
   PTHREADINFO pti;
   PUSER_SENT_MESSAGE SaveMsg, Message;
   NTSTATUS WaitStatus;
   LARGE_INTEGER Timeout;
   PLIST_ENTRY Entry;
   PWND pWnd;
   BOOLEAN SwapStateEnabled;
   LRESULT Result = 0;   
 
   pti = PsGetCurrentThreadWin32Thread();
   ASSERT(pti != ptirec);
   ASSERT(ptirec->pcti); // Send must have a client side to receive it!!!!
 
   /* Don't send from or to a dying thread */
   if (pti->TIF_flags & TIF_INCLEANUP || ptirec->TIF_flags & TIF_INCLEANUP)
   {
       // Unless we are dying and need to tell our parents.
       if (pti->TIF_flags & TIF_INCLEANUP && !(ptirec->TIF_flags & TIF_INCLEANUP))
       {
           // Parent notify is the big one. Fire and forget!
           TRACE("Send message from dying thread %u\n", Msg);
           co_MsqSendMessageAsync(ptirec, Wnd, Msg, wParam, lParam, NULL, 0, FALSE, HookMessage);
       }
       if (uResult) *uResult = -1;
       TRACE("MsqSM: Msg %u Current pti %lu or Rec pti %lu\n", Msg, pti->TIF_flags & TIF_INCLEANUP, ptirec->TIF_flags & TIF_INCLEANUP);
       return STATUS_UNSUCCESSFUL;
   }
 
   if (IsThreadSuspended(ptirec))
   {
      ERR("Sending to Suspended Thread Msg %lx\n",Msg);
      if (uResult) *uResult = -1;
      return STATUS_UNSUCCESSFUL;
   }
 
   // Should we do the same for No Wait?
   if ( HookMessage == MSQ_NORMAL )
   {
      pWnd = ValidateHwndNoErr(Wnd);
 
      // These can not cross International Border lines!
      if ( pti->ppi != ptirec->ppi && pWnd )
      {
         switch(Msg)
         {
             // Handle the special case when working with password transfers across bordering processes.
             case EM_GETLINE:
             case EM_SETPASSWORDCHAR:
             case WM_GETTEXT:
                // Look for edit controls setup for passwords.
                if ( gpsi->atomSysClass[ICLS_EDIT] == pWnd->pcls->atomClassName && // Use atomNVClassName.
                     pWnd->style & ES_PASSWORD )
                {
                   if (uResult) *uResult = -1;
                   ERR("Running across the border without a passport!\n");
                   EngSetLastError(ERROR_ACCESS_DENIED);
                   return STATUS_UNSUCCESSFUL;
                }
                break;
             case WM_NOTIFY:
                if (uResult) *uResult = -1;
                ERR("Running across the border without a passport!\n");
                return STATUS_UNSUCCESSFUL;
         }
      }
 
      // These can not cross State lines!
      if ( Msg == WM_CREATE || Msg == WM_NCCREATE )
      {
         if (uResult) *uResult = -1;
         ERR("Can not tell the other State we have Create!\n");
         return STATUS_UNSUCCESSFUL;
      }
   }
 
   if(!(Message = AllocateUserMessage(TRUE)))
   {
      ERR("MsqSendMessage(): Not enough memory to allocate a message\n");
      if (uResult) *uResult = -1;
      return STATUS_INSUFFICIENT_RESOURCES;
   }
 
   Timeout.QuadPart = Int32x32To64(-10000,uTimeout); // Pass SMTO test with a TO of 0x80000000.
   TRACE("Timeout val %lld\n",Timeout.QuadPart);
 
   Message->Msg.hwnd = Wnd;
   Message->Msg.message = Msg;
   Message->Msg.wParam = wParam;
   Message->Msg.lParam = lParam;
   Message->ptiReceiver = ptirec;
   Message->ptiSender = pti;
   Message->HookMessage = HookMessage;
   Message->QS_Flags = QS_SENDMESSAGE;
 
   SaveMsg = pti->pusmSent;
   pti->pusmSent = Message;
 
   /* Queue it in the destination's message queue */
   InsertTailList(&ptirec->SentMessagesListHead, &Message->ListEntry);
 
   MsqWakeQueue(ptirec, QS_SENDMESSAGE, TRUE);
 
   // First time in, turn off swapping of the stack.
   if (pti->cEnterCount == 0)
   {
      SwapStateEnabled = KeSetKernelStackSwapEnable(FALSE);
   }
   pti->cEnterCount++;
 
   if (Block)
   {
      PVOID WaitObjects[2];
 
      WaitObjects[0] = Message->pkCompletionEvent; // Wait 0
      WaitObjects[1] = ptirec->pEThread;           // Wait 1
 
      UserLeaveCo();
 
      WaitStatus = KeWaitForMultipleObjects( 2,
                                             WaitObjects,
                                             WaitAny,
                                             UserRequest,
                                             UserMode,
                                             FALSE,
                                            (uTimeout ? &Timeout : NULL),
                                             NULL );
 
      UserEnterCo();
 
      if (WaitStatus == STATUS_TIMEOUT)
      {
         /* Look up if the message has not yet dispatched, if so
            make sure it can't pass a result and it must not set the completion event anymore */
         Entry = ptirec->SentMessagesListHead.Flink;
         while (Entry != &ptirec->SentMessagesListHead)
         {
            if (CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry) == Message)
            {
               Message->pkCompletionEvent = NULL;
               RemoveEntryList(&Message->ListEntry);
               ClearMsgBitsMask(ptirec, Message->QS_Flags);
               InsertTailList(&usmList, &Message->ListEntry);
               break;
            }
            Entry = Entry->Flink;
         }
 
         ERR("MsqSendMessage (blocked) timed out 1 Status %lx\n", WaitStatus);
      }
      // Receiving thread passed on and left us hanging with issues still pending.
      else if (WaitStatus == STATUS_WAIT_1)
      {
         ERR("Bk Receiving Thread woken up dead!\n");
         Message->flags |= SMF_RECEIVERDIED;
      }
 
      while (co_MsqDispatchOneSentMessage(pti))
         ;
   }
   else
   {
      PVOID WaitObjects[3];
 
      WaitObjects[0] = Message->pkCompletionEvent; // Wait 0
      WaitObjects[1] = pti->pEventQueueServer;     // Wait 1
      WaitObjects[2] = ptirec->pEThread;           // Wait 2
 
      do
      {
         UserLeaveCo();
 
         WaitStatus = KeWaitForMultipleObjects( 3,
                                                WaitObjects,
                                                WaitAny,
                                                UserRequest,
                                                UserMode,
                                                FALSE,
                                               (uTimeout ? &Timeout : NULL),
                                                NULL);
 
         UserEnterCo();
 
         if (WaitStatus == STATUS_TIMEOUT)
         {
            /* Look up if the message has not yet been dispatched, if so
               make sure it can't pass a result and it must not set the completion event anymore */
            Entry = ptirec->SentMessagesListHead.Flink;
            while (Entry != &ptirec->SentMessagesListHead)
            {
               if (CONTAINING_RECORD(Entry, USER_SENT_MESSAGE, ListEntry) == Message)
               {
                  Message->pkCompletionEvent = NULL;
                  RemoveEntryList(&Message->ListEntry);
                  ClearMsgBitsMask(ptirec, Message->QS_Flags);
                  InsertTailList(&usmList, &Message->ListEntry);
                  break;
               }
               Entry = Entry->Flink;
            }
 
            WARN("MsqSendMessage timed out 2 Status %lx\n", WaitStatus);
            break;
         }
         // Receiving thread passed on and left us hanging with issues still pending.
         else if (WaitStatus == STATUS_WAIT_2)
         {
            ERR("NB Receiving Thread woken up dead!\n");
            Message->flags |= SMF_RECEIVERDIED;
            break;
         }
 
         if (WaitStatus == STATUS_USER_APC) break;
 
         while (co_MsqDispatchOneSentMessage(pti))
            ;
      } while (WaitStatus == STATUS_WAIT_1);
   }
 
   // Count is nil, restore swapping of the stack.
   if (--pti->cEnterCount == 0 )
   {
      KeSetKernelStackSwapEnable(SwapStateEnabled);
   }
 
   // Handle User APC
   if (WaitStatus == STATUS_USER_APC)
   {
     // The current thread is dying!
     TRACE("User APC\n");
 
     // The Message will be on the Trouble list until Thread cleanup.
     Message->flags |= SMF_SENDERDIED;
 
     co_IntDeliverUserAPC();
     ERR("User APC Returned\n"); // Should not see this message.
   }
 
   // Force this thread to wake up for the next go around.
   KeSetEvent(pti->pEventQueueServer, IO_NO_INCREMENT, FALSE);
 
   Result = Message->lResult;
 
   // Determine whether this message is being processed or not.
   if ((Message->flags & (SMF_RECEIVERBUSY|SMF_RECEIVEDMESSAGE)) != SMF_RECEIVEDMESSAGE)
   {
      Message->flags |= SMF_RECEIVERFREE;
   }
 
   if (!(Message->flags & SMF_RECEIVERFREE))
   {
      TRACE("Sender Freeing Message %p ptirec %p bit %d list empty %d\n",Message,ptirec,!!(ptirec->pcti->fsChangeBits & QS_SENDMESSAGE),IsListEmpty(&ptirec->SentMessagesListHead));
      // Make it to this point, the message was received.
      FreeUserMessage(Message);
   }
 
   pti->pusmSent = SaveMsg;
 
   TRACE("MSM Allocation Count %d Status %lx Result %d\n",SendMsgCount,WaitStatus,Result);
 
   if (WaitStatus != STATUS_TIMEOUT)
   {
      if (uResult)
      {
         *uResult = (STATUS_WAIT_0 == WaitStatus ? Result : 0);
      }
   }
 
   return WaitStatus;
}

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.

{
    PTHREADINFO ptiSender;
    PUSER_SENT_MESSAGE Message;
 
    if(!(Message = AllocateUserMessage(FALSE)))
    {
        ERR("MsqSendMessageAsync(): Not enough memory to allocate a message\n");
        return FALSE;
    }
 
    ptiSender = PsGetCurrentThreadWin32Thread();
 
    Message->Msg.hwnd = hwnd;
    Message->Msg.message = Msg;
    Message->Msg.wParam = wParam;
    Message->Msg.lParam = lParam;
    Message->pkCompletionEvent = NULL; // No event needed.
    Message->ptiReceiver = ptiReceiver;
    Message->ptiCallBackSender = ptiSender;
    Message->CompletionCallback = CompletionCallback;
    Message->CompletionCallbackContext = CompletionCallbackContext;
    Message->HookMessage = HookMessage;
    Message->HasPackedLParam = HasPackedLParam;
    Message->QS_Flags = QS_SENDMESSAGE;
    Message->flags = SMF_RECEIVERFREE;
 
    InsertTailList(&ptiReceiver->SentMessagesListHead, &Message->ListEntry);
    MsqWakeQueue(ptiReceiver, QS_SENDMESSAGE, TRUE);
 
    return TRUE;
}

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.

{
   NTSTATUS ret = STATUS_SUCCESS;
 
   // Post mouse moves before waiting for messages.
   if (pti->MessageQueue->QF_flags & QF_MOUSEMOVED)
   {
      IntCoalesceMouseMove(pti);
   }
 
   UserLeaveCo();
 
   ZwYieldExecution(); // Let someone else run!
 
   ret = KeWaitForSingleObject( pti->pEventQueueServer,
                                UserRequest,
                                UserMode,
                                FALSE,
                                NULL );
   UserEnterCo();
   if ( ret == STATUS_USER_APC )
   {
      TRACE("MWFNW User APC\n");
      co_IntDeliverUserAPC();
   }
   return ret;
}

Referenced by co_IntGetPeekMessage(), and co_IntWaitMessage().

CODE_SEG()

CODE_SEG

(

"INIT"

)

Definition at line 1810 of file Interface.c.

{
    UNICODE_STRING DeviceName = RTL_CONSTANT_STRING(L"\\FileSystem\\Filters\\"DRIVER_NAME);
    PDEVICE_OBJECT RawDeviceObject;
    PDEVICE_OBJECT DeviceObject;
    PFILE_OBJECT RawFileObject;
    UNICODE_STRING ObjectName;
    UNICODE_STRING SymLink;
 
    NTSTATUS Status;
 
    RtlZeroMemory(&DriverData, sizeof(DRIVER_DATA));
    DriverData.DriverObject = DriverObject;
 
    /* Save the registry key for this driver */
    DriverData.ServiceKey.Length = RegistryPath->Length;
    DriverData.ServiceKey.MaximumLength = RegistryPath->MaximumLength;
    DriverData.ServiceKey.Buffer = (PWCHAR)ExAllocatePoolWithTag(NonPagedPool,
                                                                 RegistryPath->MaximumLength,
                                                                 FM_TAG_REGISTRY_DATA);
    if (!DriverData.ServiceKey.Buffer) return STATUS_INSUFFICIENT_RESOURCES;
    RtlCopyUnicodeString(&DriverData.ServiceKey, RegistryPath);
 
    /* Do some initialization */
    ExInitializeFastMutex(&DriverData.FilterAttachLock);
 
    /* Create the main filter manager device object */
    Status = IoCreateDevice(DriverObject,
                            0,
                            &DeviceName,
                            FILE_DEVICE_DISK_FILE_SYSTEM,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status))
    {
        DPRINT1("fltmgr IoCreateDevice failed.  Status = %X\n", Status);
        goto Cleanup;
    }
 
    /* Store a global reference so we can access from callbacks */
    DriverData.DeviceObject = DeviceObject;
 
    /* Generate the symbolic link name */
    RtlInitUnicodeString(&SymLink, L"\\??\\"DRIVER_NAME);
    Status = IoCreateSymbolicLink(&SymLink, &DeviceName);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Create the callbacks for the dispatch table, FastIo and FS callbacks */
    Status = SetupDispatchAndCallbacksTables(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Initialize the comms objects */
    Status = FltpSetupCommunicationObjects(DriverObject);
    if (!NT_SUCCESS(Status)) goto Cleanup;
 
    /* Register for notifications when a new file system is loaded. This also enumerates any existing file systems */
    Status = IoRegisterFsRegistrationChange(DriverObject, FltpFsNotification);
    FLT_ASSERT(Status != STATUS_DEVICE_ALREADY_ATTACHED); // Windows checks for this, I'm not sure how it can happen. Needs investigation??
    if (!NT_SUCCESS(Status))  goto Cleanup;
 
    InitializeListHead(&FilterList);
    ExInitializeResourceLite(&FilterListLock);
 
    /* IoRegisterFsRegistrationChange isn't notified about the raw  file systems, so we attach to them manually */
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawDisk");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    RtlInitUnicodeString(&ObjectName, L"\\Device\\RawCdRom");
    Status = IoGetDeviceObjectPointer(&ObjectName,
                                      FILE_READ_ATTRIBUTES,
                                      &RawFileObject,
                                      &RawDeviceObject);
    if (NT_SUCCESS(Status))
    {
        FltpFsNotification(RawDeviceObject, TRUE);
        ObDereferenceObject(RawFileObject);
    }
 
    /* We're done, clear the initializing flag */
    ClearFlag(DeviceObject->Flags, DO_DEVICE_INITIALIZING);
    Status = STATUS_SUCCESS;
 
Cleanup:
 
    if (!NT_SUCCESS(Status))
    {
        if (DriverData.FastIoDispatch)
        {
            DriverObject->FastIoDispatch = NULL;
            ExFreePoolWithTag(DriverData.FastIoDispatch, FM_TAG_DISPATCH_TABLE);
        }
 
        IoDeleteSymbolicLink(&SymLink);
 
        if (DeviceObject)
            IoDeleteDevice(DeviceObject);
 
        if (DriverData.ServiceKey.Buffer)
            ExFreePoolWithTag(DriverData.ServiceKey.Buffer, FM_TAG_REGISTRY_DATA);
    }
 
    return Status;
}

FreeUserMessage()

VOID FASTCALL FreeUserMessage

(

PUSER_SENT_MESSAGE

Message

)

Definition at line 786 of file msgqueue.c.

{
   Message->pkCompletionEvent = NULL;
 
   /* Remove it from the list */
   RemoveEntryList(&Message->ListEntry);
 
   ExFreeToPagedLookasideList(pgSendMsgLookasideList, Message);
   SendMsgCount--;
}

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.

{
   DoTheScreenSaver();
   TRACE("HungAppSysTimerProc\n");
   // Process list of windows that are hung and waiting.
}

Referenced by StartTheTimers().

IdlePing()

VOID FASTCALL IdlePing

(

VOID

)

Definition at line 526 of file message.c.

{
   PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
   PTHREADINFO pti;
 
   pti = PsGetCurrentThreadWin32Thread();
 
   if ( pti )
   {
      pti->pClientInfo->cSpins = 0; // Reset spins.
 
      if ( pti->pDeskInfo && pti == gptiForeground )
      {
         if ( pti->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE) ||
              pti->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE) )
         {
            co_HOOK_CallHooks(WH_FOREGROUNDIDLE,HC_ACTION,0,0);
         }
      }
   }
 
   TRACE("IdlePing ppi %p\n", ppi);
   if ( ppi && ppi->InputIdleEvent )
   {
      TRACE("InputIdleEvent\n");
      KeSetEvent( ppi->InputIdleEvent, IO_NO_INCREMENT, FALSE);
   }
}

Referenced by co_IntGetPeekMessage(), and IntMsqSetWakeMask().

IdlePong()

VOID FASTCALL IdlePong

(

VOID

)

Definition at line 556 of file message.c.

{
   PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
 
   TRACE("IdlePong ppi %p\n", ppi);
   if ( ppi && ppi->InputIdleEvent )
   {
      KeClearEvent(ppi->InputIdleEvent);
   }
}

Referenced by co_IntGetPeekMessage(), co_IntPeekMessage(), and IntMsqClearWakeMask().

IntCallMsgFilter()

BOOL FASTCALL IntCallMsgFilter	(	LPMSG	lpmsg,
		INT	code
	)

Definition at line 2133 of file message.c.

{
    BOOL Ret = FALSE;
 
    if ( co_HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)lpmsg))
    {
        Ret = TRUE;
    }
    else
    {
        Ret = co_HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)lpmsg);
    }
    return Ret;
}

Referenced by DefWndDoSizeMove(), DefWndStartSizeMove(), MENU_TrackMenu(), NC_DoButton(), and NC_HandleNCRButtonDown().

IntCoalesceMouseMove()

VOID FASTCALL IntCoalesceMouseMove

(

PTHREADINFO

pti

)

Definition at line 551 of file msgqueue.c.

{
    MSG Msg;
 
    // Force time stamp to update, keeping message time in sync.
    if (gdwMouseMoveTimeStamp == 0)
    {
        gdwMouseMoveTimeStamp = EngGetTickCount32();
    }
 
    // Build mouse move message.
    Msg.hwnd    = NULL;
    Msg.message = WM_MOUSEMOVE;
    Msg.wParam  = 0;
    Msg.lParam  = MAKELONG(gpsi->ptCursor.x, gpsi->ptCursor.y);
    Msg.time    = gdwMouseMoveTimeStamp;
    Msg.pt      = gpsi->ptCursor;
 
    // Post the move.
    MsqPostMouseMove(pti, &Msg, gdwMouseMoveExtraInfo);
 
    // Zero the time stamp.
    gdwMouseMoveTimeStamp = 0;
 
    // Clear flag since the move was posted.
    pti->MessageQueue->QF_flags &= ~QF_MOUSEMOVED;
}

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

IntDispatchMessage()

LRESULT FASTCALL IntDispatchMessage

(

MSG *

Msg

)

IntGetQueueStatus()

DWORD APIENTRY IntGetQueueStatus

(

DWORD

Changes

)

Definition at line 2082 of file message.c.

{
    PTHREADINFO pti;
    DWORD Result;
 
    pti = PsGetCurrentThreadWin32Thread();
// wine:
    Changes &= (QS_ALLINPUT|QS_ALLPOSTMESSAGE|QS_SMRESULT);
 
    /* High word, types of messages currently in the queue.
       Low  word, types of messages that have been added to the queue and that
                  are still in the queue
     */
    Result = MAKELONG(pti->pcti->fsChangeBits & Changes, pti->pcti->fsWakeBits & Changes);
 
    pti->pcti->fsChangeBits &= ~Changes;
 
    return Result;
}

Referenced by NtUserCallOneParam(), and NtUserGetThreadState().

IntInitMessagePumpHook()

BOOL APIENTRY IntInitMessagePumpHook

(

VOID

)

Definition at line 2103 of file message.c.

{
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    if (pti->pcti)
    {
        pti->pcti->dwcPumpHook++;
        return TRUE;
    }
    return FALSE;
}

Referenced by NtUserCallNoParam().

IntMsqClearWakeMask()

BOOL FASTCALL IntMsqClearWakeMask

(

VOID

)

Definition at line 392 of file msgqueue.c.

{
   PTHREADINFO Win32Thread;
 
   Win32Thread = PsGetCurrentThreadWin32Thread();
   if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
      return FALSE;
   // Very hacky, but that is what they do.
   Win32Thread->pcti->fsWakeBits = 0;
 
   IdlePong();
 
   return TRUE;
}

Referenced by NtUserCallNoParam().

IntMsqSetWakeMask()

HANDLE FASTCALL IntMsqSetWakeMask

(

DWORD

WakeMask

)

Definition at line 362 of file msgqueue.c.

{
   PTHREADINFO Win32Thread;
   HANDLE MessageEventHandle;
   DWORD dwFlags = HIWORD(WakeMask);
 
   Win32Thread = PsGetCurrentThreadWin32Thread();
   if (Win32Thread == NULL || Win32Thread->MessageQueue == NULL)
      return 0;
 
// Win32Thread->pEventQueueServer; IntMsqSetWakeMask returns Win32Thread->hEventQueueClient
   MessageEventHandle = Win32Thread->hEventQueueClient;
 
   if (Win32Thread->pcti)
   {
      if ( (Win32Thread->pcti->fsChangeBits & LOWORD(WakeMask)) ||
           ( (dwFlags & MWMO_INPUTAVAILABLE) && (Win32Thread->pcti->fsWakeBits & LOWORD(WakeMask)) ) )
      {
         ERR("Chg 0x%x Wake 0x%x Mask 0x%x\n",Win32Thread->pcti->fsChangeBits, Win32Thread->pcti->fsWakeBits, WakeMask);
         KeSetEvent(Win32Thread->pEventQueueServer, IO_NO_INCREMENT, FALSE); // Wake it up!
         return MessageEventHandle;
      }
   }
 
   IdlePing();
 
   return MessageEventHandle;
}

Referenced by NtUserCallOneParam().

IntTranslateKbdMessage()

BOOL FASTCALL IntTranslateKbdMessage	(	LPMSG	lpMsg,
		UINT	flags
	)

Definition at line 1152 of file keyboard.c.

{
    PTHREADINFO pti;
    INT cch = 0, i;
    WCHAR wch[3] = { 0 };
    MSG NewMsg = { 0 };
    PKBDTABLES pKbdTbl;
    BOOL bResult = FALSE;
 
    switch(lpMsg->message)
    {
       case WM_KEYDOWN:
       case WM_KEYUP:
       case WM_SYSKEYDOWN:
       case WM_SYSKEYUP:
          break;
       default:
          return FALSE;
    }
 
    pti = PsGetCurrentThreadWin32Thread();
 
    if (!pti->KeyboardLayout)
    {
        PKL pDefKL = W32kGetDefaultKeyLayout();
        UserAssignmentLock((PVOID*)&(pti->KeyboardLayout), pDefKL);
        if (pDefKL)
        {
            pti->pClientInfo->hKL = pDefKL->hkl;
            pKbdTbl = pDefKL->spkf->pKbdTbl;
        }
        else
        {
            pti->pClientInfo->hKL = NULL;
            pKbdTbl = NULL;
        }
    }
    else
       pKbdTbl = pti->KeyboardLayout->spkf->pKbdTbl;
    if (!pKbdTbl)
        return FALSE;
 
    if (lpMsg->message != WM_KEYDOWN && lpMsg->message != WM_SYSKEYDOWN)
        return FALSE;
 
    /* Init pt, hwnd and time msg fields */
    NewMsg.pt = gpsi->ptCursor;
    NewMsg.hwnd = lpMsg->hwnd;
    NewMsg.time = EngGetTickCount32();
 
    TRACE("Enter IntTranslateKbdMessage msg %s, vk %x\n",
        lpMsg->message == WM_SYSKEYDOWN ? "WM_SYSKEYDOWN" : "WM_KEYDOWN", lpMsg->wParam);
 
    if (lpMsg->wParam == VK_PACKET)
    {
        NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
        NewMsg.wParam = HIWORD(lpMsg->lParam);
        NewMsg.lParam = LOWORD(lpMsg->lParam);
        MsqPostMessage(pti, &NewMsg, FALSE, QS_KEY, 0, 0);
        return TRUE;
    }
 
    cch = IntToUnicodeEx(lpMsg->wParam,
                         HIWORD(lpMsg->lParam) & 0xFF,
                         pti->MessageQueue->afKeyState,
                         wch,
                         sizeof(wch) / sizeof(wch[0]),
                         0,
                         pKbdTbl);
 
    if (cch)
    {
        if (cch > 0) /* Normal characters */
            NewMsg.message = (lpMsg->message == WM_KEYDOWN) ? WM_CHAR : WM_SYSCHAR;
        else /* Dead character */
        {
            cch = -cch;
            NewMsg.message =
                (lpMsg->message == WM_KEYDOWN) ? WM_DEADCHAR : WM_SYSDEADCHAR;
        }
        NewMsg.lParam = lpMsg->lParam;
 
        /* Send all characters */
        for (i = 0; i < cch; ++i)
        {
            TRACE("Msg: %x '%lc' (%04x) %08x\n", NewMsg.message, wch[i], wch[i], NewMsg.lParam);
            NewMsg.wParam = wch[i];
            MsqPostMessage(pti, &NewMsg, FALSE, QS_KEY, 0, 0);
        }
        bResult = TRUE;
    }
 
    TRACE("Leave IntTranslateKbdMessage ret %d, cch %d, msg %x, wch %x\n",
        bResult, cch, NewMsg.message, NewMsg.wParam);
    return bResult;
}

Referenced by DefWndDoSizeMove(), DefWndStartSizeMove(), MENU_TrackMenu(), and NtUserTranslateMessage().

IntUninitMessagePumpHook()

BOOL APIENTRY IntUninitMessagePumpHook

(

VOID

)

Definition at line 2116 of file message.c.

{
    PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 
    if (pti->pcti)
    {
        if (pti->pcti->dwcPumpHook <= 0)
        {
            return FALSE;
        }
        pti->pcti->dwcPumpHook--;
        return TRUE;
    }
    return FALSE;
}

Referenced by NtUserCallNoParam().

IsThreadSuspended()

BOOL FASTCALL IsThreadSuspended

(

PTHREADINFO

pti

)

Definition at line 2226 of file msgqueue.c.

{
   if (pti->pEThread)
   {
      BOOL Ret = TRUE;
      if (!(pti->pEThread->Tcb.SuspendCount) && !PsGetThreadFreezeCount(pti->pEThread)) Ret = FALSE;
      return Ret;
   }
   return FALSE;
}

Referenced by co_MsqSendMessage(), and UpdateThreadWindows().

lParamMemorySize()

UINT lParamMemorySize	(	UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 254 of file message.c.

{
    PMSGMEMORY MsgMemoryEntry = FindMsgMemory(Msg);
    if(MsgMemoryEntry == NULL) return 0;
    return MsgMemorySize(MsgMemoryEntry, wParam, lParam);
}

Referenced by co_IntCallHookProc().

MsqCleanupThreadMsgs()

VOID FASTCALL MsqCleanupThreadMsgs

(

PTHREADINFO

pti

)

Definition at line 2267 of file msgqueue.c.

{
   PLIST_ENTRY CurrentEntry;
   PUSER_MESSAGE CurrentMessage;
   PUSER_SENT_MESSAGE CurrentSentMessage;
 
   TRACE("MsqCleanupThreadMsgs %p\n",pti);
 
   // Clear it all out.
   if (pti->pcti)
   {
       pti->pcti->fsWakeBits = 0;
       pti->pcti->fsChangeBits = 0;
   }
 
   pti->nCntsQBits[QSRosKey] = 0;
   pti->nCntsQBits[QSRosMouseMove] = 0;
   pti->nCntsQBits[QSRosMouseButton] = 0;
   pti->nCntsQBits[QSRosPostMessage] = 0;
   pti->nCntsQBits[QSRosSendMessage] = 0;
   pti->nCntsQBits[QSRosHotKey] = 0;
   pti->nCntsQBits[QSRosEvent] = 0;
 
   /* cleanup posted messages */
   while (!IsListEmpty(&pti->PostedMessagesListHead))
   {
      CurrentEntry = pti->PostedMessagesListHead.Flink;
      CurrentMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
      ERR("Thread Cleanup Post Messages %p\n",CurrentMessage);
      if (CurrentMessage->dwQEvent)
      {
         if (CurrentMessage->dwQEvent == POSTEVENT_NWE)
         {
            ExFreePoolWithTag( (PVOID)CurrentMessage->ExtraInfo, TAG_HOOK);
         }
      }
      MsqDestroyMessage(CurrentMessage);
   }
 
   /* remove the messages that have not yet been dispatched */
   while (!IsListEmpty(&pti->SentMessagesListHead))
   {
      CurrentEntry = pti->SentMessagesListHead.Flink;
      CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE, ListEntry);
 
      ERR("Thread Cleanup Sent Messages %p\n",CurrentSentMessage);
 
      /* wake the sender's thread */
      if (CurrentSentMessage->pkCompletionEvent != NULL)
      {
         KeSetEvent(CurrentSentMessage->pkCompletionEvent, IO_NO_INCREMENT, FALSE);
      }
 
      if (CurrentSentMessage->HasPackedLParam)
      {
         if (CurrentSentMessage->Msg.lParam)
            ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
      }
 
      /* free the message */
      FreeUserMessage(CurrentSentMessage);
   }
 
   // Process Trouble Message List
   if (!IsListEmpty(&usmList))
   {
      CurrentEntry = usmList.Flink;
      while (CurrentEntry != &usmList)
      {
         CurrentSentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE, ListEntry);
         CurrentEntry = CurrentEntry->Flink;
 
         TRACE("Found troubled messages %p on the list\n",CurrentSentMessage);
 
         if ( pti == CurrentSentMessage->ptiReceiver )
         {
            if (CurrentSentMessage->HasPackedLParam)
            {
               if (CurrentSentMessage->Msg.lParam)
                  ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
            }
 
            /* free the message */
            FreeUserMessage(CurrentSentMessage);
         }
         else if ( pti == CurrentSentMessage->ptiSender ||
                   pti == CurrentSentMessage->ptiCallBackSender )
         {
            // Determine whether this message is being processed or not.
            if ((CurrentSentMessage->flags & (SMF_RECEIVERBUSY|SMF_RECEIVEDMESSAGE)) != SMF_RECEIVEDMESSAGE)
            {
               CurrentSentMessage->flags |= SMF_RECEIVERFREE;
            }
 
            if (!(CurrentSentMessage->flags & SMF_RECEIVERFREE))
            {
 
               if (CurrentSentMessage->HasPackedLParam)
               {
                  if (CurrentSentMessage->Msg.lParam)
                     ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
               }
 
               /* free the message */
               FreeUserMessage(CurrentSentMessage);
            }
         }
      }
   }
}

Referenced by UserDeleteW32Thread().

MsqCreateMessage()

PUSER_MESSAGE FASTCALL MsqCreateMessage

(

LPMSG

Msg

)

Definition at line 731 of file msgqueue.c.

{
   PUSER_MESSAGE Message;
 
   Message = ExAllocateFromPagedLookasideList(pgMessageLookasideList);
   if (!Message)
   {
      return NULL;
   }
 
   RtlZeroMemory(Message, sizeof(*Message));
   RtlMoveMemory(&Message->Msg, Msg, sizeof(MSG));
   PostMsgCount++;
   return Message;
}

Referenced by MsqPostMessage().

MsqCreateMessageQueue()

PUSER_MESSAGE_QUEUE FASTCALL MsqCreateMessageQueue

(

PTHREADINFO

pti

)

Definition at line 2442 of file msgqueue.c.

{
   PUSER_MESSAGE_QUEUE MessageQueue;
 
   MessageQueue = ExAllocatePoolWithTag(NonPagedPool,
                                        sizeof(*MessageQueue),
                                        USERTAG_Q);
 
   if (!MessageQueue)
   {
      return NULL;
   }
 
   RtlZeroMemory(MessageQueue, sizeof(*MessageQueue));
   /* hold at least one reference until it'll be destroyed */
   IntReferenceMessageQueue(MessageQueue);
   /* initialize the queue */
   if (!MsqInitializeMessageQueue(pti, MessageQueue))
   {
      IntDereferenceMessageQueue(MessageQueue);
      return NULL;
   }
 
   return MessageQueue;
}

Referenced by InitThreadCallback(), and UserAttachThreadInput().

MsqDecPaintCountQueue()

VOID FASTCALL MsqDecPaintCountQueue

(

PTHREADINFO

pti

)

Definition at line 508 of file msgqueue.c.

{
   ClearMsgBitsMask(pti, QS_PAINT);
}

Referenced by co_IntUpdateWindows(), co_UserFreeWindow(), IntBeginPaint(), IntGetNCUpdateRgn(), IntGetPaintMessage(), and IntInvalidateWindows().

MsqDestroyMessage()

VOID FASTCALL MsqDestroyMessage

(

PUSER_MESSAGE

Message

)

Definition at line 748 of file msgqueue.c.

{
   TRACE("Post Destroy %d\n",PostMsgCount);
   if (Message->pti == NULL)
   {
      ERR("Double Free Message\n");
      return;
   }
   RemoveEntryList(&Message->ListEntry);
   Message->pti = NULL;
   ExFreeToPagedLookasideList(pgMessageLookasideList, Message);
   PostMsgCount--;
}

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.

{
   PDESKTOP desk;
   PUSER_MESSAGE_QUEUE MessageQueue = pti->MessageQueue;
 
   NT_ASSERT(MessageQueue != NULL);
   MessageQueue->QF_flags |= QF_INDESTROY;
 
   /* remove the message queue from any desktops */
   if ((desk = InterlockedExchangePointer((PVOID*)&MessageQueue->Desktop, 0)))
   {
      (void)InterlockedExchangePointer((PVOID*)&desk->ActiveMessageQueue, 0);
      IntDereferenceMessageQueue(MessageQueue);
   }
 
   /* clean it up */
   MsqCleanupMessageQueue(pti);
 
   /* decrease the reference counter, if it hits zero, the queue will be freed */
   _PRAGMA_WARNING_SUPPRESS(__WARNING_USING_UNINIT_VAR);
   IntDereferenceMessageQueue(MessageQueue);
}

Referenced by UserAttachThreadInput(), and UserDeleteW32Thread().

MsqGetDownKeyState()

WPARAM FASTCALL MsqGetDownKeyState

(

PUSER_MESSAGE_QUEUE

MessageQueue

)

Definition at line 338 of file msgqueue.c.

{
    WPARAM ret = 0;
 
    if (gspv.bMouseBtnSwap)
    {
       if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_RBUTTON)) ret |= MK_LBUTTON;
       if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_LBUTTON)) ret |= MK_RBUTTON;
    }
    else
    {
       if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_LBUTTON)) ret |= MK_LBUTTON;
       if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_RBUTTON)) ret |= MK_RBUTTON;
    }
 
    if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_MBUTTON))  ret |= MK_MBUTTON;
    if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_SHIFT))    ret |= MK_SHIFT;
    if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_CONTROL))  ret |= MK_CONTROL;
    if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_XBUTTON1)) ret |= MK_XBUTTON1;
    if (IS_KEY_DOWN(MessageQueue->afKeyState, VK_XBUTTON2)) ret |= MK_XBUTTON2;
    return ret;
}

Referenced by co_IntProcessMouseMessage(), and SystemTimerProc().

MsqGetMessageExtraInfo()

LPARAM FASTCALL MsqGetMessageExtraInfo

(

VOID

)

Definition at line 2513 of file msgqueue.c.

{
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE MessageQueue;
 
   pti = PsGetCurrentThreadWin32Thread();
   MessageQueue = pti->MessageQueue;
   if(!MessageQueue)
   {
      return 0;
   }
 
   return MessageQueue->ExtraInfo;
}

Referenced by NtUserGetThreadState().

MsqIncPaintCountQueue()

VOID FASTCALL MsqIncPaintCountQueue

(

PTHREADINFO

pti

)

Definition at line 501 of file msgqueue.c.

{
   pti->cPaintsReady++;
   MsqWakeQueue(pti, QS_PAINT, TRUE);
}

Referenced by IntInvalidateWindows().

MsqInitializeMessageQueue()

BOOLEAN FASTCALL MsqInitializeMessageQueue	(	PTHREADINFO	pti,
		PUSER_MESSAGE_QUEUE	MessageQueue
	)

Definition at line 2247 of file msgqueue.c.

{
   InitializeListHead(&MessageQueue->HardwareMessagesListHead); // Keep here!
   MessageQueue->spwndFocus = NULL;
   MessageQueue->iCursorLevel = 0;
   MessageQueue->CursorObject = SYSTEMCUR(WAIT); // See test_initial_cursor.
   if (MessageQueue->CursorObject)
   {
      TRACE("Default cursor hcur %p\n",UserHMGetHandle(MessageQueue->CursorObject));
      UserReferenceObject(MessageQueue->CursorObject);
   }
   RtlCopyMemory(MessageQueue->afKeyState, gafAsyncKeyState, sizeof(gafAsyncKeyState));
   MessageQueue->ptiMouse = pti;
   MessageQueue->ptiKeyboard = pti;
   MessageQueue->cThreads++;
 
   return TRUE;
}

Referenced by MsqCreateMessageQueue().

MsqIsClkLck()

BOOL FASTCALL MsqIsClkLck	(	LPMSG	Msg,
		BOOL	Remove
	)

MsqIsDblClk()

BOOL FASTCALL MsqIsDblClk	(	LPMSG	Msg,
		BOOL	Remove
	)

MsqIsHung()

BOOL FASTCALL MsqIsHung	(	PTHREADINFO	pti,
		DWORD	TimeOut
	)

Definition at line 2195 of file msgqueue.c.

{
    DWORD dwTimeStamp = EngGetTickCount32();
    if (dwTimeStamp - pti->pcti->timeLastRead > TimeOut &&
       !(pti->pcti->fsWakeMask & QS_INPUT) &&
       !PsGetThreadFreezeCount(pti->pEThread) &&
       !(pti->ppi->W32PF_flags & W32PF_APPSTARTING))
    {
        TRACE("\nMsqIsHung(pti %p, TimeOut %lu)\n"
            "pEThread %p, ThreadsProcess %p, ImageFileName '%s'\n"
            "dwTimeStamp = %lu\n"
            "pti->pcti->timeLastRead = %lu\n"
            "pti->timeLast = %lu\n"
            "PsGetThreadFreezeCount(pti->pEThread) = %lu\n",
            pti, TimeOut,
            pti->pEThread,
            pti->pEThread ? pti->pEThread->ThreadsProcess : NULL,
            (pti->pEThread && pti->pEThread->ThreadsProcess)
                ? pti->pEThread->ThreadsProcess->ImageFileName : "(None)",
            dwTimeStamp,
            pti->pcti->timeLastRead,
            pti->timeLast,
            PsGetThreadFreezeCount(pti->pEThread));
 
        return TRUE;
    }
 
   return FALSE;
}

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.

{
   PUSER_MESSAGE CurrentMessage;
   PLIST_ENTRY ListHead;
   DWORD QS_Flags;
   BOOL Ret = FALSE;
 
   ListHead = pti->PostedMessagesListHead.Flink;
 
   if (IsListEmpty(ListHead)) return FALSE;
 
   while(ListHead != &pti->PostedMessagesListHead)
   {
      CurrentMessage = CONTAINING_RECORD(ListHead, USER_MESSAGE, ListEntry);
      ListHead = ListHead->Flink;
/*
 MSDN:
 1: any window that belongs to the current thread, and any messages on the current thread's message queue whose hwnd value is NULL.
 2: retrieves only messages on the current thread's message queue whose hwnd value is NULL.
 3: handle to the window whose messages are to be retrieved.
 */
      if ( ( !Window || // 1
            ( Window == PWND_BOTTOM && CurrentMessage->Msg.hwnd == NULL ) || // 2
            ( Window != PWND_BOTTOM && Window->head.h == CurrentMessage->Msg.hwnd ) ) && // 3
            ( ( ( MsgFilterLow == 0 && MsgFilterHigh == 0 ) && CurrentMessage->QS_Flags & QSflags ) ||
              ( MsgFilterLow <= CurrentMessage->Msg.message && MsgFilterHigh >= CurrentMessage->Msg.message ) ) )
      {
         *Message   = CurrentMessage->Msg;
         *ExtraInfo = CurrentMessage->ExtraInfo;
         QS_Flags   = CurrentMessage->QS_Flags;
         if (dwQEvent) *dwQEvent = CurrentMessage->dwQEvent;
 
         if (Remove)
         {
             if (CurrentMessage->pti != NULL)
             {
                MsqDestroyMessage(CurrentMessage);
             }
             ClearMsgBitsMask(pti, QS_Flags);
         }
         Ret = TRUE;
         break;
      }
   }
 
   return Ret;
}

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.

{
   PUSER_MESSAGE Message;
   PUSER_MESSAGE_QUEUE MessageQueue;
 
   MessageQueue = pti->MessageQueue;
 
   if ((pti->TIF_flags & TIF_INCLEANUP) || (MessageQueue->QF_flags & QF_INDESTROY))
   {
      ERR("Post Msg; Thread or Q is Dead!\n");
      return;
   }
 
   Message = MsqCreateMessage(Msg);
   if (!Message)
      return;
 
   if (Msg->message == WM_HOTKEY)
      MessageBits |= QS_HOTKEY;
 
   Message->dwQEvent = dwQEvent;
   Message->ExtraInfo = ExtraInfo;
   Message->QS_Flags = MessageBits;
   Message->pti = pti;
 
   if (!HardwareMessage)
   {
       InsertTailList(&pti->PostedMessagesListHead, &Message->ListEntry);
   }
   else
   {
       InsertTailList(&MessageQueue->HardwareMessagesListHead, &Message->ListEntry);
   }
 
   MsqWakeQueue(pti, MessageBits, TRUE);
   TRACE("Post Message %d\n", PostMsgCount);
}

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

MsqPostQuitMessage()

VOID FASTCALL MsqPostQuitMessage	(	PTHREADINFO	pti,
		ULONG	ExitCode
	)

Definition at line 1381 of file msgqueue.c.

{
   pti->QuitPosted = TRUE;
   pti->exitCode = ExitCode;
   MsqWakeQueue(pti, QS_POSTMESSAGE|QS_ALLPOSTMESSAGE, TRUE);
}

Referenced by NtUserCallOneParam().

MsqRemoveWindowMessagesFromQueue()

VOID APIENTRY MsqRemoveWindowMessagesFromQueue

(

PWND

pWindow

)

Definition at line 798 of file msgqueue.c.

{
   PTHREADINFO pti;
   PUSER_SENT_MESSAGE SentMessage;
   PUSER_MESSAGE PostedMessage;
   PLIST_ENTRY CurrentEntry, ListHead;
 
   ASSERT(Window);
 
   pti = Window->head.pti;
 
   /* remove the posted messages for this window */
   CurrentEntry = pti->PostedMessagesListHead.Flink;
   ListHead = &pti->PostedMessagesListHead;
   while (CurrentEntry != ListHead)
   {
      PostedMessage = CONTAINING_RECORD(CurrentEntry, USER_MESSAGE, ListEntry);
 
      if (PostedMessage->Msg.hwnd == Window->head.h)
      {
         if (PostedMessage->Msg.message == WM_QUIT && pti->QuitPosted == 0)
         {
            pti->QuitPosted = 1;
            pti->exitCode = PostedMessage->Msg.wParam;
         }
         ClearMsgBitsMask(pti, PostedMessage->QS_Flags);
         MsqDestroyMessage(PostedMessage);
         CurrentEntry = pti->PostedMessagesListHead.Flink;
      }
      else
      {
         CurrentEntry = CurrentEntry->Flink;
      }
   }
 
   /* remove the sent messages for this window */
   CurrentEntry = pti->SentMessagesListHead.Flink;
   ListHead = &pti->SentMessagesListHead;
   while (CurrentEntry != ListHead)
   {
      SentMessage = CONTAINING_RECORD(CurrentEntry, USER_SENT_MESSAGE, ListEntry);
 
      if(SentMessage->Msg.hwnd == Window->head.h)
      {
         ERR("Remove Window Messages %p From Sent Queue\n",SentMessage);
#if 0 // Should mark these as invalid and allow the rest clean up, so far no harm by just commenting out. See CORE-9210.
         ClearMsgBitsMask(pti, SentMessage->QS_Flags);
 
         /* wake the sender's thread */
         if (SentMessage->pkCompletionEvent != NULL)
         {
            KeSetEvent(SentMessage->pkCompletionEvent, IO_NO_INCREMENT, FALSE);
         }
 
         if (SentMessage->HasPackedLParam)
         {
            if (SentMessage->Msg.lParam)
               ExFreePool((PVOID)SentMessage->Msg.lParam);
         }
 
         /* free the message */
         FreeUserMessage(SentMessage);
 
         CurrentEntry = pti->SentMessagesListHead.Flink;
#endif
         CurrentEntry = CurrentEntry->Flink;
      }
      else
      {
         CurrentEntry = CurrentEntry->Flink;
      }
   }
}

Referenced by co_UserFreeWindow().

MsqSetMessageExtraInfo()

LPARAM FASTCALL MsqSetMessageExtraInfo

(

LPARAM

lParam

)

Definition at line 2493 of file msgqueue.c.

{
   LPARAM Ret;
   PTHREADINFO pti;
   PUSER_MESSAGE_QUEUE MessageQueue;
 
   pti = PsGetCurrentThreadWin32Thread();
   MessageQueue = pti->MessageQueue;
   if(!MessageQueue)
   {
      return 0;
   }
 
   Ret = MessageQueue->ExtraInfo;
   MessageQueue->ExtraInfo = lParam;
 
   return Ret;
}

Referenced by NtUserCallOneParam().

MsqSetStateWindow()

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

Definition at line 2553 of file msgqueue.c.

{
   HWND Prev;
   PUSER_MESSAGE_QUEUE MessageQueue;
 
   MessageQueue = pti->MessageQueue;
 
   switch(Type)
   {
      case MSQ_STATE_CAPTURE:
         Prev = MessageQueue->spwndCapture ? UserHMGetHandle(MessageQueue->spwndCapture) : 0;
         MessageQueue->spwndCapture = ValidateHwndNoErr(hWnd);
         return Prev;
      case MSQ_STATE_ACTIVE:
         Prev = MessageQueue->spwndActive ? UserHMGetHandle(MessageQueue->spwndActive) : 0;
         MessageQueue->spwndActive = ValidateHwndNoErr(hWnd);
         return Prev;
      case MSQ_STATE_FOCUS:
         Prev = MessageQueue->spwndFocus ? UserHMGetHandle(MessageQueue->spwndFocus) : 0;
         MessageQueue->spwndFocus = ValidateHwndNoErr(hWnd);
         return Prev;
      case MSQ_STATE_MENUOWNER:
         Prev = MessageQueue->MenuOwner;
         MessageQueue->MenuOwner = hWnd;
         return Prev;
      case MSQ_STATE_MOVESIZE:
         Prev = MessageQueue->MoveSize;
         MessageQueue->MoveSize = hWnd;
         return Prev;
      case MSQ_STATE_CARET:
         Prev = MessageQueue->CaretInfo.hWnd;
         MessageQueue->CaretInfo.hWnd = hWnd;
         return Prev;
   }
 
   return NULL;
}

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.

{
   PUSER_MESSAGE_QUEUE Queue;
 
   Queue = pti->MessageQueue;
 
   if (Queue->QF_flags & QF_INDESTROY)
   {
      ERR("This Message Queue is in Destroy!\n");
   }
   pti->pcti->fsWakeBits |= MessageBits;
   pti->pcti->fsChangeBits |= MessageBits;
 
   // Start bit accounting to help clear the main set of bits.
   if (MessageBits & QS_KEY)
   {
      pti->nCntsQBits[QSRosKey]++;
   }
   if (MessageBits & QS_MOUSE)
   {
      if (MessageBits & QS_MOUSEMOVE)   pti->nCntsQBits[QSRosMouseMove]++;
      if (MessageBits & QS_MOUSEBUTTON) pti->nCntsQBits[QSRosMouseButton]++;
   }
   if (MessageBits & QS_POSTMESSAGE) pti->nCntsQBits[QSRosPostMessage]++;
   if (MessageBits & QS_SENDMESSAGE) pti->nCntsQBits[QSRosSendMessage]++;
   if (MessageBits & QS_HOTKEY)      pti->nCntsQBits[QSRosHotKey]++;
   if (MessageBits & QS_EVENT)       pti->nCntsQBits[QSRosEvent]++;
 
   if (KeyEvent)
      KeSetEvent(pti->pEventQueueServer, IO_NO_INCREMENT, FALSE);
}

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

UserPostThreadMessage()

BOOL FASTCALL UserPostThreadMessage	(	PTHREADINFO	pti,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1308 of file message.c.

{
    MSG Message;
 
    if (is_pointer_message(Msg, wParam))
    {
        EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
        return FALSE;
    }
    Message.hwnd = NULL;
    Message.message = Msg;
    Message.wParam = wParam;
    Message.lParam = lParam;
    Message.pt = gpsi->ptCursor;
    Message.time = EngGetTickCount32();
    MsqPostMessage(pti, &Message, FALSE, QS_POSTMESSAGE, 0, 0);
    return TRUE;
}

Referenced by co_UserProcessHotKeys(), NtUserPostThreadMessage(), and UserPostMessage().

UserSendNotifyMessage()

BOOL FASTCALL UserSendNotifyMessage	(	HWND	hWnd,
		UINT	Msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 2033 of file message.c.

{
    BOOL Ret = TRUE;
 
    if (is_pointer_message(Msg, wParam))
    {
        EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
        return FALSE;
    }
 
    // Basicly the same as IntPostOrSendMessage
    if (hWnd == HWND_BROADCAST) // Handle Broadcast
    {
        HWND *List;
        PWND DesktopWindow;
        ULONG i;
 
        DesktopWindow = UserGetDesktopWindow();
        List = IntWinListChildren(DesktopWindow);
 
        if (List != NULL)
        {
            UserSendNotifyMessage(DesktopWindow->head.h, Msg, wParam, lParam);
            for (i = 0; List[i]; i++)
            {
               PWND pwnd = UserGetWindowObject(List[i]);
               if (!pwnd) continue;
 
               if ( pwnd->fnid == FNID_MENU ||
                    pwnd->pcls->atomClassName == gpsi->atomSysClass[ICLS_SWITCH] )
                  continue;
 
               Ret = UserSendNotifyMessage(List[i], Msg, wParam, lParam);
            }
            ExFreePoolWithTag(List, USERTAG_WINDOWLIST);
        }
    }
    else
    {
        Ret = co_IntSendMessageNoWait( hWnd, Msg, wParam, lParam);
    }
    return Ret;
}

Referenced by co_IntSendActivateMessages(), NtUserMessageCall(), NtUserSetSysColors(), UserChangeDisplaySettings(), UserRealizePalette(), and UserSendNotifyMessage().

UserSetCursor()

PCURICON_OBJECT FASTCALL UserSetCursor	(	PCURICON_OBJECT	NewCursor,
		BOOL	ForceChange
	)

Definition at line 93 of file msgqueue.c.

{
    PCURICON_OBJECT OldCursor;
    HDC hdcScreen;
    PTHREADINFO pti;
    PUSER_MESSAGE_QUEUE MessageQueue;
    PWND pWnd;
 
    pti = PsGetCurrentThreadWin32Thread();
    MessageQueue = pti->MessageQueue;
 
    OldCursor = MessageQueue->CursorObject;
 
    /* Check if cursors are different */
    if (OldCursor == NewCursor)
        return OldCursor;
 
    /* Update cursor for this message queue */
    MessageQueue->CursorObject = NewCursor;
 
    /* If cursor is not visible we have nothing to do */
    if (MessageQueue->iCursorLevel < 0)
        return OldCursor;
 
    // Fixes the error message "Not the same cursor!".
    if (gpqCursor == NULL)
    {
       gpqCursor = MessageQueue;
    }
 
    /* Update cursor if this message queue controls it */
    pWnd = IntTopLevelWindowFromPoint(gpsi->ptCursor.x, gpsi->ptCursor.y);
    if (pWnd && pWnd->head.pti->MessageQueue == MessageQueue)
    {
       /* Get the screen DC */
        if (!(hdcScreen = IntGetScreenDC()))
        {
            return NULL;
        }
 
        if (NewCursor)
        {
            /* Call GDI to set the new screen cursor */
            PCURICON_OBJECT CursorFrame = NewCursor;
            if(NewCursor->CURSORF_flags & CURSORF_ACON)
            {
                FIXME("Should animate the cursor, using only the first frame now.\n");
                CursorFrame = ((PACON)NewCursor)->aspcur[0];
            }
            GreSetPointerShape(hdcScreen,
                               CursorFrame->hbmAlpha ? NULL : NewCursor->hbmMask,
                               CursorFrame->hbmAlpha ? NewCursor->hbmAlpha : NewCursor->hbmColor,
                               CursorFrame->xHotspot,
                               CursorFrame->yHotspot,
                               gpsi->ptCursor.x,
                               gpsi->ptCursor.y,
                               CursorFrame->hbmAlpha ? SPS_ALPHA : 0);
        }
        else /* Note: OldCursor != NewCursor so we have to hide cursor */
        {
            /* Remove the cursor */
            GreMovePointer(hdcScreen, -1, -1);
            TRACE("Removing pointer!\n");
        }
        IntGetSysCursorInfo()->CurrentCursorObject = NewCursor;
    }
 
    /* Return the old cursor */
    return OldCursor;
}

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

UserShowCursor()

int UserShowCursor

(

BOOL

bShow

)

Definition at line 168 of file msgqueue.c.

{
    HDC hdcScreen;
    PTHREADINFO pti;
    PUSER_MESSAGE_QUEUE MessageQueue;
    PWND pWnd;
 
    if (!(hdcScreen = IntGetScreenDC()))
    {
        return -1; /* No mouse */
    }
 
    pti = PsGetCurrentThreadWin32Thread();
    MessageQueue = pti->MessageQueue;
 
    /* Update counter */
    MessageQueue->iCursorLevel += bShow ? 1 : -1;
    pti->iCursorLevel += bShow ? 1 : -1;
 
    /* Check for trivial cases */
    if ((bShow && MessageQueue->iCursorLevel != 0) ||
        (!bShow && MessageQueue->iCursorLevel != -1))
    {
        /* Note: w don't update global info here because it is used only
          internally to check if cursor is visible */
        return MessageQueue->iCursorLevel;
    }
 
    /* Check if cursor is above window owned by this MessageQueue */
    pWnd = IntTopLevelWindowFromPoint(gpsi->ptCursor.x, gpsi->ptCursor.y);
    if (pWnd && pWnd->head.pti->MessageQueue == MessageQueue)
    {
        if (bShow)
        {
            /* Show the pointer */
            GreMovePointer(hdcScreen, gpsi->ptCursor.x, gpsi->ptCursor.y);
            TRACE("Showing pointer!\n");
        }
        else
        {
            /* Remove the pointer */
            GreMovePointer(hdcScreen, -1, -1);
            TRACE("Removing pointer!\n");
        }
 
        /* Update global info */
        IntGetSysCursorInfo()->ShowingCursor = MessageQueue->iCursorLevel;
    }
 
    return MessageQueue->iCursorLevel;
}

Referenced by DefWndDoSizeMove(), and NtUserCallOneParam().

Variable Documentation

usmList

LIST_ENTRY usmList

extern

Definition at line 23 of file msgqueue.c.

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