ReactOS 0.4.16-dev-1288-g7ec3a7e
message.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Win32k subsystem
4 * PURPOSE: Messages
5 * PROGRAMER: Casper S. Hornstrup (chorns@users.sourceforge.net)
6 */
7
8#include <win32k.h>
9
10#include <dde.h>
11
13
14#define PM_BADMSGFLAGS ~((QS_RAWINPUT << 16)|PM_QS_SENDMESSAGE|PM_QS_PAINT|PM_QS_POSTMESSAGE|PM_QS_INPUT|PM_NOYIELD|PM_REMOVE)
15
16/* Strings that are OK to pass between user and kernel mode.
17 * There may be other strings needed that can easily be added here. */
18WCHAR StrUserKernel[3][20] = {{L"intl"}, {L"Environment"}, {L"Policy"}};
19
20/* FUNCTIONS *****************************************************************/
21
22/* PosInArray checks for strings that can pass between user and kernel mode.
23 * See: https://learn.microsoft.com/en-us/windows/win32/winmsg/wm-settingchange
24 * It mentions 'Environment', 'intl', and 'Policy'.
25 * These strings are enumerated in the StrUserKernel definition.
26 * Returns: A positive integer indicating its position in the array if the
27 * string is found, or returns a minus one (-1) if the string is not found. */
29{
30 INT i;
31
32 for (i = 0; i < ARRAYSIZE(StrUserKernel); ++i)
33 {
35 return i;
36 }
37 return -1;
38}
39
42{
43 return STATUS_SUCCESS;
44}
45
48{
49 return STATUS_SUCCESS;
50}
51
52/* From wine: */
53/* flag for messages that contain pointers */
54/* 32 messages per entry, messages 0..31 map to bits 0..31 */
55
56#define SET(msg) (1 << ((msg) & 31))
57
58static const unsigned int message_pointer_flags[] =
59{
60 /* 0x00 - 0x1f */
63 /* 0x20 - 0x3f */
66 /* 0x40 - 0x5f */
68 /* 0x60 - 0x7f */
69 SET(WM_STYLECHANGING) | SET(WM_STYLECHANGED),
70 /* 0x80 - 0x9f */
72 /* 0xa0 - 0xbf */
74 /* 0xc0 - 0xdf */
76 /* 0xe0 - 0xff */
77 SET(SBM_GETRANGE) | SET(SBM_SETSCROLLINFO) | SET(SBM_GETSCROLLINFO) | SET(SBM_GETSCROLLBARINFO),
78 /* 0x100 - 0x11f */
79 0,
80 /* 0x120 - 0x13f */
81 0,
82 /* 0x140 - 0x15f */
86 /* 0x160 - 0x17f */
87 0,
88 /* 0x180 - 0x19f */
92 /* 0x1a0 - 0x1bf */
94 /* 0x1c0 - 0x1df */
95 0,
96 /* 0x1e0 - 0x1ff */
97 0,
98 /* 0x200 - 0x21f */
100 /* 0x220 - 0x23f */
103 /* 0x240 - 0x25f */
104 0,
105 /* 0x260 - 0x27f */
106 0,
107 /* 0x280 - 0x29f */
108 0,
109 /* 0x2a0 - 0x2bf */
110 0,
111 /* 0x2c0 - 0x2df */
112 0,
113 /* 0x2e0 - 0x2ff */
114 0,
115 /* 0x300 - 0x31f */
117};
118
119/* check whether a given message type includes pointers */
121{
122 if (message >= 8*sizeof(message_pointer_flags)) return FALSE;
123 if (message == WM_DEVICECHANGE && !(wparam & 0x8000)) return FALSE;
124 return (message_pointer_flags[message / 32] & SET(message)) != 0;
125}
126#undef SET
127
128#define MMS_SIZE_WPARAM -1
129#define MMS_SIZE_WPARAMWCHAR -2
130#define MMS_SIZE_LPARAMSZ -3
131#define MMS_SIZE_SPECIAL -4
132#define MMS_FLAG_READ 0x01
133#define MMS_FLAG_WRITE 0x02
134#define MMS_FLAG_READWRITE (MMS_FLAG_READ | MMS_FLAG_WRITE)
135typedef struct tagMSGMEMORY
136{
140}
142
144{
151 { WM_STYLECHANGED, sizeof(STYLESTRUCT), MMS_FLAG_READ },
152 { WM_STYLECHANGING, sizeof(STYLESTRUCT), MMS_FLAG_READWRITE },
158 { WM_SIZING, sizeof(RECT), MMS_FLAG_READWRITE },
159 { WM_MOVING, sizeof(RECT), MMS_FLAG_READWRITE },
162 { WM_HELP, sizeof(HELPINFO), MMS_FLAG_READWRITE },
165};
166
167static PMSGMEMORY FASTCALL
169{
170 PMSGMEMORY MsgMemoryEntry;
171
172 /* See if this message type is present in the table */
173 for (MsgMemoryEntry = g_MsgMemory;
174 MsgMemoryEntry < g_MsgMemory + sizeof(g_MsgMemory) / sizeof(MSGMEMORY);
175 MsgMemoryEntry++)
176 {
177 if (Msg == MsgMemoryEntry->Message)
178 {
179 return MsgMemoryEntry;
180 }
181 }
182
183 return NULL;
184}
185
186static UINT FASTCALL
188{
189 CREATESTRUCTW *Cs;
190 PLARGE_STRING WindowName;
191 PUNICODE_STRING ClassName;
192 UINT Size = 0;
193
195 {
196 if (MMS_SIZE_WPARAM == MsgMemoryEntry->Size)
197 {
198 Size = (UINT)wParam;
199 }
200 else if (MMS_SIZE_WPARAMWCHAR == MsgMemoryEntry->Size)
201 {
202 Size = (UINT) (wParam * sizeof(WCHAR));
203 }
204 else if (MMS_SIZE_LPARAMSZ == MsgMemoryEntry->Size)
205 {
206 // WM_SETTEXT and WM_SETTINGCHANGE can be null!
207 if (!lParam)
208 {
209 TRACE("lParam is NULL!\n");
210 Size = 0;
211 }
212 else
213 Size = (UINT) ((wcslen((PWSTR) lParam) + 1) * sizeof(WCHAR));
214 }
215 else if (MMS_SIZE_SPECIAL == MsgMemoryEntry->Size)
216 {
217 switch(MsgMemoryEntry->Message)
218 {
219 case WM_CREATE:
220 case WM_NCCREATE:
221 Cs = (CREATESTRUCTW *) lParam;
222 WindowName = (PLARGE_STRING) Cs->lpszName;
223 ClassName = (PUNICODE_STRING) Cs->lpszClass;
224 Size = sizeof(CREATESTRUCTW) + WindowName->Length + sizeof(WCHAR);
225 if (IS_ATOM(ClassName->Buffer))
226 {
227 Size += sizeof(WCHAR) + sizeof(ATOM);
228 }
229 else
230 {
231 Size += sizeof(WCHAR) + ClassName->Length + sizeof(WCHAR);
232 }
233 break;
234
235 case WM_NCCALCSIZE:
236 Size = wParam ? sizeof(NCCALCSIZE_PARAMS) + sizeof(WINDOWPOS) : sizeof(RECT);
237 break;
238
239 case WM_COPYDATA:
240 {
242 Size = sizeof(COPYDATASTRUCT) + cds->cbData;
243 }
244 break;
245
246 case WM_DEVICECHANGE:
247 {
248 if ( lParam && (wParam & 0x8000) )
249 {
251 Size = header->dbch_size;
252 }
253 }
254 break;
255
256 default:
257 ASSERT(FALSE);
258 Size = 0;
259 break;
260 }
261 }
262 else
263 {
264 Size = MsgMemoryEntry->Size;
265 }
266 }
268 {
269 ERR("Exception caught in MsgMemorySize()! Status: 0x%x\n", _SEH2_GetExceptionCode());
270 Size = 0;
271 }
272 _SEH2_END;
273 return Size;
274}
275
277{
278 PMSGMEMORY MsgMemoryEntry = FindMsgMemory(Msg);
279 if(MsgMemoryEntry == NULL) return 0;
280 return MsgMemorySize(MsgMemoryEntry, wParam, lParam);
281}
282
283static NTSTATUS
284PackParam(LPARAM *lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolNeeded)
285{
286 NCCALCSIZE_PARAMS *UnpackedNcCalcsize;
287 NCCALCSIZE_PARAMS *PackedNcCalcsize;
288 CREATESTRUCTW *UnpackedCs;
289 CREATESTRUCTW *PackedCs;
290 PLARGE_STRING WindowName;
291 PUNICODE_STRING ClassName;
293 UINT Size;
294 PCHAR CsData;
295
296 *lParamPacked = lParam;
297
298 if (NonPagedPoolNeeded)
300 else
302
303 if (WM_NCCALCSIZE == Msg && wParam)
304 {
305
306 UnpackedNcCalcsize = (NCCALCSIZE_PARAMS *) lParam;
307 PackedNcCalcsize = ExAllocatePoolWithTag(PoolType,
308 sizeof(NCCALCSIZE_PARAMS) + sizeof(WINDOWPOS),
309 TAG_MSG);
310
311 if (NULL == PackedNcCalcsize)
312 {
313 ERR("Not enough memory to pack lParam\n");
314 return STATUS_NO_MEMORY;
315 }
316 RtlCopyMemory(PackedNcCalcsize, UnpackedNcCalcsize, sizeof(NCCALCSIZE_PARAMS));
317 PackedNcCalcsize->lppos = (PWINDOWPOS) (PackedNcCalcsize + 1);
318 RtlCopyMemory(PackedNcCalcsize->lppos, UnpackedNcCalcsize->lppos, sizeof(WINDOWPOS));
319 *lParamPacked = (LPARAM) PackedNcCalcsize;
320 }
321 else if (WM_CREATE == Msg || WM_NCCREATE == Msg)
322 {
323 UnpackedCs = (CREATESTRUCTW *) lParam;
324 WindowName = (PLARGE_STRING) UnpackedCs->lpszName;
325 ClassName = (PUNICODE_STRING) UnpackedCs->lpszClass;
326 Size = sizeof(CREATESTRUCTW) + WindowName->Length + sizeof(WCHAR);
327 if (IS_ATOM(ClassName->Buffer))
328 {
329 Size += sizeof(WCHAR) + sizeof(ATOM);
330 }
331 else
332 {
333 Size += sizeof(WCHAR) + ClassName->Length + sizeof(WCHAR);
334 }
336 if (NULL == PackedCs)
337 {
338 ERR("Not enough memory to pack lParam\n");
339 return STATUS_NO_MEMORY;
340 }
341 RtlCopyMemory(PackedCs, UnpackedCs, sizeof(CREATESTRUCTW));
342 CsData = (PCHAR) (PackedCs + 1);
343 PackedCs->lpszName = (LPCWSTR) (CsData - (PCHAR) PackedCs);
344 RtlCopyMemory(CsData, WindowName->Buffer, WindowName->Length);
345 CsData += WindowName->Length;
346 *((WCHAR *) CsData) = L'\0';
347 CsData += sizeof(WCHAR);
348 PackedCs->lpszClass = (LPCWSTR) (CsData - (PCHAR) PackedCs);
349 if (IS_ATOM(ClassName->Buffer))
350 {
351 *((WCHAR *) CsData) = L'A';
352 CsData += sizeof(WCHAR);
353 *((ATOM *) CsData) = (ATOM)(DWORD_PTR) ClassName->Buffer;
354 CsData += sizeof(ATOM);
355 }
356 else
357 {
358 NT_ASSERT(ClassName->Buffer != NULL);
359 *((WCHAR *) CsData) = L'S';
360 CsData += sizeof(WCHAR);
361 RtlCopyMemory(CsData, ClassName->Buffer, ClassName->Length);
362 CsData += ClassName->Length;
363 *((WCHAR *) CsData) = L'\0';
364 CsData += sizeof(WCHAR);
365 }
366 ASSERT(CsData == (PCHAR) PackedCs + Size);
367 *lParamPacked = (LPARAM) PackedCs;
368 }
369 else if (PoolType == NonPagedPool)
370 {
371 PMSGMEMORY MsgMemoryEntry;
372 PVOID PackedData;
373 SIZE_T size;
374
375 MsgMemoryEntry = FindMsgMemory(Msg);
376
377 if (!MsgMemoryEntry)
378 {
379 /* Keep previous behavior */
380 return STATUS_SUCCESS;
381 }
382 size = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
383 if (!size)
384 {
385 ERR("No size for lParamPacked\n");
386 return STATUS_SUCCESS;
387 }
389 if (PackedData == NULL)
390 {
391 ERR("Not enough memory to pack lParam\n");
392 return STATUS_NO_MEMORY;
393 }
394 RtlCopyMemory(PackedData, (PVOID)lParam, MsgMemorySize(MsgMemoryEntry, wParam, lParam));
395 *lParamPacked = (LPARAM)PackedData;
396 }
397
398 return STATUS_SUCCESS;
399}
400
401static NTSTATUS
402UnpackParam(LPARAM lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolUsed)
403{
404 NCCALCSIZE_PARAMS *UnpackedParams;
405 NCCALCSIZE_PARAMS *PackedParams;
406 PWINDOWPOS UnpackedWindowPos;
407
408 if (lParamPacked == lParam)
409 {
410 return STATUS_SUCCESS;
411 }
412
413 if (WM_NCCALCSIZE == Msg && wParam)
414 {
415 PackedParams = (NCCALCSIZE_PARAMS *) lParamPacked;
416 UnpackedParams = (NCCALCSIZE_PARAMS *) lParam;
417 UnpackedWindowPos = UnpackedParams->lppos;
418 RtlCopyMemory(UnpackedParams, PackedParams, sizeof(NCCALCSIZE_PARAMS));
419 UnpackedParams->lppos = UnpackedWindowPos;
420 RtlCopyMemory(UnpackedWindowPos, PackedParams + 1, sizeof(WINDOWPOS));
421 ExFreePool((PVOID) lParamPacked);
422
423 return STATUS_SUCCESS;
424 }
425 else if (WM_CREATE == Msg || WM_NCCREATE == Msg)
426 {
427 ExFreePool((PVOID) lParamPacked);
428
429 return STATUS_SUCCESS;
430 }
431 else if (NonPagedPoolUsed)
432 {
433 PMSGMEMORY MsgMemoryEntry;
434 MsgMemoryEntry = FindMsgMemory(Msg);
435 ASSERT(MsgMemoryEntry);
436
437 if (MsgMemoryEntry->Flags == MMS_FLAG_READWRITE)
438 {
439 //RtlCopyMemory((PVOID)lParam, (PVOID)lParamPacked, MsgMemoryEntry->Size);
440 }
441 ExFreePool((PVOID) lParamPacked);
442 return STATUS_SUCCESS;
443 }
444
445 ASSERT(FALSE);
446
448}
449
450static NTSTATUS FASTCALL
451CopyMsgToKernelMem(MSG *KernelModeMsg, MSG *UserModeMsg, PMSGMEMORY MsgMemoryEntry)
452{
454
455 PVOID KernelMem;
456 UINT Size;
457
458 *KernelModeMsg = *UserModeMsg;
459
460 /* See if this message type is present in the table */
461 if (NULL == MsgMemoryEntry)
462 {
463 /* Not present, no copying needed */
464 return STATUS_SUCCESS;
465 }
466
467 /* Determine required size */
468 Size = MsgMemorySize(MsgMemoryEntry, UserModeMsg->wParam, UserModeMsg->lParam);
469
470 if (0 != Size)
471 {
472 /* Allocate kernel mem */
474 if (NULL == KernelMem)
475 {
476 ERR("Not enough memory to copy message to kernel mem\n");
477 return STATUS_NO_MEMORY;
478 }
479 KernelModeMsg->lParam = (LPARAM) KernelMem;
480
481 /* Copy data if required */
482 if (0 != (MsgMemoryEntry->Flags & MMS_FLAG_READ))
483 {
484 TRACE("Copy Message %u from usermode buffer\n", KernelModeMsg->message);
485 /* Don't do extra testing for 1 word messages. For examples see
486 * https://wiki.winehq.org/List_Of_Windows_Messages and
487 * we are just handling WM_WININICHANGE here. */
488 if (Size > 1 && UserModeMsg->lParam &&
489 KernelModeMsg->message == WM_WININICHANGE)
490 {
491 WCHAR lParamMsg[_countof(StrUserKernel[0]) + 1] = { 0 };
493 {
494 RtlCopyMemory(lParamMsg, (WCHAR*)UserModeMsg->lParam, sizeof(lParamMsg));
495 }
497 {
499 }
500 _SEH2_END;
501
502 /* Make sure that we have a UNICODE_NULL within lParamMsg */
503 lParamMsg[ARRAYSIZE(lParamMsg) - 1] = UNICODE_NULL;
504
505 if (!UserModeMsg->wParam && PosInArray(lParamMsg) >= 0)
506 {
507 TRACE("Copy String '%S' from usermode buffer\n", lParamMsg);
508 wcscpy(KernelMem, lParamMsg);
509 return STATUS_SUCCESS;
510 }
511 }
512
513 Status = MmCopyFromCaller(KernelMem, (PVOID)UserModeMsg->lParam, Size);
514 if (!NT_SUCCESS(Status))
515 {
516 ERR("Failed to copy message to kernel: invalid usermode lParam buffer\n");
517 ExFreePoolWithTag(KernelMem, TAG_MSG);
518 return Status;
519 }
520 }
521 else
522 {
523 /* Make sure we don't pass any secrets to usermode */
524 RtlZeroMemory(KernelMem, Size);
525 }
526 }
527 else
528 {
529 KernelModeMsg->lParam = 0;
530 }
531
532 return STATUS_SUCCESS;
533}
534
535static NTSTATUS FASTCALL
536CopyMsgToUserMem(MSG *UserModeMsg, MSG *KernelModeMsg)
537{
539 PMSGMEMORY MsgMemoryEntry;
540 UINT Size;
541
542 /* See if this message type is present in the table */
543 MsgMemoryEntry = FindMsgMemory(UserModeMsg->message);
544 if (NULL == MsgMemoryEntry)
545 {
546 /* Not present, no copying needed */
547 return STATUS_SUCCESS;
548 }
549
550 /* Determine required size */
551 Size = MsgMemorySize(MsgMemoryEntry, UserModeMsg->wParam, UserModeMsg->lParam);
552
553 if (0 != Size)
554 {
555 /* Copy data if required */
556 if (0 != (MsgMemoryEntry->Flags & MMS_FLAG_WRITE))
557 {
558 Status = MmCopyToCaller((PVOID) UserModeMsg->lParam, (PVOID) KernelModeMsg->lParam, Size);
559 if (! NT_SUCCESS(Status))
560 {
561 ERR("Failed to copy message from kernel: invalid usermode lParam buffer\n");
562 ExFreePool((PVOID) KernelModeMsg->lParam);
563 return Status;
564 }
565 }
566 ExFreePool((PVOID) KernelModeMsg->lParam);
567 }
568
569 return STATUS_SUCCESS;
570}
571
572//
573// Wakeup any thread/process waiting on idle input.
574//
577{
579 PTHREADINFO pti;
580
582
583 if ( pti )
584 {
585 pti->pClientInfo->cSpins = 0; // Reset spins.
586
587 if ( pti->pDeskInfo && pti == gptiForeground )
588 {
591 {
593 }
594 }
595 }
596
597 TRACE("IdlePing ppi %p\n", ppi);
598 if ( ppi && ppi->InputIdleEvent )
599 {
600 TRACE("InputIdleEvent\n");
601 KeSetEvent( ppi->InputIdleEvent, IO_NO_INCREMENT, FALSE);
602 }
603}
604
607{
609
610 TRACE("IdlePong ppi %p\n", ppi);
611 if ( ppi && ppi->InputIdleEvent )
612 {
613 KeClearEvent(ppi->InputIdleEvent);
614 }
615}
616
618{
619 return msg < WM_USER || msg >= 0xc000;
620}
621
624{
625 UINT mask = QS_POSTMESSAGE | QS_SENDMESSAGE; /* Always selected */
626
627 if (first || last)
628 {
629 if ((first <= WM_KEYLAST) && (last >= WM_KEYFIRST)) mask |= QS_KEY;
630 if ( ((first <= WM_MOUSELAST) && (last >= WM_MOUSEFIRST)) ||
632 if ((first <= WM_TIMER) && (last >= WM_TIMER)) mask |= QS_TIMER;
633 if ((first <= WM_SYSTIMER) && (last >= WM_SYSTIMER)) mask |= QS_TIMER;
634 if ((first <= WM_PAINT) && (last >= WM_PAINT)) mask |= QS_PAINT;
635 }
636 else mask = QS_ALLINPUT;
637
638 return mask;
639}
640
641//
642// Pass Strings to User Heap Space for Message Hook Callbacks.
643//
644BOOL
647 PWND Window,
648 CREATESTRUCTW *pCsw,
649 CREATESTRUCTW *Cs,
650 PVOID *ppszClass,
651 PVOID *ppszName )
652{
653 PLARGE_STRING WindowName;
654 PUNICODE_STRING ClassName;
655 PVOID pszClass = NULL, pszName = NULL;
656
657 /* Fill the new CREATESTRUCTW */
658 RtlCopyMemory(pCsw, Cs, sizeof(CREATESTRUCTW));
659 pCsw->style = Window->style; /* HCBT_CREATEWND needs the real window style */
660
661 WindowName = (PLARGE_STRING) Cs->lpszName;
662 ClassName = (PUNICODE_STRING) Cs->lpszClass;
663
664 // Based on the assumption this is from "unicode source" user32, ReactOS, answer is yes.
665 if (!IS_ATOM(ClassName->Buffer))
666 {
667 if (ClassName->Length)
668 {
669 if (Window->state & WNDS_ANSICREATOR)
670 {
672 AnsiString.MaximumLength = (USHORT)RtlUnicodeStringToAnsiSize(ClassName)+sizeof(CHAR);
673 pszClass = UserHeapAlloc(AnsiString.MaximumLength);
674 if (!pszClass)
675 {
676 ERR("UserHeapAlloc() failed!\n");
677 return FALSE;
678 }
679 RtlZeroMemory(pszClass, AnsiString.MaximumLength);
680 AnsiString.Buffer = (PCHAR)pszClass;
682 }
683 else
684 {
686 UnicodeString.MaximumLength = ClassName->Length + sizeof(UNICODE_NULL);
687 pszClass = UserHeapAlloc(UnicodeString.MaximumLength);
688 if (!pszClass)
689 {
690 ERR("UserHeapAlloc() failed!\n");
691 return FALSE;
692 }
693 RtlZeroMemory(pszClass, UnicodeString.MaximumLength);
694 UnicodeString.Buffer = (PWSTR)pszClass;
696 }
697 *ppszClass = pszClass;
698 pCsw->lpszClass = UserHeapAddressToUser(pszClass);
699 }
700 else
701 {
702 pCsw->lpszClass = NULL;
703 }
704 }
705 else
706 {
707 pCsw->lpszClass = ClassName->Buffer;
708 }
709 if (WindowName->Length)
710 {
712 Name.Buffer = WindowName->Buffer;
713 Name.Length = (USHORT)min(WindowName->Length, MAXUSHORT); // FIXME: LARGE_STRING truncated
714 Name.MaximumLength = (USHORT)min(WindowName->MaximumLength, MAXUSHORT);
715
716 if (Window->state & WNDS_ANSICREATOR)
717 {
719 AnsiString.MaximumLength = (USHORT)RtlUnicodeStringToAnsiSize(&Name) + sizeof(CHAR);
720 pszName = UserHeapAlloc(AnsiString.MaximumLength);
721 if (!pszName)
722 {
723 ERR("UserHeapAlloc() failed!\n");
724 return FALSE;
725 }
726 RtlZeroMemory(pszName, AnsiString.MaximumLength);
727 AnsiString.Buffer = (PCHAR)pszName;
729 }
730 else
731 {
733 UnicodeString.MaximumLength = Name.Length + sizeof(UNICODE_NULL);
734 pszName = UserHeapAlloc(UnicodeString.MaximumLength);
735 if (!pszName)
736 {
737 ERR("UserHeapAlloc() failed!\n");
738 return FALSE;
739 }
740 RtlZeroMemory(pszName, UnicodeString.MaximumLength);
741 UnicodeString.Buffer = (PWSTR)pszName;
743 }
744 *ppszName = pszName;
745 pCsw->lpszName = UserHeapAddressToUser(pszName);
746 }
747 else
748 {
749 pCsw->lpszName = NULL;
750 }
751
752 return TRUE;
753}
754
755static VOID FASTCALL
757{
758 BOOL SameThread = FALSE;
759 CWPSTRUCT CWP;
760 PVOID pszClass = NULL, pszName = NULL;
761 CREATESTRUCTW Csw;
762
764 if ( !ISITHOOKED(WH_CALLWNDPROC) && !(Window->head.rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CALLWNDPROC)) )
765 return;
766
768 SameThread = TRUE;
769
770 if ( Msg == WM_CREATE || Msg == WM_NCCREATE )
771 { //
772 // String pointers are in user heap space, like WH_CBT HCBT_CREATEWND.
773 //
774 if (!IntMsgCreateStructW( Window, &Csw, (CREATESTRUCTW *)lParam, &pszClass, &pszName ))
775 return;
776 lParam = (LPARAM)&Csw;
777 }
778
779 CWP.hwnd = hWnd;
780 CWP.message = Msg;
781 CWP.wParam = wParam;
782 CWP.lParam = lParam;
783 co_HOOK_CallHooks( WH_CALLWNDPROC, HC_ACTION, SameThread, (LPARAM)&CWP );
784
785 if (pszName) UserHeapFree(pszName);
786 if (pszClass) UserHeapFree(pszClass);
787}
788
789static VOID FASTCALL
791{
792 BOOL SameThread = FALSE;
793 CWPRETSTRUCT CWPR;
794 PVOID pszClass = NULL, pszName = NULL;
795 CREATESTRUCTW Csw;
796
797 if ( !ISITHOOKED(WH_CALLWNDPROCRET) && !(Window->head.rpdesk->pDeskInfo->fsHooks & HOOKID_TO_FLAG(WH_CALLWNDPROCRET)) )
798 return;
799
801 SameThread = TRUE;
802
803 if ( Msg == WM_CREATE || Msg == WM_NCCREATE )
804 {
805 if (!IntMsgCreateStructW( Window, &Csw, (CREATESTRUCTW *)lParam, &pszClass, &pszName ))
806 return;
807 lParam = (LPARAM)&Csw;
808 }
809
810 CWPR.hwnd = hWnd;
811 CWPR.message = Msg;
812 CWPR.wParam = wParam;
813 CWPR.lParam = lParam;
814 CWPR.lResult = uResult ? (*uResult) : 0;
815 co_HOOK_CallHooks( WH_CALLWNDPROCRET, HC_ACTION, SameThread, (LPARAM)&CWPR );
816
817 if (pszName) UserHeapFree(pszName);
818 if (pszClass) UserHeapFree(pszClass);
819}
820
822{
823 LRESULT lRes;
824// USER_REFERENCE_ENTRY Ref;
825// PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
826
827 if (!pWnd || UserIsDesktopWindow(pWnd) || UserIsMessageWindow(pWnd))
828 return 0;
829
830 TRACE("Internal Event Msg 0x%x hWnd 0x%p\n", msg, UserHMGetHandle(pWnd));
831
832 switch(msg)
833 {
835 return co_WinPosShowWindow( pWnd, wparam );
837 {
838 PWINDOWPOS winpos = (PWINDOWPOS)lparam;
839 if (!winpos) return 0;
840 lRes = co_WinPosSetWindowPos( pWnd,
841 winpos->hwndInsertAfter,
842 winpos->x,
843 winpos->y,
844 winpos->cx,
845 winpos->cy,
846 winpos->flags);
848 return lRes;
849 }
851 {
852 TRACE("WM_ASYNC_DESTROYWINDOW\n");
853 if (pWnd->style & WS_CHILD)
855 else
857 }
858 }
859 return 0;
860}
861
862static LRESULT handle_internal_events( PTHREADINFO pti, PWND pWnd, DWORD dwQEvent, LONG_PTR ExtraInfo, PMSG pMsg)
863{
864 LRESULT Result = 0;
865
866 switch(dwQEvent)
867 {
868 case POSTEVENT_NWE:
869 {
870 co_EVENT_CallEvents( pMsg->message, pMsg->hwnd, pMsg->wParam, ExtraInfo);
871 }
872 break;
873 case POSTEVENT_SAW:
874 {
875 //ERR("HIE : SAW : pti 0x%p hWnd 0x%p\n",pti,pMsg->hwnd);
876 IntActivateWindow((PWND)pMsg->wParam, pti, (HANDLE)pMsg->lParam, (DWORD)ExtraInfo);
877 }
878 break;
879 case POSTEVENT_DAW:
880 {
881 //ERR("HIE : DAW : pti 0x%p tid 0x%p hWndPrev 0x%p\n",pti,ExtraInfo,pMsg->hwnd);
882 IntDeactivateWindow(pti, (HANDLE)ExtraInfo);
883 }
884 break;
885 }
886 return Result;
887}
888
891{
892 LONG Time;
893 LRESULT retval = 0;
894 PTHREADINFO pti;
895 PWND Window = NULL;
896 BOOL DoCallBack = TRUE;
897
898 if (pMsg->hwnd)
899 {
901 if (!Window) return 0;
902 }
903
905
906 if ( Window && Window->head.pti != pti)
907 {
909 return 0;
910 }
911
912 if (((pMsg->message == WM_SYSTIMER) ||
913 (pMsg->message == WM_TIMER)) &&
914 (pMsg->lParam) )
915 {
916 if (pMsg->message == WM_TIMER)
917 {
918 if (ValidateTimerCallback(pti,pMsg->lParam))
919 {
922 TRUE,
923 pMsg->hwnd,
924 WM_TIMER,
925 pMsg->wParam,
926 (LPARAM)Time,
927 -1);
928 }
929 return retval;
930 }
931 else
932 {
933 PTIMER pTimer = FindSystemTimer(pMsg);
934 if (pTimer && pTimer->pfn)
935 {
937 pTimer->pfn(pMsg->hwnd, WM_SYSTIMER, (UINT)pMsg->wParam, Time);
938 }
939 return 0;
940 }
941 }
942 // Need a window!
943 if ( !Window ) return 0;
944
945 if (pMsg->message == WM_PAINT) Window->state |= WNDS_PAINTNOTPROCESSED;
946
947 if ( Window->state & WNDS_SERVERSIDEWINDOWPROC )
948 {
949 TRACE("Dispatch: Server Side Window Procedure\n");
950 switch(Window->fnid)
951 {
952 case FNID_DESKTOP:
953 DoCallBack = !DesktopWindowProc( Window,
954 pMsg->message,
955 pMsg->wParam,
956 pMsg->lParam,
957 &retval);
958 break;
959 case FNID_MESSAGEWND:
960 DoCallBack = !UserMessageWindowProc( Window,
961 pMsg->message,
962 pMsg->wParam,
963 pMsg->lParam,
964 &retval);
965 break;
966 case FNID_MENU:
967 DoCallBack = !PopupMenuWndProc( Window,
968 pMsg->message,
969 pMsg->wParam,
970 pMsg->lParam,
971 &retval);
972 break;
973 }
974 }
975
976 /* Since we are doing a callback on the same thread right away, there is
977 no need to copy the lparam to kernel mode and then back to usermode.
978 We just pretend it isn't a pointer */
979
980 if (DoCallBack)
981 retval = co_IntCallWindowProc( Window->lpfnWndProc,
982 !Window->Unicode,
983 pMsg->hwnd,
984 pMsg->message,
985 pMsg->wParam,
986 pMsg->lParam,
987 -1);
988
989 if ( pMsg->message == WM_PAINT &&
990 VerifyWnd(Window) &&
991 Window->state & WNDS_PAINTNOTPROCESSED ) // <--- Cleared, paint was already processed!
992 {
993 Window->state2 &= ~WNDS2_WMPAINTSENT;
994 /* send a WM_ERASEBKGND if the non-client area is still invalid */
995 ERR("Message WM_PAINT count %d Internal Paint Set? %s\n",Window->head.pti->cPaintsReady, Window->state & WNDS_INTERNALPAINT ? "TRUE" : "FALSE");
997 }
998
999 return retval;
1000}
1001
1002/*
1003 * Internal version of PeekMessage() doing all the work
1004 *
1005 * MSDN:
1006 * Sent messages
1007 * Posted messages
1008 * Input (hardware) messages and system internal events
1009 * Sent messages (again)
1010 * WM_PAINT messages
1011 * WM_TIMER messages
1012 */
1015 PWND Window,
1016 UINT MsgFilterMin,
1017 UINT MsgFilterMax,
1018 UINT RemoveMsg,
1019 LONG_PTR *ExtraInfo,
1020 BOOL bGMSG )
1021{
1022 PTHREADINFO pti;
1023 BOOL RemoveMessages;
1024 UINT ProcessMask;
1025 BOOL Hit = FALSE;
1026
1028
1029 RemoveMessages = RemoveMsg & PM_REMOVE;
1030 ProcessMask = HIWORD(RemoveMsg);
1031
1032 /* Hint, "If wMsgFilterMin and wMsgFilterMax are both zero, PeekMessage returns
1033 all available messages (that is, no range filtering is performed)". */
1034 if (!ProcessMask) ProcessMask = (QS_ALLPOSTMESSAGE|QS_ALLINPUT);
1035
1036 IdlePong();
1037
1038 do
1039 {
1040 /* Update the last message-queue access time */
1041 pti->pcti->timeLastRead = EngGetTickCount32();
1042
1043 // Post mouse moves while looping through peek messages.
1044 if (pti->MessageQueue->QF_flags & QF_MOUSEMOVED)
1045 {
1047 }
1048
1049 /* Dispatch sent messages here. */
1050 while ( co_MsqDispatchOneSentMessage(pti) )
1051 {
1052 /* if some PM_QS* flags were specified, only handle sent messages from now on */
1053 if (HIWORD(RemoveMsg) && !bGMSG) Hit = TRUE; // wine does this; ProcessMask = QS_SENDMESSAGE;
1054 }
1055 if (Hit) return FALSE;
1056
1057 /* Clear changed bits so we can wait on them if we don't find a message */
1058 if (ProcessMask & QS_POSTMESSAGE)
1059 {
1060 pti->pcti->fsChangeBits &= ~(QS_POSTMESSAGE | QS_HOTKEY | QS_TIMER);
1061 if (MsgFilterMin == 0 && MsgFilterMax == 0) // Wine hack does this; ~0U)
1062 {
1063 pti->pcti->fsChangeBits &= ~QS_ALLPOSTMESSAGE;
1064 }
1065 }
1066
1067 if (ProcessMask & QS_INPUT)
1068 {
1069 pti->pcti->fsChangeBits &= ~QS_INPUT;
1070 }
1071
1072 /* Now check for normal messages. */
1073 if (( (ProcessMask & QS_POSTMESSAGE) ||
1074 (ProcessMask & QS_HOTKEY) ) &&
1075 MsqPeekMessage( pti,
1076 RemoveMessages,
1077 Window,
1078 MsgFilterMin,
1079 MsgFilterMax,
1080 ProcessMask,
1081 ExtraInfo,
1082 0,
1083 Msg ))
1084 {
1085 goto GotMessage;
1086 }
1087
1088 /* Only check for quit messages if not posted messages pending. */
1089 if (ProcessMask & QS_POSTMESSAGE && pti->QuitPosted)
1090 {
1091 /* According to the PSDK, WM_QUIT messages are always returned, regardless
1092 of the filter specified */
1093 Msg->hwnd = NULL;
1094 Msg->message = WM_QUIT;
1095 Msg->wParam = pti->exitCode;
1096 Msg->lParam = 0;
1097 if (RemoveMessages)
1098 {
1099 pti->QuitPosted = FALSE;
1101 pti->pcti->fsWakeBits &= ~QS_ALLPOSTMESSAGE;
1102 pti->pcti->fsChangeBits &= ~QS_ALLPOSTMESSAGE;
1103 }
1104 goto GotMessage;
1105 }
1106
1107 /* Check for hardware events. */
1108 if ((ProcessMask & QS_INPUT) &&
1110 RemoveMessages,
1111 Window,
1112 MsgFilterMin,
1113 MsgFilterMax,
1114 ProcessMask,
1115 Msg))
1116 {
1117 goto GotMessage;
1118 }
1119
1120 /* Now check for System Event messages. */
1121 {
1122 LONG_PTR eExtraInfo;
1123 MSG eMsg;
1124 DWORD dwQEvent;
1125 if (MsqPeekMessage( pti,
1126 TRUE,
1127 Window,
1128 0,
1129 0,
1130 QS_EVENT,
1131 &eExtraInfo,
1132 &dwQEvent,
1133 &eMsg ))
1134 {
1135 handle_internal_events( pti, Window, dwQEvent, eExtraInfo, &eMsg);
1136 continue;
1137 }
1138 }
1139
1140 /* Check for sent messages again. */
1141 while ( co_MsqDispatchOneSentMessage(pti) )
1142 {
1143 if (HIWORD(RemoveMsg) && !bGMSG) Hit = TRUE;
1144 }
1145 if (Hit) return FALSE;
1146
1147 /* Check for paint messages. */
1148 if ((ProcessMask & QS_PAINT) &&
1149 pti->cPaintsReady &&
1151 MsgFilterMin,
1152 MsgFilterMax,
1153 pti,
1154 Msg,
1155 RemoveMessages))
1156 {
1157 goto GotMessage;
1158 }
1159
1160 /* This is correct, check for the current threads timers waiting to be
1161 posted to this threads message queue. If any we loop again.
1162 */
1163 if ((ProcessMask & QS_TIMER) &&
1165 {
1166 continue;
1167 }
1168
1169 return FALSE;
1170 }
1171 while (TRUE);
1172
1173GotMessage:
1174 /* Update the last message-queue access time */
1175 pti->pcti->timeLastRead = EngGetTickCount32();
1176 return TRUE;
1177}
1178
1181 UINT MsgFilterMin,
1182 UINT MsgFilterMax )
1183{
1184 PTHREADINFO pti;
1186 MSG Msg;
1187 LONG_PTR ExtraInfo = 0;
1188
1190
1191 do
1192 {
1193 if ( co_IntPeekMessage( &Msg, // Dont reenter!
1194 Window,
1195 MsgFilterMin,
1196 MsgFilterMax,
1197 MAKELONG( PM_NOREMOVE, GetWakeMask( MsgFilterMin, MsgFilterMax)),
1198 &ExtraInfo,
1199 TRUE ) ) // act like GetMessage.
1200 {
1201 return TRUE;
1202 }
1203
1204 /* Nothing found. Wait for new messages. */
1206 Window,
1207 MsgFilterMin,
1208 MsgFilterMax);
1209 if (!NT_SUCCESS(Status))
1210 {
1212 ERR("Exit co_IntWaitMessage on error!\n");
1213 return FALSE;
1214 }
1216 {
1217 return FALSE;
1218 }
1219 }
1220 while ( TRUE );
1221
1222 return FALSE;
1223}
1224
1227 HWND hWnd,
1228 UINT MsgFilterMin,
1229 UINT MsgFilterMax,
1230 UINT RemoveMsg,
1231 BOOL bGMSG )
1232{
1233 PWND Window;
1234 PTHREADINFO pti;
1235 BOOL Present = FALSE;
1237 LONG_PTR ExtraInfo = 0;
1238
1239 if ( hWnd == HWND_TOPMOST || hWnd == HWND_BROADCAST )
1240 hWnd = HWND_BOTTOM;
1241
1242 /* Validate input */
1243 if (hWnd && hWnd != HWND_BOTTOM)
1244 {
1246 {
1247 if (bGMSG)
1248 return -1;
1249 else
1250 return FALSE;
1251 }
1252 }
1253 else
1254 {
1255 Window = (PWND)hWnd;
1256 }
1257
1258 if (MsgFilterMax < MsgFilterMin)
1259 {
1260 MsgFilterMin = 0;
1261 MsgFilterMax = 0;
1262 }
1263
1264 if (bGMSG)
1265 {
1266 RemoveMsg |= ((GetWakeMask( MsgFilterMin, MsgFilterMax ))<< 16);
1267 }
1268
1270 pti->pClientInfo->cSpins++; // Bump up the spin count.
1271
1272 do
1273 {
1274 Present = co_IntPeekMessage( pMsg,
1275 Window,
1276 MsgFilterMin,
1277 MsgFilterMax,
1278 RemoveMsg,
1279 &ExtraInfo,
1280 bGMSG );
1281 if (Present)
1282 {
1283 if ( pMsg->message != WM_DEVICECHANGE || (pMsg->wParam & 0x8000) )
1284 {
1285 /* GetMessage or PostMessage must never get messages that contain pointers */
1286 ASSERT(FindMsgMemory(pMsg->message) == NULL);
1287 }
1288
1289 if ( pMsg->message >= WM_DDE_FIRST && pMsg->message <= WM_DDE_LAST )
1290 {
1291 if (!IntDdeGetMessageHook(pMsg, ExtraInfo))
1292 {
1293 TRACE("DDE Get return ERROR\n");
1294 continue;
1295 }
1296 }
1297
1298 if (pMsg->message != WM_PAINT && pMsg->message != WM_QUIT)
1299 {
1300 if (!RtlEqualMemory(&pti->ptLast, &pMsg->pt, sizeof(POINT)))
1301 {
1303 }
1304 pti->timeLast = pMsg->time;
1305 pti->ptLast = pMsg->pt;
1306 }
1307
1308 // The WH_GETMESSAGE hook enables an application to monitor messages about to
1309 // be returned by the GetMessage or PeekMessage function.
1310
1312
1313 if ( bGMSG || pMsg->message == WM_PAINT) break;
1314 }
1315
1316 if ( bGMSG )
1317 {
1319 Window,
1320 MsgFilterMin,
1321 MsgFilterMax);
1322 if ( !NT_SUCCESS(Status) ||
1325 {
1326 Present = -1;
1327 break;
1328 }
1329 }
1330 else
1331 {
1332 if (!(RemoveMsg & PM_NOYIELD))
1333 {
1334 IdlePing();
1335 // Yield this thread!
1336 UserLeave();
1339 // Fall through to exit.
1340 IdlePong();
1341 }
1342 break;
1343 }
1344 }
1345 while( bGMSG && !Present );
1346
1347 // Been spinning, time to swap vinyl...
1348 if (pti->pClientInfo->cSpins >= 100)
1349 {
1350 // Clear the spin cycle to fix the mix.
1351 pti->pClientInfo->cSpins = 0;
1352 //if (!(pti->TIF_flags & TIF_SPINNING)) // FIXME: Need to swap vinyl...
1353 }
1354 return Present;
1355}
1356
1359 UINT Msg,
1360 WPARAM wParam,
1361 LPARAM lParam )
1362{
1363 MSG Message;
1364
1366 {
1368 return FALSE;
1369 }
1370 Message.hwnd = NULL;
1371 Message.message = Msg;
1372 Message.wParam = wParam;
1373 Message.lParam = lParam;
1374 Message.pt = gpsi->ptCursor;
1375 Message.time = EngGetTickCount32();
1377 return TRUE;
1378}
1379
1382{
1383 if ( ptiCur )
1384 {
1385 if (!Window ||
1386 Window->head.pti == ptiCur )
1387 {
1388 return NULL;
1389 }
1390 }
1391 return Window ? Window->head.pti : NULL;
1392}
1393
1396 UINT Msg,
1397 WPARAM wParam,
1398 LPARAM lParam )
1399{
1400 PTHREADINFO pti;
1401 MSG Message;
1402 LONG_PTR ExtraInfo = 0;
1403
1404 Message.hwnd = Wnd;
1405 Message.message = Msg;
1406 Message.wParam = wParam;
1407 Message.lParam = lParam;
1408 Message.pt = gpsi->ptCursor;
1409 Message.time = EngGetTickCount32();
1410
1411 if (is_pointer_message(Message.message, Message.wParam))
1412 {
1414 return FALSE;
1415 }
1416
1417 if (Wnd == HWND_BROADCAST || Wnd == HWND_TOPMOST)
1418 {
1419 HWND *List;
1421 ULONG i;
1422
1423 if (!is_message_broadcastable(Msg)) return TRUE;
1424
1427
1428 if (List != NULL)
1429 {
1431 for (i = 0; List[i]; i++)
1432 {
1433 PWND pwnd = UserGetWindowObject(List[i]);
1434 if (!pwnd) continue;
1435
1436 if ( pwnd->fnid == FNID_MENU || // Also need pwnd->pcls->atomClassName == gaOleMainThreadWndClass
1438 continue;
1439
1441 }
1443 }
1444 }
1445 else
1446 {
1447 PWND Window;
1448
1449 if (!Wnd)
1450 {
1452 Msg,
1453 wParam,
1454 lParam);
1455 }
1456
1458 if ( !Window )
1459 {
1460 ERR("UserPostMessage: Invalid handle 0x%p Msg 0x%x!\n", Wnd, Msg);
1461 return FALSE;
1462 }
1463
1464 pti = Window->head.pti;
1465
1466 if ( pti->TIF_flags & TIF_INCLEANUP )
1467 {
1468 ERR("Attempted to post message to window %p when the thread is in cleanup!\n", Wnd);
1469 return FALSE;
1470 }
1471
1472 if ( Window->state & WNDS_DESTROYED )
1473 {
1474 ERR("Attempted to post message to window %p that is being destroyed!\n", Wnd);
1476 return FALSE;
1477 }
1478
1479 if ( Msg >= WM_DDE_FIRST && Msg <= WM_DDE_LAST )
1480 {
1481 if (!IntDdePostMessageHook(Window, Msg, wParam, &lParam, &ExtraInfo))
1482 {
1483 TRACE("Posting Exit DDE 0x%x\n",Msg);
1484 return FALSE;
1485 }
1486 Message.lParam = lParam;
1487 }
1488
1489 MsqPostMessage(pti, &Message, FALSE, QS_POSTMESSAGE, 0, ExtraInfo);
1490 }
1491 return TRUE;
1492}
1493
1496 UINT Msg,
1497 WPARAM wParam,
1498 LPARAM lParam )
1499{
1500 ULONG_PTR Result = 0;
1501
1503 {
1504 return (LRESULT)Result;
1505 }
1506 return 0;
1507}
1508
1509static LRESULT FASTCALL
1511 UINT Msg,
1512 WPARAM wParam,
1513 LPARAM lParam,
1514 UINT uFlags,
1515 UINT uTimeout,
1516 ULONG_PTR *uResult )
1517{
1519 PWND Window;
1520 PMSGMEMORY MsgMemoryEntry;
1521 INT lParamBufferSize;
1522 LPARAM lParamPacked;
1523 PTHREADINFO Win32Thread, ptiSendTo = NULL;
1524 ULONG_PTR Result = 0;
1525 LRESULT Ret = FALSE;
1527 BOOL DoCallBack = TRUE;
1528
1530 {
1531 TRACE("SendMessageTimeoutSingle: Invalid handle 0x%p!\n",hWnd);
1532 return FALSE;
1533 }
1534
1535 UserRefObjectCo(Window, &Ref);
1536
1537 Win32Thread = PsGetCurrentThreadWin32Thread();
1538
1539 ptiSendTo = IntSendTo(Window, Win32Thread, Msg);
1540
1541 if ( Msg >= WM_DDE_FIRST && Msg <= WM_DDE_LAST )
1542 {
1544 {
1545 ERR("Sending Exit DDE 0x%x\n",Msg);
1546 goto Cleanup; // Return FALSE
1547 }
1548 }
1549
1550 if ( !ptiSendTo )
1551 {
1552 if (Win32Thread->TIF_flags & TIF_INCLEANUP)
1553 {
1554 /* Never send messages to exiting threads */
1555 goto Cleanup; // Return FALSE
1556 }
1557
1558 if (Msg & 0x80000000)
1559 {
1560 TRACE("SMTS: Internal Message!\n");
1562 if (uResult) *uResult = Result;
1563 Ret = TRUE;
1564 goto Cleanup;
1565 }
1566
1567 // Only happens when calling the client!
1569
1570 if ( Window->state & WNDS_SERVERSIDEWINDOWPROC )
1571 {
1572 TRACE("SMT: Server Side Window Procedure\n");
1573 // Handle it here. Safeguard against excessive recursions.
1574 if (IoGetRemainingStackSize() < PAGE_SIZE)
1575 {
1576 ERR("Server Callback Exceeded Stack!\n");
1577 goto Cleanup; // Return FALSE
1578 }
1579 /* Return after server side call, IntCallWndProcRet will not be called. */
1580 switch(Window->fnid)
1581 {
1582 case FNID_DESKTOP:
1583 DoCallBack = !DesktopWindowProc(Window, Msg, wParam, lParam,(LRESULT*)&Result);
1584 break;
1585 case FNID_MESSAGEWND:
1587 break;
1588 case FNID_MENU:
1589 DoCallBack = !PopupMenuWndProc( Window, Msg, wParam, lParam,(LRESULT*)&Result);
1590 break;
1591 }
1592 if (!DoCallBack)
1593 {
1594 if (uResult) *uResult = Result;
1595 Ret = TRUE;
1596 goto Cleanup;
1597 }
1598 }
1599 /* See if this message type is present in the table */
1600 MsgMemoryEntry = FindMsgMemory(Msg);
1601 if (NULL == MsgMemoryEntry)
1602 {
1603 lParamBufferSize = -1;
1604 }
1605 else
1606 {
1607 lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
1608 // If zero, do not allow callback on client side to allocate a buffer!!!!! See CORE-7695.
1609 if (!lParamBufferSize) lParamBufferSize = -1;
1610 }
1611
1612 if (! NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, FALSE)))
1613 {
1614 ERR("Failed to pack message parameters\n");
1615 goto Cleanup; // Return FALSE
1616 }
1617
1619 !Window->Unicode,
1620 hWnd,
1621 Msg,
1622 wParam,
1623 lParamPacked,
1624 lParamBufferSize );
1625 if (uResult)
1626 {
1627 *uResult = Result;
1628 }
1629
1630 if (! NT_SUCCESS(UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE)))
1631 {
1632 ERR("Failed to unpack message parameters\n");
1633 Ret = TRUE;
1634 goto Cleanup;
1635 }
1636
1637 // Only happens when calling the client!
1639
1640 Ret = TRUE;
1641 goto Cleanup;
1642 }
1643
1644 if (Window->state & WNDS_DESTROYED)
1645 {
1646 /* FIXME: Last error? */
1647 ERR("Attempted to send message to window %p that is being destroyed!\n", hWnd);
1648 goto Cleanup; // Return FALSE
1649 }
1650
1651 if ((uFlags & SMTO_ABORTIFHUNG) && MsqIsHung(ptiSendTo, 4 * MSQ_HUNG))
1652 {
1653 // FIXME: Set window hung and add to a list.
1654 /* FIXME: Set a LastError? */
1655 ERR("Window %p (%p) (pti %p) is hung!\n", hWnd, Window, ptiSendTo);
1656 goto Cleanup; // Return FALSE
1657 }
1658
1659 do
1660 {
1661 Status = co_MsqSendMessage( ptiSendTo,
1662 hWnd,
1663 Msg,
1664 wParam,
1665 lParam,
1666 uTimeout,
1667 (uFlags & SMTO_BLOCK),
1668 MSQ_NORMAL,
1669 uResult );
1670 }
1671 while ((Status == STATUS_TIMEOUT) &&
1672 (uFlags & SMTO_NOTIMEOUTIFNOTHUNG) &&
1673 !MsqIsHung(ptiSendTo, MSQ_HUNG)); // FIXME: Set window hung and add to a list.
1674
1675 if (Status == STATUS_TIMEOUT)
1676 {
1677 if (0 && MsqIsHung(ptiSendTo, MSQ_HUNG))
1678 {
1679 TRACE("Let's go Ghost!\n");
1681 }
1682/*
1683 * MSDN says:
1684 * Microsoft Windows 2000: If GetLastError returns zero, then the function
1685 * timed out.
1686 * XP+ : If the function fails or times out, the return value is zero.
1687 * To get extended error information, call GetLastError. If GetLastError
1688 * returns ERROR_TIMEOUT, then the function timed out.
1689 */
1691 goto Cleanup; // Return FALSE
1692 }
1693 else if (!NT_SUCCESS(Status))
1694 {
1696 goto Cleanup; // Return FALSE
1697 }
1698
1699 Ret = TRUE;
1700
1701Cleanup:
1703 return Ret;
1704}
1705
1708 UINT Msg,
1709 WPARAM wParam,
1710 LPARAM lParam,
1711 UINT uFlags,
1712 UINT uTimeout,
1713 ULONG_PTR *uResult )
1714{
1716 HWND *Children;
1717 HWND *Child;
1718
1719 if (hWnd != HWND_BROADCAST && hWnd != HWND_TOPMOST)
1720 {
1721 return co_IntSendMessageTimeoutSingle(hWnd, Msg, wParam, lParam, uFlags, uTimeout, uResult);
1722 }
1723
1724 if (!is_message_broadcastable(Msg)) return TRUE;
1725
1727 if (NULL == DesktopWindow)
1728 {
1730 return 0;
1731 }
1732
1733 if (hWnd != HWND_TOPMOST)
1734 {
1735 /* Send message to the desktop window too! */
1737 }
1738
1740 if (NULL == Children)
1741 {
1742 return 0;
1743 }
1744
1745 for (Child = Children; NULL != *Child; Child++)
1746 {
1748 if (!pwnd) continue;
1749
1750 if ( pwnd->fnid == FNID_MENU ||
1752 continue;
1753
1755 }
1756
1758
1759 return (LRESULT) TRUE;
1760}
1761
1764 UINT Msg,
1765 WPARAM wParam,
1766 LPARAM lParam)
1767{
1768 ULONG_PTR Result = 0;
1770 Msg,
1771 wParam,
1772 lParam,
1773 NULL,
1774 0,
1775 &Result);
1776}
1777/* MSDN:
1778 If you send a message in the range below WM_USER to the asynchronous message
1779 functions (PostMessage, SendNotifyMessage, and SendMessageCallback), its
1780 message parameters cannot include pointers. Otherwise, the operation will fail.
1781 The functions will return before the receiving thread has had a chance to
1782 process the message and the sender will free the memory before it is used.
1783*/
1786 UINT Msg,
1787 WPARAM wParam,
1788 LPARAM lParam,
1790 ULONG_PTR CompletionCallbackContext,
1791 ULONG_PTR *uResult)
1792{
1794 PWND Window;
1795 PMSGMEMORY MsgMemoryEntry;
1796 INT lParamBufferSize;
1797 LPARAM lParamPacked;
1798 PTHREADINFO Win32Thread, ptiSendTo = NULL;
1799 LRESULT Ret = FALSE;
1802 BOOL DoCallBack = TRUE;
1803
1805 {
1806 TRACE("SendMessageWithCallBack: Invalid handle 0x%p\n",hWnd);
1807 return FALSE;
1808 }
1809
1810 UserRefObjectCo(Window, &Ref);
1811
1812 if (Window->state & WNDS_DESTROYED)
1813 {
1814 /* FIXME: last error? */
1815 ERR("Attempted to send message to window %p that is being destroyed\n", hWnd);
1816 goto Cleanup; // Return FALSE
1817 }
1818
1819 Win32Thread = PsGetCurrentThreadWin32Thread();
1820
1821 if (Win32Thread == NULL || Win32Thread->TIF_flags & TIF_INCLEANUP)
1822 goto Cleanup; // Return FALSE
1823
1824 ptiSendTo = IntSendTo(Window, Win32Thread, Msg);
1825
1826 if (Msg & 0x80000000 &&
1827 !ptiSendTo)
1828 {
1829 if (Win32Thread->TIF_flags & TIF_INCLEANUP)
1830 goto Cleanup; // Return FALSE
1831
1832 TRACE("SMWCB: Internal Message\n");
1834 if (uResult) *uResult = Result;
1835 Ret = TRUE;
1836 goto Cleanup;
1837 }
1838
1839 /* See if this message type is present in the table */
1840 MsgMemoryEntry = FindMsgMemory(Msg);
1841 if (NULL == MsgMemoryEntry)
1842 {
1843 lParamBufferSize = -1;
1844 }
1845 else
1846 {
1847 lParamBufferSize = MsgMemorySize(MsgMemoryEntry, wParam, lParam);
1848 if (!lParamBufferSize) lParamBufferSize = -1;
1849 }
1850
1851 if (!NT_SUCCESS(PackParam(&lParamPacked, Msg, wParam, lParam, !!ptiSendTo)))
1852 {
1853 ERR("Failed to pack message parameters\n");
1854 goto Cleanup; // Return FALSE
1855 }
1856
1857 /* If it can be sent now, then send it. */
1858 if (!ptiSendTo)
1859 {
1860 if (Win32Thread->TIF_flags & TIF_INCLEANUP)
1861 {
1862 UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE);
1863 /* Never send messages to exiting threads */
1864 goto Cleanup; // Return FALSE
1865 }
1866
1868
1869 if (Window->state & WNDS_SERVERSIDEWINDOWPROC)
1870 {
1871 TRACE("SMWCB: Server Side Window Procedure\n");
1872 switch(Window->fnid)
1873 {
1874 case FNID_DESKTOP:
1875 DoCallBack = !DesktopWindowProc(Window, Msg, wParam, lParamPacked, (LRESULT*)&Result);
1876 break;
1877 case FNID_MESSAGEWND:
1879 break;
1880 case FNID_MENU:
1881 DoCallBack = !PopupMenuWndProc(Window, Msg, wParam, lParam, (LRESULT*)&Result);
1882 break;
1883 }
1884 }
1885
1886 if (DoCallBack)
1888 !Window->Unicode,
1889 hWnd,
1890 Msg,
1891 wParam,
1892 lParamPacked,
1893 lParamBufferSize);
1894 if(uResult)
1895 {
1896 *uResult = Result;
1897 }
1898
1900
1902 {
1904 hWnd,
1905 Msg,
1906 CompletionCallbackContext,
1907 Result);
1908 }
1909 }
1910
1911 if (!ptiSendTo)
1912 {
1913 if (!NT_SUCCESS(UnpackParam(lParamPacked, Msg, wParam, lParam, FALSE)))
1914 {
1915 ERR("Failed to unpack message parameters\n");
1916 }
1917 Ret = TRUE;
1918 goto Cleanup;
1919 }
1920
1922 {
1923 ERR("Failed to allocate message\n");
1924 goto Cleanup; // Return FALSE
1925 }
1926
1927 Message->Msg.hwnd = hWnd;
1928 Message->Msg.message = Msg;
1929 Message->Msg.wParam = wParam;
1930 Message->Msg.lParam = lParamPacked;
1931 Message->pkCompletionEvent = NULL; // No event needed.
1932 Message->lResult = 0;
1933 Message->QS_Flags = 0;
1934 Message->ptiReceiver = ptiSendTo;
1935 Message->ptiSender = NULL;
1936 Message->ptiCallBackSender = Win32Thread;
1937 Message->CompletionCallback = CompletionCallback;
1938 Message->CompletionCallbackContext = CompletionCallbackContext;
1939 Message->HookMessage = MSQ_NORMAL;
1940 Message->HasPackedLParam = (lParamBufferSize > 0);
1941 Message->QS_Flags = QS_SENDMESSAGE;
1942 Message->flags = SMF_RECEIVERFREE;
1943
1944 if (Msg & 0x80000000) // Higher priority event message!
1945 InsertHeadList(&ptiSendTo->SentMessagesListHead, &Message->ListEntry);
1946 else
1947 InsertTailList(&ptiSendTo->SentMessagesListHead, &Message->ListEntry);
1948 MsqWakeQueue(ptiSendTo, QS_SENDMESSAGE, TRUE);
1949
1950 Ret = TRUE;
1951
1952Cleanup:
1954 return Ret;
1955}
1956
1957#if 0
1958/*
1959 This HACK function posts a message if the destination's message queue belongs to
1960 another thread, otherwise it sends the message. It does not support broadcast
1961 messages!
1962*/
1965 UINT Msg,
1966 WPARAM wParam,
1967 LPARAM lParam )
1968{
1970 PTHREADINFO pti;
1971 PWND Window;
1972
1973 if ( hWnd == HWND_BROADCAST )
1974 {
1975 return 0;
1976 }
1977
1979 {
1980 TRACE("PostOrSendMessage: Invalid handle 0x%p!\n",hWnd);
1981 return 0;
1982 }
1983
1985
1986 if ( IntSendTo(Window, pti, Msg) &&
1987 FindMsgMemory(Msg) == 0 )
1988 {
1990 }
1991 else
1992 {
1994 {
1995 Result = 0;
1996 }
1997 }
1998
1999 return (LRESULT)Result;
2000}
2001#endif
2002
2003static LRESULT FASTCALL
2005 UINT Msg,
2006 WPARAM wParam,
2007 LPARAM lParam,
2008 PDOSENDMESSAGE dsm)
2009{
2012 PWND Window = NULL;
2013 MSG UserModeMsg, KernelModeMsg;
2014 PMSGMEMORY MsgMemoryEntry;
2015 PTHREADINFO ptiSendTo;
2016
2017 if (hWnd != HWND_BROADCAST && hWnd != HWND_TOPMOST)
2018 {
2020 if ( !Window )
2021 {
2022 return 0;
2023 }
2024 }
2025
2026 /* Check for an exiting window. */
2027 if (Window && Window->state & WNDS_DESTROYED)
2028 {
2029 ERR("co_IntDoSendMessage Window Exiting!\n");
2030 }
2031
2032 /* See if the current thread can handle this message */
2033 ptiSendTo = IntSendTo(Window, gptiCurrent, Msg);
2034
2035 // If broadcasting or sending to another thread, save the users data.
2036 if (!Window || ptiSendTo )
2037 {
2038 UserModeMsg.hwnd = hWnd;
2039 UserModeMsg.message = Msg;
2040 UserModeMsg.wParam = wParam;
2041 UserModeMsg.lParam = lParam;
2042 MsgMemoryEntry = FindMsgMemory(UserModeMsg.message);
2043 Status = CopyMsgToKernelMem(&KernelModeMsg, &UserModeMsg, MsgMemoryEntry);
2044 if (!NT_SUCCESS(Status))
2045 {
2047 return (dsm ? 0 : -1);
2048 }
2049 }
2050 else
2051 {
2052 KernelModeMsg.hwnd = hWnd;
2053 KernelModeMsg.message = Msg;
2054 KernelModeMsg.wParam = wParam;
2055 KernelModeMsg.lParam = lParam;
2056 }
2057
2058 if (!dsm)
2059 {
2060 Result = co_IntSendMessage( KernelModeMsg.hwnd,
2061 KernelModeMsg.message,
2062 KernelModeMsg.wParam,
2063 KernelModeMsg.lParam );
2064 }
2065 else
2066 {
2067 Result = co_IntSendMessageTimeout( KernelModeMsg.hwnd,
2068 KernelModeMsg.message,
2069 KernelModeMsg.wParam,
2070 KernelModeMsg.lParam,
2071 dsm->uFlags,
2072 dsm->uTimeout,
2073 &dsm->Result );
2074 }
2075
2076 if (!Window || ptiSendTo )
2077 {
2078 Status = CopyMsgToUserMem(&UserModeMsg, &KernelModeMsg);
2079 if (!NT_SUCCESS(Status))
2080 {
2082 return(dsm ? 0 : -1);
2083 }
2084 }
2085
2086 return (LRESULT)Result;
2087}
2088
2091 UINT Msg,
2092 WPARAM wParam,
2093 LPARAM lParam )
2094{
2095 BOOL Ret = TRUE;
2096
2098 {
2100 return FALSE;
2101 }
2102
2103 // Basicly the same as IntPostOrSendMessage
2104 if (hWnd == HWND_BROADCAST) // Handle Broadcast
2105 {
2106 HWND *List;
2108 ULONG i;
2109
2112
2113 if (List != NULL)
2114 {
2116 for (i = 0; List[i]; i++)
2117 {
2118 PWND pwnd = UserGetWindowObject(List[i]);
2119 if (!pwnd) continue;
2120
2121 if ( pwnd->fnid == FNID_MENU ||
2123 continue;
2124
2126 }
2128 }
2129 }
2130 else
2131 {
2133 }
2134 return Ret;
2135}
2136
2137
2140{
2141 PTHREADINFO pti;
2142 DWORD Result;
2143
2145// wine:
2147
2148 /* High word, types of messages currently in the queue.
2149 Low word, types of messages that have been added to the queue and that
2150 are still in the queue
2151 */
2152 Result = MAKELONG(pti->pcti->fsChangeBits & Changes, pti->pcti->fsWakeBits & Changes);
2153
2154 pti->pcti->fsChangeBits &= ~Changes;
2155
2156 return Result;
2157}
2158
2161{
2163
2164 if (pti->pcti)
2165 {
2166 pti->pcti->dwcPumpHook++;
2167 return TRUE;
2168 }
2169 return FALSE;
2170}
2171
2174{
2176
2177 if (pti->pcti)
2178 {
2179 if (pti->pcti->dwcPumpHook <= 0)
2180 {
2181 return FALSE;
2182 }
2183 pti->pcti->dwcPumpHook--;
2184 return TRUE;
2185 }
2186 return FALSE;
2187}
2188
2191{
2192 BOOL Ret;
2193
2194 Ret = co_HOOK_CallHooks(WH_SYSMSGFILTER, code, 0, (LPARAM)lpmsg);
2195 if (!Ret)
2196 Ret = co_HOOK_CallHooks(WH_MSGFILTER, code, 0, (LPARAM)lpmsg);
2197
2198 return Ret;
2199}
2200
2203BOOL
2206 HWND hWnd,
2207 POINT pt) // Just like the User call.
2208{
2209 MSG msg;
2210 RECT rect;
2211 ULONG wDragWidth, wDragHeight;
2212 BOOL Ret = FALSE;
2213
2214 TRACE("Enter NtUserDragDetect(%p)\n", hWnd);
2216
2217 wDragWidth = UserGetSystemMetrics(SM_CXDRAG);
2218 wDragHeight= UserGetSystemMetrics(SM_CYDRAG);
2219
2220 rect.left = pt.x - wDragWidth;
2221 rect.right = pt.x + wDragWidth;
2222
2223 rect.top = pt.y - wDragHeight;
2224 rect.bottom = pt.y + wDragHeight;
2225
2227
2228 for (;;)
2229 {
2233 {
2234 if ( msg.message == WM_LBUTTONUP )
2235 {
2237 goto Exit; // Return FALSE
2238 }
2239 if ( msg.message == WM_MOUSEMOVE )
2240 {
2241 POINT tmp;
2242 tmp.x = (short)LOWORD(msg.lParam);
2243 tmp.y = (short)HIWORD(msg.lParam);
2244 if( !RECTL_bPointInRect( &rect, tmp.x, tmp.y ) )
2245 {
2247 Ret = TRUE;
2248 goto Exit;
2249 }
2250 }
2251 if ( msg.message == WM_KEYDOWN )
2252 {
2253 if ( msg.wParam == VK_ESCAPE )
2254 {
2256 Ret = TRUE;
2257 goto Exit;
2258 }
2259 }
2260 if ( msg.message == WM_QUEUESYNC )
2261 {
2263 }
2264 }
2265 co_IntWaitMessage(NULL, 0, 0);
2266 }
2267
2268Exit:
2269 TRACE("Leave NtUserDragDetect, ret=%i\n", Ret);
2270 UserLeave();
2271 return Ret;
2272}
2273
2276 UINT Msg,
2277 WPARAM wParam,
2278 LPARAM lParam)
2279{
2280 BOOL ret;
2281
2283
2285
2286 UserLeave();
2287
2288 return ret;
2289}
2290
2293 UINT Msg,
2294 WPARAM wParam,
2295 LPARAM lParam)
2296{
2297 BOOL ret = FALSE;
2298 PETHREAD peThread;
2299 PTHREADINFO pThread;
2301
2303
2304 Status = PsLookupThreadByThreadId(UlongToHandle(idThread), &peThread);
2305
2306 if ( Status == STATUS_SUCCESS )
2307 {
2308 pThread = (PTHREADINFO)peThread->Tcb.Win32Thread;
2309 if( !pThread ||
2310 !pThread->MessageQueue ||
2311 (pThread->TIF_flags & TIF_INCLEANUP))
2312 {
2313 ObDereferenceObject( peThread );
2314 goto exit;
2315 }
2316 ret = UserPostThreadMessage( pThread, Msg, wParam, lParam);
2317 ObDereferenceObject( peThread );
2318 }
2319 else
2320 {
2322 }
2323exit:
2324 UserLeave();
2325 return ret;
2326}
2327
2330{
2331 BOOL ret;
2332
2334 TRACE("NtUserWaitMessage Enter\n");
2335 ret = co_IntWaitMessage(NULL, 0, 0);
2336 TRACE("NtUserWaitMessage Leave\n");
2337 UserLeave();
2338
2339 return ret;
2340}
2341
2344 HWND hWnd,
2345 UINT MsgFilterMin,
2346 UINT MsgFilterMax )
2347{
2348 MSG Msg;
2349 BOOL Ret;
2350
2351 if ( (MsgFilterMin|MsgFilterMax) & ~WM_MAXIMUM )
2352 {
2354 return FALSE;
2355 }
2356
2358
2359 RtlZeroMemory(&Msg, sizeof(MSG));
2360
2361 Ret = co_IntGetPeekMessage(&Msg, hWnd, MsgFilterMin, MsgFilterMax, PM_REMOVE, TRUE);
2362
2363 UserLeave();
2364
2365 if (Ret)
2366 {
2367 _SEH2_TRY
2368 {
2369 ProbeForWrite(pMsg, sizeof(MSG), 1);
2370 RtlCopyMemory(pMsg, &Msg, sizeof(MSG));
2371 }
2373 {
2375 Ret = FALSE;
2376 }
2377 _SEH2_END;
2378 }
2379
2380 if ((INT)Ret != -1)
2381 Ret = Ret ? (WM_QUIT != pMsg->message) : FALSE;
2382
2383 return Ret;
2384}
2385
2388 HWND hWnd,
2389 UINT MsgFilterMin,
2390 UINT MsgFilterMax,
2391 UINT RemoveMsg)
2392{
2393 MSG Msg;
2394 BOOL Ret;
2395
2396 if ( RemoveMsg & PM_BADMSGFLAGS )
2397 {
2399 return FALSE;
2400 }
2401
2403
2404 RtlZeroMemory(&Msg, sizeof(MSG));
2405
2406 Ret = co_IntGetPeekMessage(&Msg, hWnd, MsgFilterMin, MsgFilterMax, RemoveMsg, FALSE);
2407
2408 UserLeave();
2409
2410 if (Ret)
2411 {
2412 _SEH2_TRY
2413 {
2414 ProbeForWrite(pMsg, sizeof(MSG), 1);
2415 RtlCopyMemory(pMsg, &Msg, sizeof(MSG));
2416 }
2418 {
2420 Ret = FALSE;
2421 }
2422 _SEH2_END;
2423 }
2424
2425 return Ret;
2426}
2427
2430{
2431 BOOL Ret = FALSE;
2432 MSG Msg;
2433
2434 _SEH2_TRY
2435 {
2436 ProbeForRead(lpmsg, sizeof(MSG), 1);
2437 RtlCopyMemory( &Msg, lpmsg, sizeof(MSG));
2438 }
2440 {
2441 _SEH2_YIELD(return FALSE);
2442 }
2443 _SEH2_END;
2444
2446 Ret = IntCallMsgFilter(&Msg, code);
2447 UserLeave();
2448
2449 _SEH2_TRY
2450 {
2451 ProbeForWrite(lpmsg, sizeof(MSG), 1);
2452 RtlCopyMemory(lpmsg, &Msg, sizeof(MSG));
2453 }
2455 {
2456 Ret = FALSE;
2457 }
2458 _SEH2_END;
2459
2460 return Ret;
2461}
2462
2465{
2466 LRESULT Res = 0;
2467 MSG SafeMsg;
2468
2469 _SEH2_TRY
2470 {
2471 ProbeForRead(UnsafeMsgInfo, sizeof(MSG), 1);
2472 RtlCopyMemory(&SafeMsg, UnsafeMsgInfo, sizeof(MSG));
2473 }
2475 {
2477 _SEH2_YIELD(return FALSE);
2478 }
2479 _SEH2_END;
2480
2482
2483 Res = IntDispatchMessage(&SafeMsg);
2484
2485 UserLeave();
2486 return Res;
2487}
2488
2491{
2492 MSG SafeMsg;
2493 BOOL Ret;
2494 PWND pWnd;
2495
2496 _SEH2_TRY
2497 {
2498 ProbeForRead(lpMsg, sizeof(MSG), 1);
2499 RtlCopyMemory(&SafeMsg, lpMsg, sizeof(MSG));
2500 }
2502 {
2504 _SEH2_YIELD(return FALSE);
2505 }
2506 _SEH2_END;
2507
2509 pWnd = UserGetWindowObject(SafeMsg.hwnd);
2510 if (pWnd) // Must have a window!
2511 {
2512 Ret = IntTranslateKbdMessage(&SafeMsg, flags);
2513 }
2514 else
2515 {
2516 TRACE("No Window for Translate. hwnd 0x%p Msg %u\n", SafeMsg.hwnd, SafeMsg.message);
2517 Ret = FALSE;
2518 }
2519 UserLeave();
2520
2521 return Ret;
2522}
2523
2525
2528 UINT Msg,
2529 WPARAM wParam,
2530 LPARAM lParam,
2531 ULONG_PTR ResultInfo,
2532 DWORD dwType, // fnID?
2533 BOOL Ansi)
2534{
2535 LRESULT lResult = 0;
2536 BOOL Ret = FALSE;
2537 PWND Window = NULL;
2539
2541
2542 switch(dwType)
2543 {
2544 case FNID_SCROLLBAR:
2545 {
2546 lResult = ScrollBarWndProc(hWnd, Msg, wParam, lParam);
2547 break;
2548 }
2549 case FNID_DESKTOP:
2550 {
2552 if (Window)
2553 {
2554 //ERR("FNID_DESKTOP IN\n");
2555 Ret = DesktopWindowProc(Window, Msg, wParam, lParam, &lResult);
2556 //ERR("FNID_DESKTOP OUT\n");
2557 }
2558 break;
2559 }
2560 case FNID_MENU:
2561 {
2563 if (Window)
2564 {
2565 Ret = PopupMenuWndProc( Window, Msg, wParam, lParam, &lResult);
2566 }
2567 break;
2568 }
2569 case FNID_MESSAGEWND:
2570 {
2572 if (Window)
2573 {
2574 Ret = !UserMessageWindowProc(Window, Msg, wParam, lParam, &lResult);
2575 }
2576 break;
2577 }
2578 case FNID_DEFWINDOWPROC:
2579 /* Validate input */
2580 if (hWnd)
2581 {
2583 if (!Window)
2584 {
2585 UserLeave();
2586 return FALSE;
2587 }
2588 UserRefObjectCo(Window, &Ref);
2589 }
2590 lResult = IntDefWindowProc(Window, Msg, wParam, lParam, Ansi);
2591 Ret = TRUE;
2592 if (hWnd)
2594 break;
2597 break;
2599 {
2600 BROADCASTPARM parm, *retparam;
2601 DWORD_PTR RetVal = 0;
2602
2603 if (ResultInfo)
2604 {
2605 _SEH2_TRY
2606 {
2607 ProbeForWrite((PVOID)ResultInfo, sizeof(BROADCASTPARM), 1);
2608 RtlCopyMemory(&parm, (PVOID)ResultInfo, sizeof(BROADCASTPARM));
2609 }
2611 {
2612 _SEH2_YIELD(break);
2613 }
2614 _SEH2_END;
2615 }
2616 else
2617 break;
2618
2619 if ( parm.recipients & BSM_ALLDESKTOPS ||
2621 {
2622 PLIST_ENTRY DesktopEntry;
2623 PDESKTOP rpdesk;
2624 HWND *List, hwndDenied = NULL;
2625 HDESK hDesk = NULL;
2626 PWND pwnd, pwndDesk;
2627 ULONG i;
2628 UINT fuFlags;
2629
2630 for (DesktopEntry = InputWindowStation->DesktopListHead.Flink;
2631 DesktopEntry != &InputWindowStation->DesktopListHead;
2632 DesktopEntry = DesktopEntry->Flink)
2633 {
2634 rpdesk = CONTAINING_RECORD(DesktopEntry, DESKTOP, ListEntry);
2635 pwndDesk = rpdesk->pDeskInfo->spwnd;
2636 List = IntWinListChildren(pwndDesk);
2637
2638 if (parm.flags & BSF_QUERY)
2639 {
2640 if (List != NULL)
2641 {
2642 if (parm.flags & BSF_FORCEIFHUNG || parm.flags & BSF_NOHANG)
2643 {
2644 fuFlags = SMTO_ABORTIFHUNG;
2645 }
2646 else if (parm.flags & BSF_NOTIMEOUTIFNOTHUNG)
2647 {
2648 fuFlags = SMTO_NOTIMEOUTIFNOTHUNG;
2649 }
2650 else
2651 {
2652 fuFlags = SMTO_NORMAL;
2653 }
2655 Msg,
2656 wParam,
2657 lParam,
2658 fuFlags,
2659 2000,
2660 &RetVal);
2661 Ret = TRUE;
2662 for (i = 0; List[i]; i++)
2663 {
2664 pwnd = UserGetWindowObject(List[i]);
2665 if (!pwnd) continue;
2666
2667 if ( pwnd->fnid == FNID_MENU ||
2669 continue;
2670
2671 if ( parm.flags & BSF_IGNORECURRENTTASK )
2672 {
2673 if ( pwnd->head.pti == gptiCurrent )
2674 continue;
2675 }
2677 Msg,
2678 wParam,
2679 lParam,
2680 fuFlags,
2681 2000,
2682 &RetVal);
2683
2684 if (!RetVal && EngGetLastError() == ERROR_TIMEOUT)
2685 {
2686 if (!(parm.flags & BSF_FORCEIFHUNG))
2687 Ret = FALSE;
2688 }
2689 if (RetVal == BROADCAST_QUERY_DENY)
2690 {
2691 hwndDenied = List[i];
2692 hDesk = UserHMGetHandle(pwndDesk);
2693 Ret = FALSE;
2694 }
2695 }
2697 _SEH2_TRY
2698 {
2699 retparam = (PBROADCASTPARM) ResultInfo;
2700 retparam->hDesk = hDesk;
2701 retparam->hWnd = hwndDenied;
2702 }
2704 {
2705 _SEH2_YIELD(break);
2706 }
2707 _SEH2_END;
2708 if (!Ret) break; // Have a hit! Let everyone know!
2709 }
2710 }
2711 else if (parm.flags & BSF_POSTMESSAGE)
2712 {
2713 if (List != NULL)
2714 {
2716
2717 for (i = 0; List[i]; i++)
2718 {
2719 pwnd = UserGetWindowObject(List[i]);
2720 if (!pwnd) continue;
2721
2722 if ( pwnd->fnid == FNID_MENU ||
2724 continue;
2725
2726 if ( parm.flags & BSF_IGNORECURRENTTASK )
2727 {
2728 if ( pwnd->head.pti == gptiCurrent )
2729 continue;
2730 }
2732 }
2734 }
2735 Ret = TRUE;
2736 }
2737 else
2738 {
2739 if (List != NULL)
2740 {
2742
2743 for (i = 0; List[i]; i++)
2744 {
2745 pwnd = UserGetWindowObject(List[i]);
2746 if (!pwnd) continue;
2747
2748 if ( pwnd->fnid == FNID_MENU ||
2750 continue;
2751
2752 if ( parm.flags & BSF_IGNORECURRENTTASK )
2753 {
2754 if ( pwnd->head.pti == gptiCurrent )
2755 continue;
2756 }
2758 }
2760 }
2761 if (lParam && !wParam && _wcsicmp((WCHAR*)lParam, L"Environment") == 0)
2762 {
2763 /* Handle Broadcast of WM_SETTINGCHAGE for Environment */
2765 0, (LPARAM)L"Environment", 0);
2766 }
2767 Ret = TRUE;
2768 }
2769 }
2770 }
2771 else if (parm.recipients & BSM_APPLICATIONS)
2772 {
2773 HWND *List, hwndDenied = NULL;
2774 HDESK hDesk = NULL;
2775 PWND pwnd, pwndDesk;
2776 ULONG i;
2777 UINT fuFlags;
2778
2779 pwndDesk = UserGetDesktopWindow();
2780 List = IntWinListChildren(pwndDesk);
2781
2782 if (parm.flags & BSF_QUERY)
2783 {
2784 if (List != NULL)
2785 {
2786 if (parm.flags & BSF_FORCEIFHUNG || parm.flags & BSF_NOHANG)
2787 {
2788 fuFlags = SMTO_ABORTIFHUNG;
2789 }
2790 else if (parm.flags & BSF_NOTIMEOUTIFNOTHUNG)
2791 {
2792 fuFlags = SMTO_NOTIMEOUTIFNOTHUNG;
2793 }
2794 else
2795 {
2796 fuFlags = SMTO_NORMAL;
2797 }
2799 Msg,
2800 wParam,
2801 lParam,
2802 fuFlags,
2803 2000,
2804 &RetVal);
2805 Ret = TRUE;
2806 for (i = 0; List[i]; i++)
2807 {
2808 pwnd = UserGetWindowObject(List[i]);
2809 if (!pwnd) continue;
2810
2811 if ( pwnd->fnid == FNID_MENU ||
2813 continue;
2814
2815 if ( parm.flags & BSF_IGNORECURRENTTASK )
2816 {
2817 if ( pwnd->head.pti == gptiCurrent )
2818 continue;
2819 }
2821 Msg,
2822 wParam,
2823 lParam,
2824 fuFlags,
2825 2000,
2826 &RetVal);
2827
2828 if (!RetVal && EngGetLastError() == ERROR_TIMEOUT)
2829 {
2830 if (!(parm.flags & BSF_FORCEIFHUNG))
2831 Ret = FALSE;
2832 }
2833 if (RetVal == BROADCAST_QUERY_DENY)
2834 {
2835 hwndDenied = List[i];
2836 hDesk = UserHMGetHandle(pwndDesk);
2837 Ret = FALSE;
2838 }
2839 }
2841 _SEH2_TRY
2842 {
2843 retparam = (PBROADCASTPARM) ResultInfo;
2844 retparam->hDesk = hDesk;
2845 retparam->hWnd = hwndDenied;
2846 }
2848 {
2849 _SEH2_YIELD(break);
2850 }
2851 _SEH2_END;
2852 }
2853 }
2854 else if (parm.flags & BSF_POSTMESSAGE)
2855 {
2856 if (List != NULL)
2857 {
2859
2860 for (i = 0; List[i]; i++)
2861 {
2862 pwnd = UserGetWindowObject(List[i]);
2863 if (!pwnd) continue;
2864
2865 if ( pwnd->fnid == FNID_MENU ||
2867 continue;
2868
2869 if ( parm.flags & BSF_IGNORECURRENTTASK )
2870 {
2871 if ( pwnd->head.pti == gptiCurrent )
2872 continue;
2873 }
2875 }
2877 }
2878 Ret = TRUE;
2879 }
2880 else
2881 {
2882 if (List != NULL)
2883 {
2885
2886 for (i = 0; List[i]; i++)
2887 {
2888 pwnd = UserGetWindowObject(List[i]);
2889 if (!pwnd) continue;
2890
2891 if ( pwnd->fnid == FNID_MENU ||
2893 continue;
2894
2895 if ( parm.flags & BSF_IGNORECURRENTTASK )
2896 {
2897 if ( pwnd->head.pti == gptiCurrent )
2898 continue;
2899 }
2901 }
2903 }
2904 Ret = TRUE;
2905 }
2906 }
2907 }
2908 break;
2910 {
2911 CALL_BACK_INFO CallBackInfo;
2912 ULONG_PTR uResult;
2913
2914 _SEH2_TRY
2915 {
2916 ProbeForRead((PVOID)ResultInfo, sizeof(CALL_BACK_INFO), 1);
2917 RtlCopyMemory(&CallBackInfo, (PVOID)ResultInfo, sizeof(CALL_BACK_INFO));
2918 }
2920 {
2921 _SEH2_YIELD(break);
2922 }
2923 _SEH2_END;
2924
2926 {
2928 break;
2929 }
2930
2932 CallBackInfo.CallBack, CallBackInfo.Context, &uResult)))
2933 {
2934 ERR("Callback failure!\n");
2935 }
2936 }
2937 break;
2938 case FNID_SENDMESSAGE:
2939 {
2940 lResult = co_IntDoSendMessage(hWnd, Msg, wParam, lParam, 0);
2941 Ret = TRUE;
2942
2943 if (ResultInfo)
2944 {
2945 _SEH2_TRY
2946 {
2947 ProbeForWrite((PVOID)ResultInfo, sizeof(ULONG_PTR), 1);
2948 RtlCopyMemory((PVOID)ResultInfo, &lResult, sizeof(ULONG_PTR));
2949 }
2951 {
2952 Ret = FALSE;
2953 _SEH2_YIELD(break);
2954 }
2955 _SEH2_END;
2956 }
2957 break;
2958 }
2959 case FNID_SENDMESSAGEFF:
2961 {
2962 DOSENDMESSAGE dsm, *pdsm = (PDOSENDMESSAGE)ResultInfo;
2963 if (ResultInfo)
2964 {
2965 _SEH2_TRY
2966 {
2967 ProbeForRead(pdsm, sizeof(DOSENDMESSAGE), 1);
2968 RtlCopyMemory(&dsm, pdsm, sizeof(DOSENDMESSAGE));
2969 }
2971 {
2972 _SEH2_YIELD(break);
2973 }
2974 _SEH2_END;
2975 }
2976
2977 Ret = co_IntDoSendMessage( hWnd, Msg, wParam, lParam, pdsm ? &dsm : NULL );
2978
2979 if (pdsm)
2980 {
2981 _SEH2_TRY
2982 {
2983 ProbeForWrite(pdsm, sizeof(DOSENDMESSAGE), 1);
2984 RtlCopyMemory(pdsm, &dsm, sizeof(DOSENDMESSAGE));
2985 }
2987 {
2988 Ret = FALSE;
2989 _SEH2_YIELD(break);
2990 }
2991 _SEH2_END;
2992 }
2993 break;
2994 }
2995 // CallNextHook bypass.
2996 case FNID_CALLWNDPROC:
2998 {
2999 PTHREADINFO pti;
3001 PHOOK NextObj, Hook;
3002
3003 pti = GetW32ThreadInfo();
3004
3005 Hook = pti->sphkCurrent;
3006
3007 if (!Hook) break;
3008
3009 NextObj = Hook->phkNext;
3010 ClientInfo = pti->pClientInfo;
3011 _SEH2_TRY
3012 {
3013 ClientInfo->phkCurrent = NextObj;
3014 }
3016 {
3017 ClientInfo = NULL;
3018 }
3019 _SEH2_END;
3020
3021 if (!ClientInfo || !NextObj) break;
3022
3023 NextObj->phkNext = IntGetNextHook(NextObj);
3024
3025 if ( Hook->HookId == WH_CALLWNDPROC)
3026 {
3027 CWPSTRUCT CWP;
3028 CWP.hwnd = hWnd;
3029 CWP.message = Msg;
3030 CWP.wParam = wParam;
3031 CWP.lParam = lParam;
3032 TRACE("WH_CALLWNDPROC: Hook %p NextHook %p\n", Hook, NextObj);
3033
3034 lResult = co_IntCallHookProc( Hook->HookId,
3035 HC_ACTION,
3036 ((ClientInfo->CI_flags & CI_CURTHPRHOOK) ? 1 : 0),
3037 (LPARAM)&CWP,
3038 Hook->Proc,
3039 Hook->ihmod,
3040 Hook->offPfn,
3041 Hook->Ansi,
3042 &Hook->ModuleName);
3043 }
3044 else
3045 {
3046 CWPRETSTRUCT CWPR;
3047 CWPR.hwnd = hWnd;
3048 CWPR.message = Msg;
3049 CWPR.wParam = wParam;
3050 CWPR.lParam = lParam;
3051 CWPR.lResult = ClientInfo->dwHookData;
3052
3053 lResult = co_IntCallHookProc( Hook->HookId,
3054 HC_ACTION,
3055 ((ClientInfo->CI_flags & CI_CURTHPRHOOK) ? 1 : 0),
3056 (LPARAM)&CWPR,
3057 Hook->Proc,
3058 Hook->ihmod,
3059 Hook->offPfn,
3060 Hook->Ansi,
3061 &Hook->ModuleName);
3062 }
3063 }
3064 break;
3065 }
3066
3067 switch(dwType)
3068 {
3069 case FNID_DEFWINDOWPROC:
3070 case FNID_CALLWNDPROC:
3072 case FNID_SCROLLBAR:
3073 case FNID_DESKTOP:
3074 case FNID_MENU:
3075 if (ResultInfo)
3076 {
3077 _SEH2_TRY
3078 {
3079 ProbeForWrite((PVOID)ResultInfo, sizeof(LRESULT), 1);
3080 RtlCopyMemory((PVOID)ResultInfo, &lResult, sizeof(LRESULT));
3081 }
3083 {
3084 Ret = FALSE;
3085 }
3086 _SEH2_END;
3087 }
3088 break;
3089 default:
3090 break;
3091 }
3092
3093 UserLeave();
3094
3095 return Ret;
3096}
3097
3098#define INFINITE 0xFFFFFFFF
3099#define WAIT_FAILED ((DWORD)0xFFFFFFFF)
3100
3101DWORD
3104 IN DWORD dwMilliseconds,
3105 IN BOOL bSharedWow)
3106{
3108 PPROCESSINFO W32Process;
3109 PTHREADINFO pti;
3111 HANDLE Handles[3];
3114
3116
3120 UserMode,
3121 (PVOID*)&Process,
3122 NULL);
3123
3124 if (!NT_SUCCESS(Status))
3125 {
3126 UserLeave();
3128 return WAIT_FAILED;
3129 }
3130
3132
3133 W32Process = (PPROCESSINFO)Process->Win32Process;
3134
3136 !W32Process ||
3137 pti->ppi == W32Process)
3138 {
3140 UserLeave();
3142 return WAIT_FAILED;
3143 }
3144
3145 Handles[0] = Process;
3146 Handles[1] = W32Process->InputIdleEvent;
3147 Handles[2] = pti->pEventQueueServer; // IntMsqSetWakeMask returns hEventQueueClient
3148
3149 if (!Handles[1])
3150 {
3152 UserLeave();
3153 return STATUS_SUCCESS; /* no event to wait on */
3154 }
3155
3156 if (dwMilliseconds != INFINITE)
3157 Timeout.QuadPart = (LONGLONG) dwMilliseconds * (LONGLONG) -10000;
3158
3160 W32Process->W32PF_flags |= W32PF_WAITFORINPUTIDLE;
3161 for (pti = W32Process->ptiList; pti; pti = pti->ptiSibling)
3162 {
3164 pti->pClientInfo->dwTIFlags = pti->TIF_flags;
3165 }
3167
3168 TRACE("WFII: ppi %p\n", W32Process);
3169 TRACE("WFII: waiting for %p\n", Handles[1] );
3170
3171 /*
3172 * We must add a refcount to our current PROCESSINFO,
3173 * because anything could happen (including process death) we're leaving win32k
3174 */
3175 IntReferenceProcessInfo(W32Process);
3176
3177 do
3178 {
3179 UserLeave();
3181 Handles,
3182 WaitAny,
3184 UserMode,
3185 FALSE,
3186 dwMilliseconds == INFINITE ? NULL : &Timeout,
3187 NULL);
3189
3190 if (!NT_SUCCESS(Status))
3191 {
3194 goto WaitExit;
3195 }
3196
3197 switch (Status)
3198 {
3199 case STATUS_WAIT_0:
3200 goto WaitExit;
3201
3202 case STATUS_WAIT_2:
3203 {
3204 MSG Msg;
3205 co_IntGetPeekMessage( &Msg, 0, 0, 0, PM_REMOVE | PM_QS_SENDMESSAGE, FALSE);
3206 ERR("WFII: WAIT 2\n");
3207 }
3208 break;
3209
3210 case STATUS_TIMEOUT:
3211 ERR("WFII: timeout\n");
3212 case WAIT_FAILED:
3213 goto WaitExit;
3214
3215 default:
3216 ERR("WFII: finished\n");
3218 goto WaitExit;
3219 }
3220 }
3221 while (TRUE);
3222
3223WaitExit:
3225 for (pti = W32Process->ptiList; pti; pti = pti->ptiSibling)
3226 {
3227 pti->TIF_flags &= ~TIF_WAITFORINPUTIDLE;
3228 pti->pClientInfo->dwTIFlags = pti->TIF_flags;
3229 }
3230 W32Process->W32PF_flags &= ~W32PF_WAITFORINPUTIDLE;
3232
3233 IntDereferenceProcessInfo(W32Process);
3235 UserLeave();
3236 return Status;
3237}
3238
3239/* EOF */
const TCHAR * CompletionCallback(unsigned __int64 &rnIndex, const BOOL *pblnForward, const TCHAR *pszContext, const TCHAR *pszBegin)
Definition: Completion.cpp:439
@ lparam
Definition: SystemMenu.c:31
@ wparam
Definition: SystemMenu.c:30
#define msg(x)
Definition: auth_time.c:54
HWND hWnd
Definition: settings.c:17
LONG NTSTATUS
Definition: precomp.h:26
#define CHAR(Char)
#define ERR(fmt,...)
Definition: precomp.h:57
#define UlongToHandle(ul)
Definition: basetsd.h:97
#define DBG_DEFAULT_CHANNEL(ch)
Definition: debug.h:106
#define IS_ATOM(x)
Definition: class.h:3
struct @1709 Msg[]
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
#define WM_SYSTIMER
Definition: comctl32.h:125
wcscpy
#define STATUS_TIMEOUT
Definition: d3dkmdt.h:49
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
#define BSF_POSTMESSAGE
Definition: dbt.h:58
#define BSF_NOTIMEOUTIFNOTHUNG
Definition: dbt.h:57
#define BSF_NOHANG
Definition: dbt.h:56
#define BSF_IGNORECURRENTTASK
Definition: dbt.h:55
#define BSF_QUERY
Definition: dbt.h:59
#define BSM_APPLICATIONS
Definition: dbt.h:48
#define BSF_FORCEIFHUNG
Definition: dbt.h:54
#define BSM_ALLDESKTOPS
Definition: dbt.h:49
#define BSM_ALLCOMPONENTS
Definition: dbt.h:47
#define WM_DDE_FIRST
Definition: dde.h:47
#define WM_DDE_LAST
Definition: dde.h:46
LPWSTR Name
Definition: desk.c:124
WORD ATOM
Definition: dimm.idl:113
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
#define APIENTRY
Definition: api.h:79
UINT uFlags
Definition: api.c:59
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
unsigned short(__cdecl typeof(TIFFCurrentDirectory))(struct tiff *)
Definition: typeof.h:94
static const WCHAR Message[]
Definition: register.c:74
static const WCHAR Cleanup[]
Definition: register.c:80
@ AnsiString
Definition: dnslib.h:19
#define pt(x, y)
Definition: drawing.c:79
#define ULONG_PTR
Definition: config.h:101
#define EngGetTickCount32()
Definition: eng.h:43
#define InsertTailList(ListHead, Entry)
#define InsertHeadList(ListHead, Entry)
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define PAGE_SIZE
Definition: env_spec_w32.h:49
#define KeSetEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:476
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define NonPagedPool
Definition: env_spec_w32.h:307
#define PagedPool
Definition: env_spec_w32.h:308
VOID NTAPI KeClearEvent(IN PKEVENT Event)
Definition: eventobj.c:22
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL FASTCALL IntDeactivateWindow(PTHREADINFO pti, HANDLE tid)
Definition: focus.c:191
VOID FASTCALL IntActivateWindow(PWND Wnd, PTHREADINFO pti, HANDLE tid, DWORD Type)
Definition: focus.c:360
HWND FASTCALL co_UserSetCapture(HWND hWnd)
Definition: focus.c:1460
_Must_inspect_result_ _In_ PLARGE_INTEGER _In_ PLARGE_INTEGER _In_ ULONG _In_ PFILE_OBJECT _In_ PVOID Process
Definition: fsrtlfuncs.h:223
Status
Definition: gdiplustypes.h:25
GLsizeiptr size
Definition: glext.h:5919
GLenum GLint GLuint mask
Definition: glext.h:6028
GLbitfield flags
Definition: glext.h:7161
const GLint * first
Definition: glext.h:5794
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define ISITHOOKED(HookId)
Definition: hook.h:6
#define HOOKID_TO_FLAG(HookId)
Definition: hook.h:5
PSERVERINFO gpsi
Definition: imm.c:18
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define PROCESS_QUERY_INFORMATION
Definition: pstypes.h:167
#define FNID_SENDMESSAGEFF
Definition: ntuser.h:883
#define TIF_INCLEANUP
Definition: ntuser.h:263
#define FNID_SCROLLBAR
Definition: ntuser.h:859
#define FNID_DEFWINDOWPROC
Definition: ntuser.h:863
#define FNID_DESKTOP
Definition: ntuser.h:862
#define WNDS_DESTROYED
Definition: ntuser.h:636
#define TIF_WAITFORINPUTIDLE
Definition: ntuser.h:277
#define WNDS_SERVERSIDEWINDOWPROC
Definition: ntuser.h:623
#define UserHMGetHandle(obj)
Definition: ntuser.h:230
#define WNDS_INTERNALPAINT
Definition: ntuser.h:617
#define FNID_SENDMESSAGECALLBACK
Definition: ntuser.h:890
struct _THREADINFO * GetW32ThreadInfo(VOID)
Definition: misc.c:807
struct _WND * PWND
#define FNID_SENDMESSAGEWTOOPTION
Definition: ntuser.h:885
#define FNID_CALLWNDPROCRET
Definition: ntuser.h:877
#define FNID_CALLWNDPROC
Definition: ntuser.h:876
#define ICLS_SWITCH
Definition: ntuser.h:932
#define CI_CURTHPRHOOK
Definition: ntuser.h:304
struct tagDOSENDMESSAGE * PDOSENDMESSAGE
#define FNID_SENDMESSAGE
Definition: ntuser.h:882
struct _LARGE_STRING * PLARGE_STRING
#define WNDS_ANSICREATOR
Definition: ntuser.h:634
#define FNID_MENU
Definition: ntuser.h:861
struct _BROADCASTPARM * PBROADCASTPARM
#define FNID_BROADCASTSYSTEMMESSAGE
Definition: ntuser.h:887
#define FNID_MESSAGEWND
Definition: ntuser.h:864
#define TIF_MSGPOSCHANGED
Definition: ntuser.h:283
#define WNDS_PAINTNOTPROCESSED
Definition: ntuser.h:627
#define FNID_SENDNOTIFYMESSAGE
Definition: ntuser.h:889
CLIENT_DATA ClientInfo
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
if(dx< 0)
Definition: linetemp.h:194
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:71
#define PCHAR
Definition: match.c:90
#define MmCopyToCaller(x, y, z)
Definition: mmcopy.h:19
#define ASSERT(a)
Definition: mode.c:44
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
static UINT UINT last
Definition: font.c:45
static PLARGE_INTEGER Time
Definition: time.c:105
#define min(a, b)
Definition: monoChain.cc:55
VOID FASTCALL ClearMsgBitsMask(PTHREADINFO pti, UINT MessageBits)
Definition: msgqueue.c:445
BOOLEAN FASTCALL co_MsqDispatchOneSentMessage(_In_ PTHREADINFO pti)
Definition: msgqueue.c:873
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: msgqueue.c:1939
VOID FASTCALL IntCoalesceMouseMove(PTHREADINFO pti)
Definition: msgqueue.c:551
NTSTATUS FASTCALL co_MsqSendMessage(PTHREADINFO ptirec, HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uTimeout, BOOL Block, INT HookMessage, ULONG_PTR *uResult)
Definition: msgqueue.c:1056
VOID FASTCALL MsqPostMessage(PTHREADINFO pti, MSG *Msg, BOOLEAN HardwareMessage, DWORD MessageBits, DWORD dwQEvent, LONG_PTR ExtraInfo)
Definition: msgqueue.c:1337
BOOL FASTCALL MsqIsHung(PTHREADINFO pti, DWORD TimeOut)
Definition: msgqueue.c:2149
NTSTATUS FASTCALL co_MsqWaitForNewMessages(PTHREADINFO pti, PWND WndFilter, UINT MsgFilterMin, UINT MsgFilterMax)
Definition: msgqueue.c:2119
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: msgqueue.c:2062
VOID FASTCALL MsqWakeQueue(PTHREADINFO pti, DWORD MessageBits, BOOL KeyEvent)
Definition: msgqueue.c:412
PUSER_SENT_MESSAGE FASTCALL AllocateUserMessage(BOOL KEvent)
Definition: msgqueue.c:763
#define POSTEVENT_NWE
Definition: msgqueue.h:125
#define MSQ_NORMAL
Definition: msgqueue.h:4
LRESULT FASTCALL co_IntPostOrSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
@ WM_ASYNC_SHOWWINDOW
Definition: msgqueue.h:117
@ WM_ASYNC_SETWINDOWPOS
Definition: msgqueue.h:118
@ WM_ASYNC_DESTROYWINDOW
Definition: msgqueue.h:120
#define WM_NCMOUSEFIRST
Definition: msgqueue.h:239
#define WM_NCMOUSELAST
Definition: msgqueue.h:240
#define SMF_RECEIVERFREE
Definition: msgqueue.h:40
#define QF_MOUSEMOVED
Definition: msgqueue.h:99
#define MSQ_HUNG
Definition: msgqueue.h:3
#define POSTEVENT_SAW
Definition: msgqueue.h:124
#define POSTEVENT_DAW
Definition: msgqueue.h:123
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
unsigned int UINT
Definition: ndis.h:50
#define UserMode
Definition: asm.h:39
NTSYSAPI NTSTATUS NTAPI ZwYieldExecution(VOID)
#define _In_
Definition: no_sal2.h:158
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
NTSYSAPI NTSTATUS NTAPI RtlUnicodeStringToAnsiString(PANSI_STRING DestinationString, PUNICODE_STRING SourceString, BOOLEAN AllocateDestinationString)
#define FASTCALL
Definition: nt_native.h:50
#define UNICODE_NULL
@ WaitAny
_Out_ PKAPC_STATE ApcState
Definition: mm.h:1770
NTSTATUS NTAPI KeWaitForMultipleObjects(IN ULONG Count, IN PVOID Object[], IN WAIT_TYPE WaitType, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL, OUT PKWAIT_BLOCK WaitBlockArray OPTIONAL)
Definition: wait.c:586
BOOLEAN NTAPI PsGetProcessExitProcessCalled(PEPROCESS Process)
Definition: process.c:1043
POBJECT_TYPE PsProcessType
Definition: process.c:20
PVOID NTAPI PsGetCurrentProcessWin32Process(VOID)
Definition: process.c:1183
NTSTATUS NTAPI PsLookupThreadByThreadId(IN HANDLE ThreadId, OUT PETHREAD *Thread)
Definition: thread.c:643
PVOID NTAPI PsGetCurrentThreadWin32Thread(VOID)
Definition: thread.c:805
#define STATUS_WAIT_0
Definition: ntstatus.h:237
#define STATUS_USER_APC
Definition: ntstatus.h:78
#define STATUS_WAIT_2
Definition: ntstatus.h:72
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
LRESULT FASTCALL IntDefWindowProc(PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL Ansi)
Definition: defwnd.c:587
BOOL FASTCALL IntMakeHungWindowGhosted(HWND hwndHung)
Definition: ghost.c:156
PHOOK FASTCALL IntGetNextHook(PHOOK Hook)
Definition: hook.c:995
LRESULT APIENTRY co_HOOK_CallHooks(INT HookId, INT Code, WPARAM wParam, LPARAM lParam)
Definition: hook.c:1102
BOOLEAN FASTCALL co_WinPosSetWindowPos(PWND Window, HWND WndInsertAfter, INT x, INT y, INT cx, INT cy, UINT flags)
Definition: winpos.c:1792
BOOLEAN FASTCALL co_WinPosShowWindow(PWND Wnd, INT Cmd)
Definition: winpos.c:2594
PWINSTATION_OBJECT InputWindowStation
Definition: winsta.c:21
VOID FASTCALL UserLeave(VOID)
Definition: ntuser.c:258
PTHREADINFO gptiCurrent
Definition: ntuser.c:15
VOID FASTCALL UserEnterExclusive(VOID)
Definition: ntuser.c:249
#define L(x)
Definition: ntvdm.h:50
struct _THREADINFO * PTHREADINFO
Definition: ntwin32.h:6
struct _PROCESSINFO * PPROCESSINFO
Definition: ntwin32.h:5
static __inline VOID UserDerefObjectCo(PVOID obj)
Definition: object.h:43
static __inline VOID UserRefObjectCo(PVOID obj, PUSER_REFERENCE_ENTRY UserReferenceEntry)
Definition: object.h:27
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
#define LOWORD(l)
Definition: pedump.c:82
#define WS_CHILD
Definition: pedump.c:617
long LONG
Definition: pedump.c:60
unsigned short USHORT
Definition: pedump.c:61
static ULONG Timeout
Definition: ping.c:61
#define MmCopyFromCaller
Definition: polytest.cpp:29
VOID NTAPI KeStackAttachProcess(IN PKPROCESS Process, OUT PRKAPC_STATE ApcState)
Definition: procobj.c:704
VOID NTAPI KeUnstackDetachProcess(IN PRKAPC_STATE ApcState)
Definition: procobj.c:756
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
#define _SEH2_END
Definition: pseh2_64.h:171
#define _SEH2_TRY
Definition: pseh2_64.h:71
#define _SEH2_YIELD(__stmt)
Definition: pseh2_64.h:184
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_Check_return_ _CRTIMP int __cdecl wcsncmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
#define exit(n)
Definition: config.h:202
#define STATUS_SUCCESS
Definition: shellext.h:65
SIGDN PWSTR * ppszName
Definition: shobjidl.idl:606
#define _countof(array)
Definition: sndvol32.h:70
static void Exit(void)
Definition: sock.c:1330
#define TRACE(s)
Definition: solgame.cpp:4
& rect
Definition: startmenu.cpp:1413
Implementation of the Explorer desktop window.
Definition: desktop.h:52
Definition: window.c:28
DWORD recipients
Definition: ntuser.h:1109
DWORD flags
Definition: ntuser.h:1108
HDESK hDesk
Definition: ntuser.h:1110
SENDASYNCPROC CallBack
Definition: callback.h:45
ULONG_PTR Context
Definition: callback.h:46
RTL_ATOM atomClassName
Definition: ntuser.h:568
struct _WND * spwnd
Definition: ntuser.h:137
PDESKTOPINFO pDeskInfo
Definition: desktop.h:8
KTHREAD Tcb
Definition: pstypes.h:1104
PVOID Win32Thread
Definition: ketypes.h:2029
ULONG Length
Definition: ntuser.h:91
ULONG MaximumLength
Definition: ntuser.h:92
PVOID Buffer
Definition: ntuser.h:94
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
PTHREADINFO ptiList
Definition: win32.h:257
PPROCESSINFO ppi
Definition: win32.h:88
struct _DESKTOPINFO * pDeskInfo
Definition: win32.h:93
PTHREADINFO ptiSibling
Definition: win32.h:116
INT exitCode
Definition: win32.h:107
struct tagHOOK * sphkCurrent
Definition: win32.h:118
ULONG fsHooks
Definition: win32.h:117
POINT ptLast
Definition: win32.h:129
struct _CLIENTINFO * pClientInfo
Definition: win32.h:94
PKEVENT pEventQueueServer
Definition: win32.h:125
BOOLEAN QuitPosted
Definition: win32.h:105
LONG timeLast
Definition: win32.h:102
struct _CLIENTTHREADINFO * pcti
Definition: win32.h:91
FLONG TIF_flags
Definition: win32.h:95
LIST_ENTRY SentMessagesListHead
Definition: win32.h:100
UINT cPaintsReady
Definition: win32.h:109
struct _USER_MESSAGE_QUEUE * MessageQueue
Definition: win32.h:89
Definition: timer.h:4
TIMERPROC pfn
Definition: timer.h:13
Definition: object.h:4
UINT flags
Definition: winuser.h:3670
HWND hwndInsertAfter
Definition: winuser.h:3665
LIST_ENTRY DesktopListHead
Definition: winsta.h:19
Definition: ntuser.h:694
PCLS pcls
Definition: ntuser.h:720
THRDESKHEAD head
Definition: ntuser.h:695
DWORD style
Definition: ntuser.h:706
DWORD fnid
Definition: ntuser.h:709
Definition: inflate.c:139
Definition: tftpd.h:60
LPCWSTR lpszClass
Definition: winuser.h:3041
LPCWSTR lpszName
Definition: winuser.h:3040
WPARAM wParam
Definition: winuser.h:3095
LRESULT lResult
Definition: winuser.h:3093
LPARAM lParam
Definition: winuser.h:3094
LPARAM lParam
Definition: winuser.h:3101
WPARAM wParam
Definition: winuser.h:3102
UINT message
Definition: winuser.h:3103
ULONG_PTR Result
Definition: ntuser.h:2663
INT_PTR ihmod
Definition: ntuser.h:245
struct tagHOOK * phkNext
Definition: ntuser.h:241
HOOKPROC Proc
Definition: ntuser.h:250
ULONG_PTR offPfn
Definition: ntuser.h:243
int HookId
Definition: ntuser.h:242
BOOLEAN Ansi
Definition: ntuser.h:251
UNICODE_STRING ModuleName
Definition: ntuser.h:252
UINT Size
Definition: message.c:138
UINT Message
Definition: message.c:137
UINT message
Definition: winuser.h:3191
HWND hwnd
Definition: winuser.h:3190
DWORD time
Definition: winuser.h:3194
WPARAM wParam
Definition: winuser.h:3192
LPARAM lParam
Definition: winuser.h:3193
POINT pt
Definition: winuser.h:3195
PWINDOWPOS lppos
Definition: winuser.h:3675
long y
Definition: polytest.cpp:48
long x
Definition: polytest.cpp:48
ATOM atomSysClass[ICLS_NOTUSED+1]
Definition: ntuser.h:1060
TW_UINT32 TW_UINT16 TW_UINT16 MSG
Definition: twain.h:1829
uint16_t * PWSTR
Definition: typedefs.h:56
const uint16_t * PCWSTR
Definition: typedefs.h:57
uint32_t DWORD_PTR
Definition: typedefs.h:65
INT POOL_TYPE
Definition: typedefs.h:78
int64_t LONGLONG
Definition: typedefs.h:68
ULONG_PTR SIZE_T
Definition: typedefs.h:80
int32_t INT
Definition: typedefs.h:58
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
#define MAXUSHORT
Definition: typedefs.h:83
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
uint32_t ULONG
Definition: typedefs.h:59
#define HIWORD(l)
Definition: typedefs.h:247
char * PCHAR
Definition: typedefs.h:51
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define WM_DRAGLOOP
Definition: undocuser.h:59
#define WM_COPYGLOBALDATA
Definition: undocuser.h:38
#define WM_DRAGSELECT
Definition: undocuser.h:60
#define WM_QUERYDROPOBJECT
Definition: undocuser.h:57
#define WM_DROPOBJECT
Definition: undocuser.h:56
#define WM_DRAGMOVE
Definition: undocuser.h:61
#define QS_SMRESULT
Definition: undocuser.h:96
#define WM_MAXIMUM
Definition: undocuser.h:65
#define QS_EVENT
Definition: undocuser.h:98
VOID FASTCALL IntPaintWindow(PWND Window)
Definition: painting.c:1184
BOOL FASTCALL IntGetPaintMessage(PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, PTHREADINFO Thread, MSG *Message, BOOL Remove)
Definition: painting.c:1191
PWND FASTCALL UserGetWindowObject(HWND hWnd)
Definition: window.c:124
BOOLEAN co_UserDestroyWindow(PVOID Object)
Definition: window.c:2870
static __inline PVOID UserHeapAlloc(SIZE_T Bytes)
Definition: usrheap.h:34
static __inline PVOID UserHeapAddressToUser(PVOID lpMem)
Definition: usrheap.h:99
static __inline BOOL UserHeapFree(PVOID lpMem)
Definition: usrheap.h:44
int ret
int retval
Definition: wcstombs.cpp:91
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3815
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFSTRING String
Definition: wdfdevice.h:2433
_Must_inspect_result_ _In_ WDFDEVICE _In_ WDFDEVICE Child
Definition: wdffdo.h:536
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
#define IntReferenceProcessInfo(ppi)
Definition: win32.h:182
#define W32PF_WAITFORINPUTIDLE
Definition: win32.h:22
#define IntDereferenceProcessInfo(ppi)
Definition: win32.h:187
VOID FASTCALL SetLastNtError(_In_ NTSTATUS Status)
Definition: error.c:31
#define RECT
Definition: precomp.h:26
FORCEINLINE BOOL RECTL_bPointInRect(_In_ const RECTL *prcl, _In_ INT x, _In_ INT y)
Definition: rect.h:52
LRESULT APIENTRY co_IntCallHookProc(INT HookId, INT Code, WPARAM wParam, LPARAM lParam, HOOKPROC Proc, INT Mod, ULONG_PTR offPfn, BOOLEAN Ansi, PUNICODE_STRING ModuleName)
Definition: callback.c:508
VOID APIENTRY co_IntCallSentMessageCallback(SENDASYNCPROC CompletionCallback, HWND hWnd, UINT Msg, ULONG_PTR CompletionCallbackContext, LRESULT Result)
Definition: callback.c:238
LRESULT APIENTRY co_IntCallWindowProc(WNDPROC Proc, BOOLEAN IsAnsiProc, HWND Wnd, UINT Message, WPARAM wParam, LPARAM lParam, INT lParamBufferSize)
Definition: callback.c:282
BOOL APIENTRY IntDdePostMessageHook(IN PWND pWnd, IN UINT Msg, IN WPARAM wParam, IN OUT LPARAM *lParam, IN OUT LONG_PTR *ExtraInfo)
Definition: dde.c:172
BOOL APIENTRY IntDdeGetMessageHook(PMSG pMsg, LONG_PTR ExtraInfo)
Definition: dde.c:326
BOOL FASTCALL IntDdeSendMessageHook(PWND pWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: dde.c:386
PWND FASTCALL UserGetDesktopWindow(VOID)
Definition: desktop.c:1403
BOOL FASTCALL DesktopWindowProc(PWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
Definition: desktop.c:1456
BOOL FASTCALL UserMessageWindowProc(PWND pwnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
Definition: desktop.c:1542
PTHREADINFO gptiForeground
Definition: focus.c:15
#define UserIsMessageWindow(pWnd)
Definition: desktop.h:197
#define UserIsDesktopWindow(pWnd)
Definition: desktop.h:194
LRESULT APIENTRY co_EVENT_CallEvents(DWORD event, HWND hwnd, UINT_PTR idObject, LONG_PTR idChild)
Definition: event.c:150
BOOL FASTCALL IntTranslateKbdMessage(LPMSG lpMsg, UINT flags)
Definition: keyboard.c:1276
BOOL WINAPI PopupMenuWndProc(PWND Wnd, UINT Message, WPARAM wParam, LPARAM lParam, LRESULT *lResult)
Definition: menu.c:4657
struct tagMSGMEMORY * PMSGMEMORY
static MSGMEMORY g_MsgMemory[]
Definition: message.c:143
UINT FASTCALL GetWakeMask(UINT first, UINT last)
Definition: message.c:623
#define PM_BADMSGFLAGS
Definition: message.c:14
BOOL FASTCALL IntCallMsgFilter(LPMSG lpmsg, INT code)
Definition: message.c:2190
#define MMS_SIZE_LPARAMSZ
Definition: message.c:130
BOOL APIENTRY NtUserDragDetect(HWND hWnd, POINT pt)
Definition: message.c:2205
static LRESULT FASTCALL co_IntSendMessageTimeoutSingle(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uFlags, UINT uTimeout, ULONG_PTR *uResult)
Definition: message.c:1510
#define MMS_SIZE_WPARAMWCHAR
Definition: message.c:129
static int is_pointer_message(UINT message, WPARAM wparam)
Definition: message.c:120
VOID FASTCALL IdlePing(VOID)
Definition: message.c:576
static VOID FASTCALL IntCallWndProcRet(PWND Window, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, LRESULT *uResult)
Definition: message.c:790
DWORD APIENTRY IntGetQueueStatus(DWORD Changes)
Definition: message.c:2139
BOOL APIENTRY NtUserCallMsgFilter(LPMSG lpmsg, INT code)
Definition: message.c:2429
LRESULT FASTCALL IntDispatchMessage(PMSG pMsg)
Definition: message.c:890
static UINT FASTCALL MsgMemorySize(PMSGMEMORY MsgMemoryEntry, WPARAM wParam, LPARAM lParam)
Definition: message.c:187
DWORD APIENTRY NtUserWaitForInputIdle(IN HANDLE hProcess, IN DWORD dwMilliseconds, IN BOOL bSharedWow)
Definition: message.c:3103
static LRESULT FASTCALL co_IntDoSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, PDOSENDMESSAGE dsm)
Definition: message.c:2004
BOOL FASTCALL IntMsgCreateStructW(PWND Window, CREATESTRUCTW *pCsw, CREATESTRUCTW *Cs, PVOID *ppszClass, PVOID *ppszName)
Definition: message.c:646
BOOL APIENTRY NtUserPeekMessage(PMSG pMsg, HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax, UINT RemoveMsg)
Definition: message.c:2387
BOOL APIENTRY NtUserMessageCall(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, ULONG_PTR ResultInfo, DWORD dwType, BOOL Ansi)
Definition: message.c:2527
#define MMS_FLAG_WRITE
Definition: message.c:133
LRESULT FASTCALL co_IntSendMessageWithCallBack(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, SENDASYNCPROC CompletionCallback, ULONG_PTR CompletionCallbackContext, ULONG_PTR *uResult)
Definition: message.c:1785
static const unsigned int message_pointer_flags[]
Definition: message.c:58
BOOL APIENTRY NtUserWaitMessage(VOID)
Definition: message.c:2329
BOOL APIENTRY IntInitMessagePumpHook(VOID)
Definition: message.c:2160
struct tagMSGMEMORY MSGMEMORY
LRESULT FASTCALL co_IntSendMessageNoWait(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1763
BOOL APIENTRY NtUserPostThreadMessage(DWORD idThread, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2292
#define MMS_SIZE_SPECIAL
Definition: message.c:131
BOOL FASTCALL UserSendNotifyMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2090
NTSTATUS FASTCALL IntInitMessageImpl(VOID)
Definition: message.c:41
BOOL APIENTRY NtUserTranslateMessage(LPMSG lpMsg, UINT flags)
Definition: message.c:2490
#define MMS_FLAG_READ
Definition: message.c:132
WCHAR StrUserKernel[3][20]
Definition: message.c:18
static BOOL is_message_broadcastable(UINT msg)
Definition: message.c:617
#define SET(msg)
Definition: message.c:56
static NTSTATUS FASTCALL CopyMsgToKernelMem(MSG *KernelModeMsg, MSG *UserModeMsg, PMSGMEMORY MsgMemoryEntry)
Definition: message.c:451
BOOL FASTCALL UserPostMessage(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1395
BOOL APIENTRY NtUserPostMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:2275
BOOL FASTCALL co_IntWaitMessage(PWND Window, UINT MsgFilterMin, UINT MsgFilterMax)
Definition: message.c:1180
PTHREADINFO FASTCALL IntSendTo(PWND Window, PTHREADINFO ptiCur, UINT Msg)
Definition: message.c:1381
#define INFINITE
Definition: message.c:3098
LRESULT FASTCALL co_IntSendMessageTimeout(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam, UINT uFlags, UINT uTimeout, ULONG_PTR *uResult)
Definition: message.c:1707
BOOL APIENTRY co_IntGetPeekMessage(PMSG pMsg, HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax, UINT RemoveMsg, BOOL bGMSG)
Definition: message.c:1226
static INT PosInArray(_In_ PCWSTR String)
Definition: message.c:28
static NTSTATUS PackParam(LPARAM *lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolNeeded)
Definition: message.c:284
#define MMS_FLAG_READWRITE
Definition: message.c:134
#define WAIT_FAILED
Definition: message.c:3099
VOID FASTCALL IdlePong(VOID)
Definition: message.c:606
BOOL APIENTRY co_IntPeekMessage(PMSG Msg, PWND Window, UINT MsgFilterMin, UINT MsgFilterMax, UINT RemoveMsg, LONG_PTR *ExtraInfo, BOOL bGMSG)
Definition: message.c:1014
LRESULT APIENTRY NtUserDispatchMessage(PMSG UnsafeMsgInfo)
Definition: message.c:2464
#define MMS_SIZE_WPARAM
Definition: message.c:128
BOOL APIENTRY IntUninitMessagePumpHook(VOID)
Definition: message.c:2173
static VOID FASTCALL IntCallWndProc(PWND Window, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:756
static PMSGMEMORY FASTCALL FindMsgMemory(UINT Msg)
Definition: message.c:168
BOOL FASTCALL UserPostThreadMessage(PTHREADINFO pti, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1358
LRESULT APIENTRY ScrollBarWndProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: scrollbar.c:1123
static NTSTATUS FASTCALL CopyMsgToUserMem(MSG *UserModeMsg, MSG *KernelModeMsg)
Definition: message.c:536
LRESULT FASTCALL co_IntSendMessage(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:1495
static LRESULT handle_internal_message(PWND pWnd, UINT msg, WPARAM wparam, LPARAM lparam)
Definition: message.c:821
static NTSTATUS UnpackParam(LPARAM lParamPacked, UINT Msg, WPARAM wParam, LPARAM lParam, BOOL NonPagedPoolUsed)
Definition: message.c:402
NTSTATUS FASTCALL IntCleanupMessageImpl(VOID)
Definition: message.c:47
UINT lParamMemorySize(UINT Msg, WPARAM wParam, LPARAM lParam)
Definition: message.c:276
static LRESULT handle_internal_events(PTHREADINFO pti, PWND pWnd, DWORD dwQEvent, LONG_PTR ExtraInfo, PMSG pMsg)
Definition: message.c:862
BOOL APIENTRY NtUserGetMessage(PMSG pMsg, HWND hWnd, UINT MsgFilterMin, UINT MsgFilterMax)
Definition: message.c:2343
LONG NTAPI UserGetSystemMetrics(ULONG Index)
Definition: metric.c:210
#define USERTAG_SWP
Definition: tags.h:281
#define USERTAG_WINDOWLIST
Definition: tags.h:298
#define TAG_MSG
Definition: tags.h:7
BOOL FASTCALL ValidateTimerCallback(PTHREADINFO pti, LPARAM lParam)
Definition: timer.c:155
BOOL FASTCALL PostTimerMessages(PWND Window)
Definition: timer.c:401
PTIMER FASTCALL FindSystemTimer(PMSG pMsg)
Definition: timer.c:131
HWND *FASTCALL IntWinListChildren(PWND Window)
Definition: window.c:276
LRESULT co_UserFreeWindow(PWND Window, PPROCESSINFO ProcessData, PTHREADINFO ThreadData, BOOLEAN SendMessages)
Definition: window.c:576
PWND FASTCALL VerifyWnd(PWND pWnd)
Definition: window.c:88
ENGAPI ULONG APIENTRY EngGetLastError(VOID)
Definition: error.c:9
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:22
LONG_PTR LPARAM
Definition: windef.h:208
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
#define ERROR_MESSAGE_SYNC_ONLY
Definition: winerror.h:681
#define ERROR_INVALID_WINDOW_HANDLE
Definition: winerror.h:881
#define ERROR_INVALID_FLAGS
Definition: winerror.h:583
#define ERROR_TIMEOUT
Definition: winerror.h:941
#define ERROR_INTERNAL_ERROR
Definition: winerror.h:840
#define WM_PAINT
Definition: winuser.h:1639
#define LB_ADDFILE
Definition: winuser.h:2049
struct tagMDINEXTMENU MDINEXTMENU
#define CB_SELECTSTRING
Definition: winuser.h:1979
#define QS_KEY
Definition: winuser.h:885
#define EM_GETRECT
Definition: winuser.h:2015
#define LB_FINDSTRINGEXACT
Definition: winuser.h:2054
void(CALLBACK * SENDASYNCPROC)(HWND, UINT, ULONG_PTR, LRESULT)
Definition: winuser.h:2992
#define QS_SENDMESSAGE
Definition: winuser.h:891
#define WH_CALLWNDPROCRET
Definition: winuser.h:42
#define CB_GETLBTEXT
Definition: winuser.h:1971
#define WM_MOUSEFIRST
Definition: winuser.h:1793
#define SM_CXDRAG
Definition: winuser.h:1039
#define WM_NEXTMENU
Definition: winuser.h:1825
#define WM_QUIT
Definition: winuser.h:1642
#define WM_MOUSELAST
Definition: winuser.h:1820
#define WM_MDICREATE
Definition: winuser.h:1831
#define HWND_TOPMOST
Definition: winuser.h:1219
#define LB_GETTEXT
Definition: winuser.h:2068
#define WM_WINDOWPOSCHANGING
Definition: winuser.h:1680
struct tagNCCALCSIZE_PARAMS NCCALCSIZE_PARAMS
#define QS_TIMER
Definition: winuser.h:889
#define WM_CREATE
Definition: winuser.h:1627
#define EM_GETSEL
Definition: winuser.h:2016
#define LB_DIR
Definition: winuser.h:2052
#define SMTO_BLOCK
Definition: winuser.h:1235
#define HWND_BROADCAST
Definition: winuser.h:1215
#define WH_MSGFILTER
Definition: winuser.h:29
#define WM_WININICHANGE
Definition: winuser.h:1649
#define LB_GETITEMRECT
Definition: winuser.h:2062
#define EM_REPLACESEL
Definition: winuser.h:2025
#define WM_DEVMODECHANGE
Definition: winuser.h:1650
#define WM_KEYFIRST
Definition: winuser.h:1733
#define HC_ACTION
Definition: winuser.h:48
#define EM_SETRECT
Definition: winuser.h:2035
#define QS_ALLPOSTMESSAGE
Definition: winuser.h:893
#define QS_ALLINPUT
Definition: winuser.h:914
struct tagCREATESTRUCTW CREATESTRUCTW
#define WM_MOUSEMOVE
Definition: winuser.h:1794
#define WM_GETTEXT
Definition: winuser.h:1637
struct tagMEASUREITEMSTRUCT MEASUREITEMSTRUCT
struct _WINDOWPOS WINDOWPOS
#define CB_FINDSTRINGEXACT
Definition: winuser.h:1959
#define WM_DEVICECHANGE
Definition: winuser.h:1830
#define WH_CBT
Definition: winuser.h:35
#define LB_ADDSTRING
Definition: winuser.h:2050
#define CB_DIR
Definition: winuser.h:1957
#define SBM_GETRANGE
Definition: winuser.h:2098
struct tagDRAWITEMSTRUCT DRAWITEMSTRUCT
#define WM_ASKCBFORMATNAME
Definition: winuser.h:1892
#define WM_DELETEITEM
Definition: winuser.h:1666
#define WM_DRAWITEM
Definition: winuser.h:1664
#define WM_NCCREATE
Definition: winuser.h:1702
struct tagMINMAXINFO MINMAXINFO
#define WM_QUEUESYNC
Definition: winuser.h:1658
#define QS_HOTKEY
Definition: winuser.h:892
#define WM_SETTINGCHANGE
Definition: winuser.h:1648
#define WM_SETTEXT
Definition: winuser.h:1636
#define LB_SELECTSTRING
Definition: winuser.h:2075
#define EM_GETLINE
Definition: winuser.h:2010
#define CB_GETDROPPEDCONTROLRECT
Definition: winuser.h:1963
#define EM_SETRECTNP
Definition: winuser.h:2036
#define WM_GETMINMAXINFO
Definition: winuser.h:1659
#define LB_FINDSTRING
Definition: winuser.h:2053
#define PM_NOYIELD
Definition: winuser.h:1208
#define WM_TIMER
Definition: winuser.h:1761
struct tagCOPYDATASTRUCT COPYDATASTRUCT
#define PM_REMOVE
Definition: winuser.h:1207
#define LB_INSERTSTRING
Definition: winuser.h:2072
#define CB_ADDSTRING
Definition: winuser.h:1955
#define QS_INPUT
Definition: winuser.h:910
#define WM_COPYDATA
Definition: winuser.h:1683
#define QS_MOUSE
Definition: winuser.h:903
#define HCBT_QS
Definition: winuser.h:57
struct tagSTYLESTRUCT STYLESTRUCT
struct tagHELPINFO HELPINFO
#define WM_MEASUREITEM
Definition: winuser.h:1665
#define WM_LBUTTONUP
Definition: winuser.h:1796
#define WH_GETMESSAGE
Definition: winuser.h:33
#define WH_SYSMSGFILTER
Definition: winuser.h:36
#define QS_POSTMESSAGE
Definition: winuser.h:888
#define SMTO_ABORTIFHUNG
Definition: winuser.h:1234
#define WM_SIZING
Definition: winuser.h:1826
#define CB_GETEDITSEL
Definition: winuser.h:1966
#define QS_PAINT
Definition: winuser.h:890
#define LB_SETTABSTOPS
Definition: winuser.h:2088
#define EM_SETTABSTOPS
Definition: winuser.h:2038
#define CB_FINDSTRING
Definition: winuser.h:1958
#define WM_KEYDOWN
Definition: winuser.h:1734
#define BROADCAST_QUERY_DENY
Definition: winuser.h:178
#define WM_MOVING
Definition: winuser.h:1828
struct _WINDOWPOS * PWINDOWPOS
#define WM_COMPAREITEM
Definition: winuser.h:1674
#define WM_MDIGETACTIVE
Definition: winuser.h:1840
#define CB_INSERTSTRING
Definition: winuser.h:1976
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2982
#define WH_FOREGROUNDIDLE
Definition: winuser.h:41
#define SM_CYDRAG
Definition: winuser.h:1040
#define WM_NCCALCSIZE
Definition: winuser.h:1704
#define LB_GETSELITEMS
Definition: winuser.h:2067
#define WM_KEYLAST
Definition: winuser.h:1747
#define VK_ESCAPE
Definition: winuser.h:2233
#define WM_WINDOWPOSCHANGED
Definition: winuser.h:1681
#define PM_NOREMOVE
Definition: winuser.h:1206
#define WM_GETDLGCODE
Definition: winuser.h:1708
#define HWND_BOTTOM
Definition: winuser.h:1216
#define SMTO_NORMAL
Definition: winuser.h:1236
#define WH_CALLWNDPROC
Definition: winuser.h:34
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:409
#define IO_NO_INCREMENT
Definition: iotypes.h:598
@ UserRequest
Definition: ketypes.h:421
KAPC_STATE
Definition: ketypes.h:1572
#define ObDereferenceObject
Definition: obfuncs.h:203
#define NT_ASSERT
Definition: rtlfuncs.h:3327
#define RtlUnicodeStringToAnsiSize(String)
Definition: rtlfuncs.h:1022
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185