bf26bc279621d1c6b8ddf562a8908c05dc65ac26
[reactos.git] / reactos / subsystems / win32 / win32k / ntuser / simplecall.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS kernel
4 * PURPOSE: NtUserCallXxx call stubs
5 * FILE: subsystem/win32/win32k/ntuser/simplecall.c
6 * PROGRAMER: Ge van Geldorp (ge@gse.nl)
7 * REVISION HISTORY:
8 * 2008/03/20 Split from misc.c
9 */
10
11 #include <win32k.h>
12
13 #define NDEBUG
14 #include <debug.h>
15
16
17 /* registered Logon process */
18 PPROCESSINFO LogonProcess = NULL;
19
20 BOOL FASTCALL
21 co_IntRegisterLogonProcess(HANDLE ProcessId, BOOL Register)
22 {
23 PEPROCESS Process;
24 NTSTATUS Status;
25 CSR_API_MESSAGE Request;
26
27 Status = PsLookupProcessByProcessId(ProcessId,
28 &Process);
29 if (!NT_SUCCESS(Status))
30 {
31 SetLastWin32Error(RtlNtStatusToDosError(Status));
32 return FALSE;
33 }
34
35 if (Register)
36 {
37 /* Register the logon process */
38 if (LogonProcess != NULL)
39 {
40 ObDereferenceObject(Process);
41 return FALSE;
42 }
43
44 LogonProcess = (PPROCESSINFO)Process->Win32Process;
45 }
46 else
47 {
48 /* Deregister the logon process */
49 if (LogonProcess != (PPROCESSINFO)Process->Win32Process)
50 {
51 ObDereferenceObject(Process);
52 return FALSE;
53 }
54
55 LogonProcess = NULL;
56 }
57
58 ObDereferenceObject(Process);
59
60 Request.Type = MAKE_CSR_API(REGISTER_LOGON_PROCESS, CSR_GUI);
61 Request.Data.RegisterLogonProcessRequest.ProcessId = ProcessId;
62 Request.Data.RegisterLogonProcessRequest.Register = Register;
63
64 Status = co_CsrNotify(&Request);
65 if (! NT_SUCCESS(Status))
66 {
67 DPRINT1("Failed to register logon process with CSRSS\n");
68 return FALSE;
69 }
70
71 return TRUE;
72 }
73
74 /*
75 * @unimplemented
76 */
77 DWORD_PTR
78 APIENTRY
79 NtUserCallNoParam(DWORD Routine)
80 {
81 DWORD_PTR Result = 0;
82 DECLARE_RETURN(DWORD_PTR);
83
84 DPRINT("Enter NtUserCallNoParam\n");
85 UserEnterExclusive();
86
87 switch(Routine)
88 {
89 case NOPARAM_ROUTINE_CREATEMENU:
90 Result = (DWORD_PTR)UserCreateMenu(FALSE);
91 break;
92
93 case NOPARAM_ROUTINE_CREATEMENUPOPUP:
94 Result = (DWORD_PTR)UserCreateMenu(TRUE);
95 break;
96
97 case NOPARAM_ROUTINE_DESTROY_CARET:
98 Result = (DWORD_PTR)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread);
99 break;
100
101 case NOPARAM_ROUTINE_INIT_MESSAGE_PUMP:
102 Result = (DWORD_PTR)IntInitMessagePumpHook();
103 break;
104
105 case NOPARAM_ROUTINE_UNINIT_MESSAGE_PUMP:
106 Result = (DWORD_PTR)IntUninitMessagePumpHook();
107 break;
108
109 case NOPARAM_ROUTINE_GETMESSAGEEXTRAINFO:
110 Result = (DWORD_PTR)MsqGetMessageExtraInfo();
111 break;
112
113 case NOPARAM_ROUTINE_MSQCLEARWAKEMASK:
114 RETURN( (DWORD_PTR)IntMsqClearWakeMask());
115
116 default:
117 DPRINT1("Calling invalid routine number 0x%x in NtUserCallNoParam\n", Routine);
118 SetLastWin32Error(ERROR_INVALID_PARAMETER);
119 break;
120 }
121 RETURN(Result);
122
123 CLEANUP:
124 DPRINT("Leave NtUserCallNoParam, ret=%i\n",_ret_);
125 UserLeave();
126 END_CLEANUP;
127 }
128
129
130 /*
131 * @implemented
132 */
133 DWORD_PTR
134 APIENTRY
135 NtUserCallOneParam(
136 DWORD_PTR Param,
137 DWORD Routine)
138 {
139 DECLARE_RETURN(DWORD_PTR);
140
141 DPRINT("Enter NtUserCallOneParam\n");
142
143 UserEnterExclusive();
144
145 switch(Routine)
146 {
147 case ONEPARAM_ROUTINE_POSTQUITMESSAGE:
148 {
149 PTHREADINFO pti;
150 pti = PsGetCurrentThreadWin32Thread();
151 MsqPostQuitMessage(pti->MessageQueue, Param);
152 RETURN(TRUE);
153 }
154 case ONEPARAM_ROUTINE_SHOWCURSOR:
155 RETURN( (DWORD_PTR)UserShowCursor((BOOL)Param) );
156
157 case ONEPARAM_ROUTINE_GETDESKTOPMAPPING:
158 {
159 PTHREADINFO ti;
160 ti = GetW32ThreadInfo();
161 if (ti != NULL)
162 {
163 /* Try convert the pointer to a user mode pointer if the desktop is
164 mapped into the process */
165 RETURN((DWORD_PTR)DesktopHeapAddressToUser((PVOID)Param));
166 }
167 else
168 {
169 RETURN(0);
170 }
171 }
172
173 case ONEPARAM_ROUTINE_WINDOWFROMDC:
174 RETURN( (DWORD_PTR)IntWindowFromDC((HDC)Param));
175
176 case ONEPARAM_ROUTINE_SWAPMOUSEBUTTON:
177 {
178 DWORD_PTR Result;
179
180 Result = gspv.bMouseBtnSwap;
181 gspv.bMouseBtnSwap = Param ? TRUE : FALSE;
182 gpsi->aiSysMet[SM_SWAPBUTTON] = gspv.bMouseBtnSwap;
183 RETURN(Result);
184 }
185
186 case ONEPARAM_ROUTINE_SWITCHCARETSHOWING:
187 RETURN( (DWORD_PTR)IntSwitchCaretShowing((PVOID)Param));
188
189 case ONEPARAM_ROUTINE_SETCARETBLINKTIME:
190 RETURN( (DWORD_PTR)IntSetCaretBlinkTime((UINT)Param));
191
192 case ONEPARAM_ROUTINE_SETMESSAGEEXTRAINFO:
193 RETURN( (DWORD_PTR)MsqSetMessageExtraInfo((LPARAM)Param));
194
195 case ONEPARAM_ROUTINE_CREATEEMPTYCUROBJECT:
196 {
197 PCURICON_OBJECT CurIcon;
198 DWORD_PTR Result ;
199
200 if (!(CurIcon = IntCreateCurIconHandle()))
201 {
202 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
203 RETURN(0);
204 }
205
206 Result = (DWORD_PTR)CurIcon->Self;
207 UserDereferenceObject(CurIcon);
208 RETURN(Result);
209 }
210
211 case ONEPARAM_ROUTINE_GETCURSORPOSITION:
212 {
213 BOOL ret = TRUE;
214
215
216 _SEH2_TRY
217 {
218 ProbeForWrite((POINT*)Param,sizeof(POINT),1);
219 RtlCopyMemory((POINT*)Param,&gpsi->ptCursor,sizeof(POINT));
220 }
221 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
222 {
223 SetLastNtError(_SEH2_GetExceptionCode());
224 ret = FALSE;
225 }
226 _SEH2_END;
227
228 RETURN (ret);
229 }
230
231 case ONEPARAM_ROUTINE_ISWINDOWINDESTROY:
232 {
233 PWINDOW_OBJECT Window;
234 DWORD_PTR Result;
235
236 if(!(Window = UserGetWindowObject((HWND)Param)))
237 {
238 RETURN( FALSE);
239 }
240
241 Result = (DWORD_PTR)IntIsWindowInDestroy(Window);
242
243 RETURN( Result);
244 }
245
246 case ONEPARAM_ROUTINE_ENABLEPROCWNDGHSTING:
247 {
248 BOOL Enable;
249 PPROCESSINFO Process = PsGetCurrentProcessWin32Process();
250
251 if(Process != NULL)
252 {
253 Enable = (BOOL)(Param != 0);
254
255 if(Enable)
256 {
257 Process->W32PF_flags &= ~W32PF_NOWINDOWGHOSTING;
258 }
259 else
260 {
261 Process->W32PF_flags |= W32PF_NOWINDOWGHOSTING;
262 }
263
264 RETURN( TRUE);
265 }
266
267 RETURN( FALSE);
268 }
269
270 case ONEPARAM_ROUTINE_MSQSETWAKEMASK:
271 RETURN( (DWORD_PTR)IntMsqSetWakeMask(Param));
272
273 case ONEPARAM_ROUTINE_GETKEYBOARDTYPE:
274 RETURN( UserGetKeyboardType(Param));
275
276 case ONEPARAM_ROUTINE_GETKEYBOARDLAYOUT:
277 RETURN( (DWORD_PTR)UserGetKeyboardLayout(Param));
278
279 case ONEPARAM_ROUTINE_RELEASEDC:
280 RETURN (UserReleaseDC(NULL, (HDC) Param, FALSE));
281
282 case ONEPARAM_ROUTINE_REALIZEPALETTE:
283 RETURN (UserRealizePalette((HDC) Param));
284
285 case ONEPARAM_ROUTINE_GETQUEUESTATUS:
286 {
287 DWORD Ret;
288 WORD changed_bits, wake_bits;
289 Ret = IntGetQueueStatus(FALSE);
290 changed_bits = LOWORD(Ret);
291 wake_bits = HIWORD(Ret);
292 RETURN( MAKELONG(changed_bits & Param, wake_bits & Param));
293 }
294 case ONEPARAM_ROUTINE_ENUMCLIPBOARDFORMATS:
295 /* FIXME: Should use UserEnterShared */
296 RETURN(IntEnumClipboardFormats(Param));
297
298 case ONEPARAM_ROUTINE_CSRSS_GUICHECK:
299 IntUserManualGuiCheck(Param);
300 RETURN(TRUE);
301
302 case ONEPARAM_ROUTINE_GETCURSORPOS:
303 {
304 BOOL Ret = TRUE;
305 PPOINTL pptl;
306 PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
307 if (pti->hdesk != InputDesktopHandle) RETURN(FALSE);
308 _SEH2_TRY
309 {
310 pptl = (PPOINTL)Param;
311 *pptl = gpsi->ptCursor;
312 }
313 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
314 {
315 Ret = FALSE;
316 }
317 _SEH2_END;
318 RETURN(Ret);
319 }
320 }
321 DPRINT1("Calling invalid routine number 0x%x in NtUserCallOneParam(), Param=0x%x\n",
322 Routine, Param);
323 SetLastWin32Error(ERROR_INVALID_PARAMETER);
324 RETURN( 0);
325
326 CLEANUP:
327 DPRINT("Leave NtUserCallOneParam, ret=%i\n",_ret_);
328 UserLeave();
329 END_CLEANUP;
330 }
331
332
333 /*
334 * @implemented
335 */
336 DWORD_PTR
337 APIENTRY
338 NtUserCallTwoParam(
339 DWORD_PTR Param1,
340 DWORD_PTR Param2,
341 DWORD Routine)
342 {
343 NTSTATUS Status;
344 PWINDOW_OBJECT Window;
345 DECLARE_RETURN(DWORD_PTR);
346
347 DPRINT("Enter NtUserCallTwoParam\n");
348 UserEnterExclusive();
349
350 switch(Routine)
351 {
352 case TWOPARAM_ROUTINE_GETWINDOWRGNBOX:
353 {
354 DWORD_PTR Ret;
355 RECTL rcRect;
356 Window = UserGetWindowObject((HWND)Param1);
357 if (!Window) RETURN(ERROR);
358
359 Ret = (DWORD_PTR)IntGetWindowRgnBox(Window, &rcRect);
360 Status = MmCopyToCaller((PVOID)Param2, &rcRect, sizeof(RECT));
361 if(!NT_SUCCESS(Status))
362 {
363 SetLastNtError(Status);
364 RETURN( ERROR);
365 }
366 RETURN( Ret);
367 }
368 case TWOPARAM_ROUTINE_GETWINDOWRGN:
369 {
370 Window = UserGetWindowObject((HWND)Param1);
371 if (!Window) RETURN(ERROR);
372
373 RETURN( (DWORD_PTR)IntGetWindowRgn(Window, (HRGN)Param2));
374 }
375 case TWOPARAM_ROUTINE_SETMENUBARHEIGHT:
376 {
377 DWORD_PTR Ret;
378 PMENU_OBJECT MenuObject = IntGetMenuObject((HMENU)Param1);
379 if(!MenuObject)
380 RETURN( 0);
381
382 if(Param2 > 0)
383 {
384 Ret = (MenuObject->MenuInfo.Height == (int)Param2);
385 MenuObject->MenuInfo.Height = (int)Param2;
386 }
387 else
388 Ret = (DWORD_PTR)MenuObject->MenuInfo.Height;
389 IntReleaseMenuObject(MenuObject);
390 RETURN( Ret);
391 }
392
393 case TWOPARAM_ROUTINE_SETGUITHRDHANDLE:
394 {
395 PUSER_MESSAGE_QUEUE MsgQueue = ((PTHREADINFO)PsGetCurrentThread()->Tcb.Win32Thread)->MessageQueue;
396
397 ASSERT(MsgQueue);
398 RETURN( (DWORD_PTR)MsqSetStateWindow(MsgQueue, (ULONG)Param1, (HWND)Param2));
399 }
400
401 case TWOPARAM_ROUTINE_ENABLEWINDOW:
402 UNIMPLEMENTED
403 RETURN( 0);
404
405 case TWOPARAM_ROUTINE_SHOWOWNEDPOPUPS:
406 {
407 Window = UserGetWindowObject((HWND)Param1);
408 if (!Window) RETURN(0);
409
410 RETURN( (DWORD_PTR)IntShowOwnedPopups(Window, (BOOL) Param2));
411 }
412
413 case TWOPARAM_ROUTINE_ROS_UPDATEUISTATE:
414 {
415 WPARAM wParam;
416 Window = UserGetWindowObject((HWND)Param1);
417 if (!Window) RETURN(0);
418
419 /* Unpack wParam */
420 wParam = MAKEWPARAM((Param2 >> 3) & 0x3,
421 Param2 & (UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE));
422
423 RETURN( UserUpdateUiState(Window->Wnd, wParam) );
424 }
425
426 case TWOPARAM_ROUTINE_SWITCHTOTHISWINDOW:
427 UNIMPLEMENTED
428 RETURN( 0);
429
430
431 case TWOPARAM_ROUTINE_SETCARETPOS:
432 RETURN( (DWORD_PTR)co_IntSetCaretPos((int)Param1, (int)Param2));
433
434 case TWOPARAM_ROUTINE_REGISTERLOGONPROC:
435 RETURN( (DWORD_PTR)co_IntRegisterLogonProcess((HANDLE)Param1, (BOOL)Param2));
436
437 case TWOPARAM_ROUTINE_SETCURSORPOS:
438 RETURN( (DWORD_PTR)UserSetCursorPos((int)Param1, (int)Param2, FALSE));
439
440 }
441 DPRINT1("Calling invalid routine number 0x%x in NtUserCallTwoParam(), Param1=0x%x Parm2=0x%x\n",
442 Routine, Param1, Param2);
443 SetLastWin32Error(ERROR_INVALID_PARAMETER);
444 RETURN( 0);
445
446 CLEANUP:
447 DPRINT("Leave NtUserCallTwoParam, ret=%i\n",_ret_);
448 UserLeave();
449 END_CLEANUP;
450 }
451
452
453 /*
454 * @unimplemented
455 */
456 BOOL
457 APIENTRY
458 NtUserCallHwndLock(
459 HWND hWnd,
460 DWORD Routine)
461 {
462 BOOL Ret = 0;
463 PWINDOW_OBJECT Window;
464 PWND Wnd;
465 USER_REFERENCE_ENTRY Ref;
466 DECLARE_RETURN(BOOLEAN);
467
468 DPRINT("Enter NtUserCallHwndLock\n");
469 UserEnterExclusive();
470
471 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
472 {
473 RETURN( FALSE);
474 }
475 UserRefObjectCo(Window, &Ref);
476
477 Wnd = Window->Wnd;
478
479 /* FIXME: Routine can be 0x53 - 0x5E */
480 switch (Routine)
481 {
482 case HWNDLOCK_ROUTINE_ARRANGEICONICWINDOWS:
483 co_WinPosArrangeIconicWindows(Window);
484 break;
485
486 case HWNDLOCK_ROUTINE_DRAWMENUBAR:
487 {
488 DPRINT("HWNDLOCK_ROUTINE_DRAWMENUBAR\n");
489 Ret = TRUE;
490 if ((Wnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD)
491 co_WinPosSetWindowPos( Window,
492 HWND_DESKTOP,
493 0,0,0,0,
494 SWP_NOSIZE|
495 SWP_NOMOVE|
496 SWP_NOZORDER|
497 SWP_NOACTIVATE|
498 SWP_FRAMECHANGED );
499 break;
500 }
501
502 case HWNDLOCK_ROUTINE_REDRAWFRAME:
503 co_WinPosSetWindowPos( Window,
504 HWND_DESKTOP,
505 0,0,0,0,
506 SWP_NOSIZE|
507 SWP_NOMOVE|
508 SWP_NOZORDER|
509 SWP_NOACTIVATE|
510 SWP_FRAMECHANGED );
511 Ret = TRUE;
512 break;
513
514 case HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK:
515 co_WinPosSetWindowPos( Window,
516 HWND_DESKTOP,
517 0,0,0,0,
518 SWP_NOSIZE|
519 SWP_NOMOVE|
520 SWP_NOZORDER|
521 SWP_NOACTIVATE|
522 SWP_FRAMECHANGED );
523 if (!Window->spwndOwner && !IntGetParent(Window))
524 {
525 co_IntShellHookNotify(HSHELL_REDRAW, (LPARAM) hWnd);
526 }
527 Ret = TRUE;
528 break;
529
530 case HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOW:
531 Ret = co_IntSetForegroundWindow(Window);
532 break;
533
534 case HWNDLOCK_ROUTINE_UPDATEWINDOW:
535 Ret = co_UserRedrawWindow( Window, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);
536 break;
537 }
538
539 UserDerefObjectCo(Window);
540
541 RETURN( Ret);
542
543 CLEANUP:
544 DPRINT("Leave NtUserCallHwndLock, ret=%i\n",_ret_);
545 UserLeave();
546 END_CLEANUP;
547 }
548
549 /*
550 * @unimplemented
551 */
552 HWND
553 APIENTRY
554 NtUserCallHwndOpt(
555 HWND hWnd,
556 DWORD Routine)
557 {
558 switch (Routine)
559 {
560 case HWNDOPT_ROUTINE_SETPROGMANWINDOW:
561 GetW32ThreadInfo()->pDeskInfo->hProgmanWindow = hWnd;
562 break;
563
564 case HWNDOPT_ROUTINE_SETTASKMANWINDOW:
565 GetW32ThreadInfo()->pDeskInfo->hTaskManWindow = hWnd;
566 break;
567 }
568
569 return hWnd;
570 }
571
572 DWORD
573 APIENTRY
574 NtUserCallHwnd(
575 HWND hWnd,
576 DWORD Routine)
577 {
578 switch (Routine)
579 {
580 case HWND_ROUTINE_GETWNDCONTEXTHLPID:
581 {
582 PWINDOW_OBJECT Window;
583 PPROPERTY HelpId;
584 USER_REFERENCE_ENTRY Ref;
585
586 UserEnterExclusive();
587
588 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
589 {
590 UserLeave();
591 return 0;
592 }
593 UserRefObjectCo(Window, &Ref);
594
595 HelpId = IntGetProp(Window, gpsi->atomContextHelpIdProp);
596
597 UserDerefObjectCo(Window);
598 UserLeave();
599 return (DWORD)HelpId;
600 }
601 case HWND_ROUTINE_REGISTERSHELLHOOKWINDOW:
602 if (IntIsWindow(hWnd))
603 return IntRegisterShellHookWindow(hWnd);
604 return FALSE;
605 break;
606 case HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW:
607 if (IntIsWindow(hWnd))
608 return IntDeRegisterShellHookWindow(hWnd);
609 return FALSE;
610 }
611 UNIMPLEMENTED;
612
613 return 0;
614 }
615
616 DWORD
617 APIENTRY
618 NtUserCallHwndParam(
619 HWND hWnd,
620 DWORD Param,
621 DWORD Routine)
622 {
623
624 switch (Routine)
625 {
626 case HWNDPARAM_ROUTINE_KILLSYSTEMTIMER:
627 return IntKillTimer(hWnd, (UINT_PTR)Param, TRUE);
628
629 case HWNDPARAM_ROUTINE_SETWNDCONTEXTHLPID:
630 {
631 PWINDOW_OBJECT Window;
632
633 UserEnterExclusive();
634 if(!(Window = UserGetWindowObject(hWnd)))
635 {
636 UserLeave();
637 return FALSE;
638 }
639
640 if ( Param )
641 IntSetProp(Window, gpsi->atomContextHelpIdProp, (HANDLE)Param);
642 else
643 IntRemoveProp(Window, gpsi->atomContextHelpIdProp);
644
645 UserLeave();
646 return TRUE;
647 }
648
649 case HWNDPARAM_ROUTINE_SETDIALOGPOINTER:
650 {
651 PWINDOW_OBJECT Window;
652 PWND pWnd;
653 USER_REFERENCE_ENTRY Ref;
654
655 UserEnterExclusive();
656
657 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
658 {
659 UserLeave();
660 return 0;
661 }
662 UserRefObjectCo(Window, &Ref);
663
664 pWnd = Window->Wnd;
665 if (pWnd->head.pti->ppi == PsGetCurrentProcessWin32Process() &&
666 pWnd->cbwndExtra == DLGWINDOWEXTRA &&
667 !(pWnd->state & WNDS_SERVERSIDEWINDOWPROC))
668 {
669 if (Param)
670 {
671 if (!pWnd->fnid) pWnd->fnid = FNID_DIALOG;
672 pWnd->state |= WNDS_DIALOGWINDOW;
673 }
674 else
675 {
676 pWnd->fnid |= FNID_DESTROY;
677 pWnd->state &= ~WNDS_DIALOGWINDOW;
678 }
679 }
680
681 UserDerefObjectCo(Window);
682 UserLeave();
683 return 0;
684 }
685 }
686
687 UNIMPLEMENTED;
688
689 return 0;
690 }
691
692 DWORD
693 APIENTRY
694 NtUserCallHwndParamLock(
695 HWND hWnd,
696 DWORD Param,
697 DWORD Routine)
698 {
699 DWORD Ret = 0;
700 PWINDOW_OBJECT Window;
701 PWND Wnd;
702 USER_REFERENCE_ENTRY Ref;
703 DECLARE_RETURN(DWORD);
704
705 DPRINT1("Enter NtUserCallHwndParamLock\n");
706 UserEnterExclusive();
707
708 if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
709 {
710 RETURN( FALSE);
711 }
712 UserRefObjectCo(Window, &Ref);
713
714 Wnd = Window->Wnd;
715
716 switch (Routine)
717 {
718 case TWOPARAM_ROUTINE_VALIDATERGN:
719 Ret = (DWORD)co_UserRedrawWindow( Window, NULL, (HRGN)Param, RDW_VALIDATE);
720 break;
721 }
722
723 UserDerefObjectCo(Window);
724
725 RETURN( Ret);
726
727 CLEANUP:
728 DPRINT1("Leave NtUserCallHwndParamLock, ret=%i\n",_ret_);
729 UserLeave();
730 END_CLEANUP;
731
732 }
733
734 /* EOF */