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