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