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