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