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