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