reactos/subsystems/win32/win32k/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  * REVISION HISTORY:
   8  *       2008/03/20  Split from misc.c
   9  */
  10
  11 #include <w32k.h>
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16
  17 /* registered Logon process */
  18 PW32PROCESS LogonProcess = NULL;
  19
  20 BOOL FASTCALL
  21 co_IntRegisterLogonProcess(HANDLE ProcessId, BOOL Register)
  22 {
  23    PEPROCESS Process;
  24    NTSTATUS Status;
  25    CSR_API_MESSAGE Request;
  26
  27    Status = PsLookupProcessByProcessId(ProcessId,
  28                                        &Process);
  29    if (!NT_SUCCESS(Status))
  30    {
  31       SetLastWin32Error(RtlNtStatusToDosError(Status));
  32       return FALSE;
  33    }
  34
  35    if (Register)
  36    {
  37       /* Register the logon process */
  38       if (LogonProcess != NULL)
  39       {
  40          ObDereferenceObject(Process);
  41          return FALSE;
  42       }
  43
  44       LogonProcess = (PW32PROCESS)Process->Win32Process;
  45    }
  46    else
  47    {
  48       /* Deregister the logon process */
  49       if (LogonProcess != (PW32PROCESS)Process->Win32Process)
  50       {
  51          ObDereferenceObject(Process);
  52          return FALSE;
  53       }
  54
  55       LogonProcess = NULL;
  56    }
  57
  58    ObDereferenceObject(Process);
  59
  60    Request.Type = MAKE_CSR_API(REGISTER_LOGON_PROCESS, CSR_GUI);
  61    Request.Data.RegisterLogonProcessRequest.ProcessId = ProcessId;
  62    Request.Data.RegisterLogonProcessRequest.Register = Register;
  63
  64    Status = co_CsrNotify(&Request);
  65    if (! NT_SUCCESS(Status))
  66    {
  67       DPRINT1("Failed to register logon process with CSRSS\n");
  68       return FALSE;
  69    }
  70
  71    return TRUE;
  72 }
  73
  74 /*
  75  * @unimplemented
  76  */
  77 DWORD_PTR
  78 APIENTRY
  79 NtUserCallNoParam(DWORD Routine)
  80 {
  81    DWORD_PTR Result = 0;
  82    DECLARE_RETURN(DWORD_PTR);
  83
  84    DPRINT("Enter NtUserCallNoParam\n");
  85    UserEnterExclusive();
  86
  87    switch(Routine)
  88    {
  89       case NOPARAM_ROUTINE_CREATEMENU:
  90          Result = (DWORD_PTR)UserCreateMenu(FALSE);
  91          break;
  92
  93       case NOPARAM_ROUTINE_CREATEMENUPOPUP:
  94          Result = (DWORD_PTR)UserCreateMenu(TRUE);
  95          break;
  96
  97       case NOPARAM_ROUTINE_DESTROY_CARET:
  98          Result = (DWORD_PTR)co_IntDestroyCaret(PsGetCurrentThread()->Tcb.Win32Thread);
  99          break;
 100
 101       case NOPARAM_ROUTINE_INIT_MESSAGE_PUMP:
 102          Result = (DWORD_PTR)IntInitMessagePumpHook();
 103          break;
 104
 105       case NOPARAM_ROUTINE_UNINIT_MESSAGE_PUMP:
 106          Result = (DWORD_PTR)IntUninitMessagePumpHook();
 107          break;
 108
 109       case NOPARAM_ROUTINE_GETMESSAGEEXTRAINFO:
 110          Result = (DWORD_PTR)MsqGetMessageExtraInfo();
 111          break;
 112
 113       case NOPARAM_ROUTINE_ANYPOPUP:
 114          Result = (DWORD_PTR)IntAnyPopup();
 115          break;
 116
 117       case NOPARAM_ROUTINE_CSRSS_INITIALIZED:
 118          Result = (DWORD_PTR)CsrInit();
 119          break;
 120
 121       case NOPARAM_ROUTINE_MSQCLEARWAKEMASK:
 122          RETURN( (DWORD_PTR)IntMsqClearWakeMask());
 123
 124       default:
 125          DPRINT1("Calling invalid routine number 0x%x in NtUserCallNoParam\n", Routine);
 126          SetLastWin32Error(ERROR_INVALID_PARAMETER);
 127          break;
 128    }
 129    RETURN(Result);
 130
 131 CLEANUP:
 132    DPRINT("Leave NtUserCallNoParam, ret=%i\n",_ret_);
 133    UserLeave();
 134    END_CLEANUP;
 135 }
 136
 137
 138 /*
 139  * @implemented
 140  */
 141 DWORD_PTR
 142 APIENTRY
 143 NtUserCallOneParam(
 144    DWORD Param,
 145    DWORD Routine)
 146 {
 147    DECLARE_RETURN(DWORD_PTR);
 148
 149    DPRINT("Enter NtUserCallOneParam\n");
 150
 151    UserEnterExclusive();
 152
 153    switch(Routine)
 154    {
 155       case ONEPARAM_ROUTINE_POSTQUITMESSAGE:
 156           {
 157                 PTHREADINFO pti;
 158                 pti = PsGetCurrentThreadWin32Thread();
 159                 MsqPostQuitMessage(pti->MessageQueue, Param);
 160                 RETURN(TRUE);
 161           }
 162       case ONEPARAM_ROUTINE_SHOWCURSOR:
 163          RETURN( (DWORD_PTR)UserShowCursor((BOOL)Param) );
 164
 165       case ONEPARAM_ROUTINE_GETDESKTOPMAPPING:
 166          {
 167              PW32THREADINFO ti;
 168              ti = GetW32ThreadInfo();
 169              if (ti != NULL)
 170              {
 171                 /* Try convert the pointer to a user mode pointer if the desktop is
 172                    mapped into the process */
 173                 RETURN((DWORD_PTR)DesktopHeapAddressToUser((PVOID)Param));
 174              }
 175              else
 176              {
 177                 RETURN(0);
 178              }
 179          }
 180
 181       case ONEPARAM_ROUTINE_GETMENU:
 182          {
 183             PWINDOW_OBJECT Window;
 184             DWORD_PTR Result;
 185
 186             if(!(Window = UserGetWindowObject((HWND)Param)))
 187             {
 188                RETURN( FALSE);
 189             }
 190
 191             Result = Window->Wnd->IDMenu;
 192
 193             RETURN( Result);
 194          }
 195
 196       case ONEPARAM_ROUTINE_ISWINDOWUNICODE:
 197          {
 198             PWINDOW_OBJECT Window;
 199             DWORD_PTR Result;
 200
 201             Window = UserGetWindowObject((HWND)Param);
 202             if(!Window)
 203             {
 204                RETURN( FALSE);
 205             }
 206             Result = Window->Wnd->Unicode;
 207             RETURN( Result);
 208          }
 209
 210       case ONEPARAM_ROUTINE_WINDOWFROMDC:
 211          RETURN( (DWORD_PTR)IntWindowFromDC((HDC)Param));
 212
 213       case ONEPARAM_ROUTINE_GETWNDCONTEXTHLPID:
 214          {
 215             PWINDOW_OBJECT Window;
 216             DWORD_PTR Result;
 217
 218             Window = UserGetWindowObject((HWND)Param);
 219             if(!Window)
 220             {
 221                RETURN( FALSE);
 222             }
 223
 224             Result = Window->Wnd->ContextHelpId;
 225
 226             RETURN( Result);
 227          }
 228
 229       case ONEPARAM_ROUTINE_SWAPMOUSEBUTTON:
 230          {
 231             PWINSTATION_OBJECT WinSta;
 232             NTSTATUS Status;
 233             DWORD_PTR Result;
 234
 235             Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
 236                                                     KernelMode,
 237                                                     0,
 238                                                     &WinSta);
 239             if (!NT_SUCCESS(Status))
 240                RETURN( (DWORD_PTR)FALSE);
 241
 242             /* FIXME
 243             Result = (DWORD_PTR)IntSwapMouseButton(WinStaObject, (BOOL)Param); */
 244             Result = 0;
 245
 246             ObDereferenceObject(WinSta);
 247             RETURN( Result);
 248          }
 249
 250       case ONEPARAM_ROUTINE_SWITCHCARETSHOWING:
 251          RETURN( (DWORD_PTR)IntSwitchCaretShowing((PVOID)Param));
 252
 253       case ONEPARAM_ROUTINE_SETCARETBLINKTIME:
 254          RETURN( (DWORD_PTR)IntSetCaretBlinkTime((UINT)Param));
 255
 256       case ONEPARAM_ROUTINE_GETWINDOWINSTANCE:
 257          {
 258             PWINDOW_OBJECT Window;
 259             DWORD Result;
 260
 261             if(!(Window = UserGetWindowObject((HWND)Param)))
 262             {
 263                RETURN( FALSE);
 264             }
 265
 266             Result = (DWORD_PTR)Window->Wnd->Instance;
 267             RETURN( Result);
 268          }
 269
 270       case ONEPARAM_ROUTINE_SETMESSAGEEXTRAINFO:
 271          RETURN( (DWORD_PTR)MsqSetMessageExtraInfo((LPARAM)Param));
 272
 273       case ONEPARAM_ROUTINE_CREATECURICONHANDLE:
 274          {
 275             PCURICON_OBJECT CurIcon;
 276             PWINSTATION_OBJECT WinSta;
 277
 278             WinSta = IntGetWinStaObj();
 279             if(WinSta == NULL)
 280             {
 281                RETURN(0);
 282             }
 283
 284             if (!(CurIcon = IntCreateCurIconHandle(WinSta)))
 285             {
 286                SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
 287                ObDereferenceObject(WinSta);
 288                RETURN(0);
 289             }
 290
 291             ObDereferenceObject(WinSta);
 292             RETURN((DWORD_PTR)CurIcon->Self);
 293          }
 294
 295       case ONEPARAM_ROUTINE_GETCURSORPOSITION:
 296          {
 297             PWINSTATION_OBJECT WinSta;
 298             NTSTATUS Status;
 299             POINT Pos;
 300
 301             if(!Param)
 302                RETURN( (DWORD_PTR)FALSE);
 303             Status = IntValidateWindowStationHandle(PsGetCurrentProcess()->Win32WindowStation,
 304                                                     KernelMode,
 305                                                     0,
 306                                                     &WinSta);
 307             if (!NT_SUCCESS(Status))
 308                RETURN( (DWORD_PTR)FALSE);
 309
 310             /* FIXME - check if process has WINSTA_READATTRIBUTES */
 311             IntGetCursorLocation(WinSta, &Pos);
 312
 313             Status = MmCopyToCaller((PPOINT)Param, &Pos, sizeof(POINT));
 314             if(!NT_SUCCESS(Status))
 315             {
 316                ObDereferenceObject(WinSta);
 317                SetLastNtError(Status);
 318                RETURN( FALSE);
 319             }
 320
 321             ObDereferenceObject(WinSta);
 322
 323             RETURN( (DWORD_PTR)TRUE);
 324          }
 325
 326       case ONEPARAM_ROUTINE_ISWINDOWINDESTROY:
 327          {
 328             PWINDOW_OBJECT Window;
 329             DWORD_PTR Result;
 330
 331             if(!(Window = UserGetWindowObject((HWND)Param)))
 332             {
 333                RETURN( FALSE);
 334             }
 335
 336             Result = (DWORD_PTR)IntIsWindowInDestroy(Window);
 337
 338             RETURN( Result);
 339          }
 340
 341       case ONEPARAM_ROUTINE_ENABLEPROCWNDGHSTING:
 342          {
 343             BOOL Enable;
 344             PW32PROCESS Process = PsGetCurrentProcessWin32Process();
 345
 346             if(Process != NULL)
 347             {
 348                Enable = (BOOL)(Param != 0);
 349
 350                if(Enable)
 351                {
 352                   Process->W32PF_flags &= ~W32PF_NOWINDOWGHOSTING;
 353                }
 354                else
 355                {
 356                   Process->W32PF_flags |= W32PF_NOWINDOWGHOSTING;
 357                }
 358
 359                RETURN( TRUE);
 360             }
 361
 362             RETURN( FALSE);
 363          }
 364
 365       case ONEPARAM_ROUTINE_MSQSETWAKEMASK:
 366          RETURN( (DWORD_PTR)IntMsqSetWakeMask(Param));
 367
 368       case ONEPARAM_ROUTINE_GETKEYBOARDTYPE:
 369          RETURN( UserGetKeyboardType(Param));
 370
 371       case ONEPARAM_ROUTINE_GETKEYBOARDLAYOUT:
 372          RETURN( (DWORD_PTR)UserGetKeyboardLayout(Param));
 373
 374       case ONEPARAM_ROUTINE_REGISTERUSERMODULE:
 375       {
 376           PW32THREADINFO ti;
 377
 378           ti = GetW32ThreadInfo();
 379           if (ti == NULL)
 380           {
 381               DPRINT1("Cannot register user32 module instance!\n");
 382               SetLastWin32Error(ERROR_INVALID_PARAMETER);
 383               RETURN(FALSE);
 384           }
 385
 386           if (InterlockedCompareExchangePointer(&ti->ppi->hModUser,
 387                                                 (HINSTANCE)Param,
 388                                                 NULL) == NULL)
 389           {
 390               RETURN(TRUE);
 391           }
 392       }
 393       case ONEPARAM_ROUTINE_RELEASEDC:
 394          RETURN (UserReleaseDC(NULL, (HDC) Param, FALSE));
 395
 396       case ONEPARAM_ROUTINE_REALIZEPALETTE:
 397          RETURN (UserRealizePalette((HDC) Param));
 398
 399       case ONEPARAM_ROUTINE_GETQUEUESTATUS:
 400       {
 401          DWORD Ret;
 402          WORD changed_bits, wake_bits;
 403          Ret = IntGetQueueStatus(FALSE);
 404          changed_bits = LOWORD(Ret);
 405          wake_bits = HIWORD(Ret);
 406          RETURN( MAKELONG(changed_bits & Param, wake_bits & Param));
 407       }
 408       case ONEPARAM_ROUTINE_ENUMCLIPBOARDFORMATS:
 409          /* FIXME: Should use UserEnterShared */
 410          RETURN(IntEnumClipboardFormats(Param));
 411
 412       case ONEPARAM_ROUTINE_CSRSS_GUICHECK:
 413           IntUserManualGuiCheck(Param);
 414           RETURN(TRUE);
 415
 416       case ONEPARAM_ROUTINE_GETCURSORPOS:
 417       {
 418           BOOL Ret = TRUE;
 419           PPOINTL pptl;
 420           PTHREADINFO pti = PsGetCurrentThreadWin32Thread();
 421           if (pti->hDesktop != InputDesktopHandle) RETURN(FALSE);
 422           _SEH2_TRY
 423           {
 424              pptl = (PPOINTL)Param;
 425              *pptl = gpsi->ptCursor;
 426           }
 427           _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 428           {
 429              Ret = FALSE;
 430           }
 431           _SEH2_END;
 432           RETURN(Ret);
 433       }
 434    }
 435    DPRINT1("Calling invalid routine number 0x%x in NtUserCallOneParam(), Param=0x%x\n",
 436            Routine, Param);
 437    SetLastWin32Error(ERROR_INVALID_PARAMETER);
 438    RETURN( 0);
 439
 440 CLEANUP:
 441    DPRINT("Leave NtUserCallOneParam, ret=%i\n",_ret_);
 442    UserLeave();
 443    END_CLEANUP;
 444 }
 445
 446
 447 /*
 448  * @implemented
 449  */
 450 DWORD_PTR
 451 APIENTRY
 452 NtUserCallTwoParam(
 453    DWORD Param1,
 454    DWORD Param2,
 455    DWORD Routine)
 456 {
 457    NTSTATUS Status;
 458    PWINDOW_OBJECT Window;
 459    DECLARE_RETURN(DWORD_PTR);
 460
 461    DPRINT("Enter NtUserCallTwoParam\n");
 462    UserEnterExclusive();
 463
 464    switch(Routine)
 465    {
 466       case TWOPARAM_ROUTINE_GETWINDOWRGNBOX:
 467          {
 468             DWORD_PTR Ret;
 469             RECTL rcRect;
 470             Window = UserGetWindowObject((HWND)Param1);
 471             if (!Window) RETURN(ERROR);
 472
 473             Ret = (DWORD_PTR)IntGetWindowRgnBox(Window, &rcRect);
 474             Status = MmCopyToCaller((PVOID)Param2, &rcRect, sizeof(RECT));
 475             if(!NT_SUCCESS(Status))
 476             {
 477                SetLastNtError(Status);
 478                RETURN( ERROR);
 479             }
 480             RETURN( Ret);
 481          }
 482       case TWOPARAM_ROUTINE_GETWINDOWRGN:
 483          {
 484             Window = UserGetWindowObject((HWND)Param1);
 485             if (!Window) RETURN(ERROR);
 486
 487             RETURN( (DWORD_PTR)IntGetWindowRgn(Window, (HRGN)Param2));
 488          }
 489       case TWOPARAM_ROUTINE_SETMENUBARHEIGHT:
 490          {
 491             DWORD_PTR Ret;
 492             PMENU_OBJECT MenuObject = IntGetMenuObject((HMENU)Param1);
 493             if(!MenuObject)
 494                RETURN( 0);
 495
 496             if(Param2 > 0)
 497             {
 498                Ret = (MenuObject->MenuInfo.Height == (int)Param2);
 499                MenuObject->MenuInfo.Height = (int)Param2;
 500             }
 501             else
 502                Ret = (DWORD_PTR)MenuObject->MenuInfo.Height;
 503             IntReleaseMenuObject(MenuObject);
 504             RETURN( Ret);
 505          }
 506       case TWOPARAM_ROUTINE_SETMENUITEMRECT:
 507          {
 508             BOOL Ret;
 509             SETMENUITEMRECT smir;
 510             PMENU_OBJECT MenuObject = IntGetMenuObject((HMENU)Param1);
 511             if(!MenuObject)
 512                RETURN( 0);
 513
 514             if(!NT_SUCCESS(MmCopyFromCaller(&smir, (PVOID)Param2, sizeof(SETMENUITEMRECT))))
 515             {
 516                IntReleaseMenuObject(MenuObject);
 517                RETURN( 0);
 518             }
 519
 520             Ret = IntSetMenuItemRect(MenuObject, smir.uItem, smir.fByPosition, &smir.rcRect);
 521
 522             IntReleaseMenuObject(MenuObject);
 523             RETURN( (DWORD_PTR)Ret);
 524          }
 525
 526       case TWOPARAM_ROUTINE_SETGUITHRDHANDLE:
 527          {
 528             PUSER_MESSAGE_QUEUE MsgQueue = ((PTHREADINFO)PsGetCurrentThread()->Tcb.Win32Thread)->MessageQueue;
 529
 530             ASSERT(MsgQueue);
 531             RETURN( (DWORD_PTR)MsqSetStateWindow(MsgQueue, (ULONG)Param1, (HWND)Param2));
 532          }
 533
 534       case TWOPARAM_ROUTINE_ENABLEWINDOW:
 535          UNIMPLEMENTED
 536          RETURN( 0);
 537
 538       case TWOPARAM_ROUTINE_SHOWOWNEDPOPUPS:
 539       {
 540          Window = UserGetWindowObject((HWND)Param1);
 541          if (!Window) RETURN(0);
 542
 543          RETURN( (DWORD_PTR)IntShowOwnedPopups(Window, (BOOL) Param2));
 544       }
 545
 546       case TWOPARAM_ROUTINE_ROS_UPDATEUISTATE:
 547       {
 548           WPARAM wParam;
 549           Window = UserGetWindowObject((HWND)Param1);
 550           if (!Window) RETURN(0);
 551
 552           /* Unpack wParam */
 553           wParam = MAKEWPARAM((Param2 >> 3) & 0x3,
 554                               Param2 & (UISF_HIDEFOCUS | UISF_HIDEACCEL | UISF_ACTIVE));
 555
 556           RETURN( UserUpdateUiState(Window->Wnd, wParam) );
 557       }
 558
 559       case TWOPARAM_ROUTINE_SWITCHTOTHISWINDOW:
 560          UNIMPLEMENTED
 561          RETURN( 0);
 562
 563       case TWOPARAM_ROUTINE_SETWNDCONTEXTHLPID:
 564
 565          if(!(Window = UserGetWindowObject((HWND)Param1)))
 566          {
 567             RETURN( (DWORD_PTR)FALSE);
 568          }
 569
 570          Window->Wnd->ContextHelpId = Param2;
 571
 572          RETURN( (DWORD_PTR)TRUE);
 573
 574       case TWOPARAM_ROUTINE_SETCARETPOS:
 575          RETURN( (DWORD_PTR)co_IntSetCaretPos((int)Param1, (int)Param2));
 576
 577       case TWOPARAM_ROUTINE_GETWINDOWINFO:
 578          {
 579             WINDOWINFO wi;
 580             DWORD_PTR Ret;
 581
 582             if(!(Window = UserGetWindowObject((HWND)Param1)))
 583             {
 584                RETURN( FALSE);
 585             }
 586
 587 #if 0
 588             /*
 589              * According to WINE, Windows' doesn't check the cbSize field
 590              */
 591
 592             Status = MmCopyFromCaller(&wi.cbSize, (PVOID)Param2, sizeof(wi.cbSize));
 593             if(!NT_SUCCESS(Status))
 594             {
 595                SetLastNtError(Status);
 596                RETURN( FALSE);
 597             }
 598
 599             if(wi.cbSize != sizeof(WINDOWINFO))
 600             {
 601                SetLastWin32Error(ERROR_INVALID_PARAMETER);
 602                RETURN( FALSE);
 603             }
 604 #endif
 605
 606             if((Ret = (DWORD_PTR)IntGetWindowInfo(Window, &wi)))
 607             {
 608                Status = MmCopyToCaller((PVOID)Param2, &wi, sizeof(WINDOWINFO));
 609                if(!NT_SUCCESS(Status))
 610                {
 611                   SetLastNtError(Status);
 612                   RETURN( FALSE);
 613                }
 614             }
 615
 616             RETURN( Ret);
 617          }
 618
 619       case TWOPARAM_ROUTINE_REGISTERLOGONPROC:
 620          RETURN( (DWORD_PTR)co_IntRegisterLogonProcess((HANDLE)Param1, (BOOL)Param2));
 621
 622       case TWOPARAM_ROUTINE_GETSYSCOLORBRUSHES:
 623       case TWOPARAM_ROUTINE_GETSYSCOLORPENS:
 624       case TWOPARAM_ROUTINE_GETSYSCOLORS:
 625          {
 626             DWORD_PTR Ret = 0;
 627             union
 628             {
 629                PVOID Pointer;
 630                HBRUSH *Brushes;
 631                HPEN *Pens;
 632                COLORREF *Colors;
 633             } Buffer;
 634
 635             /* FIXME - we should make use of SEH here... */
 636
 637             Buffer.Pointer = ExAllocatePool(PagedPool, Param2 * sizeof(HANDLE));
 638             if(Buffer.Pointer != NULL)
 639             {
 640                switch(Routine)
 641                {
 642                   case TWOPARAM_ROUTINE_GETSYSCOLORBRUSHES:
 643                      Ret = (DWORD_PTR)IntGetSysColorBrushes(Buffer.Brushes, (UINT)Param2);
 644                      break;
 645                   case TWOPARAM_ROUTINE_GETSYSCOLORPENS:
 646                      Ret = (DWORD_PTR)IntGetSysColorPens(Buffer.Pens, (UINT)Param2);
 647                      break;
 648                   case TWOPARAM_ROUTINE_GETSYSCOLORS:
 649                      Ret = (DWORD_PTR)IntGetSysColors(Buffer.Colors, (UINT)Param2);
 650                      break;
 651                   default:
 652                      Ret = 0;
 653                      break;
 654                }
 655
 656                if(Ret > 0)
 657                {
 658                   Status = MmCopyToCaller((PVOID)Param1, Buffer.Pointer, Param2 * sizeof(HANDLE));
 659                   if(!NT_SUCCESS(Status))
 660                   {
 661                      SetLastNtError(Status);
 662                      Ret = 0;
 663                   }
 664                }
 665
 666                ExFreePool(Buffer.Pointer);
 667             }
 668             RETURN( Ret);
 669          }
 670
 671       case TWOPARAM_ROUTINE_ROS_REGSYSCLASSES:
 672       {
 673           DWORD_PTR Ret = 0;
 674           DWORD Count = Param1;
 675           PREGISTER_SYSCLASS RegSysClassArray = (PREGISTER_SYSCLASS)Param2;
 676
 677           if (Count != 0 && RegSysClassArray != NULL)
 678           {
 679               _SEH2_TRY
 680               {
 681                   ProbeArrayForRead(RegSysClassArray,
 682                                     sizeof(RegSysClassArray[0]),
 683                                     Count,
 684                                     2);
 685
 686                   Ret = (DWORD_PTR)UserRegisterSystemClasses(Count,
 687                                                          RegSysClassArray);
 688               }
 689               _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 690               {
 691                   SetLastNtError(_SEH2_GetExceptionCode());
 692               }
 693               _SEH2_END;
 694           }
 695
 696           RETURN( Ret);
 697       }
 698    }
 699    DPRINT1("Calling invalid routine number 0x%x in NtUserCallTwoParam(), Param1=0x%x Parm2=0x%x\n",
 700            Routine, Param1, Param2);
 701    SetLastWin32Error(ERROR_INVALID_PARAMETER);
 702    RETURN( 0);
 703
 704 CLEANUP:
 705    DPRINT("Leave NtUserCallTwoParam, ret=%i\n",_ret_);
 706    UserLeave();
 707    END_CLEANUP;
 708 }
 709
 710
 711 /*
 712  * @unimplemented
 713  */
 714 BOOL
 715 APIENTRY
 716 NtUserCallHwndLock(
 717    HWND hWnd,
 718    DWORD Routine)
 719 {
 720    BOOL Ret = 0;
 721    PWINDOW_OBJECT Window;
 722    PWINDOW Wnd;
 723    USER_REFERENCE_ENTRY Ref;
 724    DECLARE_RETURN(BOOLEAN);
 725
 726    DPRINT("Enter NtUserCallHwndLock\n");
 727    UserEnterExclusive();
 728
 729    if (!(Window = UserGetWindowObject(hWnd)) || !Window->Wnd)
 730    {
 731       RETURN( FALSE);
 732    }
 733    UserRefObjectCo(Window, &Ref);
 734
 735    Wnd = Window->Wnd;
 736
 737    /* FIXME: Routine can be 0x53 - 0x5E */
 738    switch (Routine)
 739    {
 740       case HWNDLOCK_ROUTINE_ARRANGEICONICWINDOWS:
 741          co_WinPosArrangeIconicWindows(Window);
 742          break;
 743
 744       case HWNDLOCK_ROUTINE_DRAWMENUBAR:
 745          {
 746             PMENU_OBJECT Menu;
 747             DPRINT("HWNDLOCK_ROUTINE_DRAWMENUBAR\n");
 748             Ret = FALSE;
 749             if (!((Wnd->Style & (WS_CHILD | WS_POPUP)) != WS_CHILD))
 750                break;
 751
 752             if(!(Menu = UserGetMenuObject((HMENU) Wnd->IDMenu)))
 753                break;
 754
 755             Menu->MenuInfo.WndOwner = hWnd;
 756             Menu->MenuInfo.Height = 0;
 757
 758             co_WinPosSetWindowPos( Window,
 759                                    HWND_DESKTOP,
 760                                    0,0,0,0,
 761                                    SWP_NOSIZE|
 762                                    SWP_NOMOVE|
 763                                    SWP_NOZORDER|
 764                                    SWP_NOACTIVATE|
 765                                    SWP_FRAMECHANGED );
 766
 767             Ret = TRUE;
 768             break;
 769          }
 770
 771       case HWNDLOCK_ROUTINE_REDRAWFRAME:
 772          co_WinPosSetWindowPos( Window,
 773                                 HWND_DESKTOP,
 774                                 0,0,0,0,
 775                                 SWP_NOSIZE|
 776                                 SWP_NOMOVE|
 777                                 SWP_NOZORDER|
 778                                 SWP_NOACTIVATE|
 779                                 SWP_FRAMECHANGED );
 780          Ret = TRUE;
 781          break;
 782
 783       case HWNDLOCK_ROUTINE_REDRAWFRAMEANDHOOK:
 784          co_WinPosSetWindowPos( Window,
 785                                 HWND_DESKTOP,
 786                                 0,0,0,0,
 787                                 SWP_NOSIZE|
 788                                 SWP_NOMOVE|
 789                                 SWP_NOZORDER|
 790                                 SWP_NOACTIVATE|
 791                                 SWP_FRAMECHANGED );
 792          if (!IntGetOwner(Window) && !IntGetParent(Window))
 793          {
 794             co_IntShellHookNotify(HSHELL_REDRAW, (LPARAM) hWnd);
 795          }
 796          Ret = TRUE;
 797          break;
 798
 799       case HWNDLOCK_ROUTINE_SETFOREGROUNDWINDOW:
 800          Ret = co_IntSetForegroundWindow(Window);
 801          break;
 802
 803       case HWNDLOCK_ROUTINE_UPDATEWINDOW:
 804          Ret = co_UserRedrawWindow( Window, NULL, 0, RDW_UPDATENOW | RDW_ALLCHILDREN);
 805          break;
 806    }
 807
 808    UserDerefObjectCo(Window);
 809
 810    RETURN( Ret);
 811
 812 CLEANUP:
 813    DPRINT("Leave NtUserCallHwndLock, ret=%i\n",_ret_);
 814    UserLeave();
 815    END_CLEANUP;
 816 }
 817
 818 /*
 819  * @unimplemented
 820  */
 821 HWND
 822 APIENTRY
 823 NtUserCallHwndOpt(
 824    HWND hWnd,
 825    DWORD Routine)
 826 {
 827    switch (Routine)
 828    {
 829       case HWNDOPT_ROUTINE_SETPROGMANWINDOW:
 830          GetW32ThreadInfo()->pDeskInfo->hProgmanWindow = hWnd;
 831          break;
 832
 833       case HWNDOPT_ROUTINE_SETTASKMANWINDOW:
 834          GetW32ThreadInfo()->pDeskInfo->hTaskManWindow = hWnd;
 835          break;
 836    }
 837
 838    return hWnd;
 839 }
 840
 841 DWORD
 842 APIENTRY
 843 NtUserCallHwnd(
 844    HWND hWnd,
 845    DWORD Routine)
 846 {
 847    switch (Routine)
 848    {
 849       case HWND_ROUTINE_REGISTERSHELLHOOKWINDOW:
 850          if (IntIsWindow(hWnd))
 851             return IntRegisterShellHookWindow(hWnd);
 852          return FALSE;
 853          break;
 854       case HWND_ROUTINE_DEREGISTERSHELLHOOKWINDOW:
 855          if (IntIsWindow(hWnd))
 856             return IntDeRegisterShellHookWindow(hWnd);
 857          return FALSE;
 858    }
 859    UNIMPLEMENTED;
 860
 861    return 0;
 862 }
 863
 864 DWORD
 865 APIENTRY
 866 NtUserCallHwndParam(
 867    HWND hWnd,
 868    DWORD Param,
 869    DWORD Routine)
 870 {
 871
 872    switch (Routine)
 873    {
 874       case HWNDPARAM_ROUTINE_KILLSYSTEMTIMER:
 875           return IntKillTimer(hWnd, (UINT_PTR)Param, TRUE);
 876    }
 877
 878    UNIMPLEMENTED;
 879
 880    return 0;
 881 }
 882
 883 DWORD
 884 APIENTRY
 885 NtUserCallHwndParamLock(
 886    HWND hWnd,
 887    DWORD Param,
 888    DWORD Routine)
 889 {
 890    UNIMPLEMENTED;
 891
 892    return 0;
 893 }
 894
 895 /* EOF */