/* INCLUDES ******************************************************************/
-#include <w32k.h>
+#include <win32k.h>
#define NDEBUG
#include <debug.h>
VOID FASTCALL
MsqInsertSystemMessage(MSG* Msg)
{
- LARGE_INTEGER LargeTickCount;
KIRQL OldIrql;
ULONG Prev;
- EVENTMSG Event;
+ /*
+ * If we got WM_MOUSEMOVE and there are already messages in the
+ * system message queue, check if the last message is mouse move
+ * and if it is then just overwrite it.
+ */
IntLockSystemMessageQueue(OldIrql);
/*
return;
}
- KeQueryTickCount(&LargeTickCount);
- Msg->time = MsqCalculateMessageTime(&LargeTickCount);
-
- Event.message = Msg->message;
- Event.time = Msg->time;
- Event.hwnd = Msg->hwnd;
- Event.paramL = Msg->pt.x;
- Event.paramH = Msg->pt.y;
- co_HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&Event);
-
- /*
- * If we got WM_MOUSEMOVE and there are already messages in the
- * system message queue, check if the last message is mouse move
- * and if it is then just overwrite it.
- */
-
if (Msg->message == WM_MOUSEMOVE && SystemMessageQueueCount)
{
if (SystemMessageQueueTail == 0)
BOOL Res = FALSE;
pti = PsGetCurrentThreadWin32Thread();
- if (pti->Desktop == NULL)
+ if (pti->rpdesk == NULL)
{
return FALSE;
}
BOOL Res;
pti = PsGetCurrentThreadWin32Thread();
- if (pti->Desktop == NULL)
+ if (pti->rpdesk == NULL)
{
return FALSE;
}
{
PUSER_MESSAGE UserMsg;
MSG Msg;
- BOOL ProcessMessage;
ASSERT(SystemMessageQueueHead < SYSTEM_MESSAGE_QUEUE_SIZE);
Msg = SystemMessageQueue[SystemMessageQueueHead];
(SystemMessageQueueHead + 1) % SYSTEM_MESSAGE_QUEUE_SIZE;
SystemMessageQueueCount--;
IntUnLockSystemMessageQueue(OldIrql);
- if (WM_MOUSEFIRST <= Msg.message && Msg.message <= WM_MOUSELAST)
- {
- MSLLHOOKSTRUCT MouseHookData;
- 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 = 0;
- MouseHookData.time = Msg.time;
- MouseHookData.dwExtraInfo = 0;
- ProcessMessage = (0 == co_HOOK_CallHooks(WH_MOUSE_LL, HC_ACTION,
- Msg.message, (LPARAM) &MouseHookData));
- }
- else
- {
- ProcessMessage = TRUE;
- }
- if (ProcessMessage)
- {
- UserMsg = ExAllocateFromPagedLookasideList(&MessageLookasideList);
- /* What to do if out of memory? For now we just panic a bit in debug */
- ASSERT(UserMsg);
- UserMsg->FreeLParam = FALSE;
- UserMsg->Msg = Msg;
- InsertTailList(&HardwareMessageQueueHead, &UserMsg->ListEntry);
- }
+ UserMsg = ExAllocateFromPagedLookasideList(&MessageLookasideList);
+ /* What to do if out of memory? For now we just panic a bit in debug */
+ ASSERT(UserMsg);
+ UserMsg->FreeLParam = FALSE;
+ UserMsg->Msg = Msg;
+ InsertTailList(&HardwareMessageQueueHead, &UserMsg->ListEntry);
+
IntLockSystemMessageQueue(OldIrql);
}
HardwareMessageQueueStamp++;
MSG Msg;
LARGE_INTEGER LargeTickCount;
KBDLLHOOKSTRUCT KbdHookData;
- EVENTMSG Event;
BOOLEAN Entered = FALSE;
DPRINT("MsqPostKeyboardMessage(uMsg 0x%x, wParam 0x%x, lParam 0x%x)\n",
KeQueryTickCount(&LargeTickCount);
Msg.time = MsqCalculateMessageTime(&LargeTickCount);
- Event.message = Msg.message;
- Event.hwnd = Msg.hwnd;
- Event.time = Msg.time;
- Event.paramL = (Msg.wParam & 0xFF) | (HIWORD(Msg.lParam) << 8);
- Event.paramH = Msg.lParam & 0x7FFF;
- if (HIWORD(Msg.lParam) & 0x0100) Event.paramH |= 0x8000;
- co_HOOK_CallHooks( WH_JOURNALRECORD, HC_ACTION, 0, (LPARAM)&Event);
-
/* We can't get the Msg.pt point here since we don't know thread
(and thus the window station) the message will end up in yet. */
PLIST_ENTRY Entry;
LRESULT Result;
BOOL SenderReturned;
- PUSER_SENT_MESSAGE_NOTIFY NotifyMessage;
if (IsListEmpty(&MessageQueue->SentMessagesListHead))
{
to be cleaned up on thread termination anymore */
RemoveEntryList(&Message->ListEntry);
- /* remove the message from the dispatching list, so lock the sender's message queue */
- SenderReturned = (Message->DispatchingListEntry.Flink == NULL);
- if(!SenderReturned)
+ /* remove the message from the dispatching list if needed, so lock the sender's message queue */
+ if (!(Message->HookMessage & MSQ_SENTNOWAIT))
{
- /* only remove it from the dispatching list if not already removed by a timeout */
- RemoveEntryList(&Message->DispatchingListEntry);
+ SenderReturned = (Message->DispatchingListEntry.Flink == NULL);
+ if (!SenderReturned)
+ {
+ /* only remove it from the dispatching list if not already removed by a timeout */
+ RemoveEntryList(&Message->DispatchingListEntry);
+ }
}
/* still keep the sender's message queue locked, so the sender can't exit the
MsqSendMessage() function (if timed out) */
*Message->Result = Result;
}
+ if (Message->HasPackedLParam == TRUE)
+ {
+ if (Message->Msg.lParam)
+ ExFreePool((PVOID)Message->Msg.lParam);
+ }
+
/* Notify the sender. */
if (Message->CompletionEvent != NULL)
{
KeSetEvent(Message->CompletionEvent, IO_NO_INCREMENT, FALSE);
}
- /* Notify the sender if they specified a callback. */
+ /* Call the callback if the message was sent with SendMessageCallback */
if (!SenderReturned && Message->CompletionCallback != NULL)
{
- if(!(NotifyMessage = ExAllocatePoolWithTag(NonPagedPool,
- sizeof(USER_SENT_MESSAGE_NOTIFY), TAG_USRMSG)))
- {
- DPRINT1("MsqDispatchOneSentMessage(): Not enough memory to create a callback notify message\n");
- goto Notified;
- }
- NotifyMessage->CompletionCallback =
- Message->CompletionCallback;
- NotifyMessage->CompletionCallbackContext =
- Message->CompletionCallbackContext;
- NotifyMessage->Result = Result;
- NotifyMessage->hWnd = Message->Msg.hwnd;
- NotifyMessage->Msg = Message->Msg.message;
- MsqSendNotifyMessage(Message->SenderQueue, NotifyMessage);
+ co_IntCallSentMessageCallback(Message->CompletionCallback,
+ Message->Msg.hwnd,
+ Message->Msg.message,
+ Message->CompletionCallbackContext,
+ Result);
}
-Notified:
-
- /* dereference both sender and our queue */
- IntDereferenceMessageQueue(MessageQueue);
- IntDereferenceMessageQueue(Message->SenderQueue);
+ /* Only if it is not a no wait message */
+ if (!(Message->HookMessage & MSQ_SENTNOWAIT))
+ {
+ IntDereferenceMessageQueue(Message->SenderQueue);
+ IntDereferenceMessageQueue(MessageQueue);
+ }
/* free the message */
- ExFreePool(Message);
+ ExFreePoolWithTag(Message, TAG_USRMSG);
return(TRUE);
}
{
DPRINT("Notify the sender and remove a message from the queue that had not been dispatched\n");
- RemoveEntryList(&SentMessage->ListEntry);
+ RemoveEntryList(&SentMessage->ListEntry);
- /* remove the message from the dispatching list */
- if(SentMessage->DispatchingListEntry.Flink != NULL)
+ /* remove the message from the dispatching list if neede */
+ if ((!(SentMessage->HookMessage & MSQ_SENTNOWAIT))
+ && (SentMessage->DispatchingListEntry.Flink != NULL))
{
RemoveEntryList(&SentMessage->DispatchingListEntry);
}
KeSetEvent(SentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
}
- /* dereference our and the sender's message queue */
- IntDereferenceMessageQueue(MessageQueue);
- IntDereferenceMessageQueue(SentMessage->SenderQueue);
+ if (SentMessage->HasPackedLParam == TRUE)
+ {
+ if (SentMessage->Msg.lParam)
+ ExFreePool((PVOID)SentMessage->Msg.lParam);
+ }
+
+ /* Only if it is not a no wait message */
+ if (!(SentMessage->HookMessage & MSQ_SENTNOWAIT))
+ {
+ /* dereference our and the sender's message queue */
+ IntDereferenceMessageQueue(MessageQueue);
+ IntDereferenceMessageQueue(SentMessage->SenderQueue);
+ }
/* free the message */
- ExFreePool(SentMessage);
+ ExFreePoolWithTag(SentMessage, TAG_USRMSG);
CurrentEntry = MessageQueue->SentMessagesListHead.Flink;
}
IntReferenceMessageQueue(ThreadQueue);
Message->CompletionCallback = NULL;
Message->HookMessage = HookMessage;
+ Message->HasPackedLParam = FALSE;
IntReferenceMessageQueue(MessageQueue);
UINT MsgFilterMin, UINT MsgFilterMax)
{
PVOID WaitObjects[2] = {MessageQueue->NewMessages, &HardwareMessageEvent};
- LARGE_INTEGER TimerExpiry;
- PLARGE_INTEGER Timeout;
NTSTATUS ret;
- if (MsqGetFirstTimerExpiry(MessageQueue, WndFilter, MsgFilterMin, MsgFilterMax, &TimerExpiry))
- {
- Timeout = &TimerExpiry;
- }
- else
- {
- Timeout = NULL;
- }
-
IdlePing(); // Going to wait so send Idle ping.
UserLeaveCo();
Executive,
UserMode,
FALSE,
- Timeout,
+ NULL,
NULL);
-
UserEnterCo();
-
return ret;
}
DPRINT("Notify the sender and remove a message from the queue that had not been dispatched\n");
- /* remove the message from the dispatching list */
- if(CurrentSentMessage->DispatchingListEntry.Flink != NULL)
+ /* remove the message from the dispatching list if needed */
+ if ((!(CurrentSentMessage->HookMessage & MSQ_SENTNOWAIT))
+ && (CurrentSentMessage->DispatchingListEntry.Flink != NULL))
{
RemoveEntryList(&CurrentSentMessage->DispatchingListEntry);
}
KeSetEvent(CurrentSentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
}
- /* dereference our and the sender's message queue */
- IntDereferenceMessageQueue(MessageQueue);
- IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
+ if (CurrentSentMessage->HasPackedLParam == TRUE)
+ {
+ if (CurrentSentMessage->Msg.lParam)
+ ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
+ }
+
+ /* Only if it is not a no wait message */
+ if (!(CurrentSentMessage->HookMessage & MSQ_SENTNOWAIT))
+ {
+ /* dereference our and the sender's message queue */
+ IntDereferenceMessageQueue(MessageQueue);
+ IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
+ }
/* free the message */
ExFreePool(CurrentSentMessage);
KeSetEvent(CurrentSentMessage->CompletionEvent, IO_NO_INCREMENT, FALSE);
}
- /* dereference our and the sender's message queue */
- IntDereferenceMessageQueue(MessageQueue);
- IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
+ if (CurrentSentMessage->HasPackedLParam == TRUE)
+ {
+ if (CurrentSentMessage->Msg.lParam)
+ ExFreePool((PVOID)CurrentSentMessage->Msg.lParam);
+ }
+
+ /* Only if it is not a no wait message */
+ if (!(CurrentSentMessage->HookMessage & MSQ_SENTNOWAIT))
+ {
+ /* dereference our and the sender's message queue */
+ IntDereferenceMessageQueue(MessageQueue);
+ IntDereferenceMessageQueue(CurrentSentMessage->SenderQueue);
+ }
/* free the message */
ExFreePool(CurrentSentMessage);
projects / reactos.git / blobdiff