reactos/win32ss/user/ntuser/ntstubs.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS Win32k subsystem
   4  * PURPOSE:          Native User stubs
   5  * FILE:             win32ss/user/ntuser/ntstubs.c
   6  * PROGRAMER:        Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  */
   8
   9 #include <win32k.h>
  10 DBG_DEFAULT_CHANNEL(UserMisc);
  11
  12 DWORD
  13 APIENTRY
  14 NtUserAssociateInputContext(
  15     DWORD dwUnknown1,
  16     DWORD dwUnknown2,
  17     DWORD dwUnknown3)
  18 {
  19     STUB
  20     return 0;
  21 }
  22
  23 //
  24 // Works like BitBlt, http://msdn.microsoft.com/en-us/library/ms532278(VS.85).aspx
  25 //
  26 BOOL
  27 APIENTRY
  28 NtUserBitBltSysBmp(
  29    HDC hdc,
  30    INT nXDest,
  31    INT nYDest,
  32    INT nWidth,
  33    INT nHeight,
  34    INT nXSrc,
  35    INT nYSrc,
  36    DWORD dwRop )
  37 {
  38    BOOL Ret = FALSE;
  39    UserEnterExclusive();
  40
  41    Ret = NtGdiBitBlt( hdc,
  42                    nXDest,
  43                    nYDest,
  44                    nWidth,
  45                   nHeight,
  46                 hSystemBM,
  47                     nXSrc,
  48                     nYSrc,
  49                     dwRop,
  50                         0,
  51                         0);
  52
  53    UserLeave();
  54    return Ret;
  55 }
  56
  57 DWORD
  58 APIENTRY
  59 NtUserBuildHimcList(
  60     DWORD dwUnknown1,
  61     DWORD dwUnknown2,
  62     DWORD dwUnknown3,
  63     DWORD dwUnknown4)
  64 {
  65     STUB;
  66     return 0;
  67 }
  68
  69 DWORD
  70 APIENTRY
  71 NtUserDragObject(
  72    HWND    hwnd1,
  73    HWND    hwnd2,
  74    UINT    u1,
  75    DWORD   dw1,
  76    HCURSOR hc1
  77 )
  78 {
  79    STUB
  80
  81    return 0;
  82 }
  83
  84 BOOL
  85 APIENTRY
  86 NtUserDrawAnimatedRects(
  87    HWND hwnd,
  88    INT idAni,
  89    RECT *lprcFrom,
  90    RECT *lprcTo)
  91 {
  92    STUB
  93
  94    return 0;
  95 }
  96
  97 DWORD
  98 APIENTRY
  99 NtUserEvent(
 100    DWORD Unknown0)
 101 {
 102    STUB
 103
 104    return 0;
 105 }
 106
 107 DWORD
 108 APIENTRY
 109 NtUserExcludeUpdateRgn(
 110   HDC hDC,
 111   HWND hWnd)
 112 {
 113    STUB
 114
 115    return 0;
 116 }
 117
 118 BOOL
 119 APIENTRY
 120 NtUserGetAltTabInfo(
 121    HWND hwnd,
 122    INT  iItem,
 123    PALTTABINFO pati,
 124    LPWSTR pszItemText,
 125    UINT   cchItemText,
 126    BOOL   Ansi)
 127 {
 128    STUB
 129
 130    return 0;
 131 }
 132
 133 NTSTATUS
 134 APIENTRY
 135 NtUserInitializeClientPfnArrays(
 136   PPFNCLIENT pfnClientA,
 137   PPFNCLIENT pfnClientW,
 138   PPFNCLIENTWORKER pfnClientWorker,
 139   HINSTANCE hmodUser)
 140 {
 141    NTSTATUS Status = STATUS_SUCCESS;
 142    TRACE("Enter NtUserInitializeClientPfnArrays User32 0x%p\n", hmodUser);
 143
 144    if (ClientPfnInit) return Status;
 145
 146    UserEnterExclusive();
 147
 148    _SEH2_TRY
 149    {
 150       ProbeForRead( pfnClientA, sizeof(PFNCLIENT), 1);
 151       ProbeForRead( pfnClientW, sizeof(PFNCLIENT), 1);
 152       ProbeForRead( pfnClientWorker, sizeof(PFNCLIENTWORKER), 1);
 153       RtlCopyMemory(&gpsi->apfnClientA, pfnClientA, sizeof(PFNCLIENT));
 154       RtlCopyMemory(&gpsi->apfnClientW, pfnClientW, sizeof(PFNCLIENT));
 155       RtlCopyMemory(&gpsi->apfnClientWorker, pfnClientWorker, sizeof(PFNCLIENTWORKER));
 156
 157       //// FIXME: HAX! Temporary until server side is finished.
 158       //// Copy the client side procs for now.
 159       RtlCopyMemory(&gpsi->aStoCidPfn, pfnClientW, sizeof(gpsi->aStoCidPfn));
 160
 161       hModClient = hmodUser;
 162       ClientPfnInit = TRUE;
 163    }
 164    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 165    {
 166       Status =_SEH2_GetExceptionCode();
 167    }
 168    _SEH2_END
 169
 170    if (!NT_SUCCESS(Status))
 171    {
 172       ERR("Failed reading Client Pfns from user space.\n");
 173       SetLastNtError(Status);
 174    }
 175
 176    UserLeave();
 177    return Status;
 178 }
 179
 180 DWORD
 181 APIENTRY
 182 NtUserInitTask(
 183    DWORD Unknown0,
 184    DWORD Unknown1,
 185    DWORD Unknown2,
 186    DWORD Unknown3,
 187    DWORD Unknown4,
 188    DWORD Unknown5,
 189    DWORD Unknown6,
 190    DWORD Unknown7,
 191    DWORD Unknown8,
 192    DWORD Unknown9,
 193    DWORD Unknown10,
 194    DWORD Unknown11)
 195 {
 196    STUB
 197
 198    return 0;
 199 }
 200
 201 DWORD
 202 APIENTRY
 203 NtUserMNDragLeave(VOID)
 204 {
 205    STUB
 206
 207    return 0;
 208 }
 209
 210 DWORD
 211 APIENTRY
 212 NtUserMNDragOver(
 213    DWORD Unknown0,
 214    DWORD Unknown1)
 215 {
 216    STUB
 217
 218    return 0;
 219 }
 220
 221 DWORD
 222 APIENTRY
 223 NtUserModifyUserStartupInfoFlags(
 224    DWORD Unknown0,
 225    DWORD Unknown1)
 226 {
 227    STUB
 228
 229    return 0;
 230 }
 231
 232 DWORD
 233 APIENTRY
 234 NtUserQueryUserCounters(
 235    DWORD Unknown0,
 236    DWORD Unknown1,
 237    DWORD Unknown2,
 238    DWORD Unknown3,
 239    DWORD Unknown4)
 240 {
 241    STUB
 242
 243    return 0;
 244 }
 245
 246 DWORD
 247 APIENTRY
 248 NtUserRegisterTasklist(
 249    DWORD Unknown0)
 250 {
 251    STUB
 252
 253    return 0;
 254 }
 255
 256 DWORD
 257 APIENTRY
 258 NtUserSetConsoleReserveKeys(
 259    DWORD Unknown0,
 260    DWORD Unknown1)
 261 {
 262    STUB
 263
 264    return 0;
 265 }
 266
 267 DWORD
 268 APIENTRY
 269 NtUserSetDbgTag(
 270    DWORD Unknown0,
 271    DWORD Unknown1)
 272 {
 273    STUB;
 274
 275    return 0;
 276 }
 277
 278 DWORD
 279 APIENTRY
 280 NtUserSetDbgTagCount(
 281     DWORD Unknown0)
 282 {
 283     STUB;
 284
 285     return 0;
 286 }
 287
 288 DWORD
 289 APIENTRY
 290 NtUserSetRipFlags(
 291    DWORD Unknown0)
 292 {
 293    STUB;
 294
 295    return 0;
 296 }
 297
 298 DWORD
 299 APIENTRY
 300 NtUserDbgWin32HeapFail(
 301     DWORD Unknown0,
 302     DWORD Unknown1)
 303 {
 304    STUB
 305
 306    return 0;
 307 }
 308
 309 DWORD
 310 APIENTRY
 311 NtUserDbgWin32HeapStat(
 312     DWORD Unknown0,
 313     DWORD Unknown1)
 314 {
 315    STUB
 316
 317    return 0;
 318 }
 319
 320 BOOL
 321 APIENTRY
 322 NtUserSetSysColors(
 323    int cElements,
 324    IN CONST INT *lpaElements,
 325    IN CONST COLORREF *lpaRgbValues,
 326    FLONG Flags)
 327 {
 328    DWORD Ret = TRUE;
 329
 330    if (cElements == 0)
 331       return TRUE;
 332
 333    /* We need this check to prevent overflow later */
 334    if ((ULONG)cElements >= 0x40000000)
 335    {
 336       EngSetLastError(ERROR_NOACCESS);
 337       return FALSE;
 338    }
 339
 340    UserEnterExclusive();
 341
 342    _SEH2_TRY
 343    {
 344       ProbeForRead(lpaElements, cElements * sizeof(INT), 1);
 345       ProbeForRead(lpaRgbValues, cElements * sizeof(COLORREF), 1);
 346
 347       IntSetSysColors(cElements, lpaElements, lpaRgbValues);
 348    }
 349    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 350    {
 351       SetLastNtError(_SEH2_GetExceptionCode());
 352       Ret = FALSE;
 353    }
 354    _SEH2_END;
 355
 356    if (Ret)
 357    {
 358       UserSendNotifyMessage(HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0);
 359
 360       UserRedrawDesktop();
 361    }
 362
 363    UserLeave();
 364    return Ret;
 365 }
 366
 367 DWORD
 368 APIENTRY
 369 NtUserUpdateInputContext(
 370    DWORD Unknown0,
 371    DWORD Unknown1,
 372    DWORD Unknown2)
 373 {
 374    STUB
 375
 376    return 0;
 377 }
 378
 379 DWORD
 380 APIENTRY
 381 NtUserUpdateInstance(
 382    DWORD Unknown0,
 383    DWORD Unknown1,
 384    DWORD Unknown2)
 385 {
 386    STUB
 387
 388    return 0;
 389 }
 390
 391 BOOL
 392 APIENTRY
 393 NtUserUserHandleGrantAccess(
 394    IN HANDLE hUserHandle,
 395    IN HANDLE hJob,
 396    IN BOOL bGrant)
 397 {
 398    STUB
 399
 400    return 0;
 401 }
 402
 403 DWORD
 404 APIENTRY
 405 NtUserWaitForMsgAndEvent(
 406    DWORD Unknown0)
 407 {
 408    STUB
 409
 410    return 0;
 411 }
 412
 413 DWORD
 414 APIENTRY
 415 NtUserWin32PoolAllocationStats(
 416    DWORD Unknown0,
 417    DWORD Unknown1,
 418    DWORD Unknown2,
 419    DWORD Unknown3,
 420    DWORD Unknown4,
 421    DWORD Unknown5)
 422 {
 423    STUB
 424
 425    return 0;
 426 }
 427
 428 DWORD
 429 APIENTRY
 430 NtUserYieldTask(VOID)
 431 {
 432    STUB
 433
 434    return 0;
 435 }
 436
 437 DWORD
 438 APIENTRY
 439 NtUserCreateInputContext(
 440     DWORD dwUnknown1)
 441 {
 442     STUB;
 443     return 0;
 444 }
 445
 446 DWORD
 447 APIENTRY
 448 NtUserDestroyInputContext(
 449     DWORD dwUnknown1)
 450 {
 451     STUB;
 452     return 0;
 453 }
 454
 455 DWORD
 456 APIENTRY
 457 NtUserGetRawInputBuffer(
 458     PRAWINPUT pData,
 459     PUINT pcbSize,
 460     UINT cbSizeHeader)
 461 {
 462     STUB;
 463     return 0;
 464 }
 465
 466 DWORD
 467 APIENTRY
 468 NtUserGetRawInputData(
 469     HRAWINPUT hRawInput,
 470     UINT uiCommand,
 471     LPVOID pData,
 472     PUINT pcbSize,
 473     UINT cbSizeHeader)
 474 {
 475     STUB;
 476     return 0;
 477 }
 478
 479 DWORD
 480 APIENTRY
 481 NtUserGetRawInputDeviceInfo(
 482     HANDLE hDevice,
 483     UINT uiCommand,
 484     LPVOID pData,
 485     PUINT pcbSize
 486 )
 487 {
 488     STUB;
 489     return 0;
 490 }
 491
 492 DWORD
 493 APIENTRY
 494 NtUserGetRawInputDeviceList(
 495     PRAWINPUTDEVICELIST pRawInputDeviceList,
 496     PUINT puiNumDevices,
 497     UINT cbSize)
 498 {
 499     STUB;
 500     return 0;
 501 }
 502
 503 DWORD
 504 APIENTRY
 505 NtUserGetRegisteredRawInputDevices(
 506     PRAWINPUTDEVICE pRawInputDevices,
 507     PUINT puiNumDevices,
 508     UINT cbSize)
 509 {
 510     STUB;
 511     return 0;
 512 }
 513
 514 DWORD
 515 APIENTRY
 516 NtUserHardErrorControl(
 517     DWORD dwUnknown1,
 518     DWORD dwUnknown2,
 519     DWORD dwUnknown3)
 520 {
 521     STUB;
 522     return 0;
 523 }
 524
 525 BOOL
 526 NTAPI
 527 NtUserNotifyProcessCreate(
 528     HANDLE NewProcessId,
 529     HANDLE ParentThreadId,
 530     ULONG  dwUnknown,
 531     ULONG  CreateFlags)
 532 {
 533     // STUB;
 534     TRACE("NtUserNotifyProcessCreate is UNIMPLEMENTED\n");
 535     return FALSE;
 536 }
 537
 538 NTSTATUS
 539 APIENTRY
 540 NtUserProcessConnect(
 541     IN  HANDLE ProcessHandle,
 542     OUT PUSERCONNECT pUserConnect,
 543     IN  ULONG Size)
 544 {
 545     NTSTATUS Status;
 546     PEPROCESS Process = NULL;
 547     PPROCESSINFO W32Process;
 548
 549     TRACE("NtUserProcessConnect\n");
 550
 551     if ( pUserConnect == NULL ||
 552          Size         != sizeof(*pUserConnect) )
 553     {
 554         return STATUS_UNSUCCESSFUL;
 555     }
 556
 557     /* Get the process object the user handle was referencing */
 558     Status = ObReferenceObjectByHandle(ProcessHandle,
 559                                        PROCESS_VM_OPERATION,
 560                                        *PsProcessType,
 561                                        UserMode,
 562                                        (PVOID*)&Process,
 563                                        NULL);
 564     if (!NT_SUCCESS(Status)) return Status;
 565
 566     UserEnterShared();
 567
 568     /* Get Win32 process information */
 569     W32Process = PsGetProcessWin32Process(Process);
 570
 571     _SEH2_TRY
 572     {
 573         // FIXME: Check that pUserConnect->ulVersion == USER_VERSION;
 574
 575         ProbeForWrite(pUserConnect, sizeof(*pUserConnect), sizeof(PVOID));
 576         pUserConnect->siClient.psi = gpsi;
 577         pUserConnect->siClient.aheList = gHandleTable;
 578         pUserConnect->siClient.ulSharedDelta =
 579             (ULONG_PTR)W32Process->HeapMappings.KernelMapping -
 580             (ULONG_PTR)W32Process->HeapMappings.UserMapping;
 581     }
 582     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 583     {
 584         Status = _SEH2_GetExceptionCode();
 585     }
 586     _SEH2_END;
 587
 588     if (!NT_SUCCESS(Status))
 589         SetLastNtError(Status);
 590
 591     UserLeave();
 592
 593     /* Dereference the process object */
 594     ObDereferenceObject(Process);
 595
 596     return Status;
 597 }
 598
 599 NTSTATUS
 600 APIENTRY
 601 NtUserQueryInformationThread(IN HANDLE ThreadHandle,
 602                              IN USERTHREADINFOCLASS ThreadInformationClass,
 603                              OUT PVOID ThreadInformation,
 604                              IN ULONG ThreadInformationLength)
 605 {
 606     NTSTATUS Status = STATUS_SUCCESS;
 607     PETHREAD Thread;
 608
 609     /* Allow only CSRSS to perform this operation */
 610     if (PsGetCurrentProcess() != gpepCSRSS)
 611         return STATUS_ACCESS_DENIED;
 612
 613     UserEnterExclusive();
 614
 615     /* Get the Thread */
 616     Status = ObReferenceObjectByHandle(ThreadHandle,
 617                                        THREAD_QUERY_INFORMATION,
 618                                        *PsThreadType,
 619                                        UserMode,
 620                                        (PVOID)&Thread,
 621                                        NULL);
 622     if (!NT_SUCCESS(Status)) goto Quit;
 623
 624     switch (ThreadInformationClass)
 625     {
 626         default:
 627         {
 628             STUB;
 629             Status = STATUS_NOT_IMPLEMENTED;
 630             break;
 631         }
 632     }
 633
 634     ObDereferenceObject(Thread);
 635
 636 Quit:
 637     UserLeave();
 638     return Status;
 639 }
 640
 641 DWORD
 642 APIENTRY
 643 NtUserQueryInputContext(
 644     DWORD dwUnknown1,
 645     DWORD dwUnknown2)
 646 {
 647     STUB;
 648     return 0;
 649 }
 650
 651 BOOL
 652 APIENTRY
 653 NtUserRealInternalGetMessage(
 654     LPMSG lpMsg,
 655     HWND hWnd,
 656     UINT wMsgFilterMin,
 657     UINT wMsgFilterMax,
 658     UINT wRemoveMsg,
 659     BOOL bGMSG)
 660 {
 661     STUB;
 662     return 0;
 663 }
 664
 665 BOOL
 666 APIENTRY
 667 NtUserRealWaitMessageEx(
 668     DWORD dwWakeMask,
 669     UINT uTimeout)
 670 {
 671     STUB;
 672     return 0;
 673 }
 674
 675 BOOL
 676 APIENTRY
 677 NtUserRegisterRawInputDevices(
 678     IN PCRAWINPUTDEVICE pRawInputDevices,
 679     IN UINT uiNumDevices,
 680     IN UINT cbSize)
 681 {
 682     STUB;
 683     return 0;
 684 }
 685
 686 DWORD APIENTRY
 687 NtUserResolveDesktopForWOW(DWORD Unknown0)
 688 {
 689     STUB
 690     return 0;
 691 }
 692
 693 DWORD
 694 APIENTRY
 695 NtUserSetInformationProcess(
 696     DWORD dwUnknown1,
 697     DWORD dwUnknown2,
 698     DWORD dwUnknown3,
 699     DWORD dwUnknown4)
 700 {
 701     STUB;
 702     return 0;
 703 }
 704
 705 NTSTATUS
 706 APIENTRY
 707 NtUserSetInformationThread(IN HANDLE ThreadHandle,
 708                            IN USERTHREADINFOCLASS ThreadInformationClass,
 709                            IN PVOID ThreadInformation,
 710                            IN ULONG ThreadInformationLength)
 711 {
 712     NTSTATUS Status = STATUS_SUCCESS;
 713     PETHREAD Thread;
 714
 715     /* Allow only CSRSS to perform this operation */
 716     if (PsGetCurrentProcess() != gpepCSRSS)
 717         return STATUS_ACCESS_DENIED;
 718
 719     UserEnterExclusive();
 720
 721     /* Get the Thread */
 722     Status = ObReferenceObjectByHandle(ThreadHandle,
 723                                        THREAD_SET_INFORMATION,
 724                                        *PsThreadType,
 725                                        UserMode,
 726                                        (PVOID)&Thread,
 727                                        NULL);
 728     if (!NT_SUCCESS(Status)) goto Quit;
 729
 730     switch (ThreadInformationClass)
 731     {
 732         case UserThreadInitiateShutdown:
 733         {
 734             ULONG CapturedFlags = 0;
 735
 736             ERR("Shutdown initiated\n");
 737
 738             if (ThreadInformationLength != sizeof(ULONG))
 739             {
 740                 Status = STATUS_INFO_LENGTH_MISMATCH;
 741                 break;
 742             }
 743
 744             /* Capture the caller value */
 745             Status = STATUS_SUCCESS;
 746             _SEH2_TRY
 747             {
 748                 ProbeForWrite(ThreadInformation, sizeof(CapturedFlags), sizeof(PVOID));
 749                 CapturedFlags = *(PULONG)ThreadInformation;
 750             }
 751             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 752             {
 753                 Status = _SEH2_GetExceptionCode();
 754                 _SEH2_YIELD(break);
 755             }
 756             _SEH2_END;
 757
 758             Status = UserInitiateShutdown(Thread, &CapturedFlags);
 759
 760             /* Return the modified value to the caller */
 761             _SEH2_TRY
 762             {
 763                 *(PULONG)ThreadInformation = CapturedFlags;
 764             }
 765             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 766             {
 767                 Status = _SEH2_GetExceptionCode();
 768             }
 769             _SEH2_END;
 770
 771             break;
 772         }
 773
 774         case UserThreadEndShutdown:
 775         {
 776             NTSTATUS ShutdownStatus;
 777
 778             ERR("Shutdown ended\n");
 779
 780             if (ThreadInformationLength != sizeof(ShutdownStatus))
 781             {
 782                 Status = STATUS_INFO_LENGTH_MISMATCH;
 783                 break;
 784             }
 785
 786             /* Capture the caller value */
 787             Status = STATUS_SUCCESS;
 788             _SEH2_TRY
 789             {
 790                 ProbeForRead(ThreadInformation, sizeof(ShutdownStatus), sizeof(PVOID));
 791                 ShutdownStatus = *(NTSTATUS*)ThreadInformation;
 792             }
 793             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 794             {
 795                 Status = _SEH2_GetExceptionCode();
 796                 _SEH2_YIELD(break);
 797             }
 798             _SEH2_END;
 799
 800             Status = UserEndShutdown(Thread, ShutdownStatus);
 801             break;
 802         }
 803
 804         case UserThreadCsrApiPort:
 805         {
 806             HANDLE CsrPortHandle;
 807
 808             ERR("Set CSR API Port for Win32k\n");
 809
 810             if (ThreadInformationLength != sizeof(CsrPortHandle))
 811             {
 812                 Status = STATUS_INFO_LENGTH_MISMATCH;
 813                 break;
 814             }
 815
 816             /* Capture the caller value */
 817             Status = STATUS_SUCCESS;
 818             _SEH2_TRY
 819             {
 820                 ProbeForRead(ThreadInformation, sizeof(CsrPortHandle), sizeof(PVOID));
 821                 CsrPortHandle = *(PHANDLE)ThreadInformation;
 822             }
 823             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 824             {
 825                 Status = _SEH2_GetExceptionCode();
 826                 _SEH2_YIELD(break);
 827             }
 828             _SEH2_END;
 829
 830             Status = InitCsrApiPort(CsrPortHandle);
 831             break;
 832         }
 833
 834         default:
 835         {
 836             STUB;
 837             Status = STATUS_NOT_IMPLEMENTED;
 838             break;
 839         }
 840     }
 841
 842     ObDereferenceObject(Thread);
 843
 844 Quit:
 845     UserLeave();
 846     return Status;
 847 }
 848
 849 DWORD
 850 APIENTRY
 851 NtUserSetThreadLayoutHandles(
 852     DWORD dwUnknown1,
 853     DWORD dwUnknown2)
 854 {
 855     STUB;
 856     return 0;
 857 }
 858
 859 BOOL
 860 APIENTRY
 861 NtUserSoundSentry(VOID)
 862 {
 863     STUB;
 864     return 0;
 865 }
 866
 867 DWORD
 868 APIENTRY
 869 NtUserTestForInteractiveUser(
 870     DWORD dwUnknown1)
 871 {
 872     STUB;
 873     return 0;
 874 }
 875
 876 /* http://www.cyber-ta.org/releases/malware-analysis/public/SOURCES/b47155634ccb2c30630da7e3666d3d07/b47155634ccb2c30630da7e3666d3d07.trace.html#NtUserGetIconSize */
 877 DWORD
 878 APIENTRY
 879 NtUserCalcMenuBar(
 880     DWORD dwUnknown1,
 881     DWORD dwUnknown2,
 882     DWORD dwUnknown3,
 883     DWORD dwUnknown4,
 884     DWORD dwUnknown5)
 885 {
 886     STUB;
 887     return 0;
 888 }
 889
 890 DWORD
 891 APIENTRY
 892 NtUserPaintMenuBar(
 893     DWORD dwUnknown1,
 894     DWORD dwUnknown2,
 895     DWORD dwUnknown3,
 896     DWORD dwUnknown4,
 897     DWORD dwUnknown5,
 898     DWORD dwUnknown6)
 899 {
 900     STUB;
 901     return 0;
 902 }
 903
 904
 905 DWORD
 906 APIENTRY
 907 NtUserRemoteConnect(
 908     DWORD dwUnknown1,
 909     DWORD dwUnknown2,
 910     DWORD dwUnknown3)
 911 {
 912     STUB;
 913     return 0;
 914 }
 915
 916 DWORD
 917 APIENTRY
 918 NtUserRemoteRedrawRectangle(
 919     DWORD dwUnknown1,
 920     DWORD dwUnknown2,
 921     DWORD dwUnknown3,
 922     DWORD dwUnknown4)
 923 {
 924     STUB;
 925     return 0;
 926 }
 927
 928 DWORD
 929 APIENTRY
 930 NtUserRemoteRedrawScreen(VOID)
 931 {
 932     STUB;
 933     return 0;
 934 }
 935
 936 DWORD
 937 APIENTRY
 938 NtUserRemoteStopScreenUpdates(VOID)
 939 {
 940     STUB;
 941     return 0;
 942 }
 943
 944 DWORD
 945 APIENTRY
 946 NtUserCtxDisplayIOCtl(
 947     DWORD dwUnknown1,
 948     DWORD dwUnknown2,
 949     DWORD dwUnknown3)
 950 {
 951     STUB;
 952     return 0;
 953 }
 954
 955 /*
 956  * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
 957  */
 958 /*
 959  * @unimplemented
 960  */
 961 BOOL APIENTRY
 962 NtUserFillWindow(HWND hWndPaint,
 963                  HWND hWndPaint1,
 964                  HDC  hDC,
 965                  HBRUSH hBrush)
 966 {
 967    STUB
 968
 969    return 0;
 970 }
 971
 972 /*
 973  * @unimplemented
 974  */
 975 BOOL APIENTRY
 976 NtUserLockWindowUpdate(HWND hWnd)
 977 {
 978    STUB
 979
 980    return 0;
 981 }
 982
 983 DWORD APIENTRY
 984 NtUserQuerySendMessage(DWORD Unknown0)
 985 {
 986     STUB;
 987
 988     return 0;
 989 }
 990
 991 BOOL APIENTRY NtUserAddClipboardFormatListener(
 992     HWND hwnd
 993 )
 994 {
 995     STUB;
 996     return FALSE;
 997 }
 998
 999 BOOL APIENTRY NtUserRemoveClipboardFormatListener(
1000     HWND hwnd
1001 )
1002 {
1003     STUB;
1004     return FALSE;
1005 }
1006
1007 BOOL APIENTRY NtUserGetUpdatedClipboardFormats(
1008     PUINT lpuiFormats,
1009     UINT cFormats,
1010     PUINT pcFormatsOut
1011 )
1012 {
1013     STUB;
1014     return FALSE;
1015 }
1016
1017 // Yes, I know, these do not belong here, just tell me where to put them
1018 BOOL
1019 APIENTRY
1020 NtGdiMakeObjectXferable(
1021     _In_ HANDLE hHandle,
1022     _In_ DWORD dwProcessId)
1023 {
1024     STUB;
1025     return 0;
1026 }
1027
1028 DWORD
1029 APIENTRY
1030 NtDxEngGetRedirectionBitmap(
1031     DWORD Unknown0)
1032 {
1033     STUB;
1034     return 0;
1035 }
1036
1037
1038 /* EOF */