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