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