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 NtUserSetRipFlags(
 281    DWORD Unknown0,
 282    DWORD Unknown1)
 283 {
 284    STUB
 285
 286    return 0;
 287 }
 288
 289 BOOL
 290 APIENTRY
 291 NtUserSetSysColors(
 292    int cElements,
 293    IN CONST INT *lpaElements,
 294    IN CONST COLORREF *lpaRgbValues,
 295    FLONG Flags)
 296 {
 297    DWORD Ret = TRUE;
 298
 299    if (cElements == 0)
 300       return TRUE;
 301
 302    /* We need this check to prevent overflow later */
 303    if ((ULONG)cElements >= 0x40000000)
 304    {
 305       EngSetLastError(ERROR_NOACCESS);
 306       return FALSE;
 307    }
 308
 309    UserEnterExclusive();
 310
 311    _SEH2_TRY
 312    {
 313       ProbeForRead(lpaElements, cElements * sizeof(INT), 1);
 314       ProbeForRead(lpaRgbValues, cElements * sizeof(COLORREF), 1);
 315
 316       IntSetSysColors(cElements, lpaElements, lpaRgbValues);
 317    }
 318    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 319    {
 320       SetLastNtError(_SEH2_GetExceptionCode());
 321       Ret = FALSE;
 322    }
 323    _SEH2_END;
 324
 325    if (Ret)
 326    {
 327       UserSendNotifyMessage(HWND_BROADCAST, WM_SYSCOLORCHANGE, 0, 0);
 328
 329       UserRedrawDesktop();
 330    }
 331
 332    UserLeave();
 333    return Ret;
 334 }
 335
 336 DWORD
 337 APIENTRY
 338 NtUserUpdateInputContext(
 339    DWORD Unknown0,
 340    DWORD Unknown1,
 341    DWORD Unknown2)
 342 {
 343    STUB
 344
 345    return 0;
 346 }
 347
 348 DWORD
 349 APIENTRY
 350 NtUserUpdateInstance(
 351    DWORD Unknown0,
 352    DWORD Unknown1,
 353    DWORD Unknown2)
 354 {
 355    STUB
 356
 357    return 0;
 358 }
 359
 360 BOOL
 361 APIENTRY
 362 NtUserUserHandleGrantAccess(
 363    IN HANDLE hUserHandle,
 364    IN HANDLE hJob,
 365    IN BOOL bGrant)
 366 {
 367    STUB
 368
 369    return 0;
 370 }
 371
 372 DWORD
 373 APIENTRY
 374 NtUserWaitForMsgAndEvent(
 375    DWORD Unknown0)
 376 {
 377    STUB
 378
 379    return 0;
 380 }
 381
 382 DWORD
 383 APIENTRY
 384 NtUserWin32PoolAllocationStats(
 385    DWORD Unknown0,
 386    DWORD Unknown1,
 387    DWORD Unknown2,
 388    DWORD Unknown3,
 389    DWORD Unknown4,
 390    DWORD Unknown5)
 391 {
 392    STUB
 393
 394    return 0;
 395 }
 396
 397 DWORD
 398 APIENTRY
 399 NtUserYieldTask(VOID)
 400 {
 401    STUB
 402
 403    return 0;
 404 }
 405
 406 DWORD
 407 APIENTRY
 408 NtUserCreateInputContext(
 409     DWORD dwUnknown1)
 410 {
 411     STUB;
 412     return 0;
 413 }
 414
 415 DWORD
 416 APIENTRY
 417 NtUserDestroyInputContext(
 418     DWORD dwUnknown1)
 419 {
 420     STUB;
 421     return 0;
 422 }
 423
 424 DWORD
 425 APIENTRY
 426 NtUserGetRawInputBuffer(
 427     PRAWINPUT pData,
 428     PUINT pcbSize,
 429     UINT cbSizeHeader)
 430 {
 431     STUB;
 432     return 0;
 433 }
 434
 435 DWORD
 436 APIENTRY
 437 NtUserGetRawInputData(
 438     HRAWINPUT hRawInput,
 439     UINT uiCommand,
 440     LPVOID pData,
 441     PUINT pcbSize,
 442     UINT cbSizeHeader)
 443 {
 444     STUB;
 445     return 0;
 446 }
 447
 448 DWORD
 449 APIENTRY
 450 NtUserGetRawInputDeviceInfo(
 451     HANDLE hDevice,
 452     UINT uiCommand,
 453     LPVOID pData,
 454     PUINT pcbSize
 455 )
 456 {
 457     STUB;
 458     return 0;
 459 }
 460
 461 DWORD
 462 APIENTRY
 463 NtUserGetRawInputDeviceList(
 464     PRAWINPUTDEVICELIST pRawInputDeviceList,
 465     PUINT puiNumDevices,
 466     UINT cbSize)
 467 {
 468     STUB;
 469     return 0;
 470 }
 471
 472 DWORD
 473 APIENTRY
 474 NtUserGetRegisteredRawInputDevices(
 475     PRAWINPUTDEVICE pRawInputDevices,
 476     PUINT puiNumDevices,
 477     UINT cbSize)
 478 {
 479     STUB;
 480     return 0;
 481 }
 482
 483 DWORD
 484 APIENTRY
 485 NtUserHardErrorControl(
 486     DWORD dwUnknown1,
 487     DWORD dwUnknown2,
 488     DWORD dwUnknown3)
 489 {
 490     STUB;
 491     return 0;
 492 }
 493
 494 BOOL
 495 NTAPI
 496 NtUserNotifyProcessCreate(
 497     HANDLE NewProcessId,
 498     HANDLE ParentThreadId,
 499     ULONG  dwUnknown,
 500     ULONG  CreateFlags)
 501 {
 502     // STUB;
 503     TRACE("NtUserNotifyProcessCreate is UNIMPLEMENTED\n");
 504     return FALSE;
 505 }
 506
 507 NTSTATUS
 508 APIENTRY
 509 NtUserProcessConnect(
 510     IN  HANDLE ProcessHandle,
 511     OUT PUSERCONNECT pUserConnect,
 512     IN  ULONG Size)
 513 {
 514     NTSTATUS Status;
 515     PEPROCESS Process = NULL;
 516     PPROCESSINFO W32Process;
 517
 518     TRACE("NtUserProcessConnect\n");
 519
 520     if ( pUserConnect == NULL ||
 521          Size         != sizeof(*pUserConnect) )
 522     {
 523         return STATUS_UNSUCCESSFUL;
 524     }
 525
 526     /* Get the process object the user handle was referencing */
 527     Status = ObReferenceObjectByHandle(ProcessHandle,
 528                                        PROCESS_VM_OPERATION,
 529                                        *PsProcessType,
 530                                        UserMode,
 531                                        (PVOID*)&Process,
 532                                        NULL);
 533     if (!NT_SUCCESS(Status)) return Status;
 534
 535     UserEnterShared();
 536
 537     /* Get Win32 process information */
 538     W32Process = PsGetProcessWin32Process(Process);
 539
 540     _SEH2_TRY
 541     {
 542         // FIXME: Check that pUserConnect->ulVersion == USER_VERSION;
 543
 544         ProbeForWrite(pUserConnect, sizeof(*pUserConnect), sizeof(PVOID));
 545         pUserConnect->siClient.psi = gpsi;
 546         pUserConnect->siClient.aheList = gHandleTable;
 547         pUserConnect->siClient.ulSharedDelta =
 548             (ULONG_PTR)W32Process->HeapMappings.KernelMapping -
 549             (ULONG_PTR)W32Process->HeapMappings.UserMapping;
 550     }
 551     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 552     {
 553         Status = _SEH2_GetExceptionCode();
 554     }
 555     _SEH2_END;
 556
 557     if (!NT_SUCCESS(Status))
 558         SetLastNtError(Status);
 559
 560     UserLeave();
 561
 562     /* Dereference the process object */
 563     ObDereferenceObject(Process);
 564
 565     return Status;
 566 }
 567
 568 NTSTATUS
 569 APIENTRY
 570 NtUserQueryInformationThread(IN HANDLE ThreadHandle,
 571                              IN USERTHREADINFOCLASS ThreadInformationClass,
 572                              OUT PVOID ThreadInformation,
 573                              IN ULONG ThreadInformationLength)
 574 {
 575     NTSTATUS Status = STATUS_SUCCESS;
 576     PETHREAD Thread;
 577
 578     /* Allow only CSRSS to perform this operation */
 579     if (PsGetCurrentProcess() != gpepCSRSS)
 580         return STATUS_ACCESS_DENIED;
 581
 582     UserEnterExclusive();
 583
 584     /* Get the Thread */
 585     Status = ObReferenceObjectByHandle(ThreadHandle,
 586                                        THREAD_QUERY_INFORMATION,
 587                                        *PsThreadType,
 588                                        UserMode,
 589                                        (PVOID)&Thread,
 590                                        NULL);
 591     if (!NT_SUCCESS(Status)) goto Quit;
 592
 593     switch (ThreadInformationClass)
 594     {
 595         default:
 596         {
 597             STUB;
 598             Status = STATUS_NOT_IMPLEMENTED;
 599             break;
 600         }
 601     }
 602
 603     ObDereferenceObject(Thread);
 604
 605 Quit:
 606     UserLeave();
 607     return Status;
 608 }
 609
 610 DWORD
 611 APIENTRY
 612 NtUserQueryInputContext(
 613     DWORD dwUnknown1,
 614     DWORD dwUnknown2)
 615 {
 616     STUB;
 617     return 0;
 618 }
 619
 620 BOOL
 621 APIENTRY
 622 NtUserRealInternalGetMessage(
 623     LPMSG lpMsg,
 624     HWND hWnd,
 625     UINT wMsgFilterMin,
 626     UINT wMsgFilterMax,
 627     UINT wRemoveMsg,
 628     BOOL bGMSG)
 629 {
 630     STUB;
 631     return 0;
 632 }
 633
 634 BOOL
 635 APIENTRY
 636 NtUserRealWaitMessageEx(
 637     DWORD dwWakeMask,
 638     UINT uTimeout)
 639 {
 640     STUB;
 641     return 0;
 642 }
 643
 644 BOOL
 645 APIENTRY
 646 NtUserRegisterRawInputDevices(
 647     IN PCRAWINPUTDEVICE pRawInputDevices,
 648     IN UINT uiNumDevices,
 649     IN UINT cbSize)
 650 {
 651     STUB;
 652     return 0;
 653 }
 654
 655 DWORD APIENTRY
 656 NtUserResolveDesktopForWOW(DWORD Unknown0)
 657 {
 658     STUB
 659     return 0;
 660 }
 661
 662 DWORD
 663 APIENTRY
 664 NtUserSetInformationProcess(
 665     DWORD dwUnknown1,
 666     DWORD dwUnknown2,
 667     DWORD dwUnknown3,
 668     DWORD dwUnknown4)
 669 {
 670     STUB;
 671     return 0;
 672 }
 673
 674 NTSTATUS
 675 APIENTRY
 676 NtUserSetInformationThread(IN HANDLE ThreadHandle,
 677                            IN USERTHREADINFOCLASS ThreadInformationClass,
 678                            IN PVOID ThreadInformation,
 679                            IN ULONG ThreadInformationLength)
 680 {
 681     NTSTATUS Status = STATUS_SUCCESS;
 682     PETHREAD Thread;
 683
 684     /* Allow only CSRSS to perform this operation */
 685     if (PsGetCurrentProcess() != gpepCSRSS)
 686         return STATUS_ACCESS_DENIED;
 687
 688     UserEnterExclusive();
 689
 690     /* Get the Thread */
 691     Status = ObReferenceObjectByHandle(ThreadHandle,
 692                                        THREAD_SET_INFORMATION,
 693                                        *PsThreadType,
 694                                        UserMode,
 695                                        (PVOID)&Thread,
 696                                        NULL);
 697     if (!NT_SUCCESS(Status)) goto Quit;
 698
 699     switch (ThreadInformationClass)
 700     {
 701         case UserThreadInitiateShutdown:
 702         {
 703             ULONG CapturedFlags = 0;
 704
 705             ERR("Shutdown initiated\n");
 706
 707             if (ThreadInformationLength != sizeof(ULONG))
 708             {
 709                 Status = STATUS_INFO_LENGTH_MISMATCH;
 710                 break;
 711             }
 712
 713             /* Capture the caller value */
 714             Status = STATUS_SUCCESS;
 715             _SEH2_TRY
 716             {
 717                 ProbeForWrite(ThreadInformation, sizeof(CapturedFlags), sizeof(PVOID));
 718                 CapturedFlags = *(PULONG)ThreadInformation;
 719             }
 720             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 721             {
 722                 Status = _SEH2_GetExceptionCode();
 723                 _SEH2_YIELD(break);
 724             }
 725             _SEH2_END;
 726
 727             Status = UserInitiateShutdown(Thread, &CapturedFlags);
 728
 729             /* Return the modified value to the caller */
 730             _SEH2_TRY
 731             {
 732                 *(PULONG)ThreadInformation = CapturedFlags;
 733             }
 734             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 735             {
 736                 Status = _SEH2_GetExceptionCode();
 737             }
 738             _SEH2_END;
 739
 740             break;
 741         }
 742
 743         case UserThreadEndShutdown:
 744         {
 745             NTSTATUS ShutdownStatus;
 746
 747             ERR("Shutdown ended\n");
 748
 749             if (ThreadInformationLength != sizeof(ShutdownStatus))
 750             {
 751                 Status = STATUS_INFO_LENGTH_MISMATCH;
 752                 break;
 753             }
 754
 755             /* Capture the caller value */
 756             Status = STATUS_SUCCESS;
 757             _SEH2_TRY
 758             {
 759                 ProbeForRead(ThreadInformation, sizeof(ShutdownStatus), sizeof(PVOID));
 760                 ShutdownStatus = *(NTSTATUS*)ThreadInformation;
 761             }
 762             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 763             {
 764                 Status = _SEH2_GetExceptionCode();
 765                 _SEH2_YIELD(break);
 766             }
 767             _SEH2_END;
 768
 769             Status = UserEndShutdown(Thread, ShutdownStatus);
 770             break;
 771         }
 772
 773         case UserThreadCsrApiPort:
 774         {
 775             HANDLE CsrPortHandle;
 776
 777             ERR("Set CSR API Port for Win32k\n");
 778
 779             if (ThreadInformationLength != sizeof(CsrPortHandle))
 780             {
 781                 Status = STATUS_INFO_LENGTH_MISMATCH;
 782                 break;
 783             }
 784
 785             /* Capture the caller value */
 786             Status = STATUS_SUCCESS;
 787             _SEH2_TRY
 788             {
 789                 ProbeForRead(ThreadInformation, sizeof(CsrPortHandle), sizeof(PVOID));
 790                 CsrPortHandle = *(PHANDLE)ThreadInformation;
 791             }
 792             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 793             {
 794                 Status = _SEH2_GetExceptionCode();
 795                 _SEH2_YIELD(break);
 796             }
 797             _SEH2_END;
 798
 799             Status = InitCsrApiPort(CsrPortHandle);
 800             break;
 801         }
 802
 803         default:
 804         {
 805             STUB;
 806             Status = STATUS_NOT_IMPLEMENTED;
 807             break;
 808         }
 809     }
 810
 811     ObDereferenceObject(Thread);
 812
 813 Quit:
 814     UserLeave();
 815     return Status;
 816 }
 817
 818 DWORD
 819 APIENTRY
 820 NtUserSetThreadLayoutHandles(
 821     DWORD dwUnknown1,
 822     DWORD dwUnknown2)
 823 {
 824     STUB;
 825     return 0;
 826 }
 827
 828 BOOL
 829 APIENTRY
 830 NtUserSoundSentry(VOID)
 831 {
 832     STUB;
 833     return 0;
 834 }
 835
 836 DWORD
 837 APIENTRY
 838 NtUserTestForInteractiveUser(
 839     DWORD dwUnknown1)
 840 {
 841     STUB;
 842     return 0;
 843 }
 844
 845 /* http://www.cyber-ta.org/releases/malware-analysis/public/SOURCES/b47155634ccb2c30630da7e3666d3d07/b47155634ccb2c30630da7e3666d3d07.trace.html#NtUserGetIconSize */
 846 DWORD
 847 APIENTRY
 848 NtUserCalcMenuBar(
 849     DWORD dwUnknown1,
 850     DWORD dwUnknown2,
 851     DWORD dwUnknown3,
 852     DWORD dwUnknown4,
 853     DWORD dwUnknown5)
 854 {
 855     STUB;
 856     return 0;
 857 }
 858
 859 DWORD
 860 APIENTRY
 861 NtUserPaintMenuBar(
 862     DWORD dwUnknown1,
 863     DWORD dwUnknown2,
 864     DWORD dwUnknown3,
 865     DWORD dwUnknown4,
 866     DWORD dwUnknown5,
 867     DWORD dwUnknown6)
 868 {
 869     STUB;
 870     return 0;
 871 }
 872
 873
 874 DWORD
 875 APIENTRY
 876 NtUserRemoteConnect(
 877     DWORD dwUnknown1,
 878     DWORD dwUnknown2,
 879     DWORD dwUnknown3)
 880 {
 881     STUB;
 882     return 0;
 883 }
 884
 885 DWORD
 886 APIENTRY
 887 NtUserRemoteRedrawRectangle(
 888     DWORD dwUnknown1,
 889     DWORD dwUnknown2,
 890     DWORD dwUnknown3,
 891     DWORD dwUnknown4)
 892 {
 893     STUB;
 894     return 0;
 895 }
 896
 897 DWORD
 898 APIENTRY
 899 NtUserRemoteRedrawScreen(VOID)
 900 {
 901     STUB;
 902     return 0;
 903 }
 904
 905 DWORD
 906 APIENTRY
 907 NtUserRemoteStopScreenUpdates(VOID)
 908 {
 909     STUB;
 910     return 0;
 911 }
 912
 913 DWORD
 914 APIENTRY
 915 NtUserCtxDisplayIOCtl(
 916     DWORD dwUnknown1,
 917     DWORD dwUnknown2,
 918     DWORD dwUnknown3)
 919 {
 920     STUB;
 921     return 0;
 922 }
 923
 924 /*
 925  * FillWindow: Called from User; Dialog, Edit and ListBox procs during a WM_ERASEBKGND.
 926  */
 927 /*
 928  * @unimplemented
 929  */
 930 BOOL APIENTRY
 931 NtUserFillWindow(HWND hWndPaint,
 932                  HWND hWndPaint1,
 933                  HDC  hDC,
 934                  HBRUSH hBrush)
 935 {
 936    STUB
 937
 938    return 0;
 939 }
 940
 941 /*
 942  * @unimplemented
 943  */
 944 BOOL APIENTRY
 945 NtUserLockWindowUpdate(HWND hWnd)
 946 {
 947    STUB
 948
 949    return 0;
 950 }
 951
 952 BOOL
 953 APIENTRY
 954 NtUserGetLayeredWindowAttributes(
 955     HWND hwnd,
 956     COLORREF *pcrKey,
 957     BYTE *pbAlpha,
 958     DWORD *pdwFlags)
 959 {
 960     STUB;
 961     return 0;
 962 }
 963
 964 /*
 965  * @unimplemented
 966  */
 967 BOOL APIENTRY
 968 NtUserSetLayeredWindowAttributes(HWND hwnd,
 969                            COLORREF crKey,
 970                            BYTE bAlpha,
 971                            DWORD dwFlags)
 972 {
 973   STUB;
 974   return FALSE;
 975 }
 976
 977 /*
 978  * @unimplemented
 979  */
 980 BOOL
 981 APIENTRY
 982 NtUserUpdateLayeredWindow(
 983    HWND hwnd,
 984    HDC hdcDst,
 985    POINT *pptDst,
 986    SIZE *psize,
 987    HDC hdcSrc,
 988    POINT *pptSrc,
 989    COLORREF crKey,
 990    BLENDFUNCTION *pblend,
 991    DWORD dwFlags,
 992    RECT *prcDirty)
 993 {
 994    STUB
 995
 996    return 0;
 997 }
 998
 999 DWORD APIENTRY
1000 NtUserQuerySendMessage(DWORD Unknown0)
1001 {
1002     STUB;
1003
1004     return 0;
1005 }
1006
1007 BOOL APIENTRY NtUserAddClipboardFormatListener(
1008     HWND hwnd
1009 )
1010 {
1011     STUB;
1012     return FALSE;
1013 }
1014
1015 BOOL APIENTRY NtUserRemoveClipboardFormatListener(
1016     HWND hwnd
1017 )
1018 {
1019     STUB;
1020     return FALSE;
1021 }
1022
1023 BOOL APIENTRY NtUserGetUpdatedClipboardFormats(
1024     PUINT lpuiFormats,
1025     UINT cFormats,
1026     PUINT pcFormatsOut
1027 )
1028 {
1029     STUB;
1030     return FALSE;
1031 }
1032
1033 /* EOF */