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