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