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