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_CREATECURICONHANDLE:
 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 */