xref: /reactos/win32ss/user/ntuser/simplecall.c (revision 0623a6f8) 
1 /*
2  * COPYRIGHT:        See COPYING in the top level directory
3  * PROJECT:          ReactOS kernel
4  * PURPOSE:          NtUserCallXxx call stubs
5  * FILE:             win32ss/user/ntuser/simplecall.c
6  * PROGRAMER:        Ge van Geldorp (ge@gse.nl)
7  */
8 
9 #include <win32k.h>
10 
11 DBG_DEFAULT_CHANNEL(UserMisc);
12 
13 /* Registered logon process ID */
14 HANDLE gpidLogon = 0;
15 
16 BOOL FASTCALL
17 co_IntRegisterLogonProcess(HANDLE ProcessId, BOOL Register)
18 {
19     NTSTATUS Status;
20     PEPROCESS Process;
21 
22     Status = PsLookupProcessByProcessId(ProcessId, &Process);
23     if (!NT_SUCCESS(Status))
24     {
25         EngSetLastError(RtlNtStatusToDosError(Status));
26         return FALSE;
27     }
28 
29     ProcessId = Process->UniqueProcessId;
30 
31     ObDereferenceObject(Process);
32 
33     if (Register)
34     {
35         /* Register the logon process */
36         if (gpidLogon != 0)
37             return FALSE;
38 
39         gpidLogon = ProcessId;
40     }
41     else
42     {
43         /* Deregister the logon process */
44         if (gpidLogon != ProcessId)
45             return FALSE;
46 
47         gpidLogon = 0;
48     }
49 
50     return TRUE;
51 }
52 
53 /*
54  * @unimplemented
55  */
56 DWORD_PTR
57 APIENTRY
58 NtUserCallNoParam(DWORD Routine)
59 {
60     DWORD_PTR Result = 0;
61 
62     TRACE("Enter NtUserCallNoParam\n");
63     UserEnterExclusive();
64 
65     switch (Routine)
66     {
67         case NOPARAM_ROUTINE_CREATEMENU:
68             Result = (DWORD_PTR)UserCreateMenu(GetW32ThreadInfo()->rpdesk, FALSE);
69             break;
70 
71         case NOPARAM_ROUTINE_CREATEMENUPOPUP:
72             Result = (DWORD_PTR)UserCreateMenu(GetW32ThreadInfo()->rpdesk, TRUE);
73             break;
74 
75         case NOPARAM_ROUTINE_DESTROY_CARET:
76             Result = (DWORD_PTR)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread);
77             break;
78 
79         case NOPARAM_ROUTINE_INIT_MESSAGE_PUMP:
80             Result = (DWORD_PTR)IntInitMessagePumpHook();
81             break;
82 
83         case NOPARAM_ROUTINE_UNINIT_MESSAGE_PUMP:
84             Result = (DWORD_PTR)IntUninitMessagePumpHook();
85             break;
86 
87         case NOPARAM_ROUTINE_MSQCLEARWAKEMASK:
88             Result = (DWORD_PTR)IntMsqClearWakeMask();
89             break;
90 
91         case NOPARAM_ROUTINE_GETMSESSAGEPOS:
92         {
93             PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
94             Result = (DWORD_PTR)MAKELONG(pti->ptLast.x, pti->ptLast.y);
95             break;
96         }
97 
98         case NOPARAM_ROUTINE_RELEASECAPTURE:
99             Result = (DWORD_PTR)IntReleaseCapture();
100             break;
101 
102         case NOPARAM_ROUTINE_LOADUSERAPIHOOK:
103             Result = UserLoadApiHook();
104             break;
105 
106         case NOPARAM_ROUTINE_ZAPACTIVEANDFOUS:
107         {
108             PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
109             TRACE("Zapping the Active and Focus window out of the Queue!\n");
110             pti->MessageQueue->spwndFocus = NULL;
111             pti->MessageQueue->spwndActive = NULL;
112             Result = 0;
113             break;
114         }
115 
116         /* this is a ReactOS only case and is needed for gui-on-demand */
117         case NOPARAM_ROUTINE_ISCONSOLEMODE:
118             Result = (ScreenDeviceContext == NULL);
119             break;
120 
121         case NOPARAM_ROUTINE_UPDATEPERUSERIMMENABLING:
122             gpsi->dwSRVIFlags |= SRVINFO_IMM32; // Always set.
123             Result = TRUE; // Always return TRUE.
124             break;
125 
126         default:
127             ERR("Calling invalid routine number 0x%x in NtUserCallNoParam\n", Routine);
128             EngSetLastError(ERROR_INVALID_PARAMETER);
129             break;
130     }
131 
132     TRACE("Leave NtUserCallNoParam, ret=%p\n",(PVOID)Result);
133     UserLeave();
134 
135     return Result;
136 }
137 
138 
139 /*
140  * @implemented
141  */
142 DWORD_PTR
143 APIENTRY
144 NtUserCallOneParam(
145     DWORD_PTR Param,
146     DWORD Routine)
147 {
148     DWORD_PTR Result;
149 
150     TRACE("Enter NtUserCallOneParam\n");
151 
152     UserEnterExclusive();
153 
154     switch (Routine)
155     {
156         case ONEPARAM_ROUTINE_POSTQUITMESSAGE:
157         {
158             PTHREADINFO pti;
159             pti = PsGetCurrentThreadWin32Thread();
160             MsqPostQuitMessage(pti, Param);
161             Result = TRUE;
162             break;
163         }
164 
165         case ONEPARAM_ROUTINE_BEGINDEFERWNDPOS:
166         {
167             PSMWP psmwp;
168             HDWP hDwp = NULL;
169             INT count = (INT)Param;
170 
171             if (count < 0)
172             {
173                 EngSetLastError(ERROR_INVALID_PARAMETER);
174                 Result = 0;
175                 break;
176             }
177 
178             /* Windows allows zero count, in which case it allocates context for 8 moves */
179             if (count == 0) count = 8;
180 
181             psmwp = (PSMWP)UserCreateObject(gHandleTable,
182                                             NULL,
183                                             NULL,
184                                             (PHANDLE)&hDwp,
185                                             TYPE_SETWINDOWPOS,
186                                             sizeof(SMWP));
187             if (!psmwp)
188             {
189                 Result = 0;
190                 break;
191             }
192 
193             psmwp->acvr = ExAllocatePoolWithTag(PagedPool, count * sizeof(CVR), USERTAG_SWP);
194             if (!psmwp->acvr)
195             {
196                 UserDeleteObject(hDwp, TYPE_SETWINDOWPOS);
197                 Result = 0;
198                 break;
199             }
200 
201             RtlZeroMemory(psmwp->acvr, count * sizeof(CVR));
202             psmwp->bHandle = TRUE;
203             psmwp->ccvr = 0;          // actualCount
204             psmwp->ccvrAlloc = count; // suggestedCount
205             Result = (DWORD_PTR)hDwp;
206             break;
207         }
208 
209         case ONEPARAM_ROUTINE_SHOWCURSOR:
210             Result = (DWORD_PTR)UserShowCursor((BOOL)Param);
211             break;
212 
213         case ONEPARAM_ROUTINE_GETDESKTOPMAPPING:
214         {
215             PTHREADINFO ti;
216             ti = GetW32ThreadInfo();
217             if (ti != NULL)
218             {
219                 /* Try convert the pointer to a user mode pointer if the desktop is
220                    mapped into the process */
221                 Result = (DWORD_PTR)DesktopHeapAddressToUser((PVOID)Param);
222             }
223             else
224             {
225                 Result = 0;
226             }
227             break;
228         }
229 
230         case ONEPARAM_ROUTINE_WINDOWFROMDC:
231             Result = (DWORD_PTR)IntWindowFromDC((HDC)Param);
232             break;
233 
234         case ONEPARAM_ROUTINE_SWAPMOUSEBUTTON:
235         {
236             Result = gspv.bMouseBtnSwap;
237             gspv.bMouseBtnSwap = Param ? TRUE : FALSE;
238             gpsi->aiSysMet[SM_SWAPBUTTON] = gspv.bMouseBtnSwap;
239             break;
240         }
241 
242         case ONEPARAM_ROUTINE_SETCARETBLINKTIME:
243             Result = (DWORD_PTR)IntSetCaretBlinkTime((UINT)Param);
244             break;
245 
246         case ONEPARAM_ROUTINE_SETMESSAGEEXTRAINFO:
247             Result = (DWORD_PTR)MsqSetMessageExtraInfo((LPARAM)Param);
248             break;
249 
250         case ONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT:
251         {
252             if (!(Result = (DWORD_PTR)IntCreateCurIconHandle((DWORD)Param)))
253             {
254                 EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
255                 Result = 0;
256             }
257             break;
258         }
259 
260         case ONEPARAM_ROUTINE_ENABLEPROCWNDGHSTING:
261         {
262             BOOL Enable;
263             PPROCESSINFO Process = PsGetCurrentProcessWin32Process();
264 
265             if (Process != NULL)
266             {
267                 Enable = (BOOL)(Param != 0);
268 
269                 if (Enable)
270                 {
271                     Process->W32PF_flags &= ~W32PF_NOWINDOWGHOSTING;
272                 }
273                 else
274                 {
275                     Process->W32PF_flags |= W32PF_NOWINDOWGHOSTING;
276                 }
277 
278                 Result = TRUE;
279                 break;
280             }
281 
282             Result = FALSE;
283             break;
284         }
285 
286         case ONEPARAM_ROUTINE_GETINPUTEVENT:
287             Result = (DWORD_PTR)IntMsqSetWakeMask(Param);
288             break;
289 
290         case ONEPARAM_ROUTINE_GETKEYBOARDTYPE:
291             Result = UserGetKeyboardType(Param);
292             break;
293 
294         case ONEPARAM_ROUTINE_GETKEYBOARDLAYOUT:
295             Result = (DWORD_PTR)UserGetKeyboardLayout(Param);
296             break;
297 
298         case ONEPARAM_ROUTINE_RELEASEDC:
299             Result = UserReleaseDC(NULL, (HDC) Param, FALSE);
300             break;
301 
302         case ONEPARAM_ROUTINE_REALIZEPALETTE:
303             Result = UserRealizePalette((HDC) Param);
304             break;
305 
306         case ONEPARAM_ROUTINE_GETQUEUESTATUS:
307         {
308             Result = IntGetQueueStatus((DWORD)Param);
309             break;
310         }
311 
312         case ONEPARAM_ROUTINE_ENUMCLIPBOARDFORMATS:
313             /* FIXME: Should use UserEnterShared */
314             Result = UserEnumClipboardFormats(Param);
315             break;
316 
317         case ONEPARAM_ROUTINE_GETCURSORPOS:
318         {
319             PPOINTL pptl;
320             PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
321             Result = TRUE;
322             if (pti->rpdesk != IntGetActiveDesktop())
323             {
324                 Result = FALSE;
325                 break;
326             }
327             _SEH2_TRY
328             {
329                 ProbeForWrite((POINT*)Param,sizeof(POINT),1);
330                pptl = (PPOINTL)Param;
331                *pptl = gpsi->ptCursor;
332             }
333             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
334             {
335                 Result = FALSE;
336             }
337             _SEH2_END;
338             break;
339         }
340 
341         case ONEPARAM_ROUTINE_SETPROCDEFLAYOUT:
342         {
343             PPROCESSINFO ppi;
344             if (Param & LAYOUT_ORIENTATIONMASK)
345             {
346                 ppi = PsGetCurrentProcessWin32Process();
347                 ppi->dwLayout = Param;
348                 Result = TRUE;
349                 break;
350             }
351             EngSetLastError(ERROR_INVALID_PARAMETER);
352             Result = FALSE;
353             break;
354         }
355 
356         case ONEPARAM_ROUTINE_GETPROCDEFLAYOUT:
357         {
358             PPROCESSINFO ppi;
359             PDWORD pdwLayout;
360             Result = TRUE;
361 
362             if (PsGetCurrentProcess() == gpepCSRSS)
363             {
364                 EngSetLastError(ERROR_INVALID_ACCESS);
365                 Result = FALSE;
366                 break;
367             }
368 
369             ppi = PsGetCurrentProcessWin32Process();
370             _SEH2_TRY
371             {
372                pdwLayout = (PDWORD)Param;
373                *pdwLayout = ppi->dwLayout;
374             }
375             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
376             {
377                 SetLastNtError(_SEH2_GetExceptionCode());
378                 Result = FALSE;
379             }
380             _SEH2_END;
381             break;
382         }
383 
384         case ONEPARAM_ROUTINE_REPLYMESSAGE:
385             Result = co_MsqReplyMessage((LRESULT)Param);
386             break;
387 
388         case ONEPARAM_ROUTINE_MESSAGEBEEP:
389             /* TODO: Implement sound sentry */
390             Result = UserPostMessage(hwndSAS, WM_LOGONNOTIFY, LN_MESSAGE_BEEP, Param);
391            break;
392 
393         case ONEPARAM_ROUTINE_CREATESYSTEMTHREADS:
394             Result = CreateSystemThreads(Param);
395             break;
396 
397         case ONEPARAM_ROUTINE_LOCKFOREGNDWINDOW:
398             Result = (DWORD_PTR)IntLockSetForegroundWindow(Param);
399             break;
400 
401         case ONEPARAM_ROUTINE_ALLOWSETFOREGND:
402             Result = (DWORD_PTR)IntAllowSetForegroundWindow(Param);
403             break;
404 
405         default:
406             ERR("Calling invalid routine number 0x%x in NtUserCallOneParam(), Param=0x%x\n",
407                 Routine, Param);
408             EngSetLastError(ERROR_INVALID_PARAMETER);
409             Result = 0;
410             break;
411     }
412 
413    TRACE("Leave NtUserCallOneParam, ret=%p\n", (PVOID)Result);
414    UserLeave();
415 
416    return Result;
417 }
418 
419 
420 /*
421  * @implemented
422  */
423 DWORD_PTR
424 APIENTRY
425 NtUserCallTwoParam(
426     DWORD_PTR Param1,
427     DWORD_PTR Param2,
428     DWORD Routine)
429 {
430     PWND Window;
431     DWORD_PTR Ret;
432     TRACE("Enter NtUserCallTwoParam\n");
433     UserEnterExclusive();
434 
435     switch (Routine)
436     {
437         case TWOPARAM_ROUTINE_REDRAWTITLE:
438         {
439             Window = UserGetWindowObject((HWND)Param1);
440             Ret = (DWORD_PTR)UserPaintCaption(Window, (INT)Param2);
441             break;
442         }
443 
444         case TWOPARAM_ROUTINE_SETMENUBARHEIGHT:
445         {
446             PMENU MenuObject = IntGetMenuObject((HMENU)Param1);
447             if (!MenuObject)
448             {
449                 Ret = 0;
450                 break;
451             }
452 
453             if (Param2 > 0)
454             {
455                 Ret = (MenuObject->cyMenu == (int)Param2);
456                 MenuObject->cyMenu = (int)Param2;
457             }
458             else
459                 Ret = (DWORD_PTR)MenuObject->cyMenu;
460             IntReleaseMenuObject(MenuObject);
461             break;
462         }
463 
464         case TWOPARAM_ROUTINE_SETGUITHRDHANDLE:
465         {
466             PTHREADINFO pti = (PTHREADINFO)PsGetCurrentThreadWin32Thread();
467             ASSERT(pti->MessageQueue);
468             Ret = (DWORD_PTR)MsqSetStateWindow(pti, (ULONG)Param1, (HWND)Param2);
469             break;
470         }
471 
472         case TWOPARAM_ROUTINE_ENABLEWINDOW:
473             Ret = IntEnableWindow((HWND)Param1, (BOOL)Param2);
474             break;
475 
476         case TWOPARAM_ROUTINE_SHOWOWNEDPOPUPS:
477         {
478             Window = UserGetWindowObject((HWND)Param1);
479             if (!Window)
480             {
481                 Ret = 0;
482                 break;
483             }
484 
485             Ret = (DWORD_PTR)IntShowOwnedPopups(Window, (BOOL)Param2);
486             break;
487         }
488 
489         case TWOPARAM_ROUTINE_ROS_UPDATEUISTATE:
490         {
491             WPARAM wParam;
492             Window = UserGetWindowObject((HWND)Param1);
493             if (!Window)
494             {
495                 Ret = 0;
496                 break;
497             }
498 
499             /* Unpack wParam */
500             wParam = MAKEWPARAM((Param2 >> 3) & 0x3,
501                                 Param2 & (UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE));
502 
503             Ret = UserUpdateUiState(Window, wParam);
504             break;
505         }
506 
507         case TWOPARAM_ROUTINE_SWITCHTOTHISWINDOW:
508             STUB
509             Ret = 0;
510             break;
511 
512         case TWOPARAM_ROUTINE_SETCARETPOS:
513             Ret = (DWORD_PTR)co_IntSetCaretPos((int)Param1, (int)Param2);
514             break;
515 
516         case TWOPARAM_ROUTINE_REGISTERLOGONPROCESS:
517             Ret = (DWORD_PTR)co_IntRegisterLogonProcess((HANDLE)Param1, (BOOL)Param2);
518             break;
519 
520         case TWOPARAM_ROUTINE_SETCURSORPOS:
521             Ret = (DWORD_PTR)UserSetCursorPos((int)Param1, (int)Param2, 0, 0, FALSE);
522             break;
523 
524         case TWOPARAM_ROUTINE_UNHOOKWINDOWSHOOK:
525             Ret = IntUnhookWindowsHook((int)Param1, (HOOKPROC)Param2);
526             break;
527 
528         default:
529             ERR("Calling invalid routine number 0x%x in NtUserCallTwoParam(), Param1=0x%x Parm2=0x%x\n",
530                 Routine, Param1, Param2);
531             EngSetLastError(ERROR_INVALID_PARAMETER);
532             Ret = 0;
533     }
534 
535 
536     TRACE("Leave NtUserCallTwoParam, ret=%p\n", (PVOID)Ret);
537     UserLeave();
538 
539     return Ret;
540 }
541 
542 
543 /*
544  * @unimplemented
545  */
546 BOOL
547 APIENTRY
548 NtUserCallHwndLock(
549     HWND hWnd,
550     DWORD Routine)
551 {
552     BOOL Ret = FALSE;
553     PWND Window;
554     USER_REFERENCE_ENTRY Ref;
555 
556     TRACE("Enter NtUserCallHwndLock\n");
557     UserEnterExclusive();
558 
559     if (!(Window = UserGetWindowObject(hWnd)))
560     {
561         Ret = FALSE;
562         goto Exit;
563     }
564 
565     UserRefObjectCo(Window, &Ref);
566 
567     /* FIXME: Routine can be 0x53 - 0x5E */
568     switch (Routine)
569     {
570         case HWNDLOCK_ROUTINE_ARRANGEICONICWINDOWS:
571             co_WinPosArrangeIconicWindows(Window);
572             break;
573 
574         case HWNDLOCK_ROUTINE_DRAWMENUBAR:
575         {
576             TRACE("HWNDLOCK_ROUTINE_DRAWMENUBAR\n");
577             Ret = TRUE;
578             if ((Window->style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
579                 co_WinPosSetWindowPos(Window,
580                                       HWND_DESKTOP,
581                                       0, 0, 0, 0,
582                                       SWP_NOSIZE |
583                                       SWP_NOMOVE |
584                                       SWP_NOZORDER |
585                                       SWP_NOACTIVATE |
586                                       SWP_FRAMECHANGED);
587             break;
588         }
589 
590         case HWNDLOCK_ROUTINE_REDRAWFRAME:
591             co_WinPosSetWindowPos(Window,
592                                   HWND_DESKTOP,
593                                   0, 0, 0, 0,
594                                   SWP_NOSIZE |
595                                   SWP_NOMOVE |
596                                   SWP_NOZORDER |
597                                   SWP_NOACTIVATE |
598                                   SWP_FRAMECHANGED);
599             Ret = TRUE;
600             break;
601 
602         case HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK:
603             co_WinPosSetWindowPos(Window,
604                                   HWND_DESKTOP,
605                                   0, 0, 0, 0,
606                                   SWP_NOSIZE |
607                                   SWP_NOMOVE |
608                                   SWP_NOZORDER |
609                                   SWP_NOACTIVATE |
610                                   SWP_FRAMECHANGED);
611             if (!Window->spwndOwner && !IntGetParent(Window))
612             {
613                 co_IntShellHookNotify(HSHELL_REDRAW, (WPARAM)hWnd, FALSE); // FIXME Flashing?
614             }
615             Ret = TRUE;
616             break;
617 
618         case HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOW:
619             TRACE("co_IntSetForegroundWindow 1 0x%p\n", hWnd);
620             Ret = co_IntSetForegroundWindow(Window);
621             TRACE("co_IntSetForegroundWindow 2 0x%p\n", hWnd);
622             break;
623 
624         case HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOWMOUSE:
625             TRACE("co_IntSetForegroundWindow M 1 0x%p\n", hWnd);
626             Ret = co_IntSetForegroundWindowMouse(Window);
627             TRACE("co_IntSetForegroundWindow M 2 0x%p\n", hWnd);
628             break;
629 
630         case HWNDLOCK_ROUTINE_UPDATEWINDOW:
631             co_IntUpdateWindows(Window, RDW_ALLCHILDREN, FALSE);
632             Ret = TRUE;
633             break;
634     }
635 
636     UserDerefObjectCo(Window);
637 
638 Exit:
639     TRACE("Leave NtUserCallHwndLock, ret=%u\n", Ret);
640     UserLeave();
641 
642     return Ret;
643 }
644 
645 /*
646  * @unimplemented
647  */
648 HWND
649 APIENTRY
650 NtUserCallHwndOpt(
651     HWND hWnd,
652     DWORD Routine)
653 {
654     switch (Routine)
655     {
656         case HWNDOPT_ROUTINE_SETPROGMANWINDOW:
657             GetW32ThreadInfo()->pDeskInfo->hProgmanWindow = hWnd;
658             break;
659 
660         case HWNDOPT_ROUTINE_SETTASKMANWINDOW:
661             GetW32ThreadInfo()->pDeskInfo->hTaskManWindow = hWnd;
662             break;
663     }
664 
665     return hWnd;
666 }
667 
668 DWORD
669 APIENTRY
670 NtUserCallHwnd(
671     HWND hWnd,
672     DWORD Routine)
673 {
674     switch (Routine)
675     {
676         case HWND_ROUTINE_GETWNDCONTEXTHLPID:
677         {
678             PWND Window;
679             DWORD HelpId;
680 
681             UserEnterShared();
682 
683             if (!(Window = UserGetWindowObject(hWnd)))
684             {
685                 UserLeave();
686                 return 0;
687             }
688 
689             HelpId = (DWORD)(DWORD_PTR)UserGetProp(Window, gpsi->atomContextHelpIdProp, TRUE);
690 
691             UserLeave();
692             return HelpId;
693         }
694 
695         case HWND_ROUTINE_REGISTERSHELLHOOKWINDOW:
696             if (IntIsWindow(hWnd))
697                 return IntRegisterShellHookWindow(hWnd);
698             return FALSE;
699             break;
700 
701         case HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW:
702             if (IntIsWindow(hWnd))
703                 return IntDeRegisterShellHookWindow(hWnd);
704             return FALSE;
705 
706         case HWND_ROUTINE_SETMSGBOX:
707         {
708             PWND Window;
709             UserEnterExclusive();
710             if ((Window = UserGetWindowObject(hWnd)))
711             {
712                 Window->state |= WNDS_MSGBOX;
713             }
714             UserLeave();
715             return FALSE;
716         }
717     }
718 
719     STUB;
720 
721     return 0;
722 }
723 
724 DWORD
725 APIENTRY
726 NtUserCallHwndParam(
727     HWND hWnd,
728     DWORD_PTR Param,
729     DWORD Routine)
730 {
731 
732     switch (Routine)
733     {
734         case HWNDPARAM_ROUTINE_KILLSYSTEMTIMER:
735             return IntKillTimer(UserGetWindowObject(hWnd), (UINT_PTR)Param, TRUE);
736 
737         case HWNDPARAM_ROUTINE_SETWNDCONTEXTHLPID:
738         {
739             PWND Window;
740 
741             UserEnterExclusive();
742             if (!(Window = UserGetWindowObject(hWnd)))
743             {
744                 UserLeave();
745                 return FALSE;
746             }
747 
748             if (Param)
749                 UserSetProp(Window, gpsi->atomContextHelpIdProp, (HANDLE)Param, TRUE);
750             else
751                 UserRemoveProp(Window, gpsi->atomContextHelpIdProp, TRUE);
752 
753             UserLeave();
754             return TRUE;
755         }
756 
757         case HWNDPARAM_ROUTINE_SETDIALOGPOINTER:
758         {
759             PWND pWnd;
760             USER_REFERENCE_ENTRY Ref;
761 
762             UserEnterExclusive();
763 
764             if (!(pWnd = UserGetWindowObject(hWnd)))
765             {
766                 UserLeave();
767                 return 0;
768             }
769             UserRefObjectCo(pWnd, &Ref);
770 
771             if (pWnd->head.pti->ppi == PsGetCurrentProcessWin32Process() &&
772                 pWnd->cbwndExtra == DLGWINDOWEXTRA &&
773                 !(pWnd->state & WNDS_SERVERSIDEWINDOWPROC))
774             {
775                 if (Param)
776                 {
777                     if (!pWnd->fnid) pWnd->fnid = FNID_DIALOG;
778                     pWnd->state |= WNDS_DIALOGWINDOW;
779                 }
780                 else
781                 {
782                     pWnd->fnid |= FNID_DESTROY;
783                     pWnd->state &= ~WNDS_DIALOGWINDOW;
784                 }
785             }
786 
787             UserDerefObjectCo(pWnd);
788             UserLeave();
789             return 0;
790         }
791 
792         case HWNDPARAM_ROUTINE_ROS_NOTIFYWINEVENT:
793         {
794             PWND pWnd;
795             PNOTIFYEVENT pne;
796             UserEnterExclusive();
797             pne = (PNOTIFYEVENT)Param;
798             if (hWnd)
799                 pWnd = UserGetWindowObject(hWnd);
800             else
801                 pWnd = NULL;
802             IntNotifyWinEvent(pne->event, pWnd, pne->idObject, pne->idChild, pne->flags);
803             UserLeave();
804             return 0;
805         }
806 
807         case HWNDPARAM_ROUTINE_CLEARWINDOWSTATE:
808         {
809             PWND pWnd;
810             UserEnterExclusive();
811             pWnd = UserGetWindowObject(hWnd);
812             if (pWnd) IntClearWindowState(pWnd, (UINT)Param);
813             UserLeave();
814             return 0;
815         }
816 
817         case HWNDPARAM_ROUTINE_SETWINDOWSTATE:
818         {
819             PWND pWnd;
820             UserEnterExclusive();
821             pWnd = UserGetWindowObject(hWnd);
822             if (pWnd) IntSetWindowState(pWnd, (UINT)Param);
823             UserLeave();
824             return 0;
825         }
826     }
827 
828     STUB;
829 
830     return 0;
831 }
832 
833 DWORD
834 APIENTRY
835 NtUserCallHwndParamLock(
836     HWND hWnd,
837     DWORD_PTR Param,
838     DWORD Routine)
839 {
840     DWORD Ret = FALSE;
841     PWND Window;
842     USER_REFERENCE_ENTRY Ref;
843 
844     TRACE("Enter NtUserCallHwndParamLock\n");
845     UserEnterExclusive();
846 
847     if (!(Window = UserGetWindowObject(hWnd)))
848     {
849         Ret = FALSE;
850         goto Exit;
851     }
852 
853     UserRefObjectCo(Window, &Ref);
854 
855     switch (Routine)
856     {
857         case TWOPARAM_ROUTINE_VALIDATERGN:
858         {
859             PREGION Rgn = REGION_LockRgn((HRGN)Param);
860             Ret = (DWORD)co_UserRedrawWindow(Window, NULL, Rgn, RDW_VALIDATE);
861             if (Rgn) REGION_UnlockRgn(Rgn);
862             break;
863         }
864     }
865 
866     UserDerefObjectCo(Window);
867 
868 Exit:
869 
870     TRACE("Leave NtUserCallHwndParamLock, ret=%lu\n", Ret);
871     UserLeave();
872 
873     return Ret;
874 }
875 
876 /* EOF */
877