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
  78 APIENTRY
  79 NtUserCallNoParam(DWORD Routine)
  80 {
  81    DWORD Result = 0;
  82    DECLARE_RETURN(DWORD);
  83
  84    DPRINT("Enter NtUserCallNoParam\n");
  85    UserEnterExclusive();
  86
  87    switch(Routine)
  88    {
  89       case NOPARAM_ROUTINE_CREATEMENU:
  90          Result = (DWORD)UserCreateMenu(FALSE);
  91          break;
  92
  93       case NOPARAM_ROUTINE_CREATEMENUPOPUP:
  94          Result = (DWORD)UserCreateMenu(TRUE);
  95          break;
  96
  97       case NOPARAM_ROUTINE_DESTROY_CARET:
  98          Result = (DWORD)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread);
  99          break;
 100
 101       case NOPARAM_ROUTINE_INIT_MESSAGE_PUMP:
 102          Result = (DWORD)IntInitMessagePumpHook();
 103          break;
 104
 105       case NOPARAM_ROUTINE_UNINIT_MESSAGE_PUMP:
 106          Result = (DWORD)IntUninitMessagePumpHook();
 107          break;
 108
 109       case NOPARAM_ROUTINE_GETMESSAGEEXTRAINFO:
 110          Result = (DWORD)MsqGetMessageExtraInfo();
 111          break;
 112
 113       case NOPARAM_ROUTINE_ANYPOPUP:
 114          Result = (DWORD)IntAnyPopup();
 115          break;
 116
 117       case NOPARAM_ROUTINE_CSRSS_INITIALIZED:
 118          Result = (DWORD)CsrInit();
 119          break;
 120
 121       case NOPARAM_ROUTINE_MSQCLEARWAKEMASK:
 122          RETURN( (DWORD)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
 142 APIENTRY
 143 NtUserCallOneParam(
 144    DWORD Param,
 145    DWORD Routine)
 146 {
 147    DECLARE_RETURN(DWORD);
 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)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)DesktopHeapAddressToUser((PVOID)Param));
 174              }
 175              else
 176              {
 177                 RETURN(0);
 178              }
 179          }
 180
 181       case ONEPARAM_ROUTINE_WINDOWFROMDC:
 182          RETURN( (DWORD)IntWindowFromDC((HDC)Param));
 183
 184       case ONEPARAM_ROUTINE_SWAPMOUSEBUTTON:
 185          {
 186             DWORD 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)IntSwitchCaretShowing((PVOID)Param));
 196
 197       case ONEPARAM_ROUTINE_SETCARETBLINKTIME:
 198          RETURN( (DWORD)IntSetCaretBlinkTime((UINT)Param));
 199
 200       case ONEPARAM_ROUTINE_SETMESSAGEEXTRAINFO:
 201          RETURN( (DWORD)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)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 Result;
 240
 241             if(!(Window = UserGetWindowObject((HWND)Param)))
 242             {
 243                RETURN( FALSE);
 244             }
 245
 246             Result = (DWORD)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)IntMsqSetWakeMask(Param));
 277
 278       case ONEPARAM_ROUTINE_GETKEYBOARDTYPE:
 279          RETURN( UserGetKeyboardType(Param));
 280
 281       case ONEPARAM_ROUTINE_GETKEYBOARDLAYOUT:
 282          RETURN( (DWORD)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
 342 APIENTRY
 343 NtUserCallTwoParam(
 344    DWORD Param1,
 345    DWORD Param2,
 346    DWORD Routine)
 347 {
 348    NTSTATUS Status;
 349    PWINDOW_OBJECT Window;
 350    DECLARE_RETURN(DWORD);
 351
 352    DPRINT("Enter NtUserCallTwoParam\n");
 353    UserEnterExclusive();
 354
 355    switch(Routine)
 356    {
 357       case TWOPARAM_ROUTINE_GETWINDOWRGNBOX:
 358          {
 359             DWORD Ret;
 360             RECTL rcRect;
 361             Window = UserGetWindowObject((HWND)Param1);
 362             if (!Window) RETURN(ERROR);
 363
 364             Ret = (DWORD)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)IntGetWindowRgn(Window, (HRGN)Param2));
 379          }
 380       case TWOPARAM_ROUTINE_SETMENUBARHEIGHT:
 381          {
 382             DWORD 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)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)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)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)co_IntSetCaretPos((int)Param1, (int)Param2));
 438
 439       case TWOPARAM_ROUTINE_REGISTERLOGONPROC:
 440          RETURN( (DWORD)co_IntRegisterLogonProcess((HANDLE)Param1, (BOOL)Param2));
 441    }
 442    DPRINT1("Calling invalid routine number 0x%x in NtUserCallTwoParam(), Param1=0x%x Parm2=0x%x\n",
 443            Routine, Param1, Param2);
 444    SetLastWin32Error(ERROR_INVALID_PARAMETER);
 445    RETURN( 0);
 446
 447 CLEANUP:
 448    DPRINT("Leave NtUserCallTwoParam, ret=%i\n",_ret_);
 449    UserLeave();
 450    END_CLEANUP;
 451 }
 452
 453
 454 /*
 455  * @unimplemented
 456  */
 457 BOOL
 458 APIENTRY
 459 NtUserCallHwndLock(
 460    HWND hWnd,
 461    DWORD Routine)
 462 {
 463    BOOL Ret = 0;
 464    PWINDOW_OBJECT Window;
 465    PWND Wnd;
 466    USER_REFERENCE_ENTRY Ref;
 467    DECLARE_RETURN(BOOLEAN);
 468
 469    DPRINT("Enter NtUserCallHwndLock\n");
 470    UserEnterExclusive();
 471
 472    if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
 473    {
 474       RETURN( FALSE);
 475    }
 476    UserRefObjectCo(Window, &Ref);
 477
 478    Wnd = Window->Wnd;
 479
 480    /* FIXME: Routine can be 0x53 - 0x5E */
 481    switch (Routine)
 482    {
 483       case HWNDLOCK_ROUTINE_ARRANGEICONICWINDOWS:
 484          co_WinPosArrangeIconicWindows(Window);
 485          break;
 486
 487       case HWNDLOCK_ROUTINE_DRAWMENUBAR:
 488          {
 489             PMENU_OBJECT Menu;
 490             DPRINT("HWNDLOCK_ROUTINE_DRAWMENUBAR\n");
 491             Ret = FALSE;
 492             if (!((Wnd->style & (WS_CHILD | WS_POPUP)) != WS_CHILD))
 493                break;
 494
 495             if(!(Menu = UserGetMenuObject((HMENU) Wnd->IDMenu)))
 496                break;
 497
 498             Menu->MenuInfo.WndOwner = hWnd;
 499             Menu->MenuInfo.Height = 0;
 500
 501             co_WinPosSetWindowPos( Window,
 502                                    HWND_DESKTOP,
 503                                    0,0,0,0,
 504                                    SWP_NOSIZE|
 505                                    SWP_NOMOVE|
 506                                    SWP_NOZORDER|
 507                                    SWP_NOACTIVATE|
 508                                    SWP_FRAMECHANGED );
 509
 510             Ret = TRUE;
 511             break;
 512          }
 513
 514       case HWNDLOCK_ROUTINE_REDRAWFRAME:
 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          Ret = TRUE;
 524          break;
 525
 526       case HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK:
 527          co_WinPosSetWindowPos( Window,
 528                                 HWND_DESKTOP,
 529                                 0,0,0,0,
 530                                 SWP_NOSIZE|
 531                                 SWP_NOMOVE|
 532                                 SWP_NOZORDER|
 533                                 SWP_NOACTIVATE|
 534                                 SWP_FRAMECHANGED );
 535          if (!IntGetOwner(Window) && !IntGetParent(Window))
 536          {
 537             co_IntShellHookNotify(HSHELL_REDRAW, (LPARAM) hWnd);
 538          }
 539          Ret = TRUE;
 540          break;
 541
 542       case HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOW:
 543          Ret = co_IntSetForegroundWindow(Window);
 544          break;
 545
 546       case HWNDLOCK_ROUTINE_UPDATEWINDOW:
 547          Ret = co_UserRedrawWindow( Window, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);
 548          break;
 549    }
 550
 551    UserDerefObjectCo(Window);
 552
 553    RETURN( Ret);
 554
 555 CLEANUP:
 556    DPRINT("Leave NtUserCallHwndLock, ret=%i\n",_ret_);
 557    UserLeave();
 558    END_CLEANUP;
 559 }
 560
 561 /*
 562  * @unimplemented
 563  */
 564 HWND
 565 APIENTRY
 566 NtUserCallHwndOpt(
 567    HWND hWnd,
 568    DWORD Routine)
 569 {
 570    switch (Routine)
 571    {
 572       case HWNDOPT_ROUTINE_SETPROGMANWINDOW:
 573          GetW32ThreadInfo()->pDeskInfo->hProgmanWindow = hWnd;
 574          break;
 575
 576       case HWNDOPT_ROUTINE_SETTASKMANWINDOW:
 577          GetW32ThreadInfo()->pDeskInfo->hTaskManWindow = hWnd;
 578          break;
 579    }
 580
 581    return hWnd;
 582 }
 583
 584 DWORD
 585 APIENTRY
 586 NtUserCallHwnd(
 587    HWND hWnd,
 588    DWORD Routine)
 589 {
 590    switch (Routine)
 591    {
 592       case HWND_ROUTINE_GETWNDCONTEXTHLPID:
 593       {
 594          PWINDOW_OBJECT Window;
 595          PPROPERTY HelpId;
 596          USER_REFERENCE_ENTRY Ref;
 597
 598          UserEnterExclusive();
 599
 600          if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
 601          {
 602             UserLeave();
 603             return 0;
 604          }
 605          UserRefObjectCo(Window, &Ref);
 606
 607          HelpId = IntGetProp(Window, gpsi->atomContextHelpIdProp);
 608
 609          UserDerefObjectCo(Window);
 610          UserLeave();
 611          return (DWORD)HelpId;
 612       }
 613       case HWND_ROUTINE_REGISTERSHELLHOOKWINDOW:
 614          if (IntIsWindow(hWnd))
 615             return IntRegisterShellHookWindow(hWnd);
 616          return FALSE;
 617          break;
 618       case HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW:
 619          if (IntIsWindow(hWnd))
 620             return IntDeRegisterShellHookWindow(hWnd);
 621          return FALSE;
 622    }
 623    UNIMPLEMENTED;
 624
 625    return 0;
 626 }
 627
 628 DWORD
 629 APIENTRY
 630 NtUserCallHwndParam(
 631    HWND hWnd,
 632    DWORD Param,
 633    DWORD Routine)
 634 {
 635
 636    switch (Routine)
 637    {
 638       case HWNDPARAM_ROUTINE_KILLSYSTEMTIMER:
 639           return IntKillTimer(hWnd, (UINT_PTR)Param, TRUE);
 640
 641       case HWNDPARAM_ROUTINE_SETWNDCONTEXTHLPID:
 642       {
 643          PWINDOW_OBJECT Window;
 644
 645          UserEnterExclusive();
 646          if(!(Window = UserGetWindowObject(hWnd)))
 647          {
 648             UserLeave();
 649             return FALSE;
 650          }
 651
 652          if ( Param )
 653             IntSetProp(Window, gpsi->atomContextHelpIdProp, (HANDLE)Param);
 654          else
 655             IntRemoveProp(Window, gpsi->atomContextHelpIdProp);
 656
 657          UserLeave();
 658          return TRUE;
 659       }
 660
 661       case HWNDPARAM_ROUTINE_SETDIALOGPOINTER:
 662       {
 663          PWINDOW_OBJECT Window;
 664          PWND pWnd;
 665          USER_REFERENCE_ENTRY Ref;
 666
 667          UserEnterExclusive();
 668
 669          if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
 670          {
 671             UserLeave();
 672             return 0;
 673          }
 674          UserRefObjectCo(Window, &Ref);
 675
 676          pWnd = Window->Wnd;
 677          if (pWnd->head.pti->ppi == PsGetCurrentProcessWin32Process() &&
 678              pWnd->cbwndExtra == DLGWINDOWEXTRA &&
 679              !(pWnd->state & WNDS_SERVERSIDEWINDOWPROC))
 680          {
 681             if (Param)
 682             {
 683                if (!pWnd->fnid) pWnd->fnid = FNID_DIALOG;
 684                pWnd->state |= WNDS_DIALOGWINDOW;
 685             }
 686             else
 687             {
 688                pWnd->fnid |= FNID_DESTROY;
 689                pWnd->state &= ~WNDS_DIALOGWINDOW;
 690             }
 691          }
 692
 693          UserDerefObjectCo(Window);
 694          UserLeave();
 695          return 0;
 696       }
 697    }
 698
 699    UNIMPLEMENTED;
 700
 701    return 0;
 702 }
 703
 704 DWORD
 705 APIENTRY
 706 NtUserCallHwndParamLock(
 707    HWND hWnd,
 708    DWORD Param,
 709    DWORD Routine)
 710 {
 711    UNIMPLEMENTED;
 712
 713    return 0;
 714 }
 715
 716 /* EOF */