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