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