*/
#include <win32k.h>
+
+#include <dde.h>
+
DBG_DEFAULT_CHANNEL(UserMsg);
#define PM_BADMSGFLAGS ~((QS_RAWINPUT << 16)|PM_QS_SENDMESSAGE|PM_QS_PAINT|PM_QS_POSTMESSAGE|PM_QS_INPUT|PM_NOYIELD|PM_REMOVE)
}
MSGMEMORY, *PMSGMEMORY;
-static MSGMEMORY MsgMemory[] =
+static MSGMEMORY g_MsgMemory[] =
{
{ WM_CREATE, MMS_SIZE_SPECIAL, MMS_FLAG_READWRITE },
{ WM_DDE_ACK, sizeof(KMDDELPARAM), MMS_FLAG_READ },
{ WM_SETTEXT, MMS_SIZE_LPARAMSZ, MMS_FLAG_READ },
{ WM_STYLECHANGED, sizeof(STYLESTRUCT), MMS_FLAG_READ },
{ WM_STYLECHANGING, sizeof(STYLESTRUCT), MMS_FLAG_READWRITE },
+ { WM_SETTINGCHANGE, MMS_SIZE_LPARAMSZ, MMS_FLAG_READ },
{ WM_COPYDATA, MMS_SIZE_SPECIAL, MMS_FLAG_READ },
{ WM_COPYGLOBALDATA, MMS_SIZE_WPARAM, MMS_FLAG_READ },
- { WM_WINDOWPOSCHANGED, sizeof(WINDOWPOS), MMS_FLAG_READ },
+ { WM_WINDOWPOSCHANGED, sizeof(WINDOWPOS), MMS_FLAG_READWRITE },
{ WM_WINDOWPOSCHANGING, sizeof(WINDOWPOS), MMS_FLAG_READWRITE },
+ { WM_SIZING, sizeof(RECT), MMS_FLAG_READWRITE },
+ { WM_MOVING, sizeof(RECT), MMS_FLAG_READWRITE },
};
static PMSGMEMORY FASTCALL
PMSGMEMORY MsgMemoryEntry;
/* See if this message type is present in the table */
- for (MsgMemoryEntry = MsgMemory;
- MsgMemoryEntry < MsgMemory + sizeof(MsgMemory) / sizeof(MSGMEMORY);
+ for (MsgMemoryEntry = g_MsgMemory;
+ MsgMemoryEntry < g_MsgMemory + sizeof(g_MsgMemory) / sizeof(MSGMEMORY);
MsgMemoryEntry++)
{
if (Msg == MsgMemoryEntry->Message)
}
else if (MMS_SIZE_LPARAMSZ == MsgMemoryEntry->Size)
{
- Size = (UINT) ((wcslen((PWSTR) lParam) + 1) * sizeof(WCHAR));
+ // WM_SETTEXT and WM_SETTINGCHANGE can be null!
+ if (!lParam)
+ {
+ TRACE("lParam is NULL!\n");
+ Size = 0;
+ }
+ else
+ Size = (UINT) ((wcslen((PWSTR) lParam) + 1) * sizeof(WCHAR));
}
else if (MMS_SIZE_SPECIAL == MsgMemoryEntry->Size)
{
return Size;
}
+UINT lParamMemorySize(UINT Msg, WPARAM wParam, LPARAM lParam)
+{
+ PMSGMEMORY MsgMemoryEntry = FindMsgMemory(Msg);
+ if(MsgMemoryEntry == NULL) return 0;
+ return MsgMemorySize(MsgMemoryEntry, wParam, lParam);
+}
+
static NTSTATUS
PackParam(LPARAM *lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolNeeded)
{
MsgMemoryEntry = FindMsgMemory(Msg);
- if ((!MsgMemoryEntry) || (MsgMemoryEntry->Size < 0))
+ if (!MsgMemoryEntry)
{
/* Keep previous behavior */
return STATUS_SUCCESS;
PMSGMEMORY MsgMemoryEntry;
MsgMemoryEntry = FindMsgMemory(Msg);
ASSERT(MsgMemoryEntry);
- if (MsgMemoryEntry->Size < 0)
- {
- /* Keep previous behavior */
- return STATUS_INVALID_PARAMETER;
- }
- if (MsgMemory->Flags == MMS_FLAG_READWRITE)
+ if (MsgMemoryEntry->Flags == MMS_FLAG_READWRITE)
{
- //RtlCopyMemory((PVOID)lParam, (PVOID)lParamPacked, MsgMemory->Size);
+ //RtlCopyMemory((PVOID)lParam, (PVOID)lParamPacked, MsgMemoryEntry->Size);
}
ExFreePool((PVOID) lParamPacked);
return STATUS_SUCCESS;
/* Copy data if required */
if (0 != (MsgMemoryEntry->Flags & MMS_FLAG_READ))
{
+ TRACE("Copy Message %d from usermode buffer\n", KernelModeMsg->message);
Status = MmCopyFromCaller(KernelMem, (PVOID) UserModeMsg->lParam, Size);
if (! NT_SUCCESS(Status))
{
- ERR("Failed to copy message to kernel: invalid usermode buffer\n");
+ ERR("Failed to copy message to kernel: invalid usermode lParam buffer\n");
ExFreePoolWithTag(KernelMem, TAG_MSG);
return Status;
}
Status = MmCopyToCaller((PVOID) UserModeMsg->lParam, (PVOID) KernelModeMsg->lParam, Size);
if (! NT_SUCCESS(Status))
{
- ERR("Failed to copy message from kernel: invalid usermode buffer\n");
+ ERR("Failed to copy message from kernel: invalid usermode lParam buffer\n");
ExFreePool((PVOID) KernelModeMsg->lParam);
return Status;
}
IdlePing(VOID)
{
PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
- PUSER_MESSAGE_QUEUE ForegroundQueue;
- PTHREADINFO pti, ptiForeground = NULL;
-
- ForegroundQueue = IntGetFocusMessageQueue();
-
- if (ForegroundQueue)
- ptiForeground = ForegroundQueue->Thread->Tcb.Win32Thread;
+ PTHREADINFO pti;
pti = PsGetCurrentThreadWin32Thread();
{
pti->pClientInfo->cSpins = 0; // Reset spins.
- if ( pti->pDeskInfo && pti == ptiForeground )
+ if ( pti->pDeskInfo && pti == gptiForeground )
{
if ( pti->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE) ||
pti->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_FOREGROUNDIDLE) )
}
}
- TRACE("IdlePing ppi 0x%x\n",ppi);
+ TRACE("IdlePing ppi %p\n", ppi);
if ( ppi && ppi->InputIdleEvent )
{
TRACE("InputIdleEvent\n");
{
PPROCESSINFO ppi = PsGetCurrentProcessWin32Process();
- TRACE("IdlePong ppi 0x%x\n",ppi);
+ TRACE("IdlePong ppi %p\n", ppi);
if ( ppi && ppi->InputIdleEvent )
{
KeClearEvent(ppi->InputIdleEvent);
{
LRESULT lRes;
USER_REFERENCE_ENTRY Ref;
+// PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
if (!pWnd ||
pWnd == UserGetDesktopWindow() || // pWnd->fnid == FNID_DESKTOP
pWnd == UserGetMessageWindow() ) // pWnd->fnid == FNID_MESSAGEWND
return 0;
- TRACE("Internal Event Msg %p\n",msg);
+ TRACE("Internal Event Msg %p hWnd 0x%x\n",msg,pWnd->head.h);
switch(msg)
{
{
PWND Window = (PWND)wparam;
if (wparam) UserRefObjectCo(Window, &Ref);
- lRes = (LRESULT)co_IntSetActiveWindow(Window,NULL,(BOOL)lparam,TRUE);
+ lRes = (LRESULT)co_IntSetActiveWindow(Window,(BOOL)lparam,TRUE,TRUE);
if (wparam) UserDerefObjectCo(Window);
return lRes;
}
LRESULT retval = 0;
PTHREADINFO pti;
PWND Window = NULL;
- HRGN hrgn;
+ BOOL DoCallBack = TRUE;
if (pMsg->hwnd)
{
WM_TIMER,
pMsg->wParam,
(LPARAM)Time,
- 0);
+ -1);
}
return retval;
}
if ( Window->state & WNDS_SERVERSIDEWINDOWPROC )
{
TRACE("Dispatch: Server Side Window Procedure\n");
+ switch(Window->fnid)
+ {
+ case FNID_DESKTOP:
+ DoCallBack = !DesktopWindowProc( Window,
+ pMsg->message,
+ pMsg->wParam,
+ pMsg->lParam,
+ &retval);
+ break;
+ case FNID_MESSAGEWND:
+ DoCallBack = !UserMessageWindowProc( Window,
+ pMsg->message,
+ pMsg->wParam,
+ pMsg->lParam,
+ &retval);
+ break;
+ }
}
/* Since we are doing a callback on the same thread right away, there is
no need to copy the lparam to kernel mode and then back to usermode.
We just pretend it isn't a pointer */
+ if (DoCallBack)
retval = co_IntCallWindowProc( Window->lpfnWndProc,
!Window->Unicode,
pMsg->hwnd,
pMsg->message,
pMsg->wParam,
pMsg->lParam,
- 0);
+ -1);
if (pMsg->message == WM_PAINT)
{
+ PREGION Rgn;
Window->state2 &= ~WNDS2_WMPAINTSENT;
/* send a WM_NCPAINT and WM_ERASEBKGND if the non-client area is still invalid */
- hrgn = IntSysCreateRectRgn( 0, 0, 0, 0 );
- co_UserGetUpdateRgn( Window, hrgn, TRUE );
- GreDeleteObject(hrgn);
+ Rgn = IntSysCreateRectpRgn( 0, 0, 0, 0 );
+ co_UserGetUpdateRgn( Window, Rgn, TRUE );
+ REGION_Delete(Rgn);
}
return retval;
/*
* Internal version of PeekMessage() doing all the work
+ *
+ * MSDN:
+ * Sent messages
+ * Posted messages
+ * Input (hardware) messages and system internal events
+ * Sent messages (again)
+ * WM_PAINT messages
+ * WM_TIMER messages
*/
BOOL FASTCALL
co_IntPeekMessage( PMSG Msg,
BOOL bGMSG )
{
PTHREADINFO pti;
- //PCLIENTINFO pci;
LARGE_INTEGER LargeTickCount;
- PUSER_MESSAGE_QUEUE ThreadQueue;
BOOL RemoveMessages;
UINT ProcessMask;
BOOL Hit = FALSE;
pti = PsGetCurrentThreadWin32Thread();
- ThreadQueue = pti->MessageQueue;
- //pci = pti->pClientInfo;
RemoveMessages = RemoveMsg & PM_REMOVE;
ProcessMask = HIWORD(RemoveMsg);
do
{
KeQueryTickCount(&LargeTickCount);
- ThreadQueue->LastMsgRead = LargeTickCount.u.LowPart;
+ pti->timeLast = LargeTickCount.u.LowPart;
pti->pcti->tickLastMsgChecked = LargeTickCount.u.LowPart;
/* Dispatch sent messages here. */
- while ( co_MsqDispatchOneSentMessage(ThreadQueue) )
+ while ( co_MsqDispatchOneSentMessage(pti) )
{
/* if some PM_QS* flags were specified, only handle sent messages from now on */
if (HIWORD(RemoveMsg) && !bGMSG) Hit = TRUE; // wine does this; ProcessMask = QS_SENDMESSAGE;
/* Now check for normal messages. */
if (( (ProcessMask & QS_POSTMESSAGE) ||
(ProcessMask & QS_HOTKEY) ) &&
- MsqPeekMessage( ThreadQueue,
+ MsqPeekMessage( pti,
RemoveMessages,
Window,
MsgFilterMin,
}
/* Now look for a quit message. */
- if (ThreadQueue->QuitPosted)
+ if (pti->QuitPosted)
{
/* According to the PSDK, WM_QUIT messages are always returned, regardless
of the filter specified */
Msg->hwnd = NULL;
Msg->message = WM_QUIT;
- Msg->wParam = ThreadQueue->QuitExitCode;
+ Msg->wParam = pti->exitCode;
Msg->lParam = 0;
if (RemoveMessages)
{
- ThreadQueue->QuitPosted = FALSE;
- ClearMsgBitsMask(ThreadQueue, QS_POSTMESSAGE);
+ pti->QuitPosted = FALSE;
+ ClearMsgBitsMask(pti, QS_POSTMESSAGE);
pti->pcti->fsWakeBits &= ~QS_ALLPOSTMESSAGE;
pti->pcti->fsChangeBits &= ~QS_ALLPOSTMESSAGE;
}
}
/* Check for hardware events. */
- if ((ProcessMask & QS_MOUSE) &&
- co_MsqPeekMouseMove( ThreadQueue,
- RemoveMessages,
- Window,
- MsgFilterMin,
- MsgFilterMax,
- Msg ))
- {
- return TRUE;
- }
-
if ((ProcessMask & QS_INPUT) &&
- co_MsqPeekHardwareMessage( ThreadQueue,
+ co_MsqPeekHardwareMessage( pti,
RemoveMessages,
Window,
MsgFilterMin,
return TRUE;
}
+ if ((ProcessMask & QS_MOUSE) &&
+ co_MsqPeekMouseMove( pti,
+ RemoveMessages,
+ Window,
+ MsgFilterMin,
+ MsgFilterMax,
+ Msg ))
+ {
+ return TRUE;
+ }
+
/* Check for sent messages again. */
- while ( co_MsqDispatchOneSentMessage(ThreadQueue) )
+ while ( co_MsqDispatchOneSentMessage(pti) )
{
if (HIWORD(RemoveMsg) && !bGMSG) Hit = TRUE;
}
UINT MsgFilterMax )
{
PTHREADINFO pti;
- PUSER_MESSAGE_QUEUE ThreadQueue;
NTSTATUS Status = STATUS_SUCCESS;
MSG Msg;
pti = PsGetCurrentThreadWin32Thread();
- ThreadQueue = pti->MessageQueue;
do
{
}
/* Nothing found. Wait for new messages. */
- Status = co_MsqWaitForNewMessages( ThreadQueue,
+ Status = co_MsqWaitForNewMessages( pti,
Window,
MsgFilterMin,
MsgFilterMax);
if ( bGMSG )
{
- Status = co_MsqWaitForNewMessages( pti->MessageQueue,
+ Status = co_MsqWaitForNewMessages( pti,
Window,
MsgFilterMin,
MsgFilterMax);
}
BOOL FASTCALL
-UserPostThreadMessage( DWORD idThread,
+UserPostThreadMessage( PTHREADINFO pti,
UINT Msg,
WPARAM wParam,
LPARAM lParam )
{
MSG Message;
- PETHREAD peThread;
- PTHREADINFO pThread;
LARGE_INTEGER LargeTickCount;
- NTSTATUS Status;
if (is_pointer_message(Msg))
{
EngSetLastError(ERROR_MESSAGE_SYNC_ONLY );
return FALSE;
}
+ Message.hwnd = NULL;
+ Message.message = Msg;
+ Message.wParam = wParam;
+ Message.lParam = lParam;
+ Message.pt = gpsi->ptCursor;
- Status = PsLookupThreadByThreadId((HANDLE)idThread,&peThread);
-
- if( Status == STATUS_SUCCESS )
- {
- pThread = (PTHREADINFO)peThread->Tcb.Win32Thread;
- if( !pThread ||
- !pThread->MessageQueue ||
- (pThread->TIF_flags & TIF_INCLEANUP))
- {
- ObDereferenceObject( peThread );
- return FALSE;
- }
-
- Message.hwnd = NULL;
- Message.message = Msg;
- Message.wParam = wParam;
- Message.lParam = lParam;
- Message.pt = gpsi->ptCursor;
+ KeQueryTickCount(&LargeTickCount);
+ Message.time = MsqCalculateMessageTime(&LargeTickCount);
+ MsqPostMessage(pti, &Message, FALSE, QS_POSTMESSAGE, 0);
+ return TRUE;
+}
- KeQueryTickCount(&LargeTickCount);
- Message.time = MsqCalculateMessageTime(&LargeTickCount);
- MsqPostMessage(pThread->MessageQueue, &Message, FALSE, QS_POSTMESSAGE);
- ObDereferenceObject( peThread );
- return TRUE;
- }
- else
- {
- SetLastNtError( Status );
- }
- return FALSE;
+PTHREADINFO FASTCALL
+IntSendTo(PWND Window, PTHREADINFO ptiCur, UINT Msg)
+{
+ if ( ptiCur )
+ {
+ if (!Window ||
+ Window->head.pti->MessageQueue == ptiCur->MessageQueue )
+ {
+ return NULL;
+ }
+ }
+ return Window ? Window->head.pti : NULL;
}
BOOL FASTCALL
if (!Wnd)
{
- return UserPostThreadMessage( PtrToInt(PsGetCurrentThreadId()),
+ pti = PsGetCurrentThreadWin32Thread();
+ return UserPostThreadMessage( pti,
Msg,
wParam,
lParam);
Window = UserGetWindowObject(Wnd);
if ( !Window )
{
+ ERR("UserPostMessage: Invalid handle 0x%p Msg %d!\n",Wnd,Msg);
return FALSE;
}
pti = Window->head.pti;
if ( pti->TIF_flags & TIF_INCLEANUP )
{
- ERR("Attempted to post message to window 0x%x when the thread is in cleanup!\n", Wnd);
+ ERR("Attempted to post message to window %p when the thread is in cleanup!\n", Wnd);
return FALSE;
}
if ( Window->state & WNDS_DESTROYED )
{
- ERR("Attempted to post message to window 0x%x that is being destroyed!\n", Wnd);
+ ERR("Attempted to post message to window %p that is being destroyed!\n", Wnd);
/* FIXME: Last error code? */
return FALSE;
}
if (WM_QUIT == Msg)
{
- MsqPostQuitMessage(Window->head.pti->MessageQueue, wParam);
+ MsqPostQuitMessage(pti, wParam);
}
else
{
- MsqPostMessage(Window->head.pti->MessageQueue, &Message, FALSE, QS_POSTMESSAGE);
+ MsqPostMessage(pti, &Message, FALSE, QS_POSTMESSAGE, 0);
}
}
return TRUE;
PMSGMEMORY MsgMemoryEntry;
INT lParamBufferSize;
LPARAM lParamPacked;
- PTHREADINFO Win32Thread;
+ PTHREADINFO Win32Thread, ptiSendTo = NULL;
ULONG_PTR Hi, Lo, Result = 0;
DECLARE_RETURN(LRESULT);
USER_REFERENCE_ENTRY Ref;
+ BOOL DoCallBack = TRUE;
if (!(Window = UserGetWindowObject(hWnd)))
{
+ TRACE("SendMessageTimeoutSingle: Invalid handle 0x%p!\n",hWnd);
RETURN( FALSE);
}
Win32Thread = PsGetCurrentThreadWin32Thread();
- if ( Win32Thread &&
- Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
+ ptiSendTo = IntSendTo(Window, Win32Thread, Msg);
+
+ if ( !ptiSendTo )
{
if (Win32Thread->TIF_flags & TIF_INCLEANUP)
{
RETURN( FALSE);
}
/* Return after server side call, IntCallWndProcRet will not be called. */
+ switch(Window->fnid)
+ {
+ case FNID_DESKTOP:
+ DoCallBack = !DesktopWindowProc(Window, Msg, wParam, lParam,(LRESULT*)&Result);
+ break;
+ case FNID_MESSAGEWND:
+ DoCallBack = !UserMessageWindowProc(Window, Msg, wParam, lParam,(LRESULT*)&Result);
+ break;
+ }
+ if (!DoCallBack)
+ {
+ if (uResult) *uResult = Result;
+ RETURN( TRUE);
+ }
}
/* See if this message type is present in the table */
MsgMemoryEntry = FindMsgMemory(Msg);
else
{
lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
+ // If zero, do not allow callback on client side to allocate a buffer!!!!! See CORE-7695.
+ if (!lParamBufferSize) lParamBufferSize = -1;
}
if (! NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, FALSE)))
RETURN( TRUE);
}
- if (uFlags & SMTO_ABORTIFHUNG && MsqIsHung(Window->head.pti->MessageQueue))
+ if (uFlags & SMTO_ABORTIFHUNG && MsqIsHung(ptiSendTo))
{
// FIXME: Set window hung and add to a list.
/* FIXME: Set a LastError? */
if (Window->state & WNDS_DESTROYED)
{
/* FIXME: Last error? */
- ERR("Attempted to send message to window 0x%x that is being destroyed!\n", hWnd);
+ ERR("Attempted to send message to window %p that is being destroyed!\n", hWnd);
RETURN( FALSE);
}
do
{
- Status = co_MsqSendMessage( Window->head.pti->MessageQueue,
+ Status = co_MsqSendMessage( ptiSendTo,
hWnd,
Msg,
wParam,
}
while ((STATUS_TIMEOUT == Status) &&
(uFlags & SMTO_NOTIMEOUTIFNOTHUNG) &&
- !MsqIsHung(Window->head.pti->MessageQueue)); // FIXME: Set window hung and add to a list.
+ !MsqIsHung(ptiSendTo)); // FIXME: Set window hung and add to a list.
if (STATUS_TIMEOUT == Status)
{
PMSGMEMORY MsgMemoryEntry;
INT lParamBufferSize;
LPARAM lParamPacked;
- PTHREADINFO Win32Thread;
+ 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);
}
if (Window->state & WNDS_DESTROYED)
{
/* FIXME: last error? */
- ERR("Attempted to send message to window 0x%x that is being destroyed!\n", hWnd);
+ ERR("Attempted to send message to window %p that is being destroyed!\n", hWnd);
RETURN(FALSE);
}
RETURN(FALSE);
}
+ ptiSendTo = IntSendTo(Window, Win32Thread, Msg);
+
if (Msg & 0x80000000 &&
- Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
+ !ptiSendTo)
{
- ERR("SMWCB: Internal Message!\n");
+ 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);
else
{
lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
+ if (!lParamBufferSize) lParamBufferSize = -1;
}
- if (! NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, Window->head.pti->MessageQueue != Win32Thread->MessageQueue)))
+ 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 (Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
+ if ( !ptiSendTo )
{
if (Win32Thread->TIF_flags & TIF_INCLEANUP)
{
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;
+ }
}
+ if (DoCallBack)
Result = (ULONG_PTR)co_IntCallWindowProc( Window->lpfnWndProc,
!Window->Unicode,
hWnd,
}
}
- if (Window->head.pti->MessageQueue == Win32Thread->MessageQueue)
+ if ( !ptiSendTo)
{
if (! NT_SUCCESS(UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE)))
{
RETURN( FALSE);
}
- IntReferenceMessageQueue(Window->head.pti->MessageQueue);
- /* Take reference on this MessageQueue if its a callback. It will be released
- when message is processed or removed from target hwnd MessageQueue */
- if (CompletionCallback)
- IntReferenceMessageQueue(Win32Thread->MessageQueue);
-
Message->Msg.hwnd = hWnd;
Message->Msg.message = Msg;
Message->Msg.wParam = wParam;
Message->Result = 0;
Message->lResult = 0;
Message->QS_Flags = 0;
- Message->SenderQueue = NULL; // mjmartin, you are right! This is null.
- Message->CallBackSenderQueue = Win32Thread->MessageQueue;
+ Message->ptiReceiver = ptiSendTo;
+ Message->ptiSender = NULL; // mjmartin, you are right! This is null.
+ Message->ptiCallBackSender = Win32Thread;
Message->DispatchingListEntry.Flink = NULL;
Message->CompletionCallback = CompletionCallback;
Message->CompletionCallbackContext = CompletionCallbackContext;
Message->HasPackedLParam = (lParamBufferSize > 0);
Message->QS_Flags = QS_SENDMESSAGE;
- InsertTailList(&Window->head.pti->MessageQueue->SentMessagesListHead, &Message->ListEntry);
- MsqWakeQueue(Window->head.pti->MessageQueue, QS_SENDMESSAGE, TRUE);
- IntDereferenceMessageQueue(Window->head.pti->MessageQueue);
+ 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);
if(!(Window = UserGetWindowObject(hWnd)))
{
+ TRACE("PostOrSendMessage: Invalid handle 0x%p!\n",hWnd);
return 0;
}
pti = PsGetCurrentThreadWin32Thread();
- if ( Window->head.pti->MessageQueue != pti->MessageQueue &&
+ if ( IntSendTo(Window, pti, Msg) &&
FindMsgMemory(Msg) == 0 )
{
Result = UserPostMessage(hWnd, Msg, wParam, lParam);
return (LRESULT)Result;
}
-LRESULT FASTCALL
+static LRESULT FASTCALL
co_IntDoSendMessage( HWND hWnd,
UINT Msg,
WPARAM wParam,
LPARAM lParam,
PDOSENDMESSAGE dsm)
{
- //PTHREADINFO pti;
LRESULT Result = TRUE;
NTSTATUS Status;
PWND Window = NULL;
- MSG UserModeMsg;
- MSG KernelModeMsg;
+ MSG UserModeMsg, KernelModeMsg;
PMSGMEMORY MsgMemoryEntry;
+ PTHREADINFO ptiSendTo;
if (hWnd != HWND_BROADCAST && hWnd != HWND_TOPMOST)
{
ERR("co_IntDoSendMessage Window Exiting!\n");
}
- /* See if the current thread can handle the message */
- //pti = PsGetCurrentThreadWin32Thread();
+ /* See if the current thread can handle this message */
+ ptiSendTo = IntSendTo(Window, gptiCurrent, Msg);
- UserModeMsg.hwnd = hWnd;
- UserModeMsg.message = Msg;
- UserModeMsg.wParam = wParam;
- UserModeMsg.lParam = lParam;
- MsgMemoryEntry = FindMsgMemory(UserModeMsg.message);
-
- Status = CopyMsgToKernelMem(&KernelModeMsg, &UserModeMsg, MsgMemoryEntry);
- if (! NT_SUCCESS(Status))
+ // If broadcasting or sending to another thread, save the users data.
+ if (!Window || ptiSendTo )
+ {
+ UserModeMsg.hwnd = hWnd;
+ UserModeMsg.message = Msg;
+ UserModeMsg.wParam = wParam;
+ UserModeMsg.lParam = lParam;
+ MsgMemoryEntry = FindMsgMemory(UserModeMsg.message);
+ Status = CopyMsgToKernelMem(&KernelModeMsg, &UserModeMsg, MsgMemoryEntry);
+ if (!NT_SUCCESS(Status))
+ {
+ EngSetLastError(ERROR_INVALID_PARAMETER);
+ return (dsm ? 0 : -1);
+ }
+ }
+ else
{
- EngSetLastError(ERROR_INVALID_PARAMETER);
- return (dsm ? 0 : -1);
+ KernelModeMsg.hwnd = hWnd;
+ KernelModeMsg.message = Msg;
+ KernelModeMsg.wParam = wParam;
+ KernelModeMsg.lParam = lParam;
}
if (!dsm)
&dsm->Result );
}
- Status = CopyMsgToUserMem(&UserModeMsg, &KernelModeMsg);
- if (! NT_SUCCESS(Status))
+ if (!Window || ptiSendTo )
{
- EngSetLastError(ERROR_INVALID_PARAMETER);
- return(dsm ? 0 : -1);
+ Status = CopyMsgToUserMem(&UserModeMsg, &KernelModeMsg);
+ if (!NT_SUCCESS(Status))
+ {
+ EngSetLastError(ERROR_INVALID_PARAMETER);
+ return(dsm ? 0 : -1);
+ }
}
return (LRESULT)Result;
IntGetQueueStatus(DWORD Changes)
{
PTHREADINFO pti;
- //PUSER_MESSAGE_QUEUE Queue;
DWORD Result;
pti = PsGetCurrentThreadWin32Thread();
- //Queue = pti->MessageQueue;
// wine:
Changes &= (QS_ALLINPUT|QS_ALLPOSTMESSAGE|QS_SMRESULT);
return FALSE;
}
+BOOL FASTCALL
+IntCallMsgFilter( LPMSG lpmsg, INT code)
+{
+ 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;
+}
+
/** Functions ******************************************************************/
BOOL
ULONG wDragWidth, wDragHeight;
DECLARE_RETURN(BOOL);
- TRACE("Enter NtUserDragDetect(%x)\n", hWnd);
+ TRACE("Enter NtUserDragDetect(%p)\n", hWnd);
UserEnterExclusive();
wDragWidth = UserGetSystemMetrics(SM_CXDRAG);
WPARAM wParam,
LPARAM lParam)
{
- BOOL ret;
+ BOOL ret = FALSE;
+ PETHREAD peThread;
+ PTHREADINFO pThread;
+ NTSTATUS Status;
UserEnterExclusive();
- ret = UserPostThreadMessage( idThread, Msg, wParam, lParam);
+ Status = PsLookupThreadByThreadId((HANDLE)idThread,&peThread);
+ if ( Status == STATUS_SUCCESS )
+ {
+ pThread = (PTHREADINFO)peThread->Tcb.Win32Thread;
+ if( !pThread ||
+ !pThread->MessageQueue ||
+ (pThread->TIF_flags & TIF_INCLEANUP))
+ {
+ ObDereferenceObject( peThread );
+ goto exit;
+ }
+ ret = UserPostThreadMessage( pThread, Msg, wParam, lParam);
+ ObDereferenceObject( peThread );
+ }
+ else
+ {
+ SetLastNtError( Status );
+ }
+exit:
UserLeave();
-
return ret;
}
return Res;
}
-
BOOL APIENTRY
NtUserTranslateMessage(LPMSG lpMsg, UINT flags)
{
MSG SafeMsg;
BOOL Ret;
+ PWND pWnd;
_SEH2_TRY
{
_SEH2_END;
UserEnterExclusive();
-
- Ret = IntTranslateKbdMessage(&SafeMsg, flags);
-
+ pWnd = UserGetWindowObject(SafeMsg.hwnd);
+ if (pWnd) // Must have a window!
+ {
+ Ret = IntTranslateKbdMessage(&SafeMsg, flags);
+ }
+ else
+ {
+ TRACE("No Window for Translate. hwnd 0x%p Msg %u\n", SafeMsg.hwnd, SafeMsg.message);
+ Ret = FALSE;
+ }
UserLeave();
return Ret;
}
+LRESULT APIENTRY ScrollBarWndProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam);
+
BOOL APIENTRY
NtUserMessageCall( HWND hWnd,
UINT Msg,
{
case FNID_SCROLLBAR:
{
- switch(Msg)
+ lResult = ScrollBarWndProc(hWnd, Msg, wParam, lParam);
+ break;
+ }
+ case FNID_DESKTOP:
+ {
+ Window = UserGetWindowObject(hWnd);
+ if (Window)
{
- case WM_ENABLE:
- {
- Window = UserGetWindowObject(hWnd);
- if (Window->pSBInfo)
- {
- Window->pSBInfo->WSBflags = wParam ? ESB_ENABLE_BOTH : ESB_DISABLE_BOTH;
- }
- }
- break;
+ //ERR("FNID_DESKTOP IN\n");
+ Ret = DesktopWindowProc(Window, Msg, wParam, lParam, &lResult);
+ //ERR("FNID_DESKTOP OUT\n");
}
break;
}
+
+ case FNID_MESSAGEWND:
+ {
+ Window = UserGetWindowObject(hWnd);
+ if (Window)
+ {
+ Ret = !UserMessageWindowProc(Window, Msg, wParam, lParam,&lResult);
+ }
+ break;
+ }
case FNID_DEFWINDOWPROC:
/* Validate input */
if (hWnd)
if ( parm.flags & BSF_IGNORECURRENTTASK )
{
- if ( pwnd->head.pti->MessageQueue == gptiCurrent->MessageQueue )
+ if ( pwnd->head.pti == gptiCurrent )
continue;
}
co_IntSendMessageTimeout( List[i],
if ( parm.flags & BSF_IGNORECURRENTTASK )
{
- if ( pwnd->head.pti->MessageQueue == gptiCurrent->MessageQueue )
+ if ( pwnd->head.pti == gptiCurrent )
continue;
}
UserPostMessage(List[i], Msg, wParam, lParam);
if ( parm.flags & BSF_IGNORECURRENTTASK )
{
- if ( pwnd->head.pti->MessageQueue == gptiCurrent->MessageQueue )
+ if ( pwnd->head.pti == gptiCurrent )
continue;
}
UserSendNotifyMessage(List[i], Msg, wParam, lParam);
if ( parm.flags & BSF_IGNORECURRENTTASK )
{
- if ( pwnd->head.pti->MessageQueue == gptiCurrent->MessageQueue )
+ if ( pwnd->head.pti == gptiCurrent )
continue;
}
co_IntSendMessageTimeout( List[i],
if ( parm.flags & BSF_IGNORECURRENTTASK )
{
- if ( pwnd->head.pti->MessageQueue == gptiCurrent->MessageQueue )
+ if ( pwnd->head.pti == gptiCurrent )
continue;
}
UserPostMessage(List[i], Msg, wParam, lParam);
if ( parm.flags & BSF_IGNORECURRENTTASK )
{
- if ( pwnd->head.pti->MessageQueue == gptiCurrent->MessageQueue )
+ if ( pwnd->head.pti == gptiCurrent )
continue;
}
UserSendNotifyMessage(List[i], Msg, wParam, lParam);
CWP.message = Msg;
CWP.wParam = wParam;
CWP.lParam = lParam;
- TRACE("WH_CALLWNDPROC: Hook %x NextHook %x\n", Hook, NextObj );
+ TRACE("WH_CALLWNDPROC: Hook %p NextHook %p\n", Hook, NextObj);
lResult = co_IntCallHookProc( Hook->HookId,
HC_ACTION,
((ClientInfo->CI_flags & CI_CURTHPRHOOK) ? 1 : 0),
(LPARAM)&CWP,
Hook->Proc,
+ Hook->ihmod,
+ Hook->offPfn,
Hook->Ansi,
&Hook->ModuleName);
}
((ClientInfo->CI_flags & CI_CURTHPRHOOK) ? 1 : 0),
(LPARAM)&CWPR,
Hook->Proc,
+ Hook->ihmod,
+ Hook->offPfn,
Hook->Ansi,
&Hook->ModuleName);
}
case FNID_DEFWINDOWPROC:
case FNID_CALLWNDPROC:
case FNID_CALLWNDPROCRET:
+ case FNID_SCROLLBAR:
+ case FNID_DESKTOP:
if (ResultInfo)
{
_SEH2_TRY
Status = ObReferenceObjectByHandle(hProcess,
PROCESS_QUERY_INFORMATION,
- PsProcessType,
+ *PsProcessType,
UserMode,
(PVOID*)&Process,
NULL);
Handles[0] = Process;
Handles[1] = W32Process->InputIdleEvent;
- Handles[2] = pti->MessageQueue->NewMessages; // pEventQueueServer; IntMsqSetWakeMask returns hEventQueueClient
+ Handles[2] = pti->pEventQueueServer; // IntMsqSetWakeMask returns hEventQueueClient
if (!Handles[1])
{
pti->pClientInfo->dwTIFlags = pti->TIF_flags;
}
- TRACE("WFII: ppi 0x%x\n",W32Process);
+ TRACE("WFII: ppi %p\n", W32Process);
TRACE("WFII: waiting for %p\n", Handles[1] );
+
+ /*
+ * We must add a refcount to our current PROCESSINFO,
+ * because anything could happen (including process death) we're leaving win32k
+ */
+ IntReferenceProcessInfo(W32Process);
+
do
{
UserLeave();
pti->pClientInfo->dwTIFlags = pti->TIF_flags;
}
W32Process->W32PF_flags &= ~W32PF_WAITFORINPUTIDLE;
+ IntDereferenceProcessInfo(W32Process);
ObDereferenceObject(Process);
UserLeave();
return Status;
projects / reactos.git / blobdiff