[IMM32_APITEST] himc: Use ok rather than ok_int (#3970)
[reactos.git] / 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 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 HIMC hIMC,
360 DWORD Unknown1,
361 LPVOID pClientImc)
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 HIMC hIMC,
634 DWORD dwUnknown2)
635 {
636 TRACE("NtUserQueryInputContext(%p, 0x%lX)\n", hIMC, dwUnknown2);
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 */