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