Updated to 0.0.14
[reactos.git] / reactos / lib / gdi32 / misc / stubs.c
1 /* $Id: stubs.c,v 1.1 1999/05/24 20:04:44 ea Exp $
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 #ifdef UNICODE
12 #undef UNICODE
13 #endif
14 #include <windows.h>
15
16
17 BOOL
18 STDCALL
19 AnimatePalette(
20 HPALETTE a0,
21 UINT a1,
22 UINT a2,
23 CONST PALETTEENTRY *a3
24 )
25 {
26 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
27 return FALSE;
28 }
29
30
31 BOOL
32 STDCALL
33 Arc(
34 HDC a0,
35 int a1,
36 int a2,
37 int a3,
38 int a4,
39 int a5,
40 int a6,
41 int a7,
42 int a8
43 )
44 {
45 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
46 return FALSE;
47 }
48
49
50
51 BOOL
52 STDCALL
53 BitBlt(
54 HDC a0,
55 int a1,
56 int a2,
57 int a3,
58 int a4,
59 HDC a5,
60 int a6,
61 int a7,
62 DWORD a8
63 )
64 {
65 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
66 return FALSE;
67 }
68
69
70
71 BOOL
72 STDCALL
73 CancelDC(
74 HDC a0
75 )
76 {
77 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
78 return FALSE;
79 }
80
81
82
83 BOOL
84 STDCALL
85 Chord(
86 HDC a0,
87 int a1,
88 int a2,
89 int a3,
90 int a4,
91 int a5,
92 int a6,
93 int a7,
94 int a8
95 )
96 {
97 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
98 return FALSE;
99 }
100
101
102
103 int
104 STDCALL
105 ChoosePixelFormat(
106 HDC a0,
107 CONST PIXELFORMATDESCRIPTOR *a1
108 )
109 {
110 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
111 return 0;
112 }
113
114
115
116 HMETAFILE
117 STDCALL
118 CloseMetaFile(
119 HDC a0
120 )
121 {
122 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
123 return 0;
124 }
125
126
127
128 int
129 STDCALL
130 CombineRgn(
131 HRGN a0,
132 HRGN a1,
133 HRGN a2,
134 int a3
135 )
136 {
137 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
138 return 0;
139 }
140
141
142
143 HBITMAP
144 STDCALL
145 CreateBitmap(
146 int a0,
147 int a1,
148 UINT a2,
149 UINT a3,
150 CONST VOID *a4
151 )
152 {
153 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
154 return 0;
155 }
156
157
158
159 HBITMAP
160 STDCALL
161 CreateBitmapIndirect(
162 CONST BITMAP *a0
163 )
164 {
165 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
166 return 0;
167 }
168
169
170
171 HBRUSH
172 STDCALL
173 CreateBrushIndirect(
174 CONST LOGBRUSH *a0
175 )
176 {
177 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
178 return 0;
179 }
180
181
182
183 HBITMAP
184 STDCALL
185 CreateCompatibleBitmap(
186 HDC a0,
187 int a1,
188 int a2
189 )
190 {
191 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
192 return 0;
193 }
194
195
196
197 HBITMAP
198 STDCALL
199 CreateDiscardableBitmap(
200 HDC a0,
201 int a1,
202 int a2
203 )
204 {
205 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
206 return 0;
207 }
208
209
210
211 HDC
212 STDCALL
213 CreateCompatibleDC(
214 HDC a0
215 )
216 {
217 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
218 return 0;
219 }
220
221
222
223 HBITMAP
224 STDCALL
225 CreateDIBitmap(
226 HDC a0,
227 CONST BITMAPINFOHEADER *a1,
228 DWORD a2,
229 CONST VOID *a3,
230 CONST BITMAPINFO *a4,
231 UINT a5
232 )
233 {
234 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
235 return 0;
236 }
237
238
239
240 HBRUSH
241 STDCALL
242 CreateDIBPatternBrush(
243 HGLOBAL a0,
244 UINT a1
245 )
246 {
247 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
248 return 0;
249 }
250
251
252
253 HBRUSH
254 STDCALL
255 CreateDIBPatternBrushPt(
256 CONST VOID *a0,
257 UINT a1
258 )
259 {
260 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
261 return 0;
262 }
263
264
265
266 HRGN
267 STDCALL
268 CreateEllipticRgn(
269 int a0,
270 int a1,
271 int a2,
272 int a3
273 )
274 {
275 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
276 return 0;
277 }
278
279
280
281 HRGN
282 STDCALL
283 CreateEllipticRgnIndirect(
284 CONST RECT *a0
285 )
286 {
287 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
288 return 0;
289 }
290
291
292
293 HBRUSH
294 STDCALL
295 CreateHatchBrush(
296 int a0,
297 COLORREF a1
298 )
299 {
300 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
301 return 0;
302 }
303
304
305
306 HPALETTE
307 STDCALL
308 CreatePalette(
309 CONST LOGPALETTE *a0
310 )
311 {
312 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
313 return 0;
314 }
315
316
317
318 HPEN
319 STDCALL
320 CreatePen(
321 int a0,
322 int a1,
323 COLORREF a2
324 )
325 {
326 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
327 return 0;
328 }
329
330
331
332 HPEN
333 STDCALL
334 CreatePenIndirect(
335 CONST LOGPEN *a0
336 )
337 {
338 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
339 return 0;
340 }
341
342
343
344 HRGN
345 STDCALL
346 CreatePolyPolygonRgn(
347 CONST POINT *a0,
348 CONST INT *a1,
349 int a2,
350 int a3
351 )
352 {
353 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
354 return 0;
355 }
356
357
358
359 HBRUSH
360 STDCALL
361 CreatePatternBrush(
362 HBITMAP a0
363 )
364 {
365 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
366 return 0;
367 }
368
369
370
371 HRGN
372 STDCALL
373 CreateRectRgn(
374 int a0,
375 int a1,
376 int a2,
377 int a3
378 )
379 {
380 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
381 return 0;
382 }
383
384
385
386 HRGN
387 STDCALL
388 CreateRectRgnIndirect(
389 CONST RECT *a0
390 )
391 {
392 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
393 return 0;
394 }
395
396
397
398 HRGN
399 STDCALL
400 CreateRoundRectRgn(
401 int a0,
402 int a1,
403 int a2,
404 int a3,
405 int a4,
406 int a5
407 )
408 {
409 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
410 return 0;
411 }
412
413
414 HBRUSH
415 STDCALL
416 CreateSolidBrush(
417 COLORREF a0
418 )
419 {
420 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
421 return 0;
422 }
423
424
425
426 BOOL
427 STDCALL
428 DeleteDC(
429 HDC a0
430 )
431 {
432 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
433 return FALSE;
434 }
435
436
437
438 BOOL
439 STDCALL
440 DeleteMetaFile(
441 HMETAFILE a0
442 )
443 {
444 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
445 return FALSE;
446 }
447
448
449
450 BOOL
451 STDCALL
452 DeleteObject(
453 HGDIOBJ a0
454 )
455 {
456 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
457 return FALSE;
458 }
459
460
461
462 int
463 STDCALL
464 DescribePixelFormat(
465 HDC a0,
466 int a1,
467 UINT a2,
468 LPPIXELFORMATDESCRIPTOR a3
469 )
470 {
471 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
472 return 0;
473 }
474
475
476
477 int
478 STDCALL
479 DrawEscape(
480 HDC a0,
481 int a1,
482 int a2,
483 LPCSTR a3
484 )
485 {
486 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
487 return 0;
488 }
489
490
491
492 BOOL
493 STDCALL
494 Ellipse(
495 HDC a0,
496 int a1,
497 int a2,
498 int a3,
499 int a4
500 )
501 {
502 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
503 return FALSE;
504 }
505
506
507
508 int
509 STDCALL
510 EnumObjects(
511 HDC a0,
512 int a1,
513 ENUMOBJECTSPROC a2,
514 LPARAM a3
515 )
516 {
517 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
518 return 0;
519 }
520
521
522
523 BOOL
524 STDCALL
525 EqualRgn(
526 HRGN a0,
527 HRGN a1
528 )
529 {
530 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
531 return FALSE;
532 }
533
534
535
536 int
537 STDCALL
538 Escape(
539 HDC a0,
540 int a1,
541 int a2,
542 LPCSTR a3,
543 LPVOID a4
544 )
545 {
546 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
547 return 0;
548 }
549
550
551
552
553 int
554 STDCALL
555 ExtEscape(
556 HDC a0,
557 int a1,
558 int a2,
559 LPCSTR a3,
560 int a4,
561 LPSTR a5
562 )
563 {
564 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
565 return 0;
566 }
567
568
569
570 int
571 STDCALL
572 ExcludeClipRect(
573 HDC a0,
574 int a1,
575 int a2,
576 int a3,
577 int a4
578 )
579 {
580 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
581 return 0;
582 }
583
584
585
586 HRGN
587 STDCALL
588 ExtCreateRegion(
589 CONST XFORM * a0,
590 DWORD a1,
591 CONST RGNDATA * a2
592 )
593 {
594 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
595 return 0;
596 }
597
598
599
600 BOOL
601 STDCALL
602 ExtFloodFill(
603 HDC a0,
604 int a1,
605 int a2,
606 COLORREF a3,
607 UINT a4
608 )
609 {
610 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
611 return FALSE;
612 }
613
614
615
616 BOOL
617 STDCALL
618 FillRgn(
619 HDC a0,
620 HRGN a1,
621 HBRUSH a2
622 )
623 {
624 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
625 return FALSE;
626 }
627
628
629
630 BOOL
631 STDCALL
632 FloodFill(
633 HDC a0,
634 int a1,
635 int a2,
636 COLORREF a3
637 )
638 {
639 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
640 return FALSE;
641 }
642
643
644
645 BOOL
646 STDCALL
647 FrameRgn(
648 HDC a0,
649 HRGN a1,
650 HBRUSH a2,
651 int a3,
652 int a4
653 )
654 {
655 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
656 return FALSE;
657 }
658
659
660
661 int
662 STDCALL
663 GetROP2(
664 HDC a0
665 )
666 {
667 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
668 return 0;
669 }
670
671
672
673 BOOL
674 STDCALL
675 GetAspectRatioFilterEx(
676 HDC a0,
677 LPSIZE a1
678 )
679 {
680 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
681 return FALSE;
682 }
683
684
685
686 COLORREF
687 STDCALL
688 GetBkColor(
689 HDC a0
690 )
691 {
692 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
693 return 0;
694 }
695
696
697
698 int
699 STDCALL
700 GetBkMode(
701 HDC a0
702 )
703 {
704 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
705 return 0;
706 }
707
708
709
710 LONG
711 STDCALL
712 GetBitmapBits(
713 HBITMAP a0,
714 LONG a1,
715 LPVOID a2
716 )
717 {
718 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
719 return 0;
720 }
721
722
723
724 BOOL
725 STDCALL
726 GetBitmapDimensionEx(
727 HBITMAP a0,
728 LPSIZE a1
729 )
730 {
731 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
732 return FALSE;
733 }
734
735
736
737 UINT
738 STDCALL
739 GetBoundsRect(
740 HDC a0,
741 LPRECT a1,
742 UINT a2
743 )
744 {
745 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
746 return 0;
747 }
748
749
750
751 BOOL
752 STDCALL
753 GetBrushOrgEx(
754 HDC a0,
755 LPPOINT a1
756 )
757 {
758 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
759 return FALSE;
760 }
761
762
763
764 int
765 STDCALL
766 GetClipBox(
767 HDC a0,
768 LPRECT a1
769 )
770 {
771 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
772 return 0;
773 }
774
775
776
777 int
778 STDCALL
779 GetClipRgn(
780 HDC a0,
781 HRGN a1
782 )
783 {
784 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
785 return 0;
786 }
787
788
789
790 int
791 STDCALL
792 GetMetaRgn(
793 HDC a0,
794 HRGN a1
795 )
796 {
797 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
798 return 0;
799 }
800
801
802
803 HGDIOBJ
804 STDCALL
805 GetCurrentObject(
806 HDC a0,
807 UINT a1
808 )
809 {
810 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
811 return 0;
812 }
813
814
815
816 BOOL
817 STDCALL
818 GetCurrentPositionEx(
819 HDC a0,
820 LPPOINT a1
821 )
822 {
823 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
824 return FALSE;
825 }
826
827
828
829 int
830 STDCALL
831 GetDeviceCaps(
832 HDC a0,
833 int a1
834 )
835 {
836 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
837 return 0;
838 }
839
840
841
842
843 int
844 STDCALL
845 GetDIBits(
846 HDC a0,
847 HBITMAP a1,
848 UINT a2,
849 UINT a3,
850 LPVOID a4,
851 LPBITMAPINFO a5,
852 UINT a6
853 )
854 {
855 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
856 return 0;
857 }
858
859
860
861 DWORD
862 STDCALL
863 GetFontData(
864 HDC a0,
865 DWORD a1,
866 DWORD a2,
867 LPVOID a3,
868 DWORD a4
869 )
870 {
871 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
872 return 0;
873 }
874
875
876
877 int
878 STDCALL
879 GetGraphicsMode(
880 HDC a0
881 )
882 {
883 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
884 return 0;
885 }
886
887
888
889
890 int
891 STDCALL
892 GetMapMode(
893 HDC a0
894 )
895 {
896 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
897 return 0;
898 }
899
900
901
902 UINT
903 STDCALL
904 GetMetaFileBitsEx(
905 HMETAFILE a0,
906 UINT a1,
907 LPVOID a2
908 )
909 {
910 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
911 return 0;
912 }
913
914
915
916 COLORREF
917 STDCALL
918 GetNearestColor(
919 HDC a0,
920 COLORREF a1
921 )
922 {
923 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
924 return 0;
925 }
926
927
928
929 UINT
930 STDCALL
931 GetNearestPaletteIndex(
932 HPALETTE a0,
933 COLORREF a1
934 )
935 {
936 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
937 return 0;
938 }
939
940
941
942 DWORD
943 STDCALL
944 GetObjectType(
945 HGDIOBJ a0
946 )
947 {
948 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
949 return 0;
950 }
951
952
953 UINT
954 STDCALL
955 GetPaletteEntries(
956 HPALETTE a0,
957 UINT a1,
958 UINT a2,
959 LPPALETTEENTRY a3
960 )
961 {
962 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
963 return 0;
964 }
965
966
967
968 COLORREF
969 STDCALL
970 GetPixel(
971 HDC a0,
972 int a1,
973 int a2
974 )
975 {
976 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
977 return 0;
978 }
979
980
981
982 int
983 STDCALL
984 GetPixelFormat(
985 HDC a0
986 )
987 {
988 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
989 return 0;
990 }
991
992
993
994 int
995 STDCALL
996 GetPolyFillMode(
997 HDC a0
998 )
999 {
1000 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1001 return 0;
1002 }
1003
1004
1005
1006 BOOL
1007 STDCALL
1008 GetRasterizerCaps(
1009 LPRASTERIZER_STATUS a0,
1010 UINT a1
1011 )
1012 {
1013 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1014 return FALSE;
1015 }
1016
1017
1018
1019 DWORD
1020 STDCALL
1021 GetRegionData(
1022 HRGN a0,
1023 DWORD a1,
1024 LPRGNDATA a2
1025 )
1026 {
1027 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1028 return 0;
1029 }
1030
1031
1032
1033 int
1034 STDCALL
1035 GetRgnBox(
1036 HRGN a0,
1037 LPRECT a1
1038 )
1039 {
1040 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1041 return 0;
1042 }
1043
1044
1045
1046 HGDIOBJ
1047 STDCALL
1048 GetStockObject(
1049 int a0
1050 )
1051 {
1052 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1053 return 0;
1054 }
1055
1056
1057
1058 int
1059 STDCALL
1060 GetStretchBltMode(
1061 HDC a0
1062 )
1063 {
1064 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1065 return 0;
1066 }
1067
1068
1069
1070 UINT
1071 STDCALL
1072 GetSystemPaletteEntries(
1073 HDC a0,
1074 UINT a1,
1075 UINT a2,
1076 LPPALETTEENTRY a3
1077 )
1078 {
1079 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1080 return 0;
1081 }
1082
1083
1084
1085 UINT
1086 STDCALL
1087 GetSystemPaletteUse(
1088 HDC hDc
1089 )
1090 {
1091 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1092 return 0;
1093 }
1094
1095
1096
1097 int
1098 STDCALL
1099 GetTextCharacterExtra(
1100 HDC hDc
1101 )
1102 {
1103 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1104 return 0;
1105 }
1106
1107
1108
1109 UINT
1110 STDCALL
1111 GetTextAlign(
1112 HDC hDc
1113 )
1114 {
1115 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1116 return 0;
1117 }
1118
1119
1120
1121 COLORREF
1122 STDCALL
1123 GetTextColor(
1124 HDC hDc
1125 )
1126 {
1127 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1128 return 0;
1129 }
1130
1131
1132 int
1133 STDCALL
1134 GetTextCharset(
1135 HDC hdc
1136 )
1137 {
1138 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1139 return 0;
1140 }
1141
1142
1143
1144 int
1145 STDCALL
1146 GetTextCharsetInfo(
1147 HDC hdc,
1148 LPFONTSIGNATURE lpSig,
1149 DWORD dwFlags
1150 )
1151 {
1152 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1153 return 0;
1154 }
1155
1156
1157
1158 BOOL
1159 STDCALL
1160 TranslateCharsetInfo(
1161 DWORD FAR *lpSrc,
1162 LPCHARSETINFO lpCs,
1163 DWORD dwFlags
1164 )
1165 {
1166 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1167 return FALSE;
1168 }
1169
1170
1171
1172 DWORD
1173 STDCALL
1174 GetFontLanguageInfo(
1175 HDC hDc
1176 )
1177 {
1178 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1179 return 0;
1180 }
1181
1182
1183 BOOL
1184 STDCALL
1185 GetViewportExtEx(
1186 HDC hDc,
1187 LPSIZE lpSize
1188 )
1189 {
1190 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1191 return FALSE;
1192 }
1193
1194
1195
1196 BOOL
1197 STDCALL
1198 GetViewportOrgEx(
1199 HDC hDc,
1200 LPPOINT lpPoint
1201 )
1202 {
1203 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1204 return FALSE;
1205 }
1206
1207
1208
1209 BOOL
1210 STDCALL
1211 GetWindowExtEx(
1212 HDC hDc,
1213 LPSIZE lpSize
1214 )
1215 {
1216 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1217 return FALSE;
1218 }
1219
1220
1221
1222 BOOL
1223 STDCALL
1224 GetWindowOrgEx(
1225 HDC hDc,
1226 LPPOINT lpPoint
1227 )
1228 {
1229 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1230 return FALSE;
1231 }
1232
1233
1234
1235 int
1236 STDCALL
1237 IntersectClipRect(
1238 HDC hDc,
1239 int a1,
1240 int a2,
1241 int a3,
1242 int a4
1243 )
1244 {
1245 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1246 return 0;
1247 }
1248
1249
1250
1251 BOOL
1252 STDCALL
1253 InvertRgn(
1254 HDC hDc,
1255 HRGN hRgn
1256 )
1257 {
1258 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1259 return FALSE;
1260 }
1261
1262
1263
1264 BOOL
1265 STDCALL
1266 LineDDA(
1267 int a0,
1268 int a1,
1269 int a2,
1270 int a3,
1271 LINEDDAPROC a4,
1272 LPARAM a5
1273 )
1274 {
1275 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1276 return FALSE;
1277 }
1278
1279
1280
1281 BOOL
1282 STDCALL
1283 LineTo(
1284 HDC a0,
1285 int a1,
1286 int a2
1287 )
1288 {
1289 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1290 return FALSE;
1291 }
1292
1293
1294
1295 BOOL
1296 STDCALL
1297 MaskBlt(
1298 HDC a0,
1299 int a1,
1300 int a2,
1301 int a3,
1302 int a4,
1303 HDC a5,
1304 int a6,
1305 int a7,
1306 HBITMAP a8,
1307 int a9,
1308 int a10,
1309 DWORD a11
1310 )
1311 {
1312 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1313 return FALSE;
1314 }
1315
1316
1317
1318 BOOL
1319 STDCALL
1320 PlgBlt(
1321 HDC a0,
1322 CONST POINT *a1,
1323 HDC a2,
1324 int a3,
1325 int a4,
1326 int a5,
1327 int a6,
1328 HBITMAP a7,
1329 int a8,
1330 int a9
1331 )
1332 {
1333 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1334 return FALSE;
1335 }
1336
1337
1338
1339 int
1340 STDCALL
1341 OffsetClipRgn(
1342 HDC a0,
1343 int a1,
1344 int a2
1345 )
1346 {
1347 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1348 return 0;
1349 }
1350
1351
1352
1353 int
1354 STDCALL
1355 OffsetRgn(
1356 HRGN a0,
1357 int a1,
1358 int a2
1359 )
1360 {
1361 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1362 return 0;
1363 }
1364
1365
1366
1367 BOOL
1368 STDCALL
1369 PatBlt(
1370 HDC a0,
1371 int a1,
1372 int a2,
1373 int a3,
1374 int a4,
1375 DWORD a5
1376 )
1377 {
1378 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1379 return FALSE;
1380 }
1381
1382
1383
1384 BOOL
1385 STDCALL
1386 Pie(
1387 HDC a0,
1388 int a1,
1389 int a2,
1390 int a3,
1391 int a4,
1392 int a5,
1393 int a6,
1394 int a7,
1395 int a8
1396 )
1397 {
1398 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1399 return FALSE;
1400 }
1401
1402
1403
1404 BOOL
1405 STDCALL
1406 PlayMetaFile(
1407 HDC a0,
1408 HMETAFILE a1
1409 )
1410 {
1411 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1412 return FALSE;
1413 }
1414
1415
1416
1417 BOOL
1418 STDCALL
1419 PaintRgn(
1420 HDC a0,
1421 HRGN a1
1422 )
1423 {
1424 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1425 return FALSE;
1426 }
1427
1428
1429
1430 BOOL
1431 STDCALL
1432 PolyPolygon(
1433 HDC a0,
1434 CONST POINT *a1,
1435 CONST INT *a2,
1436 int a3
1437 )
1438 {
1439 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1440 return FALSE;
1441 }
1442
1443
1444
1445 BOOL
1446 STDCALL
1447 PtInRegion(
1448 HRGN a0,
1449 int a1,
1450 int a2
1451 )
1452 {
1453 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1454 return FALSE;
1455 }
1456
1457
1458
1459 BOOL
1460 STDCALL
1461 PtVisible(
1462 HDC a0,
1463 int a1,
1464 int a2
1465 )
1466 {
1467 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1468 return FALSE;
1469 }
1470
1471
1472
1473 BOOL
1474 STDCALL
1475 RectInRegion(
1476 HRGN a0,
1477 CONST RECT *a1
1478 )
1479 {
1480 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1481 return FALSE;
1482 }
1483
1484
1485
1486 BOOL
1487 STDCALL
1488 RectVisible(
1489 HDC a0,
1490 CONST RECT *a1
1491 )
1492 {
1493 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1494 return FALSE;
1495 }
1496
1497
1498
1499 BOOL
1500 STDCALL
1501 Rectangle(
1502 HDC a0,
1503 int a1,
1504 int a2,
1505 int a3,
1506 int a4
1507 )
1508 {
1509 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1510 return FALSE;
1511 }
1512
1513
1514
1515 BOOL
1516 STDCALL
1517 RestoreDC(
1518 HDC a0,
1519 int a1
1520 )
1521 {
1522 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1523 return FALSE;
1524 }
1525
1526
1527
1528 UINT
1529 STDCALL
1530 RealizePalette(
1531 HDC a0
1532 )
1533 {
1534 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1535 return 0;
1536 }
1537
1538
1539
1540 BOOL
1541 STDCALL
1542 RoundRect(
1543 HDC a0,
1544 int a1,
1545 int a2,
1546 int a3,
1547 int a4,
1548 int a5,
1549 int a6
1550 )
1551 {
1552 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1553 return FALSE;
1554 }
1555
1556
1557
1558 BOOL
1559 STDCALL
1560 ResizePalette(
1561 HPALETTE a0,
1562 UINT a1
1563 )
1564 {
1565 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1566 return FALSE;
1567 }
1568
1569
1570
1571 int
1572 STDCALL
1573 SaveDC(
1574 HDC a0
1575 )
1576 {
1577 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1578 return 0;
1579 }
1580
1581
1582
1583 int
1584 STDCALL
1585 SelectClipRgn(
1586 HDC a0,
1587 HRGN a1
1588 )
1589 {
1590 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1591 return 0;
1592 }
1593
1594
1595
1596 int
1597 STDCALL
1598 ExtSelectClipRgn(
1599 HDC a0,
1600 HRGN a1,
1601 int a2
1602 )
1603 {
1604 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1605 return 0;
1606 }
1607
1608
1609
1610 int
1611 STDCALL
1612 SetMetaRgn(
1613 HDC hdc
1614 )
1615 {
1616 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1617 return 0;
1618 }
1619
1620
1621
1622 HGDIOBJ
1623 STDCALL
1624 SelectObject(
1625 HDC a0,
1626 HGDIOBJ a1
1627 )
1628 {
1629 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1630 return 0;
1631 }
1632
1633
1634
1635 HPALETTE
1636 STDCALL
1637 SelectPalette(
1638 HDC a0,
1639 HPALETTE a1,
1640 BOOL a2
1641 )
1642 {
1643 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1644 return 0;
1645 }
1646
1647
1648
1649 COLORREF
1650 STDCALL
1651 SetBkColor(
1652 HDC a0,
1653 COLORREF a1
1654 )
1655 {
1656 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1657 return 0;
1658 }
1659
1660
1661
1662 int
1663 STDCALL
1664 SetBkMode(
1665 HDC a0,
1666 int a1
1667 )
1668 {
1669 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1670 return 0;
1671 }
1672
1673
1674
1675 LONG
1676 STDCALL
1677 SetBitmapBits(
1678 HBITMAP a0,
1679 DWORD a1,
1680 CONST VOID *a2
1681 )
1682 {
1683 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1684 return 0;
1685 }
1686
1687
1688
1689 UINT
1690 STDCALL
1691 SetBoundsRect(
1692 HDC a0,
1693 CONST RECT *a1,
1694 UINT a2
1695 )
1696 {
1697 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1698 return 0;
1699 }
1700
1701
1702
1703 int
1704 STDCALL
1705 SetDIBits(
1706 HDC a0,
1707 HBITMAP a1,
1708 UINT a2,
1709 UINT a3,
1710 CONST VOID *a4,
1711 CONST BITMAPINFO *a5,
1712 UINT a6
1713 )
1714 {
1715 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1716 return 0;
1717 }
1718
1719
1720
1721 int
1722 STDCALL
1723 SetDIBitsToDevice(
1724 HDC a0,
1725 int a1,
1726 int a2,
1727 DWORD a3,
1728 DWORD a4,
1729 int a5,
1730 int a6,
1731 UINT a7,
1732 UINT a8,
1733 CONST VOID *a9,
1734 CONST BITMAPINFO *a10,
1735 UINT a11
1736 )
1737 {
1738 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1739 return 0;
1740 }
1741
1742
1743
1744 DWORD
1745 STDCALL
1746 SetMapperFlags(
1747 HDC a0,
1748 DWORD a1
1749 )
1750 {
1751 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1752 return 0;
1753 }
1754
1755
1756
1757 int
1758 STDCALL
1759 SetGraphicsMode(
1760 HDC hdc,
1761 int iMode
1762 )
1763 {
1764 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1765 return 0;
1766 }
1767
1768
1769
1770 int
1771 STDCALL
1772 SetMapMode(
1773 HDC a0,
1774 int a1
1775 )
1776 {
1777 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1778 return 0;
1779 }
1780
1781
1782
1783 HMETAFILE
1784 STDCALL
1785 SetMetaFileBitsEx(
1786 UINT a0,
1787 CONST BYTE *a1
1788 )
1789 {
1790 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1791 return 0;
1792 }
1793
1794
1795
1796 UINT
1797 STDCALL
1798 SetPaletteEntries(
1799 HPALETTE a0,
1800 UINT a1,
1801 UINT a2,
1802 CONST PALETTEENTRY *a3
1803 )
1804 {
1805 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1806 return 0;
1807 }
1808
1809
1810
1811 COLORREF
1812 STDCALL
1813 SetPixel(
1814 HDC a0,
1815 int a1,
1816 int a2,
1817 COLORREF a3
1818 )
1819 {
1820 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1821 return 0;
1822 }
1823
1824
1825
1826 BOOL
1827 STDCALL
1828 SetPixelV(
1829 HDC a0,
1830 int a1,
1831 int a2,
1832 COLORREF a3
1833 )
1834 {
1835 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1836 return FALSE;
1837 }
1838
1839
1840
1841 BOOL
1842 STDCALL
1843 SetPixelFormat(
1844 HDC a0,
1845 int a1,
1846 CONST PIXELFORMATDESCRIPTOR *a2
1847 )
1848 {
1849 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1850 return FALSE;
1851 }
1852
1853
1854
1855 int
1856 STDCALL
1857 SetPolyFillMode(
1858 HDC a0,
1859 int a1
1860 )
1861 {
1862 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1863 return 0;
1864 }
1865
1866
1867
1868 BOOL
1869 STDCALL
1870 StretchBlt(
1871 HDC a0,
1872 int a1,
1873 int a2,
1874 int a3,
1875 int a4,
1876 HDC a5,
1877 int a6,
1878 int a7,
1879 int a8,
1880 int a9,
1881 DWORD a10
1882 )
1883 {
1884 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1885 return FALSE;
1886 }
1887
1888
1889
1890 BOOL
1891 STDCALL
1892 SetRectRgn(
1893 HRGN a0,
1894 int a1,
1895 int a2,
1896 int a3,
1897 int a4
1898 )
1899 {
1900 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1901 return FALSE;
1902 }
1903
1904
1905
1906 int
1907 STDCALL
1908 StretchDIBits(
1909 HDC a0,
1910 int a1,
1911 int a2,
1912 int a3,
1913 int a4,
1914 int a5,
1915 int a6,
1916 int a7,
1917 int a8,
1918 CONST VOID *a9,
1919 CONST BITMAPINFO *a10,
1920 UINT a11,
1921 DWORD a12
1922 )
1923 {
1924 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1925 return 0;
1926 }
1927
1928
1929
1930 int
1931 STDCALL
1932 SetROP2(
1933 HDC a0,
1934 int a1
1935 )
1936 {
1937 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1938 return 0;
1939 }
1940
1941
1942
1943 int
1944 STDCALL
1945 SetStretchBltMode(
1946 HDC a0,
1947 int a1
1948 )
1949 {
1950 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1951 return 0;
1952 }
1953
1954
1955
1956 UINT
1957 STDCALL
1958 SetSystemPaletteUse(
1959 HDC a0,
1960 UINT a1
1961 )
1962 {
1963 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1964 return 0;
1965 }
1966
1967
1968
1969 int
1970 STDCALL
1971 SetTextCharacterExtra(
1972 HDC a0,
1973 int a1
1974 )
1975 {
1976 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1977 return 0;
1978 }
1979
1980
1981
1982 COLORREF
1983 STDCALL
1984 SetTextColor(
1985 HDC a0,
1986 COLORREF a1
1987 )
1988 {
1989 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1990 return 0;
1991 }
1992
1993
1994
1995 UINT
1996 STDCALL
1997 SetTextAlign(
1998 HDC a0,
1999 UINT a1
2000 )
2001 {
2002 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2003 return 0;
2004 }
2005
2006
2007
2008 BOOL
2009 STDCALL
2010 SetTextJustification(
2011 HDC a0,
2012 int a1,
2013 int a2
2014 )
2015 {
2016 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2017 return FALSE;
2018 }
2019
2020
2021
2022 BOOL
2023 STDCALL
2024 UpdateColors(
2025 HDC hdc
2026 )
2027 {
2028 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2029 return FALSE;
2030 }
2031
2032
2033
2034 BOOL
2035 STDCALL
2036 PlayMetaFileRecord(
2037 HDC a0,
2038 LPHANDLETABLE a1,
2039 LPMETARECORD a2,
2040 UINT a3
2041 )
2042 {
2043 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2044 return FALSE;
2045 }
2046
2047
2048
2049 BOOL
2050 STDCALL
2051 EnumMetaFile(
2052 HDC a0,
2053 HMETAFILE a1,
2054 ENUMMETAFILEPROC a2,
2055 LPARAM a3
2056 )
2057 {
2058 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2059 return FALSE;
2060 }
2061
2062
2063
2064 HENHMETAFILE
2065 STDCALL
2066 CloseEnhMetaFile(
2067 HDC hdc
2068 )
2069 {
2070 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2071 return FALSE;
2072 }
2073
2074
2075
2076 BOOL
2077 STDCALL
2078 DeleteEnhMetaFile(
2079 HENHMETAFILE a0
2080 )
2081 {
2082 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2083 return FALSE;
2084 }
2085
2086
2087
2088 BOOL
2089 STDCALL
2090 EnumEnhMetaFile(
2091 HDC a0,
2092 HENHMETAFILE a1,
2093 ENHMETAFILEPROC a2,
2094 LPVOID a3,
2095 CONST RECT *a4
2096 )
2097 {
2098 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2099 return FALSE;
2100 }
2101
2102
2103
2104 UINT
2105 STDCALL
2106 GetEnhMetaFileBits(
2107 HENHMETAFILE a0,
2108 UINT a1,
2109 LPBYTE a2
2110 )
2111 {
2112 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2113 return 0;
2114 }
2115
2116
2117
2118 UINT
2119 STDCALL
2120 GetEnhMetaFileHeader(
2121 HENHMETAFILE a0,
2122 UINT a1,
2123 LPENHMETAHEADER a2
2124 )
2125 {
2126 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2127 return 0;
2128 }
2129
2130
2131
2132 UINT
2133 STDCALL
2134 GetEnhMetaFilePaletteEntries(
2135 HENHMETAFILE a0,
2136 UINT a1,
2137 LPPALETTEENTRY a2
2138 )
2139 {
2140 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2141 return 0;
2142 }
2143
2144
2145
2146 UINT
2147 STDCALL
2148 GetEnhMetaFilePixelFormat(
2149 HENHMETAFILE a0,
2150 DWORD a1,
2151 CONST PIXELFORMATDESCRIPTOR *a2
2152 )
2153 {
2154 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2155 return 0;
2156 }
2157
2158
2159
2160 UINT
2161 STDCALL
2162 GetWinMetaFileBits(
2163 HENHMETAFILE a0,
2164 UINT a1,
2165 LPBYTE a2,
2166 INT a3,
2167 HDC a4
2168 )
2169 {
2170 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2171 return 0;
2172 }
2173
2174
2175
2176 BOOL
2177 STDCALL
2178 PlayEnhMetaFile(
2179 HDC a0,
2180 HENHMETAFILE a1,
2181 CONST RECT *a2
2182 )
2183 {
2184 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2185 return FALSE;
2186 }
2187
2188
2189
2190 BOOL
2191 STDCALL
2192 PlayEnhMetaFileRecord(
2193 HDC a0,
2194 LPHANDLETABLE a1,
2195 CONST ENHMETARECORD *a2,
2196 UINT a3
2197 )
2198 {
2199 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2200 return FALSE;
2201 }
2202
2203
2204
2205 HENHMETAFILE
2206 STDCALL
2207 SetEnhMetaFileBits(
2208 UINT a0,
2209 CONST BYTE *a1
2210 )
2211 {
2212 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2213 return 0;
2214 }
2215
2216
2217
2218 HENHMETAFILE
2219 STDCALL
2220 SetWinMetaFileBits(
2221 UINT a0,
2222 CONST BYTE *a1,
2223 HDC a2,
2224 CONST METAFILEPICT *a3
2225 )
2226 {
2227 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2228 return 0;
2229 }
2230
2231
2232
2233 BOOL
2234 STDCALL
2235 GdiComment(
2236 HDC a0,
2237 UINT a1,
2238 CONST BYTE *a2
2239 )
2240 {
2241 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2242 return FALSE;
2243 }
2244
2245
2246
2247 BOOL
2248 STDCALL
2249 AngleArc(
2250 HDC hdc,
2251 int a1,
2252 int a2,
2253 DWORD a3,
2254 FLOAT a4,
2255 FLOAT a5
2256 )
2257 {
2258 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2259 return FALSE;
2260 }
2261
2262
2263
2264 BOOL
2265 STDCALL
2266 PolyPolyline(
2267 HDC hdc,
2268 CONST POINT *a1,
2269 CONST DWORD *a2,
2270 DWORD a3
2271 )
2272 {
2273 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2274 return FALSE;
2275 }
2276
2277
2278
2279 BOOL
2280 STDCALL
2281 GetWorldTransform(
2282 HDC hdc,
2283 LPXFORM a1
2284 )
2285 {
2286 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2287 return FALSE;
2288 }
2289
2290
2291
2292 BOOL
2293 STDCALL
2294 SetWorldTransform(
2295 HDC a0,
2296 CONST XFORM *a1
2297 )
2298 {
2299 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2300 return FALSE;
2301 }
2302
2303
2304
2305 BOOL
2306 STDCALL
2307 ModifyWorldTransform(
2308 HDC a0,
2309 CONST XFORM *a1,
2310 DWORD a2
2311 )
2312 {
2313 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2314 return FALSE;
2315 }
2316
2317
2318
2319 BOOL
2320 STDCALL
2321 CombineTransform(
2322 LPXFORM a0,
2323 CONST XFORM *a1,
2324 CONST XFORM *a2
2325 )
2326 {
2327 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2328 return FALSE;
2329 }
2330
2331
2332
2333 HBITMAP
2334 STDCALL
2335 CreateDIBSection(
2336 HDC hdc,
2337 CONST BITMAPINFO *a1,
2338 UINT a2,
2339 VOID **a3,
2340 HANDLE a4,
2341 DWORD a5
2342 )
2343 {
2344 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2345 return 0;
2346 }
2347
2348
2349
2350 UINT
2351 STDCALL
2352 GetDIBColorTable(
2353 HDC hdc,
2354 UINT a1,
2355 UINT a2,
2356 RGBQUAD *a3
2357 )
2358 {
2359 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2360 return 0;
2361 }
2362
2363
2364
2365 UINT
2366 STDCALL
2367 SetDIBColorTable(
2368 HDC hdc,
2369 UINT a1,
2370 UINT a2,
2371 CONST RGBQUAD *a3
2372 )
2373 {
2374 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2375 return 0;
2376 }
2377
2378
2379
2380 BOOL
2381 STDCALL
2382 SetColorAdjustment(
2383 HDC hdc,
2384 CONST COLORADJUSTMENT *a1
2385 )
2386 {
2387 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2388 return FALSE;
2389 }
2390
2391
2392
2393 BOOL
2394 STDCALL
2395 GetColorAdjustment(
2396 HDC hdc,
2397 LPCOLORADJUSTMENT a1
2398 )
2399 {
2400 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2401 return FALSE;
2402 }
2403
2404
2405
2406 HPALETTE
2407 STDCALL
2408 CreateHalftonePalette(
2409 HDC hdc
2410 )
2411 {
2412 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2413 return 0;
2414 }
2415
2416
2417
2418 int
2419 STDCALL
2420 EndDoc(
2421 HDC hdc
2422 )
2423 {
2424 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2425 return 0;
2426 }
2427
2428
2429
2430 int
2431 STDCALL
2432 StartPage(
2433 HDC hdc
2434 )
2435 {
2436 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2437 return 0;
2438 }
2439
2440
2441
2442 int
2443 STDCALL
2444 EndPage(
2445 HDC hdc
2446 )
2447 {
2448 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2449 return 0;
2450 }
2451
2452
2453
2454 int
2455 STDCALL
2456 AbortDoc(
2457 HDC hdc
2458 )
2459 {
2460 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2461 return 0;
2462 }
2463
2464
2465
2466 int
2467 STDCALL
2468 SetAbortProc(
2469 HDC hdc,
2470 ABORTPROC a1
2471 )
2472 {
2473 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2474 return 0;
2475 }
2476
2477
2478
2479 BOOL
2480 STDCALL
2481 AbortPath(
2482 HDC hdc
2483 )
2484 {
2485 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2486 return FALSE;
2487 }
2488
2489
2490
2491 BOOL
2492 STDCALL
2493 ArcTo(
2494 HDC hdc,
2495 int a1,
2496 int a2,
2497 int a3,
2498 int a4,
2499 int a5,
2500 int a6,
2501 int a7,
2502 int a8
2503 )
2504 {
2505 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2506 return FALSE;
2507 }
2508
2509
2510
2511 BOOL
2512 STDCALL
2513 BeginPath(
2514 HDC hdc
2515 )
2516 {
2517 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2518 return FALSE;
2519 }
2520
2521
2522
2523 BOOL
2524 STDCALL
2525 CloseFigure(
2526 HDC hdc
2527 )
2528 {
2529 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2530 return FALSE;
2531 }
2532
2533
2534
2535 BOOL
2536 STDCALL
2537 EndPath(
2538 HDC hdc
2539 )
2540 {
2541 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2542 return FALSE;
2543 }
2544
2545
2546
2547 BOOL
2548 STDCALL
2549 FillPath(
2550 HDC hdc
2551 )
2552 {
2553 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2554 return FALSE;
2555 }
2556
2557
2558
2559 BOOL
2560 STDCALL
2561 FlattenPath(
2562 HDC hdc
2563 )
2564 {
2565 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2566 return FALSE;
2567 }
2568
2569
2570
2571 int
2572 STDCALL
2573 GetPath(
2574 HDC hdc,
2575 LPPOINT a1,
2576 LPBYTE a2,
2577 int a3
2578 )
2579 {
2580 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2581 return 0;
2582 }
2583
2584
2585
2586 HRGN
2587 STDCALL
2588 PathToRegion(
2589 HDC hdc
2590 )
2591 {
2592 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2593 return 0;
2594 }
2595
2596
2597
2598 BOOL
2599 STDCALL
2600 PolyDraw(
2601 HDC hdc,
2602 CONST POINT *a1,
2603 CONST BYTE *a2,
2604 int a3
2605 )
2606 {
2607 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2608 return FALSE;
2609 }
2610
2611
2612
2613 BOOL
2614 STDCALL
2615 SelectClipPath(
2616 HDC hdc,
2617 int a1
2618 )
2619 {
2620 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2621 return FALSE;
2622 }
2623
2624
2625
2626 int
2627 STDCALL
2628 SetArcDirection(
2629 HDC hdc,
2630 int a1
2631 )
2632 {
2633 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2634 return 0;
2635 }
2636
2637
2638
2639 BOOL
2640 STDCALL
2641 SetMiterLimit(
2642 HDC hdc,
2643 FLOAT a1,
2644 PFLOAT a2
2645 )
2646 {
2647 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2648 return FALSE;
2649 }
2650
2651
2652
2653 BOOL
2654 STDCALL
2655 StrokeAndFillPath(
2656 HDC hdc
2657 )
2658 {
2659 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2660 return FALSE;
2661 }
2662
2663
2664
2665 BOOL
2666 STDCALL
2667 StrokePath(
2668 HDC hdc
2669 )
2670 {
2671 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2672 return FALSE;
2673 }
2674
2675
2676
2677 BOOL
2678 STDCALL
2679 WidenPath(
2680 HDC hdc
2681 )
2682 {
2683 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2684 return FALSE;
2685 }
2686
2687
2688
2689 HPEN
2690 STDCALL
2691 ExtCreatePen(
2692 DWORD a0,
2693 DWORD a1,
2694 CONST LOGBRUSH *a2,
2695 DWORD a3,
2696 CONST DWORD *a4
2697 )
2698 {
2699 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2700 return 0;
2701 }
2702
2703
2704
2705 BOOL
2706 STDCALL
2707 GetMiterLimit(
2708 HDC hdc,
2709 PFLOAT a1
2710 )
2711 {
2712 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2713 return FALSE;
2714 }
2715
2716
2717
2718 int
2719 STDCALL
2720 GetArcDirection(
2721 HDC hdc
2722 )
2723 {
2724 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2725 return 0;
2726 }
2727
2728
2729
2730 BOOL
2731 STDCALL
2732 MoveToEx(
2733 HDC hdc,
2734 int a1,
2735 int a2,
2736 LPPOINT a3
2737 )
2738 {
2739 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2740 return FALSE;
2741 }
2742
2743
2744 HRGN
2745 STDCALL
2746 CreatePolygonRgn(
2747 CONST POINT *a0,
2748 int a1,
2749 int a2
2750 )
2751 {
2752 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2753 return 0;
2754 }
2755
2756
2757
2758 BOOL
2759 STDCALL
2760 DPtoLP(
2761 HDC a0,
2762 LPPOINT a1,
2763 int a2
2764 )
2765 {
2766 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2767 return FALSE;
2768 }
2769
2770
2771
2772 BOOL
2773 STDCALL
2774 LPtoDP(
2775 HDC a0,
2776 LPPOINT a1,
2777 int a2
2778 )
2779 {
2780 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2781 return FALSE;
2782 }
2783
2784
2785
2786 BOOL
2787 STDCALL
2788 Polygon(
2789 HDC a0,
2790 CONST POINT *a1,
2791 int a2
2792 )
2793 {
2794 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2795 return FALSE;
2796 }
2797
2798
2799
2800 BOOL
2801 STDCALL
2802 Polyline(
2803 HDC a0,
2804 CONST POINT *a1,
2805 int a2
2806 )
2807 {
2808 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2809 return FALSE;
2810 }
2811
2812
2813
2814 BOOL
2815 STDCALL
2816 PolyBezier(
2817 HDC a0,
2818 CONST POINT *a1,
2819 DWORD a2
2820 )
2821 {
2822 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2823 return FALSE;
2824 }
2825
2826
2827
2828 BOOL
2829 STDCALL
2830 PolyBezierTo(
2831 HDC a0,
2832 CONST POINT *a1,
2833 DWORD a2
2834 )
2835 {
2836 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2837 return FALSE;
2838 }
2839
2840
2841
2842 BOOL
2843 STDCALL
2844 PolylineTo(
2845 HDC a0,
2846 CONST POINT *a1,
2847 DWORD a2
2848 )
2849 {
2850 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2851 return FALSE;
2852 }
2853
2854
2855
2856 BOOL
2857 STDCALL
2858 SetViewportExtEx(
2859 HDC a0,
2860 int a1,
2861 int a2,
2862 LPSIZE a3
2863 )
2864 {
2865 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2866 return FALSE;
2867 }
2868
2869
2870
2871 BOOL
2872 STDCALL
2873 SetViewportOrgEx(
2874 HDC a0,
2875 int a1,
2876 int a2,
2877 LPPOINT a3
2878 )
2879 {
2880 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2881 return FALSE;
2882 }
2883
2884
2885
2886 BOOL
2887 STDCALL
2888 SetWindowExtEx(
2889 HDC a0,
2890 int a1,
2891 int a2,
2892 LPSIZE a3
2893 )
2894 {
2895 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2896 return FALSE;
2897 }
2898
2899
2900
2901
2902 BOOL
2903 STDCALL
2904 SetWindowOrgEx(
2905 HDC a0,
2906 int a1,
2907 int a2,
2908 LPPOINT a3
2909 )
2910 {
2911 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2912 return FALSE;
2913 }
2914
2915
2916
2917 BOOL
2918 STDCALL
2919 OffsetViewportOrgEx(
2920 HDC a0,
2921 int a1,
2922 int a2,
2923 LPPOINT a3
2924 )
2925 {
2926 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2927 return FALSE;
2928 }
2929
2930
2931
2932 BOOL
2933 STDCALL
2934 OffsetWindowOrgEx(
2935 HDC a0,
2936 int a1,
2937 int a2,
2938 LPPOINT a3
2939 )
2940 {
2941 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2942 return FALSE;
2943 }
2944
2945
2946
2947 BOOL
2948 STDCALL
2949 ScaleViewportExtEx(
2950 HDC a0,
2951 int a1,
2952 int a2,
2953 int a3,
2954 int a4,
2955 LPSIZE a5
2956 )
2957 {
2958 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2959 return FALSE;
2960 }
2961
2962
2963
2964 BOOL
2965 STDCALL
2966 ScaleWindowExtEx(
2967 HDC a0,
2968 int a1,
2969 int a2,
2970 int a3,
2971 int a4,
2972 LPSIZE a5
2973 )
2974 {
2975 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2976 return FALSE;
2977 }
2978
2979
2980
2981 BOOL
2982 STDCALL
2983 SetBitmapDimensionEx(
2984 HBITMAP a0,
2985 int a1,
2986 int a2,
2987 LPSIZE a3
2988 )
2989 {
2990 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2991 return FALSE;
2992 }
2993
2994
2995
2996 BOOL
2997 STDCALL
2998 SetBrushOrgEx(
2999 HDC a0,
3000 int a1,
3001 int a2,
3002 LPPOINT a3
3003 )
3004 {
3005 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3006 return FALSE;
3007 }
3008
3009
3010
3011 BOOL
3012 STDCALL
3013 GetDCOrgEx(
3014 HDC a0,
3015 LPPOINT a1
3016 )
3017 {
3018 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3019 return FALSE;
3020 }
3021
3022
3023
3024 BOOL
3025 STDCALL
3026 FixBrushOrgEx(
3027 HDC a0,
3028 int a1,
3029 int a2,
3030 LPPOINT a3
3031 )
3032 {
3033 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3034 return FALSE;
3035 }
3036
3037
3038
3039 BOOL
3040 STDCALL
3041 UnrealizeObject(
3042 HGDIOBJ a0
3043 )
3044 {
3045 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3046 return FALSE;
3047 }
3048
3049
3050
3051 BOOL
3052 STDCALL
3053 GdiFlush()
3054 {
3055 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3056 return FALSE;
3057 }
3058
3059
3060
3061 DWORD
3062 STDCALL
3063 GdiSetBatchLimit(
3064 DWORD a0
3065 )
3066 {
3067 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3068 return 0;
3069 }
3070
3071
3072
3073 DWORD
3074 STDCALL
3075 GdiGetBatchLimit()
3076 {
3077 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3078 return 0;
3079 }
3080
3081
3082 int
3083 STDCALL
3084 SetICMMode(
3085 HDC a0,
3086 int a1
3087 )
3088 {
3089 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3090 return 0;
3091 }
3092
3093
3094 BOOL
3095 STDCALL
3096 CheckColorsInGamut(
3097 HDC a0,
3098 LPVOID a1,
3099 LPVOID a2,
3100 DWORD a3
3101 )
3102 {
3103 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3104 return FALSE;
3105 }
3106
3107
3108 HANDLE
3109 STDCALL
3110 GetColorSpace(
3111 HDC hDc
3112 )
3113 {
3114 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3115 return 0;
3116 }
3117
3118
3119 BOOL
3120 STDCALL
3121 SetColorSpace(
3122 HDC a0,
3123 HCOLORSPACE a1
3124 )
3125 {
3126 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3127 return FALSE;
3128 }
3129
3130
3131 BOOL
3132 STDCALL
3133 DeleteColorSpace(
3134 HCOLORSPACE a0
3135 )
3136 {
3137 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3138 return FALSE;
3139 }
3140
3141
3142 BOOL
3143 STDCALL
3144 GetDeviceGammaRamp(
3145 HDC a0,
3146 LPVOID a1
3147 )
3148 {
3149 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3150 return FALSE;
3151 }
3152
3153
3154 BOOL
3155 STDCALL
3156 SetDeviceGammaRamp(
3157 HDC a0,
3158 LPVOID a1
3159 )
3160 {
3161 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3162 return FALSE;
3163 }
3164
3165
3166 BOOL
3167 STDCALL
3168 ColorMatchToTarget(
3169 HDC a0,
3170 HDC a1,
3171 DWORD a2
3172 )
3173 {
3174 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3175 return FALSE;
3176 }
3177
3178
3179 BOOL
3180 STDCALL
3181 wglCopyContext(
3182 HGLRC a0,
3183 HGLRC a1,
3184 UINT a2
3185 )
3186 {
3187 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3188 return FALSE;
3189 }
3190
3191
3192
3193 HGLRC
3194 STDCALL
3195 wglCreateContext(
3196 HDC hDc
3197 )
3198 {
3199 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3200 return 0;
3201 }
3202
3203
3204
3205 HGLRC
3206 STDCALL
3207 wglCreateLayerContext(
3208 HDC hDc,
3209 int a1
3210 )
3211 {
3212 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3213 return 0;
3214 }
3215
3216
3217
3218 BOOL
3219 STDCALL
3220 wglDeleteContext(
3221 HGLRC a
3222 )
3223 {
3224 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3225 return FALSE;
3226 }
3227
3228
3229
3230 HGLRC
3231 STDCALL
3232 wglGetCurrentContext(VOID)
3233 {
3234 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3235 return 0;
3236 }
3237
3238
3239
3240 HDC
3241 STDCALL
3242 wglGetCurrentDC(VOID)
3243 {
3244 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3245 return 0;
3246 }
3247
3248
3249
3250 PROC
3251 STDCALL
3252 wglGetProcAddress(
3253 LPCSTR a0
3254 )
3255 {
3256 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3257 return 0;
3258 }
3259
3260
3261
3262 BOOL
3263 STDCALL
3264 wglMakeCurrent(
3265 HDC a0,
3266 HGLRC a1
3267 )
3268 {
3269 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3270 return FALSE;
3271 }
3272
3273
3274
3275 BOOL
3276 STDCALL
3277 wglShareLists(
3278 HGLRC a0,
3279 HGLRC a1
3280 )
3281 {
3282 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3283 return FALSE;
3284 }
3285
3286
3287 BOOL
3288 STDCALL
3289 SwapBuffers(
3290 HDC a0
3291 )
3292 {
3293 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3294 return FALSE;
3295 }
3296
3297
3298
3299 BOOL
3300 STDCALL
3301 wglDescribeLayerPlane(
3302 HDC a0,
3303 int a1,
3304 int a2,
3305 UINT a3,
3306 LPLAYERPLANEDESCRIPTOR a4
3307 )
3308 {
3309 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3310 return FALSE;
3311 }
3312
3313
3314 int
3315 STDCALL
3316 wglSetLayerPaletteEntries(
3317 HDC a0,
3318 int a1,
3319 int a2,
3320 int a3,
3321 CONST COLORREF *a4
3322 )
3323 {
3324 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3325 return 0;
3326 }
3327
3328
3329 int
3330 STDCALL
3331 wglGetLayerPaletteEntries(
3332 HDC a0,
3333 int a1,
3334 int a2,
3335 int a3,
3336 CONST COLORREF *a4
3337 )
3338 {
3339 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3340 return 0;
3341 }
3342
3343
3344 BOOL
3345 STDCALL
3346 wglRealizeLayerPalette(
3347 HDC a0,
3348 int a1,
3349 BOOL a2
3350 )
3351 {
3352 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3353 return FALSE;
3354 }
3355
3356
3357 BOOL
3358 STDCALL
3359 wglSwapLayerBuffers(
3360 HDC a0,
3361 UINT a1
3362 )
3363 {
3364 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3365 return FALSE;
3366 }
3367
3368
3369 /* === AFTER THIS POINT I GUESS... =========
3370 * (based on stack size in Norlander's .def)
3371 * === WHERE ARE THEY DEFINED? =============
3372 */
3373
3374
3375 DWORD
3376 STDCALL
3377 GdiPlayDCScript(
3378 DWORD a0,
3379 DWORD a1,
3380 DWORD a2,
3381 DWORD a3,
3382 DWORD a4,
3383 DWORD a5
3384 )
3385 {
3386 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3387 return 0;
3388 }
3389
3390
3391 DWORD
3392 STDCALL
3393 GdiPlayJournal(
3394 DWORD a0,
3395 DWORD a1,
3396 DWORD a2,
3397 DWORD a3,
3398 DWORD a4
3399 )
3400 {
3401 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3402 return 0;
3403 }
3404
3405
3406 DWORD
3407 STDCALL
3408 GdiPlayScript(
3409 DWORD a0,
3410 DWORD a1,
3411 DWORD a2,
3412 DWORD a3,
3413 DWORD a4,
3414 DWORD a5,
3415 DWORD a6
3416 )
3417 {
3418 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3419 return 0;
3420 }
3421
3422
3423 DWORD
3424 STDCALL
3425 GetGlyphOutlineWow(
3426 DWORD a0,
3427 DWORD a1,
3428 DWORD a2,
3429 DWORD a3,
3430 DWORD a4,
3431 DWORD a5,
3432 DWORD a6
3433 )
3434 {
3435 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3436 return 0;
3437 }
3438
3439
3440 DWORD
3441 STDCALL
3442 GetRandomRgn(
3443 DWORD a0,
3444 DWORD a1,
3445 DWORD a2
3446 )
3447 {
3448 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3449 return 0;
3450 }
3451
3452
3453 DWORD
3454 STDCALL
3455 GetRelAbs(
3456 DWORD a0,
3457 DWORD a1
3458 )
3459 {
3460 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3461 return 0;
3462 }
3463
3464
3465
3466 DWORD
3467 STDCALL
3468 SelectBrushLocal(
3469 DWORD a0,
3470 DWORD a1
3471 )
3472 {
3473 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3474 return 0;
3475 }
3476
3477
3478
3479 DWORD
3480 STDCALL
3481 SelectFontLocal(
3482 DWORD a0,
3483 DWORD a1
3484 )
3485 {
3486 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3487 return 0;
3488 }
3489
3490
3491 DWORD
3492 STDCALL
3493 SetFontEnumeration(
3494 DWORD a0
3495 )
3496 {
3497 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3498 return 0;
3499 }
3500
3501
3502 DWORD
3503 STDCALL
3504 SetRelAbs(
3505 DWORD a0,
3506 DWORD a1
3507 )
3508 {
3509 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3510 return 0;
3511 }
3512
3513
3514 DWORD
3515 STDCALL
3516 gdiPlaySpoolStream(
3517 DWORD a0,
3518 DWORD a1,
3519 DWORD a2,
3520 DWORD a3,
3521 DWORD a4,
3522 DWORD a5
3523 )
3524 {
3525 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3526 return 0;
3527 }
3528
3529
3530 DWORD
3531 STDCALL
3532 GetFontResourceInfo(
3533 DWORD a0,
3534 DWORD a1,
3535 DWORD a2,
3536 DWORD a3
3537 )
3538 {
3539 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3540 return 0;
3541 }
3542
3543
3544 /* EOF */