fa11337371fa2d58e770b521408abe2170393ebe
[reactos.git] / reactos / dll / win32 / gdi32 / misc / stubs.c
1 /* $Id$
2 *
3 * reactos/lib/gdi32/misc/stubs.c
4 *
5 * GDI32.DLL Stubs
6 *
7 * When you implement one of these functions,
8 * remove its stub from this file.
9 *
10 */
11
12 #include "precomp.h"
13
14 #define SIZEOF_DEVMODEA_300 124
15 #define SIZEOF_DEVMODEA_400 148
16 #define SIZEOF_DEVMODEA_500 156
17 #define SIZEOF_DEVMODEW_300 188
18 #define SIZEOF_DEVMODEW_400 212
19 #define SIZEOF_DEVMODEW_500 220
20
21 #define UNIMPLEMENTED DbgPrint("GDI32: %s is unimplemented, please try again later.\n", __FUNCTION__);
22
23
24 /*
25 * @unimplemented
26 */
27 BOOL
28 STDCALL
29 TranslateCharsetInfo(DWORD * lpSrc,
30 LPCHARSETINFO lpCs,
31 DWORD dwFlags)
32 {
33 /* FIXME share memory */
34 return NtGdiTranslateCharsetInfo(lpSrc, lpCs, dwFlags );
35 }
36
37 /*
38 * @unimplemented
39 */
40 int
41 STDCALL
42 StretchDIBits(HDC hdc,
43 int XDest,
44 int YDest,
45 int nDestWidth,
46 int nDestHeight,
47 int XSrc,
48 int YSrc,
49 int nSrcWidth,
50 int nSrcHeight,
51 CONST VOID *lpBits,
52 CONST BITMAPINFO *lpBitsInfo,
53 UINT iUsage,
54 DWORD dwRop)
55
56 {
57 /* FIXME share memory */
58 return NtGdiStretchDIBits(hdc, XDest, YDest, nDestWidth, nDestHeight, XSrc, YSrc,
59 nSrcWidth, nSrcHeight, lpBits, lpBitsInfo, iUsage, dwRop);
60 }
61
62 /*
63 * @unimplemented
64 */
65 int
66 STDCALL
67 SetDIBits(HDC hdc,
68 HBITMAP hbmp,
69 UINT uStartScan,
70 UINT cScanLines,
71 CONST VOID *lpvBits,
72 CONST BITMAPINFO *lpbmi,
73 UINT fuColorUse)
74 {
75 /* FIXME share memory */
76 return NtGdiSetDIBits(hdc, hbmp, uStartScan, cScanLines, lpvBits, lpbmi, fuColorUse);
77 }
78
79 /*
80 * @unimplemented
81 */
82 int
83 STDCALL
84 SetGraphicsMode(HDC hdc,
85 int iMode)
86 {
87 /* FIXME share memory */
88 return NtGdiSetGraphicsMode(hdc, iMode);
89 }
90
91 /*
92 * @unimplemented
93 */
94 int
95 STDCALL
96 SetPolyFillMode(HDC hdc,
97 int iPolyFillMode)
98 {
99 /* FIXME share memory */
100 return NtGdiSetPolyFillMode(hdc, iPolyFillMode);
101 }
102
103 /*
104 * @unimplemented
105 */
106 int
107 STDCALL
108 SetROP2(HDC hdc,
109 int fnDrawMode)
110 {
111 UNIMPLEMENTED;
112 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
113 return 0;
114 }
115
116 /*
117 * @unimplemented
118 */
119 int
120 STDCALL
121 SetStretchBltMode(HDC hdc, int iStretchMode)
122 {
123 /* FIXME share memory */
124 return NtGdiSetStretchBltMode(hdc, iStretchMode);
125 }
126
127 /*
128 * @unimplemented
129 */
130 BOOL
131 STDCALL
132 SetRectRgn(HRGN hrgn,
133 int nLeftRect,
134 int nTopRect,
135 int nRightRect,
136 int nBottomRect)
137 {
138 /* FIXME metadc stuff */
139 return NtGdiSetRectRgn(hrgn, nLeftRect, nTopRect, nRightRect, nBottomRect);
140 }
141
142 /*
143 * @unimplemented
144 */
145 UINT
146 STDCALL
147 SetTextAlign(HDC hdc,
148 UINT fMode)
149 {
150 /* FIXME share memory */
151 return NtGdiSetTextAlign(hdc, fMode);
152 }
153
154 /*
155 * @unimplemented
156 */
157 BOOL
158 STDCALL
159 SetViewportExtEx(HDC hdc,
160 int nXExtent,
161 int nYExtent,
162 LPSIZE lpSize)
163 {
164 /* FIXME share memory */
165 return NtGdiSetViewportExtEx(hdc, nXExtent, nYExtent, lpSize);
166 }
167
168 /*
169 * @unimplemented
170 */
171 BOOL
172 STDCALL
173 SetWindowOrgEx(HDC hdc,
174 int X,
175 int Y,
176 LPPOINT lpPoint)
177 {
178 /* FIXME share memory */
179 return NtGdiSetWindowOrgEx(hdc,X,Y,lpPoint);
180 }
181
182 /*
183 * @unimplemented
184 */
185 BOOL
186 STDCALL
187 SetWindowExtEx(HDC hdc,
188 int nXExtent,
189 int nYExtent,
190 LPSIZE lpSize)
191 {
192 /* FIXME share memory */
193 return NtGdiSetWindowExtEx(hdc, nXExtent, nYExtent, lpSize);
194 }
195
196 /*
197 * @unimplemented
198 */
199 BOOL
200 STDCALL
201 SetViewportOrgEx(HDC hdc,
202 int X,
203 int Y,
204 LPPOINT lpPoint)
205 {
206 /* FIXME share memory */
207 return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint);
208 }
209
210 /*
211 * @unimplemented
212 */
213 BOOL
214 STDCALL
215 SetBrushOrgEx(HDC hdc,
216 int nXOrg,
217 int nYOrg,
218 LPPOINT lppt)
219 {
220 /* FIXME share memory */
221 return NtGdiSetBrushOrg(hdc,nXOrg,nYOrg,lppt);
222 }
223
224 /*
225 * @unimplemented
226 */
227 BOOL
228 STDCALL
229 PtInRegion(IN HRGN hrgn,
230 int x,
231 int y)
232 {
233 /* FIXME some stuff at user mode need be fixed */
234 return NtGdiPtInRegion(hrgn,x,y);
235 }
236
237 /*
238 * @unimplemented
239 */
240 BOOL
241 STDCALL
242 RectInRegion(HRGN hrgn,
243 LPCRECT prcl)
244 {
245 /* FIXME some stuff at user mode need be fixed */
246 return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
247 }
248
249 /*
250 * @unimplemented
251 */
252 BOOL
253 STDCALL
254 RestoreDC(IN HDC hdc,
255 IN INT iLevel)
256 {
257 /* FIXME Sharememory */
258 return NtGdiRestoreDC(hdc, iLevel);
259 }
260
261 /*
262 * @unimplemented
263 */
264 INT
265 STDCALL
266 SaveDC(IN HDC hdc)
267 {
268 /* FIXME Sharememory */
269 return NtGdiSaveDC(hdc);
270 }
271
272
273
274 /*
275 * @unimplemented
276 */
277 BOOL
278 STDCALL
279 CancelDC(HDC hdc)
280 {
281 UNIMPLEMENTED;
282 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
283 return FALSE;
284 }
285
286
287 /*
288 * @unimplemented
289 */
290 int
291 STDCALL
292 DrawEscape(HDC hdc,
293 int a1,
294 int a2,
295 LPCSTR a3)
296 {
297 UNIMPLEMENTED;
298 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
299 return 0;
300 }
301
302
303 /*
304 * @unimplemented
305 */
306 int
307 STDCALL
308 EnumObjects(HDC hdc,
309 int a1,
310 GOBJENUMPROC a2,
311 LPARAM a3)
312 {
313 UNIMPLEMENTED;
314 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
315 return 0;
316 }
317
318 /*
319 * @unimplemented
320 */
321 int
322 STDCALL
323 Escape(HDC hdc, INT escape, INT in_count, LPCSTR in_data, LPVOID out_data)
324 {
325 UNIMPLEMENTED;
326 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
327 return 0;
328 }
329
330 /*
331 * @unimplemented
332 */
333 HRGN
334 STDCALL
335 ExtCreateRegion(
336 CONST XFORM * a0,
337 DWORD a1,
338 CONST RGNDATA * a2
339 )
340 {
341 UNIMPLEMENTED;
342 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
343 return 0;
344 }
345
346
347 /*
348 * @implemented
349 */
350 UINT
351 STDCALL
352 GetBoundsRect(
353 HDC hdc,
354 LPRECT lprcBounds,
355 UINT flags
356 )
357 {
358 return NtGdiGetBoundsRect(hdc,lprcBounds,flags & DCB_RESET);
359 }
360
361
362 /*
363 * @implemented
364 */
365 int
366 STDCALL
367 GetMetaRgn(HDC hdc,
368 HRGN hrgn)
369 {
370 return NtGdiGetRandomRgn(hdc,hrgn,2);
371 }
372
373
374 /*
375 * @unimplemented
376 */
377 UINT
378 STDCALL
379 GetMetaFileBitsEx(
380 HMETAFILE a0,
381 UINT a1,
382 LPVOID a2
383 )
384 {
385 UNIMPLEMENTED;
386 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
387 return 0;
388 }
389
390
391
392 /*
393 * @unimplemented
394 */
395 DWORD
396 STDCALL
397 GetFontLanguageInfo(
398 HDC hDc
399 )
400 {
401 UNIMPLEMENTED;
402 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
403 return 0;
404 }
405
406 /*
407 * @unimplemented
408 */
409 BOOL
410 STDCALL
411 PlayMetaFile(
412 HDC a0,
413 HMETAFILE a1
414 )
415 {
416 UNIMPLEMENTED;
417 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
418 return FALSE;
419 }
420
421 /*
422 * @unimplemented
423 */
424 BOOL
425 STDCALL
426 ResizePalette(
427 HPALETTE a0,
428 UINT a1
429 )
430 {
431 UNIMPLEMENTED;
432 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
433 return FALSE;
434 }
435
436 /*
437 * @unimplemented
438 */
439 int
440 STDCALL
441 SetMetaRgn(
442 HDC hdc
443 )
444 {
445 UNIMPLEMENTED;
446 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
447 return 0;
448 }
449
450 /*
451 * @implemented
452 */
453 UINT
454 STDCALL
455 SetBoundsRect(HDC hdc,
456 CONST RECT *prc,
457 UINT flags)
458 {
459 /* FIXME add check for vaildate the flags */
460 return NtGdiSetBoundsRect(hdc, (LPRECT)prc, flags);
461 }
462
463
464 /*
465 * @unimplemented
466 */
467 DWORD
468 STDCALL
469 SetMapperFlags(
470 HDC a0,
471 DWORD a1
472 )
473 {
474 UNIMPLEMENTED;
475 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
476 return 0;
477 }
478
479 /*
480 * @unimplemented
481 */
482 HMETAFILE
483 STDCALL
484 SetMetaFileBitsEx(
485 UINT a0,
486 CONST BYTE *a1
487 )
488 {
489 UNIMPLEMENTED;
490 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
491 return 0;
492 }
493
494 /*
495 * @unimplemented
496 */
497 BOOL
498 STDCALL
499 SetTextJustification(
500 HDC a0,
501 int a1,
502 int a2
503 )
504 {
505 UNIMPLEMENTED;
506 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
507 return FALSE;
508 }
509
510 /*
511 * @unimplemented
512 */
513 BOOL
514 STDCALL
515 UpdateColors(
516 HDC hdc
517 )
518 {
519 UNIMPLEMENTED;
520 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
521 return FALSE;
522 }
523
524
525 /*
526 * @unimplemented
527 */
528 BOOL
529 STDCALL
530 PlayMetaFileRecord(
531 HDC a0,
532 LPHANDLETABLE a1,
533 LPMETARECORD a2,
534 UINT a3
535 )
536 {
537 UNIMPLEMENTED;
538 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
539 return FALSE;
540 }
541
542
543 /*
544 * @unimplemented
545 */
546 BOOL
547 STDCALL
548 EnumMetaFile(
549 HDC a0,
550 HMETAFILE a1,
551 MFENUMPROC a2,
552 LPARAM a3
553 )
554 {
555 UNIMPLEMENTED;
556 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
557 return FALSE;
558 }
559
560 /*
561 * @unimplemented
562 */
563 BOOL
564 STDCALL
565 DeleteEnhMetaFile(
566 HENHMETAFILE a0
567 )
568 {
569 UNIMPLEMENTED;
570 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
571 return FALSE;
572 }
573
574 /*
575 * @unimplemented
576 */
577 BOOL
578 STDCALL
579 EnumEnhMetaFile(
580 HDC a0,
581 HENHMETAFILE a1,
582 ENHMFENUMPROC a2,
583 LPVOID a3,
584 CONST RECT *a4
585 )
586 {
587 UNIMPLEMENTED;
588 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
589 return FALSE;
590 }
591
592 /*
593 * @unimplemented
594 */
595 UINT
596 STDCALL
597 GetEnhMetaFileBits(
598 HENHMETAFILE a0,
599 UINT a1,
600 LPBYTE a2
601 )
602 {
603 UNIMPLEMENTED;
604 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
605 return 0;
606 }
607
608
609 /*
610 * @unimplemented
611 */
612 UINT
613 STDCALL
614 GetEnhMetaFileHeader(
615 HENHMETAFILE a0,
616 UINT a1,
617 LPENHMETAHEADER a2
618 )
619 {
620 UNIMPLEMENTED;
621 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
622 return 0;
623 }
624
625 /*
626 * @unimplemented
627 */
628 UINT
629 STDCALL
630 GetEnhMetaFilePaletteEntries(
631 HENHMETAFILE a0,
632 UINT a1,
633 LPPALETTEENTRY a2
634 )
635 {
636 UNIMPLEMENTED;
637 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
638 return 0;
639 }
640
641 /*
642 * @unimplemented
643 */
644 UINT
645 STDCALL
646 GetWinMetaFileBits(
647 HENHMETAFILE a0,
648 UINT a1,
649 LPBYTE a2,
650 INT a3,
651 HDC a4
652 )
653 {
654 UNIMPLEMENTED;
655 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
656 return 0;
657 }
658
659
660 /*
661 * @unimplemented
662 */
663 BOOL
664 STDCALL
665 PlayEnhMetaFile(
666 HDC a0,
667 HENHMETAFILE a1,
668 CONST RECT *a2
669 )
670 {
671 UNIMPLEMENTED;
672 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
673 return FALSE;
674 }
675
676
677 /*
678 * @unimplemented
679 */
680 BOOL
681 STDCALL
682 PlayEnhMetaFileRecord(
683 HDC a0,
684 LPHANDLETABLE a1,
685 CONST ENHMETARECORD *a2,
686 UINT a3
687 )
688 {
689 UNIMPLEMENTED;
690 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
691 return FALSE;
692 }
693
694
695 /*
696 * @unimplemented
697 */
698 HENHMETAFILE
699 STDCALL
700 SetEnhMetaFileBits(
701 UINT a0,
702 CONST BYTE *a1
703 )
704 {
705 UNIMPLEMENTED;
706 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
707 return 0;
708 }
709
710
711 /*
712 * @unimplemented
713 */
714 HENHMETAFILE
715 STDCALL
716 SetWinMetaFileBits(
717 UINT a0,
718 CONST BYTE *a1,
719 HDC a2,
720 CONST METAFILEPICT *a3)
721 {
722 UNIMPLEMENTED;
723 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
724 return 0;
725 }
726
727
728 /*
729 * @unimplemented
730 */
731 BOOL
732 STDCALL
733 GdiComment(
734 HDC hDC,
735 UINT bytes,
736 CONST BYTE *buffer
737 )
738 {
739 #if 0
740 if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF)
741 {
742 PLDC pLDC = GdiGetLDC(hDC);
743 if ( !pLDC )
744 {
745 SetLastError(ERROR_INVALID_HANDLE);
746 return FALSE;
747 }
748 if (pLDC->iType == LDC_EMFLDC)
749 { // Wine port
750 return EMFDRV_GdiComment( hDC, bytes, buffer );
751 }
752 }
753 #endif
754 return FALSE;
755 }
756
757
758 /*
759 * @unimplemented
760 */
761 BOOL
762 STDCALL
763 AngleArc(
764 HDC hdc,
765 int a1,
766 int a2,
767 DWORD a3,
768 FLOAT a4,
769 FLOAT a5
770 )
771 {
772 UNIMPLEMENTED;
773 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
774 return FALSE;
775 }
776
777
778 /*
779 * @unimplemented
780 */
781 BOOL
782 STDCALL
783 SetColorAdjustment(
784 HDC hdc,
785 CONST COLORADJUSTMENT *a1
786 )
787 {
788 UNIMPLEMENTED;
789 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
790 return FALSE;
791 }
792
793 /*
794 * @unimplemented
795 */
796 int
797 STDCALL
798 EndDoc(
799 HDC hdc
800 )
801 {
802 UNIMPLEMENTED;
803 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
804 return 0;
805 }
806
807
808 /*
809 * @unimplemented
810 */
811 int
812 STDCALL
813 StartPage(
814 HDC hdc
815 )
816 {
817 UNIMPLEMENTED;
818 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
819 return 0;
820 }
821
822
823 /*
824 * @unimplemented
825 */
826 int
827 STDCALL
828 EndPage(
829 HDC hdc
830 )
831 {
832 UNIMPLEMENTED;
833 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
834 return 0;
835 }
836
837
838 /*
839 * @unimplemented
840 */
841 int
842 STDCALL
843 AbortDoc(
844 HDC hdc
845 )
846 {
847 UNIMPLEMENTED;
848 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
849 return 0;
850 }
851
852
853 /*
854 * @unimplemented
855 */
856 int
857 STDCALL
858 SetAbortProc(
859 HDC hdc,
860 ABORTPROC a1
861 )
862 {
863 UNIMPLEMENTED;
864 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
865 return 0;
866 }
867
868
869 /*
870 * @unimplemented
871 */
872 BOOL
873 STDCALL
874 ScaleViewportExtEx(
875 HDC a0,
876 int a1,
877 int a2,
878 int a3,
879 int a4,
880 LPSIZE a5
881 )
882 {
883 UNIMPLEMENTED;
884 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
885 return FALSE;
886 }
887
888
889 /*
890 * @unimplemented
891 */
892 BOOL
893 STDCALL
894 ScaleWindowExtEx(
895 HDC a0,
896 int a1,
897 int a2,
898 int a3,
899 int a4,
900 LPSIZE a5
901 )
902 {
903 UNIMPLEMENTED;
904 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
905 return FALSE;
906 }
907
908
909 /*
910 * @implemented
911 */
912 BOOL
913 STDCALL
914 UnrealizeObject(HGDIOBJ hgdiobj)
915 {
916 BOOL retValue = TRUE;
917
918 if (GDI_HANDLE_GET_TYPE(hgdiobj) != GDI_OBJECT_TYPE_BRUSH)
919 {
920 retValue = NtGdiUnrealizeObject(hgdiobj);
921 }
922
923 return retValue;
924 }
925
926
927 /*
928 * @implemented
929 */
930 BOOL
931 STDCALL
932 GdiFlush()
933 {
934 NtGdiFlush();
935 return TRUE;
936 }
937
938
939 /*
940 * @unimplemented
941 */
942 int
943 STDCALL
944 SetICMMode(
945 HDC a0,
946 int a1
947 )
948 {
949 UNIMPLEMENTED;
950 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
951 return 0;
952 }
953
954
955 /*
956 * @unimplemented
957 */
958 BOOL
959 STDCALL
960 CheckColorsInGamut(
961 HDC a0,
962 LPVOID a1,
963 LPVOID a2,
964 DWORD a3
965 )
966 {
967 UNIMPLEMENTED;
968 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
969 return FALSE;
970 }
971
972
973 /*
974 * @unimplemented
975 */
976 HCOLORSPACE
977 STDCALL
978 GetColorSpace(HDC hDc)
979 {
980 UNIMPLEMENTED;
981 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
982 return 0;
983 }
984
985
986 /*
987 * @unimplemented
988 */
989 HCOLORSPACE
990 STDCALL
991 SetColorSpace(
992 HDC a0,
993 HCOLORSPACE a1
994 )
995 {
996 UNIMPLEMENTED;
997 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
998 return FALSE;
999 }
1000
1001 /*
1002 * @implemented
1003 */
1004 BOOL
1005 STDCALL
1006 GetDeviceGammaRamp( HDC hdc,
1007 LPVOID lpGammaRamp)
1008 {
1009 BOOL retValue = FALSE;
1010 if (lpGammaRamp == NULL)
1011 {
1012 SetLastError(ERROR_INVALID_PARAMETER);
1013 }
1014 else
1015 {
1016 retValue = NtGdiGetDeviceGammaRamp(hdc,lpGammaRamp);
1017 }
1018
1019 return retValue;
1020 }
1021
1022 /*
1023 * @implemented
1024 */
1025 BOOL
1026 STDCALL
1027 SetDeviceGammaRamp(HDC hdc,
1028 LPVOID lpGammaRamp)
1029 {
1030 BOOL retValue = FALSE;
1031
1032 if (lpGammaRamp)
1033 {
1034 retValue = NtGdiSetDeviceGammaRamp(hdc, lpGammaRamp);
1035 }
1036 else
1037 {
1038 SetLastError(ERROR_INVALID_PARAMETER);
1039 }
1040
1041 return retValue;
1042 }
1043
1044
1045 /*
1046 * @unimplemented
1047 */
1048 BOOL
1049 STDCALL
1050 ColorMatchToTarget(
1051 HDC a0,
1052 HDC a1,
1053 DWORD a2
1054 )
1055 {
1056 UNIMPLEMENTED;
1057 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1058 return FALSE;
1059 }
1060
1061
1062 /*
1063 * @unimplemented
1064 */
1065 BOOL
1066 STDCALL
1067 wglCopyContext(
1068 HGLRC a0,
1069 HGLRC a1,
1070 UINT a2
1071 )
1072 {
1073 UNIMPLEMENTED;
1074 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1075 return FALSE;
1076 }
1077
1078
1079 /*
1080 * @unimplemented
1081 */
1082 HGLRC
1083 STDCALL
1084 wglCreateContext(
1085 HDC hDc
1086 )
1087 {
1088 UNIMPLEMENTED;
1089 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1090 return 0;
1091 }
1092
1093
1094 /*
1095 * @unimplemented
1096 */
1097 HGLRC
1098 STDCALL
1099 wglCreateLayerContext(
1100 HDC hDc,
1101 int a1
1102 )
1103 {
1104 UNIMPLEMENTED;
1105 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1106 return 0;
1107 }
1108
1109
1110 /*
1111 * @unimplemented
1112 */
1113 BOOL
1114 STDCALL
1115 wglDeleteContext(
1116 HGLRC a
1117 )
1118 {
1119 UNIMPLEMENTED;
1120 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1121 return FALSE;
1122 }
1123
1124
1125 /*
1126 * @unimplemented
1127 */
1128 HGLRC
1129 STDCALL
1130 wglGetCurrentContext(VOID)
1131 {
1132 UNIMPLEMENTED;
1133 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1134 return 0;
1135 }
1136
1137
1138 /*
1139 * @unimplemented
1140 */
1141 HDC
1142 STDCALL
1143 wglGetCurrentDC(VOID)
1144 {
1145 UNIMPLEMENTED;
1146 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1147 return 0;
1148 }
1149
1150
1151 /*
1152 * @unimplemented
1153 */
1154 PROC
1155 STDCALL
1156 wglGetProcAddress(
1157 LPCSTR a0
1158 )
1159 {
1160 UNIMPLEMENTED;
1161 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1162 return 0;
1163 }
1164
1165
1166 /*
1167 * @unimplemented
1168 */
1169 BOOL
1170 STDCALL
1171 wglMakeCurrent(
1172 HDC a0,
1173 HGLRC a1
1174 )
1175 {
1176 UNIMPLEMENTED;
1177 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1178 return FALSE;
1179 }
1180
1181
1182 /*
1183 * @unimplemented
1184 */
1185 BOOL
1186 STDCALL
1187 wglShareLists(
1188 HGLRC a0,
1189 HGLRC a1
1190 )
1191 {
1192 UNIMPLEMENTED;
1193 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194 return FALSE;
1195 }
1196
1197
1198 /*
1199 * @unimplemented
1200 */
1201 BOOL
1202 STDCALL
1203 wglDescribeLayerPlane(
1204 HDC a0,
1205 int a1,
1206 int a2,
1207 UINT a3,
1208 LPLAYERPLANEDESCRIPTOR a4
1209 )
1210 {
1211 UNIMPLEMENTED;
1212 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1213 return FALSE;
1214 }
1215
1216
1217 /*
1218 * @unimplemented
1219 */
1220 int
1221 STDCALL
1222 wglSetLayerPaletteEntries(
1223 HDC a0,
1224 int a1,
1225 int a2,
1226 int a3,
1227 CONST COLORREF *a4
1228 )
1229 {
1230 UNIMPLEMENTED;
1231 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1232 return 0;
1233 }
1234
1235
1236 /*
1237 * @unimplemented
1238 */
1239 int
1240 STDCALL
1241 wglGetLayerPaletteEntries(
1242 HDC a0,
1243 int a1,
1244 int a2,
1245 int a3,
1246 COLORREF *a4
1247 )
1248 {
1249 UNIMPLEMENTED;
1250 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1251 return 0;
1252 }
1253
1254
1255 /*
1256 * @unimplemented
1257 */
1258 BOOL
1259 STDCALL
1260 wglRealizeLayerPalette(
1261 HDC a0,
1262 int a1,
1263 BOOL a2
1264 )
1265 {
1266 UNIMPLEMENTED;
1267 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1268 return FALSE;
1269 }
1270
1271
1272 /*
1273 * @unimplemented
1274 */
1275 BOOL
1276 STDCALL
1277 wglSwapLayerBuffers(
1278 HDC a0,
1279 UINT a1
1280 )
1281 {
1282 UNIMPLEMENTED;
1283 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1284 return FALSE;
1285 }
1286
1287
1288 /* === AFTER THIS POINT I GUESS... =========
1289 * (based on stack size in Norlander's .def)
1290 * === WHERE ARE THEY DEFINED? =============
1291 */
1292
1293 /*
1294 * @unimplemented
1295 */
1296 DWORD
1297 STDCALL
1298 IsValidEnhMetaRecord(
1299 DWORD a0,
1300 DWORD a1
1301 )
1302 {
1303 UNIMPLEMENTED;
1304 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1305 return 0;
1306
1307 }
1308
1309 /*
1310 * @unimplemented
1311 */
1312 DWORD
1313 STDCALL
1314 IsValidEnhMetaRecordOffExt(
1315 DWORD a0,
1316 DWORD a1,
1317 DWORD a2,
1318 DWORD a3
1319 )
1320 {
1321 UNIMPLEMENTED;
1322 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1323 return 0;
1324
1325 }
1326
1327 /*
1328 * @unimplemented
1329 */
1330 DWORD
1331 STDCALL
1332 GetGlyphOutlineWow(
1333 DWORD a0,
1334 DWORD a1,
1335 DWORD a2,
1336 DWORD a3,
1337 DWORD a4,
1338 DWORD a5,
1339 DWORD a6
1340 )
1341 {
1342 UNIMPLEMENTED;
1343 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1344 return 0;
1345 }
1346
1347 /*
1348 * @unimplemented
1349 */
1350 DWORD
1351 STDCALL
1352 gdiPlaySpoolStream(
1353 DWORD a0,
1354 DWORD a1,
1355 DWORD a2,
1356 DWORD a3,
1357 DWORD a4,
1358 DWORD a5
1359 )
1360 {
1361 UNIMPLEMENTED;
1362 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1363 return 0;
1364 }
1365
1366 /*
1367 * @unimplemented
1368 */
1369 HANDLE
1370 STDCALL
1371 AddFontMemResourceEx(
1372 PVOID pbFont,
1373 DWORD cbFont,
1374 PVOID pdv,
1375 DWORD *pcFonts
1376 )
1377 {
1378 UNIMPLEMENTED;
1379 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1380 return 0;
1381 }
1382
1383 /*
1384 * @unimplemented
1385 */
1386 int
1387 STDCALL
1388 AddFontResourceTracking(
1389 LPCSTR lpString,
1390 int unknown
1391 )
1392 {
1393 UNIMPLEMENTED;
1394 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1395 return 0;
1396 }
1397
1398
1399
1400 /*
1401 * @unimplemented
1402 */
1403 HBITMAP
1404 STDCALL
1405 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1406 {
1407 UNIMPLEMENTED;
1408 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1409 return 0;
1410 }
1411
1412 /*
1413 * @unimplemented
1414 */
1415 HBRUSH
1416 STDCALL
1417 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1418 {
1419 UNIMPLEMENTED;
1420 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421 return 0;
1422 }
1423
1424 /*
1425 * @unimplemented
1426 */
1427 BOOL
1428 STDCALL
1429 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
1430 {
1431 UNIMPLEMENTED;
1432 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1433 return 0;
1434 }
1435
1436 /*
1437 * @unimplemented
1438 */
1439 int
1440 STDCALL
1441 EndFormPage(HDC hdc)
1442 {
1443 UNIMPLEMENTED;
1444 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1445 return 0;
1446 }
1447
1448
1449
1450 /*
1451 * @unimplemented
1452 */
1453 DWORD
1454 STDCALL
1455 GdiAddGlsBounds(HDC hdc,LPRECT prc)
1456 {
1457 UNIMPLEMENTED;
1458 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1459 return 0;
1460 }
1461
1462 /*
1463 * @unimplemented
1464 */
1465 BOOL
1466 STDCALL
1467 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
1468 {
1469 UNIMPLEMENTED;
1470 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1471 return 0;
1472 }
1473
1474 /*
1475 * @unimplemented
1476 */
1477 BOOL
1478 STDCALL
1479 GdiCleanCacheDC(HDC hdc)
1480 {
1481 UNIMPLEMENTED;
1482 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1483 return 0;
1484 }
1485
1486 /*
1487 * @unimplemented
1488 */
1489 HDC
1490 STDCALL
1491 GdiConvertAndCheckDC(HDC hdc)
1492 {
1493 UNIMPLEMENTED;
1494 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1495 return 0;
1496 }
1497
1498 /*
1499 * @unimplemented
1500 */
1501 HENHMETAFILE
1502 STDCALL
1503 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
1504 {
1505 UNIMPLEMENTED;
1506 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1507 return 0;
1508 }
1509
1510 /*
1511 * @unimplemented
1512 */
1513 BOOL
1514 STDCALL
1515 GdiDrawStream(HDC dc, ULONG l, VOID *v)
1516 {
1517 UNIMPLEMENTED;
1518 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1519 return 0;
1520 }
1521
1522 /*
1523 * @unimplemented
1524 */
1525 DWORD
1526 STDCALL
1527 GdiGetCodePage(HDC hdc)
1528 {
1529 UNIMPLEMENTED;
1530 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1531 return 0;
1532 }
1533
1534 /*
1535 * @unimplemented
1536 */
1537 HBRUSH
1538 STDCALL
1539 GdiGetLocalBrush(HBRUSH hbr)
1540 {
1541 UNIMPLEMENTED;
1542 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1543 return 0;
1544 }
1545
1546 /*
1547 * @unimplemented
1548 */
1549 HDC
1550 STDCALL
1551 GdiGetLocalDC(HDC hdc)
1552 {
1553 UNIMPLEMENTED;
1554 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1555 return 0;
1556 }
1557
1558 /*
1559 * @unimplemented
1560 */
1561 HFONT
1562 STDCALL
1563 GdiGetLocalFont(HFONT hfont)
1564 {
1565 UNIMPLEMENTED;
1566 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1567 return 0;
1568 }
1569
1570 /*
1571 * @unimplemented
1572 */
1573 BOOL
1574 STDCALL
1575 GdiIsMetaFileDC(HDC hdc)
1576 {
1577 UNIMPLEMENTED;
1578 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1579 return 0;
1580 }
1581
1582 /*
1583 * @unimplemented
1584 */
1585 BOOL
1586 STDCALL
1587 GdiIsMetaPrintDC(HDC hdc)
1588 {
1589 UNIMPLEMENTED;
1590 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1591 return 0;
1592 }
1593
1594 /*
1595 * @unimplemented
1596 */
1597 BOOL
1598 STDCALL
1599 GdiIsPlayMetafileDC(HDC hdc)
1600 {
1601 UNIMPLEMENTED;
1602 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1603 return 0;
1604 }
1605
1606 /*
1607 * @unimplemented
1608 */
1609 BOOL
1610 STDCALL
1611 GdiValidateHandle(HGDIOBJ hobj)
1612 {
1613 UNIMPLEMENTED;
1614 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1615 return 0;
1616 }
1617
1618 /*
1619 * @unimplemented
1620 */
1621 DWORD
1622 STDCALL
1623 GetBitmapAttributes(HBITMAP hbm)
1624 {
1625 UNIMPLEMENTED;
1626 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1627 return 0;
1628 }
1629
1630 /*
1631 * @unimplemented
1632 */
1633 DWORD
1634 STDCALL
1635 GetBrushAttributes(HBRUSH hbr)
1636 {
1637 UNIMPLEMENTED;
1638 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1639 return 0;
1640 }
1641
1642 /*
1643 * @unimplemented
1644 */
1645 BOOL
1646 STDCALL
1647 GetCharABCWidthsI(HDC hdc,
1648 UINT giFirst,
1649 UINT cgi,
1650 LPWORD pgi,
1651 LPABC lpabc
1652 )
1653 {
1654 UNIMPLEMENTED;
1655 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1656 return 0;
1657 }
1658
1659 /*
1660 * @unimplemented
1661 */
1662 BOOL
1663 STDCALL
1664 GetCharWidthI(HDC hdc,
1665 UINT giFirst,
1666 UINT cgi,
1667 LPWORD pgi,
1668 LPINT lpBuffer
1669 )
1670 {
1671 UNIMPLEMENTED;
1672 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1673 return 0;
1674 }
1675
1676
1677
1678 /*
1679 * @implemented
1680 */
1681 ULONG
1682 STDCALL
1683 GetEUDCTimeStamp(VOID)
1684 {
1685 return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1686 }
1687
1688 /*
1689 * @implemented
1690 */
1691 ULONG
1692 STDCALL
1693 GetFontAssocStatus(HDC hdc)
1694 {
1695 ULONG retValue = 0;
1696
1697 if (hdc)
1698 {
1699 retValue = NtGdiQueryFontAssocInfo(hdc);
1700 }
1701
1702 return retValue;
1703 }
1704
1705 /*
1706 * @unimplemented
1707 */
1708 HFONT
1709 STDCALL
1710 GetHFONT(HDC dc)
1711 {
1712 UNIMPLEMENTED;
1713 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1714 return 0;
1715 }
1716
1717 /*
1718 * @unimplemented
1719 */
1720 DWORD
1721 STDCALL
1722 GetLayout(HDC hdc
1723 )
1724 {
1725 UNIMPLEMENTED;
1726 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1727 return 0;
1728 }
1729
1730 /*
1731 * @implemented
1732 */
1733 BOOL
1734 STDCALL
1735 GetTextExtentExPointWPri(HDC hdc,
1736 LPWSTR lpwsz,
1737 ULONG cwc,
1738 ULONG dxMax,
1739 ULONG *pcCh,
1740 PULONG pdxOut,
1741 LPSIZE psize)
1742 {
1743 return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1744 }
1745
1746 /*
1747 * @implemented
1748 */
1749 INT
1750 STDCALL
1751 GetTextFaceAliasW(HDC hdc,
1752 int cChar,
1753 LPWSTR pszOut)
1754 {
1755 INT retValue = 0;
1756 if ((!pszOut) || (cChar))
1757 {
1758 retValue = NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE);
1759 }
1760 else
1761 {
1762 SetLastError(ERROR_INVALID_PARAMETER);
1763 }
1764 return retValue;
1765 }
1766
1767
1768
1769 /*
1770 * @unimplemented
1771 */
1772 BOOL
1773 STDCALL
1774 MirrorRgn(HWND hwnd,HRGN hrgn)
1775 {
1776 UNIMPLEMENTED;
1777 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1778 return 0;
1779 }
1780
1781
1782
1783 /*
1784 * @unimplemented
1785 */
1786 DWORD
1787 STDCALL
1788 QueryFontAssocStatus(VOID)
1789 {
1790 UNIMPLEMENTED;
1791 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1792 return 0;
1793 }
1794
1795 /*
1796 * @implemented
1797 */
1798 BOOL
1799 STDCALL
1800 RemoveFontMemResourceEx(HANDLE fh)
1801 {
1802 BOOL retValue=0;
1803
1804 if (fh)
1805 {
1806 retValue = NtGdiRemoveFontMemResourceEx(fh);
1807 }
1808 else
1809 {
1810 SetLastError(ERROR_INVALID_PARAMETER);
1811 }
1812 return retValue;
1813 }
1814
1815 /*
1816 * @unimplemented
1817 */
1818 int
1819 STDCALL
1820 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1821 {
1822 UNIMPLEMENTED;
1823 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1824 return 0;
1825 }
1826
1827 /*
1828 * @unimplemented
1829 */
1830 HBITMAP
1831 STDCALL
1832 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1833 {
1834 UNIMPLEMENTED;
1835 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1836 return 0;
1837 }
1838
1839 /*
1840 * @unimplemented
1841 */
1842 HBRUSH
1843 STDCALL
1844 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1845 {
1846 UNIMPLEMENTED;
1847 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1848 return 0;
1849 }
1850
1851 /*
1852 * @unimplemented
1853 */
1854 DWORD
1855 STDCALL
1856 SetLayout(HDC hdc,
1857 DWORD dwLayout)
1858 {
1859 UNIMPLEMENTED;
1860 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1861 return 0;
1862 }
1863
1864 /*
1865 * @unimplemented
1866 */
1867 DWORD
1868 STDCALL
1869 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
1870 {
1871 UNIMPLEMENTED;
1872 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1873 return 0;
1874 }
1875
1876
1877
1878 /*
1879 * @implemented
1880 */
1881 int
1882 STDCALL
1883 StartFormPage(HDC hdc)
1884 {
1885 return StartPage(hdc);
1886 }
1887
1888 /*
1889 * @unimplemented
1890 */
1891 VOID
1892 STDCALL
1893 UnloadNetworkFonts(DWORD unknown)
1894 {
1895 UNIMPLEMENTED;
1896 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1897 }
1898
1899 /*
1900 * @implemented
1901 */
1902 BOOL
1903 STDCALL
1904 GetTextExtentExPointI(HDC hdc,
1905 LPWORD pgiIn,
1906 int cgi,
1907 int nMaxExtent,
1908 LPINT lpnFit,
1909 LPINT alpDx,
1910 LPSIZE lpSize)
1911 {
1912 return NtGdiGetTextExtentExW(hdc,pgiIn,cgi,nMaxExtent,(ULONG *)lpnFit, (PULONG) alpDx,lpSize,1);
1913 }
1914
1915 /*
1916 * @implemented
1917 */
1918 BOOL
1919 STDCALL
1920 GetTextExtentPointI(HDC hdc,
1921 LPWORD pgiIn,
1922 int cgi,
1923 LPSIZE lpSize)
1924 {
1925 return NtGdiGetTextExtent(hdc,pgiIn,cgi,lpSize,2);
1926 }
1927
1928
1929
1930
1931
1932 /*
1933 * @unimplemented
1934 */
1935 BOOL
1936 STDCALL
1937 GdiRealizationInfo(HDC hdc,
1938 PREALIZATION_INFO pri)
1939 {
1940 UNIMPLEMENTED;
1941 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1942 return 0;
1943 }
1944
1945
1946
1947 /*
1948 * @unimplemented
1949 */
1950 BOOL
1951 STDCALL
1952 GetETM(HDC hdc,
1953 EXTTEXTMETRIC *petm)
1954 {
1955 UNIMPLEMENTED;
1956 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1957 return 0;
1958 }
1959
1960 /*
1961 * @unimplemented
1962 */
1963 BOOL
1964 STDCALL
1965 GdiAddGlsRecord(HDC hdc,
1966 DWORD unknown1,
1967 LPCSTR unknown2,
1968 LPRECT unknown3)
1969 {
1970 UNIMPLEMENTED;
1971 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1972 return 0;
1973 }
1974
1975 /*
1976 * @unimplemented
1977 */
1978 HANDLE
1979 STDCALL
1980 GdiConvertMetaFilePict(HGLOBAL hMem)
1981 {
1982 UNIMPLEMENTED;
1983 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1984 return 0;
1985 }
1986
1987 /*
1988 * @implemented
1989 */
1990 DEVMODEW *
1991 STDCALL
1992 GdiConvertToDevmodeW(DEVMODEA *dm)
1993 {
1994 LPDEVMODEW dmw;
1995
1996 dmw = HEAP_alloc(sizeof(DEVMODEW));
1997 #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
1998 #define COPYN(f) dmw->f = dm->f
1999 COPYS(dmDeviceName, CCHDEVICENAME );
2000 COPYN(dmSpecVersion);
2001 COPYN(dmDriverVersion);
2002 switch ( dm->dmSize )
2003 {
2004 case SIZEOF_DEVMODEA_300:
2005 dmw->dmSize = SIZEOF_DEVMODEW_300;
2006 break;
2007 case SIZEOF_DEVMODEA_400:
2008 dmw->dmSize = SIZEOF_DEVMODEW_400;
2009 break;
2010 case SIZEOF_DEVMODEA_500:
2011 default: /* FIXME what to do??? */
2012 dmw->dmSize = SIZEOF_DEVMODEW_500;
2013 break;
2014 }
2015 COPYN(dmDriverExtra);
2016 COPYN(dmFields);
2017 COPYN(dmPosition.x);
2018 COPYN(dmPosition.y);
2019 COPYN(dmScale);
2020 COPYN(dmCopies);
2021 COPYN(dmDefaultSource);
2022 COPYN(dmPrintQuality);
2023 COPYN(dmColor);
2024 COPYN(dmDuplex);
2025 COPYN(dmYResolution);
2026 COPYN(dmTTOption);
2027 COPYN(dmCollate);
2028 COPYS(dmFormName,CCHFORMNAME);
2029 COPYN(dmLogPixels);
2030 COPYN(dmBitsPerPel);
2031 COPYN(dmPelsWidth);
2032 COPYN(dmPelsHeight);
2033 COPYN(dmDisplayFlags); // aka dmNup
2034 COPYN(dmDisplayFrequency);
2035
2036 if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
2037 {
2038 return dmw; // we're done with 0x300 fields
2039 }
2040
2041 COPYN(dmICMMethod);
2042 COPYN(dmICMIntent);
2043 COPYN(dmMediaType);
2044 COPYN(dmDitherType);
2045 COPYN(dmReserved1);
2046 COPYN(dmReserved2);
2047
2048 if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
2049 {
2050 return dmw; // we're done with 0x400 fields
2051 }
2052
2053 COPYN(dmPanningWidth);
2054 COPYN(dmPanningHeight);
2055
2056 return dmw;
2057
2058 #undef COPYN
2059 #undef COPYS
2060 }
2061
2062 /*
2063 * @unimplemented
2064 */
2065 HENHMETAFILE
2066 STDCALL
2067 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
2068 {
2069 UNIMPLEMENTED;
2070 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2071 return 0;
2072 }
2073
2074 /*
2075 * @unimplemented
2076 */
2077 METAFILEPICT *
2078 STDCALL
2079 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
2080 {
2081 UNIMPLEMENTED;
2082 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2083 return 0;
2084 }
2085
2086
2087 /*
2088 * @unimplemented
2089 */
2090 HANDLE
2091 STDCALL
2092 GdiGetSpoolFileHandle(LPWSTR pwszPrinterName,
2093 LPDEVMODEW pDevmode,
2094 LPWSTR pwszDocName)
2095 {
2096 UNIMPLEMENTED;
2097 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2098 return 0;
2099 }
2100
2101 /*
2102 * @unimplemented
2103 */
2104 BOOL
2105 STDCALL
2106 GdiDeleteSpoolFileHandle(HANDLE SpoolFileHandle)
2107 {
2108 UNIMPLEMENTED;
2109 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2110 return 0;
2111 }
2112
2113 /*
2114 * @unimplemented
2115 */
2116 DWORD
2117 STDCALL
2118 GdiGetPageCount(HANDLE SpoolFileHandle)
2119 {
2120 UNIMPLEMENTED;
2121 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2122 return 0;
2123 }
2124
2125 /*
2126 * @unimplemented
2127 */
2128 HDC
2129 STDCALL
2130 GdiGetDC(HANDLE SpoolFileHandle)
2131 {
2132 UNIMPLEMENTED;
2133 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2134 return 0;
2135 }
2136
2137 /*
2138 * @unimplemented
2139 */
2140 HANDLE
2141 STDCALL
2142 GdiGetPageHandle(HANDLE SpoolFileHandle,
2143 DWORD Page,
2144 LPDWORD pdwPageType)
2145 {
2146 UNIMPLEMENTED;
2147 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2148 return 0;
2149 }
2150
2151 /*
2152 * @unimplemented
2153 */
2154 BOOL
2155 STDCALL
2156 GdiStartDocEMF(HANDLE SpoolFileHandle,
2157 DOCINFOW *pDocInfo)
2158 {
2159 UNIMPLEMENTED;
2160 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2161 return 0;
2162 }
2163
2164 /*
2165 * @unimplemented
2166 */
2167 BOOL
2168 STDCALL
2169 GdiStartPageEMF(HANDLE SpoolFileHandle)
2170 {
2171 UNIMPLEMENTED;
2172 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2173 return 0;
2174 }
2175
2176 /*
2177 * @unimplemented
2178 */
2179 BOOL
2180 STDCALL
2181 GdiPlayPageEMF(HANDLE SpoolFileHandle,
2182 HANDLE hemf,
2183 RECT *prectDocument,
2184 RECT *prectBorder,
2185 RECT *prectClip)
2186 {
2187 UNIMPLEMENTED;
2188 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2189 return 0;
2190 }
2191
2192 /*
2193 * @unimplemented
2194 */
2195 BOOL
2196 STDCALL
2197 GdiEndPageEMF(HANDLE SpoolFileHandle,
2198 DWORD dwOptimization)
2199 {
2200 UNIMPLEMENTED;
2201 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2202 return 0;
2203 }
2204
2205 /*
2206 * @unimplemented
2207 */
2208 BOOL
2209 STDCALL
2210 GdiEndDocEMF(HANDLE SpoolFileHandle)
2211 {
2212 UNIMPLEMENTED;
2213 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2214 return 0;
2215 }
2216
2217 /*
2218 * @unimplemented
2219 */
2220 BOOL
2221 STDCALL
2222 GdiGetDevmodeForPage(HANDLE SpoolFileHandle,
2223 DWORD dwPageNumber,
2224 PDEVMODEW *pCurrDM,
2225 PDEVMODEW *pLastDM)
2226 {
2227 UNIMPLEMENTED;
2228 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2229 return 0;
2230 }
2231
2232 /*
2233 * @unimplemented
2234 */
2235 BOOL
2236 STDCALL
2237 GdiResetDCEMF(HANDLE SpoolFileHandle,
2238 PDEVMODEW pCurrDM)
2239 {
2240 UNIMPLEMENTED;
2241 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2242 return 0;
2243 }
2244
2245
2246 HBITMAP
2247 STDCALL
2248 CreateDIBitmap(HDC hDc,
2249 const BITMAPINFOHEADER *Header,
2250 DWORD Init, LPCVOID Bits, const BITMAPINFO *Data,
2251 UINT ColorUse)
2252 {
2253 /* FIMXE we need do more thing in user mode */
2254 return NtGdiCreateDIBitmap(hDc, Header, Init, Bits, Data, ColorUse);
2255 }
2256
2257 /*
2258 * @unimplemented
2259 */
2260 INT
2261 STDCALL
2262 CombineRgn(HRGN hDest,
2263 HRGN hSrc1,
2264 HRGN hSrc2,
2265 INT CombineMode)
2266 {
2267 /* FIXME some part should be done in user mode */
2268 return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
2269 }
2270
2271 /*
2272 * @unimplemented
2273 */
2274 HBITMAP STDCALL
2275 CreateBitmap(INT Width,
2276 INT Height,
2277 UINT Planes,
2278 UINT BitsPixel,
2279 PCVOID pUnsafeBits)
2280 {
2281 /* FIXME some part should be done in user mode */
2282 return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
2283 }
2284
2285 /*
2286 * @unimplemented
2287 */
2288 LPWSTR STDCALL
2289 EngGetDriverName(HDEV hdev)
2290 {
2291 UNIMPLEMENTED;
2292 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2293 return 0;
2294 }
2295
2296 /*
2297 * @unimplemented
2298 */
2299 ULONG STDCALL
2300 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
2301 ULONG Color)
2302 {
2303 UNIMPLEMENTED;
2304 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2305 return 0;
2306 }
2307
2308 /*
2309 * @unimplemented
2310 */
2311 ULONG *
2312 STDCALL
2313 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
2314 {
2315 return XlateObj->pulXlate;
2316 }
2317
2318 /*
2319 * @unimplemented
2320 */
2321 BOOL
2322 STDCALL
2323 GdiPlayEMF(LPWSTR pwszPrinterName,
2324 LPDEVMODEW pDevmode,
2325 LPWSTR pwszDocName,
2326 EMFPLAYPROC pfnEMFPlayFn,
2327 HANDLE hPageQuery
2328 )
2329 {
2330 UNIMPLEMENTED;
2331 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2332 return 0;
2333 }
2334
2335
2336
2337 /*
2338 * @unimplemented
2339 */
2340 BOOL
2341 STDCALL
2342 GdiPlayPrivatePageEMF(HANDLE SpoolFileHandle,
2343 DWORD unknown,
2344 RECT *prectDocument)
2345 {
2346 UNIMPLEMENTED;
2347 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2348 return 0;
2349 }
2350
2351 /*
2352 * @unimplemented
2353 */
2354 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
2355 {
2356 UNIMPLEMENTED;
2357 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2358 }
2359
2360
2361 /*
2362 * @implemented
2363 */
2364 INT
2365 STDCALL
2366 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
2367 {
2368 /* FIXME some part need be done on user mode size */
2369 return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
2370 }
2371
2372 /*
2373 * @implemented
2374 */
2375 INT
2376 STDCALL
2377 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
2378 {
2379 /* FIXME some part need be done on user mode size */
2380 return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
2381 }
2382
2383 /*
2384 * @implemented
2385 */
2386 BOOL
2387 STDCALL
2388 GdiGradientFill(
2389 IN HDC hdc,
2390 IN PTRIVERTEX pVertex,
2391 IN ULONG nVertex,
2392 IN PVOID pMesh,
2393 IN ULONG nMesh,
2394 IN ULONG ulMode)
2395 {
2396 /* FIXME some part need be done in user mode */
2397 return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
2398 }
2399
2400
2401 /*
2402 * @implemented
2403 */
2404 BOOL
2405 STDCALL
2406 GdiTransparentBlt(IN HDC hdcDst,
2407 IN INT xDst,
2408 IN INT yDst,
2409 IN INT cxDst,
2410 IN INT cyDst,
2411 IN HDC hdcSrc,
2412 IN INT xSrc,
2413 IN INT ySrc,
2414 IN INT cxSrc,
2415 IN INT cySrc,
2416 IN COLORREF TransColor
2417 )
2418 {
2419 /* FIXME some part need be done in user mode */
2420 return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
2421 }
2422
2423 /*
2424 * @unimplemented
2425 */
2426 BOOL
2427 STDCALL
2428 GdiPrinterThunk(
2429 IN HUMPD humpd,
2430 DWORD *status,
2431 DWORD unuse)
2432 {
2433 /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
2434 /* status contain some form of return value that being save, what it is I do not known */
2435 /* unsue seam have zero effect, what it is for I do not known */
2436
2437 // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
2438 return FALSE;
2439 }
2440
2441 /*
2442 * @unimplemented
2443 *
2444 */
2445 HBITMAP
2446 STDCALL
2447 GdiConvertBitmapV5(
2448 HBITMAP in_format_BitMap,
2449 HBITMAP src_BitMap,
2450 INT bpp,
2451 INT unuse)
2452 {
2453 /* FIXME guessing the prototypes */
2454
2455 /*
2456 * it have create a new bitmap with desired in format,
2457 * then convert it src_bitmap to new format
2458 * and return it as HBITMAP
2459 */
2460
2461 return FALSE;
2462 }
2463
2464
2465 /*
2466 * @implemented
2467 *
2468 */
2469 COLORREF
2470 STDCALL
2471 GetBkColor(HDC hdc)
2472 {
2473 /* FIXME some part are done in user mode */
2474 return NtGdiGetBkColor(hdc);
2475 }
2476
2477 /*
2478 * @implemented
2479 *
2480 */
2481 int
2482 STDCALL
2483 GetBkMode(HDC hdc)
2484 {
2485 /* FIXME some part are done in user mode */
2486 return NtGdiGetBkMode(hdc);
2487 }
2488
2489 /*
2490 * @implemented
2491 *
2492 */
2493 BOOL
2494 STDCALL
2495 GetBrushOrgEx(HDC hdc,LPPOINT pt)
2496 {
2497 /* FIXME some part are done in user mode */
2498 return NtGdiGetBrushOrgEx(hdc,pt);
2499 }
2500
2501 /*
2502 * @implemented
2503 *
2504 */
2505 BOOL
2506 STDCALL
2507 GetCharABCWidthsFloatW(HDC hdc,UINT FirstChar,UINT LastChar,LPABCFLOAT abcF)
2508 {
2509 /* FIXME some part are done in user mode */
2510 return NtGdiGetCharABCWidthsFloat(hdc, FirstChar, LastChar, abcF);
2511 }
2512
2513 /*
2514 * @implemented
2515 *
2516 */
2517 int
2518 STDCALL
2519 GetDeviceCaps(HDC hdc,
2520 int i)
2521 {
2522 /* FIXME some part need be done in user mode */
2523 return NtGdiGetDeviceCaps(hdc,i);
2524 }
2525
2526
2527 /*
2528 * @implemented
2529 *
2530 */
2531 BOOL
2532 STDCALL
2533 GetCurrentPositionEx(HDC hdc,
2534 LPPOINT lpPoint)
2535 {
2536 /* FIXME some part need be done in user mode */
2537 return NtGdiGetCurrentPositionEx(hdc, lpPoint);
2538 }
2539
2540 /*
2541 * @implemented
2542 *
2543 */
2544 int
2545 STDCALL
2546 GetClipBox(HDC hdc,
2547 LPRECT lprc)
2548 {
2549 /* FIXME some part need be done in user mode */
2550 return NtGdiGetClipBox(hdc, lprc);
2551 }
2552
2553 /*
2554 * @implemented
2555 *
2556 */
2557 BOOL
2558 STDCALL
2559 GetCharWidthFloatW(HDC hdc,
2560 UINT iFirstChar,
2561 UINT iLastChar,
2562 PFLOAT pxBuffer)
2563 {
2564 /* FIXME some part need be done in user mode */
2565 return NtGdiGetCharWidthFloat(hdc, iFirstChar, iLastChar, pxBuffer);
2566 }
2567
2568 /*
2569 * @implemented
2570 *
2571 */
2572 BOOL
2573 STDCALL
2574 GetCharWidth32W(HDC hdc,
2575 UINT iFirstChar,
2576 UINT iLastChar,
2577 LPINT lpBuffer)
2578 {
2579 /* FIXME some part need be done in user mode */
2580 return NtGdiGetCharWidth32(hdc, iFirstChar, iLastChar, lpBuffer);
2581 }
2582
2583 /*
2584 * @implemented
2585 *
2586 */
2587 BOOL
2588 STDCALL
2589 GetCharABCWidths(HDC hdc,
2590 UINT uFirstChar,
2591 UINT uLastChar,
2592 LPABC lpabc)
2593 {
2594 /* FIXME some part need be done in user mode */
2595 return NtGdiGetCharABCWidths(hdc, uFirstChar, uLastChar, lpabc);
2596 }
2597
2598
2599 /*
2600 * @implemented
2601 *
2602 */
2603 DWORD
2604 STDCALL
2605 GetFontData(HDC hdc,
2606 DWORD dwTable,
2607 DWORD dwOffset,
2608 LPVOID lpvBuffer,
2609 DWORD cbData)
2610 {
2611 if (!lpvBuffer)
2612 {
2613 cbData = 0;
2614 }
2615 return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2616 }
2617
2618
2619 /*
2620 * @implemented
2621 *
2622 */
2623 DWORD
2624 STDCALL
2625 GetRegionData(HRGN hrgn,
2626 DWORD nCount,
2627 LPRGNDATA lpRgnData)
2628 {
2629 if (!lpRgnData)
2630 {
2631 nCount = 0;
2632 }
2633
2634 return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
2635 }
2636
2637
2638 /*
2639 * @implemented
2640 *
2641 */
2642 INT
2643 STDCALL
2644 GetRgnBox(HRGN hrgn,
2645 LPRECT prcOut)
2646 {
2647 /* FIXME some stuff need be done in user mode */
2648 return NtGdiGetRgnBox(hrgn, prcOut);
2649 }
2650
2651
2652 /*
2653 * @implemented
2654 *
2655 */
2656 INT
2657 STDCALL
2658 OffsetRgn( HRGN hrgn,
2659 int nXOffset,
2660 int nYOffset)
2661 {
2662 /* FIXME some part are done in user mode */
2663 return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
2664 }
2665
2666
2667 INT
2668 STDCALL
2669 GetTextCharsetInfo(HDC hdc,
2670 LPFONTSIGNATURE lpSig,
2671 DWORD dwFlags)
2672 {
2673 /* FIXME some part are done in user mode */
2674 return NtGdiGetTextCharsetInfo(hdc, lpSig, dwFlags);
2675 }
2676
2677
2678
2679 INT
2680 STDCALL
2681 IntersectClipRect(HDC hdc,
2682 int nLeftRect,
2683 int nTopRect,
2684 int nRightRect,
2685 int nBottomRect)
2686 {
2687 /* FIXME some part are done in user mode */
2688 return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2689 }
2690
2691 INT
2692 STDCALL
2693 OffsetClipRgn(HDC hdc,
2694 int nXOffset,
2695 int nYOffset)
2696 {
2697 /* FIXME some part are done in user mode */
2698 return NtGdiOffsetClipRgn( hdc, nXOffset, nYOffset);
2699 }
2700
2701
2702 INT
2703 STDCALL
2704 NamedEscape(HDC hdc,
2705 PWCHAR pDriver,
2706 INT iEsc,
2707 INT cjIn,
2708 LPSTR pjIn,
2709 INT cjOut,
2710 LPSTR pjOut)
2711 {
2712 /* FIXME metadc, metadc are done most in user mode, and we do not support it
2713 * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
2714 * when it calls to NtGdiExtEscape from NamedEscape
2715 */
2716 return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
2717 }
2718
2719
2720 BOOL
2721 STDCALL
2722 PatBlt(HDC hdc,
2723 int nXLeft,
2724 int nYLeft,
2725 int nWidth,
2726 int nHeight,
2727 DWORD dwRop)
2728 {
2729 /* FIXME some part need be done in user mode */
2730 return NtGdiPatBlt( hdc, nXLeft, nYLeft, nWidth, nHeight, dwRop);
2731 }
2732
2733 BOOL
2734 STDCALL
2735 PolyPatBlt(IN HDC hdc,
2736 IN DWORD rop4,
2737 IN PPOLYPATBLT pPoly,
2738 IN DWORD Count,
2739 IN DWORD Mode)
2740 {
2741 /* FIXME some part need be done in user mode */
2742 return NtGdiPolyPatBlt(hdc, rop4, pPoly,Count,Mode);
2743 }
2744
2745
2746
2747
2748
2749
2750
2751
2752