lib/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 #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 CancelDC(
  54         HDC     a0
  55         )
  56 {
  57         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  58         return FALSE;
  59 }
  60
  61
  62
  63 BOOL
  64 STDCALL
  65 Chord(
  66         HDC     a0,
  67         int     a1,
  68         int     a2,
  69         int     a3,
  70         int     a4,
  71         int     a5,
  72         int     a6,
  73         int     a7,
  74         int     a8
  75         )
  76 {
  77         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  78         return FALSE;
  79 }
  80
  81
  82
  83 int
  84 STDCALL
  85 ChoosePixelFormat(
  86         HDC                             a0,
  87         CONST PIXELFORMATDESCRIPTOR     *a1
  88         )
  89 {
  90         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  91         return 0;
  92 }
  93
  94
  95
  96 HMETAFILE
  97 STDCALL
  98 CloseMetaFile(
  99         HDC     a0
 100         )
 101 {
 102         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 103         return 0;
 104 }
 105
 106
 107
 108 HBRUSH
 109 STDCALL
 110 CreateBrushIndirect(
 111         CONST LOGBRUSH  *a0
 112         )
 113 {
 114         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 115         return 0;
 116 }
 117
 118
 119
 120 HBRUSH
 121 STDCALL
 122 CreateDIBPatternBrush(
 123         HGLOBAL                 a0,
 124         UINT                    a1
 125         )
 126 {
 127         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 128         return 0;
 129 }
 130
 131
 132
 133 HBRUSH
 134 STDCALL
 135 CreateDIBPatternBrushPt(
 136         CONST VOID              *a0,
 137         UINT                    a1
 138         )
 139 {
 140         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 141         return 0;
 142 }
 143
 144
 145
 146 HRGN
 147 STDCALL
 148 CreateEllipticRgn(
 149         int                     a0,
 150         int                     a1,
 151         int                     a2,
 152         int                     a3
 153         )
 154 {
 155         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 156         return 0;
 157 }
 158
 159
 160
 161 HRGN
 162 STDCALL
 163 CreateEllipticRgnIndirect(
 164         CONST RECT              *a0
 165         )
 166 {
 167         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 168         return 0;
 169 }
 170
 171
 172
 173 HBRUSH
 174 STDCALL
 175 CreateHatchBrush(
 176         int             a0,
 177         COLORREF        a1
 178         )
 179 {
 180         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 181         return 0;
 182 }
 183
 184
 185
 186 HPALETTE
 187 STDCALL
 188 CreatePalette(
 189         CONST LOGPALETTE        *a0
 190         )
 191 {
 192         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 193         return 0;
 194 }
 195
 196 BOOL
 197 STDCALL
 198 DeleteMetaFile(
 199         HMETAFILE       a0
 200         )
 201 {
 202         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 203         return FALSE;
 204 }
 205
 206
 207
 208 int
 209 STDCALL
 210 DescribePixelFormat(
 211         HDC                     a0,
 212         int                     a1,
 213         UINT                    a2,
 214         LPPIXELFORMATDESCRIPTOR a3
 215         )
 216 {
 217         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 218         return 0;
 219 }
 220
 221
 222
 223 int
 224 STDCALL
 225 DrawEscape(
 226         HDC             a0,
 227         int             a1,
 228         int             a2,
 229         LPCSTR          a3
 230         )
 231 {
 232         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 233         return 0;
 234 }
 235
 236
 237
 238 BOOL
 239 STDCALL
 240 Ellipse(
 241         HDC             a0,
 242         int             a1,
 243         int             a2,
 244         int             a3,
 245         int             a4
 246         )
 247 {
 248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 249         return FALSE;
 250 }
 251
 252
 253
 254 int
 255 STDCALL
 256 EnumObjects(
 257         HDC             a0,
 258         int             a1,
 259         ENUMOBJECTSPROC a2,
 260         LPARAM          a3
 261         )
 262 {
 263         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 264         return 0;
 265 }
 266
 267
 268
 269 int
 270 STDCALL
 271 Escape(
 272         HDC             a0,
 273         int             a1,
 274         int             a2,
 275         LPCSTR          a3,
 276         LPVOID          a4
 277         )
 278 {
 279         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 280         return 0;
 281 }
 282
 283
 284
 285
 286 int
 287 STDCALL
 288 ExtEscape(
 289         HDC             a0,
 290         int             a1,
 291         int             a2,
 292         LPCSTR          a3,
 293         int             a4,
 294         LPSTR           a5
 295         )
 296 {
 297         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 298         return 0;
 299 }
 300
 301
 302
 303 int
 304 STDCALL
 305 ExcludeClipRect(
 306         HDC     a0,
 307         int     a1,
 308         int     a2,
 309         int     a3,
 310         int     a4
 311         )
 312 {
 313         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 314         return 0;
 315 }
 316
 317
 318
 319 HRGN
 320 STDCALL
 321 ExtCreateRegion(
 322         CONST XFORM *   a0,
 323         DWORD           a1,
 324         CONST RGNDATA * a2
 325         )
 326 {
 327         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 328         return 0;
 329 }
 330
 331
 332
 333 BOOL
 334 STDCALL
 335 ExtFloodFill(
 336         HDC             a0,
 337         int             a1,
 338         int             a2,
 339         COLORREF        a3,
 340         UINT            a4
 341         )
 342 {
 343         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 344         return FALSE;
 345 }
 346
 347
 348
 349 BOOL
 350 STDCALL
 351 FillRgn(
 352         HDC     a0,
 353         HRGN    a1,
 354         HBRUSH  a2
 355         )
 356 {
 357         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 358         return FALSE;
 359 }
 360
 361
 362
 363 BOOL
 364 STDCALL
 365 FloodFill(
 366         HDC             a0,
 367         int             a1,
 368         int             a2,
 369         COLORREF        a3
 370         )
 371 {
 372         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 373         return FALSE;
 374 }
 375
 376
 377
 378 BOOL
 379 STDCALL
 380 FrameRgn(
 381         HDC     a0,
 382         HRGN    a1,
 383         HBRUSH  a2,
 384         int     a3,
 385         int     a4
 386         )
 387 {
 388         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 389         return FALSE;
 390 }
 391
 392
 393
 394 int
 395 STDCALL
 396 GetROP2(
 397         HDC     a0
 398         )
 399 {
 400         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 401         return 0;
 402 }
 403
 404
 405
 406 BOOL
 407 STDCALL
 408 GetAspectRatioFilterEx(
 409         HDC     a0,
 410         LPSIZE  a1
 411         )
 412 {
 413         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 414         return FALSE;
 415 }
 416
 417
 418
 419 COLORREF
 420 STDCALL
 421 GetBkColor(
 422         HDC     a0
 423         )
 424 {
 425         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 426         return 0;
 427 }
 428
 429
 430
 431 int
 432 STDCALL
 433 GetBkMode(
 434         HDC     a0
 435         )
 436 {
 437         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 438         return 0;
 439 }
 440
 441
 442
 443 UINT
 444 STDCALL
 445 GetBoundsRect(
 446         HDC     a0,
 447         LPRECT  a1,
 448         UINT    a2
 449         )
 450 {
 451         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 452         return 0;
 453 }
 454
 455
 456
 457 BOOL
 458 STDCALL
 459 GetBrushOrgEx(
 460         HDC     a0,
 461         LPPOINT a1
 462         )
 463 {
 464         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 465         return FALSE;
 466 }
 467
 468
 469 int
 470 STDCALL
 471 GetClipRgn(
 472         HDC     a0,
 473         HRGN    a1
 474         )
 475 {
 476         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 477         return 0;
 478 }
 479
 480
 481
 482 int
 483 STDCALL
 484 GetMetaRgn(
 485         HDC     a0,
 486         HRGN    a1
 487         )
 488 {
 489         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 490         return 0;
 491 }
 492
 493
 494
 495 HGDIOBJ
 496 STDCALL
 497 GetCurrentObject(
 498         HDC     a0,
 499         UINT    a1
 500         )
 501 {
 502         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 503         return 0;
 504 }
 505
 506
 507
 508 BOOL
 509 STDCALL
 510 GetCurrentPositionEx(
 511         HDC     a0,
 512         LPPOINT a1
 513         )
 514 {
 515         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 516         return FALSE;
 517 }
 518
 519
 520
 521 int
 522 STDCALL
 523 GetDeviceCaps(
 524         HDC     a0,
 525         int     a1
 526         )
 527 {
 528         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 529         return 0;
 530 }
 531
 532
 533
 534
 535 DWORD
 536 STDCALL
 537 GetFontData(
 538         HDC     a0,
 539         DWORD   a1,
 540         DWORD   a2,
 541         LPVOID  a3,
 542         DWORD   a4
 543         )
 544 {
 545         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 546         return 0;
 547 }
 548
 549
 550
 551 int
 552 STDCALL
 553 GetGraphicsMode(
 554         HDC     a0
 555         )
 556 {
 557         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 558         return 0;
 559 }
 560
 561
 562
 563
 564 int
 565 STDCALL
 566 GetMapMode(
 567         HDC     a0
 568         )
 569 {
 570         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 571         return 0;
 572 }
 573
 574
 575
 576 UINT
 577 STDCALL
 578 GetMetaFileBitsEx(
 579         HMETAFILE       a0,
 580         UINT            a1,
 581         LPVOID          a2
 582         )
 583 {
 584         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 585         return 0;
 586 }
 587
 588
 589
 590 COLORREF
 591 STDCALL
 592 GetNearestColor(
 593         HDC             a0,
 594         COLORREF        a1
 595         )
 596 {
 597         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 598         return 0;
 599 }
 600
 601
 602
 603 UINT
 604 STDCALL
 605 GetNearestPaletteIndex(
 606         HPALETTE        a0,
 607         COLORREF        a1
 608         )
 609 {
 610         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 611         return 0;
 612 }
 613
 614
 615
 616 DWORD
 617 STDCALL
 618 GetObjectType(
 619         HGDIOBJ         a0
 620         )
 621 {
 622         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 623         return 0;
 624 }
 625
 626
 627 UINT
 628 STDCALL
 629 GetPaletteEntries(
 630         HPALETTE        a0,
 631         UINT            a1,
 632         UINT            a2,
 633         LPPALETTEENTRY  a3
 634         )
 635 {
 636         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 637         return 0;
 638 }
 639
 640
 641
 642 COLORREF
 643 STDCALL
 644 GetPixel(
 645         HDC     a0,
 646         int     a1,
 647         int     a2
 648         )
 649 {
 650         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 651         return 0;
 652 }
 653
 654
 655
 656 int
 657 STDCALL
 658 GetPixelFormat(
 659         HDC     a0
 660         )
 661 {
 662         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 663         return 0;
 664 }
 665
 666
 667
 668
 669 BOOL
 670 STDCALL
 671 GetRasterizerCaps(
 672         LPRASTERIZER_STATUS     a0,
 673         UINT                    a1
 674         )
 675 {
 676         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 677         return FALSE;
 678 }
 679
 680
 681
 682
 683
 684
 685 int
 686 STDCALL
 687 GetStretchBltMode(
 688         HDC     a0
 689         )
 690 {
 691         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 692         return 0;
 693 }
 694
 695
 696
 697 UINT
 698 STDCALL
 699 GetSystemPaletteEntries(
 700         HDC             a0,
 701         UINT            a1,
 702         UINT            a2,
 703         LPPALETTEENTRY  a3
 704         )
 705 {
 706         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 707         return 0;
 708 }
 709
 710
 711
 712 UINT
 713 STDCALL
 714 GetSystemPaletteUse(
 715         HDC     hDc
 716         )
 717 {
 718         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 719         return 0;
 720 }
 721
 722
 723
 724 int
 725 STDCALL
 726 GetTextCharacterExtra(
 727         HDC     hDc
 728         )
 729 {
 730         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 731         return 0;
 732 }
 733
 734
 735
 736 UINT
 737 STDCALL
 738 GetTextAlign(
 739         HDC     hDc
 740         )
 741 {
 742         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 743         return 0;
 744 }
 745
 746
 747
 748 COLORREF
 749 STDCALL
 750 GetTextColor(
 751         HDC     hDc
 752         )
 753 {
 754         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 755         return 0;
 756 }
 757
 758
 759 int
 760 STDCALL
 761 GetTextCharset(
 762         HDC     hdc
 763         )
 764 {
 765         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 766         return 0;
 767 }
 768
 769
 770
 771 int
 772 STDCALL
 773 GetTextCharsetInfo(
 774         HDC             hdc,
 775         LPFONTSIGNATURE lpSig,
 776         DWORD           dwFlags
 777         )
 778 {
 779         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 780         return 0;
 781 }
 782
 783
 784
 785 BOOL
 786 STDCALL
 787 TranslateCharsetInfo(
 788         DWORD FAR       *lpSrc,
 789         LPCHARSETINFO   lpCs,
 790         DWORD           dwFlags
 791         )
 792 {
 793         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 794         return FALSE;
 795 }
 796
 797
 798
 799 DWORD
 800 STDCALL
 801 GetFontLanguageInfo(
 802         HDC     hDc
 803         )
 804 {
 805         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 806         return 0;
 807 }
 808
 809
 810 BOOL
 811 STDCALL
 812 GetViewportExtEx(
 813         HDC     hDc,
 814         LPSIZE  lpSize
 815         )
 816 {
 817         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 818         return FALSE;
 819 }
 820
 821
 822
 823 BOOL
 824 STDCALL
 825 GetViewportOrgEx(
 826         HDC             hDc,
 827         LPPOINT         lpPoint
 828         )
 829 {
 830         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 831         return FALSE;
 832 }
 833
 834
 835
 836 BOOL
 837 STDCALL
 838 GetWindowExtEx(
 839         HDC             hDc,
 840         LPSIZE          lpSize
 841         )
 842 {
 843         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 844         return FALSE;
 845 }
 846
 847
 848
 849 BOOL
 850 STDCALL
 851 GetWindowOrgEx(
 852         HDC             hDc,
 853         LPPOINT         lpPoint
 854         )
 855 {
 856         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 857         return FALSE;
 858 }
 859
 860
 861
 862 int
 863 STDCALL
 864 IntersectClipRect(
 865         HDC             hDc,
 866         int             a1,
 867         int             a2,
 868         int             a3,
 869         int             a4
 870         )
 871 {
 872         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 873         return 0;
 874 }
 875
 876
 877
 878 BOOL
 879 STDCALL
 880 InvertRgn(
 881         HDC     hDc,
 882         HRGN    hRgn
 883         )
 884 {
 885         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 886         return FALSE;
 887 }
 888
 889
 890
 891 BOOL
 892 STDCALL
 893 LineDDA(
 894         int             a0,
 895         int             a1,
 896         int             a2,
 897         int             a3,
 898         LINEDDAPROC     a4,
 899         LPARAM          a5
 900         )
 901 {
 902         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 903         return FALSE;
 904 }
 905
 906
 907
 908
 909 int
 910 STDCALL
 911 OffsetClipRgn(
 912         HDC     a0,
 913         int     a1,
 914         int     a2
 915         )
 916 {
 917         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 918         return 0;
 919 }
 920
 921
 922
 923
 924
 925 BOOL
 926 STDCALL
 927 Pie(
 928         HDC     a0,
 929         int     a1,
 930         int     a2,
 931         int     a3,
 932         int     a4,
 933         int     a5,
 934         int     a6,
 935         int     a7,
 936         int     a8
 937         )
 938 {
 939         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 940         return FALSE;
 941 }
 942
 943
 944
 945 BOOL
 946 STDCALL
 947 PlayMetaFile(
 948         HDC             a0,
 949         HMETAFILE       a1
 950         )
 951 {
 952         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 953         return FALSE;
 954 }
 955
 956
 957
 958
 959
 960
 961 BOOL
 962 STDCALL
 963 PolyPolygon(
 964         HDC             a0,
 965         CONST POINT     *a1,
 966         CONST INT       *a2,
 967         int             a3
 968         )
 969 {
 970         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 971         return FALSE;
 972 }
 973
 974
 975
 976 BOOL
 977 STDCALL
 978 PtInRegion(
 979         HRGN    a0,
 980         int     a1,
 981         int     a2
 982         )
 983 {
 984         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 985         return FALSE;
 986 }
 987
 988
 989
 990 BOOL
 991 STDCALL
 992 PtVisible(
 993         HDC     a0,
 994         int     a1,
 995         int     a2
 996         )
 997 {
 998         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 999         return FALSE;
1000 }
1001
1002
1003
1004 BOOL
1005 STDCALL
1006 RectInRegion(
1007         HRGN            a0,
1008         CONST RECT      *a1
1009         )
1010 {
1011         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1012         return FALSE;
1013 }
1014
1015
1016
1017 BOOL
1018 STDCALL
1019 RectVisible(
1020         HDC             a0,
1021         CONST RECT      *a1
1022         )
1023 {
1024         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1025         return FALSE;
1026 }
1027
1028
1029
1030 BOOL
1031 STDCALL
1032 RestoreDC(
1033         HDC     a0,
1034         int     a1
1035         )
1036 {
1037         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1038         return FALSE;
1039 }
1040
1041
1042 BOOL
1043 STDCALL
1044 RoundRect(
1045         HDC     a0,
1046         int     a1,
1047         int     a2,
1048         int     a3,
1049         int     a4,
1050         int     a5,
1051         int     a6
1052         )
1053 {
1054         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1055         return FALSE;
1056 }
1057
1058
1059
1060 BOOL
1061 STDCALL
1062 ResizePalette(
1063         HPALETTE        a0,
1064         UINT            a1
1065         )
1066 {
1067         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1068         return FALSE;
1069 }
1070
1071
1072
1073 int
1074 STDCALL
1075 SaveDC(
1076         HDC     a0
1077         )
1078 {
1079         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1080         return 0;
1081 }
1082
1083
1084
1085 int
1086 STDCALL
1087 SelectClipRgn(
1088         HDC     a0,
1089         HRGN    a1
1090         )
1091 {
1092         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1093         return 0;
1094 }
1095
1096
1097
1098 int
1099 STDCALL
1100 ExtSelectClipRgn(
1101         HDC     a0,
1102         HRGN    a1,
1103         int     a2
1104         )
1105 {
1106         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1107         return 0;
1108 }
1109
1110
1111
1112 int
1113 STDCALL
1114 SetMetaRgn(
1115         HDC     hdc
1116         )
1117 {
1118         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1119         return 0;
1120 }
1121
1122
1123
1124 COLORREF
1125 STDCALL
1126 SetBkColor(
1127         HDC             a0,
1128         COLORREF        a1
1129         )
1130 {
1131         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1132         return 0;
1133 }
1134
1135
1136
1137 int
1138 STDCALL
1139 SetBkMode(
1140         HDC     a0,
1141         int     a1
1142         )
1143 {
1144         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1145         return 0;
1146 }
1147
1148
1149
1150 UINT
1151 STDCALL
1152 SetBoundsRect(
1153         HDC             a0,
1154         CONST RECT      *a1,
1155         UINT            a2
1156         )
1157 {
1158         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1159         return 0;
1160 }
1161
1162
1163
1164 DWORD
1165 STDCALL
1166 SetMapperFlags(
1167         HDC     a0,
1168         DWORD   a1
1169         )
1170 {
1171         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1172         return 0;
1173 }
1174
1175
1176
1177 int
1178 STDCALL
1179 SetGraphicsMode(
1180         HDC     hdc,
1181         int     iMode
1182         )
1183 {
1184         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1185         return 0;
1186 }
1187
1188
1189
1190 HMETAFILE
1191 STDCALL
1192 SetMetaFileBitsEx(
1193         UINT            a0,
1194         CONST BYTE      *a1
1195         )
1196 {
1197         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1198         return 0;
1199 }
1200
1201
1202
1203 UINT
1204 STDCALL
1205 SetPaletteEntries(
1206         HPALETTE                a0,
1207         UINT                    a1,
1208         UINT                    a2,
1209         CONST PALETTEENTRY      *a3
1210         )
1211 {
1212         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1213         return 0;
1214 }
1215
1216
1217
1218 BOOL
1219 STDCALL
1220 SetPixelV(
1221         HDC             a0,
1222         int             a1,
1223         int             a2,
1224         COLORREF        a3
1225         )
1226 {
1227         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1228         return FALSE;
1229 }
1230
1231
1232
1233 BOOL
1234 STDCALL
1235 SetPixelFormat(
1236         HDC                             a0,
1237         int                             a1,
1238         CONST PIXELFORMATDESCRIPTOR     *a2
1239         )
1240 {
1241         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1242         return FALSE;
1243 }
1244
1245
1246
1247
1248 BOOL
1249 STDCALL
1250 StretchBlt(
1251         HDC     a0,
1252         int     a1,
1253         int     a2,
1254         int     a3,
1255         int     a4,
1256         HDC     a5,
1257         int     a6,
1258         int     a7,
1259         int     a8,
1260         int     a9,
1261         DWORD   a10
1262         )
1263 {
1264         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1265         return FALSE;
1266 }
1267
1268
1269
1270 int
1271 STDCALL
1272 SetROP2(
1273         HDC     a0,
1274         int     a1
1275         )
1276 {
1277         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1278         return 0;
1279 }
1280
1281
1282
1283 int
1284 STDCALL
1285 SetStretchBltMode(
1286         HDC     a0,
1287         int     a1
1288         )
1289 {
1290         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1291         return 0;
1292 }
1293
1294
1295
1296 UINT
1297 STDCALL
1298 SetSystemPaletteUse(
1299         HDC     a0,
1300         UINT    a1
1301         )
1302 {
1303         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1304         return 0;
1305 }
1306
1307
1308
1309 int
1310 STDCALL
1311 SetTextCharacterExtra(
1312         HDC     a0,
1313         int     a1
1314         )
1315 {
1316         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1317         return 0;
1318 }
1319
1320
1321
1322 UINT
1323 STDCALL
1324 SetTextAlign(
1325         HDC     a0,
1326         UINT    a1
1327         )
1328 {
1329         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1330         return 0;
1331 }
1332
1333
1334
1335 BOOL
1336 STDCALL
1337 SetTextJustification(
1338         HDC     a0,
1339         int     a1,
1340         int     a2
1341         )
1342 {
1343         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1344         return FALSE;
1345 }
1346
1347
1348
1349 BOOL
1350 STDCALL
1351 UpdateColors(
1352         HDC     hdc
1353         )
1354 {
1355         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1356         return FALSE;
1357 }
1358
1359
1360
1361 BOOL
1362 STDCALL
1363 PlayMetaFileRecord(
1364         HDC             a0,
1365         LPHANDLETABLE   a1,
1366         LPMETARECORD    a2,
1367         UINT            a3
1368         )
1369 {
1370         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1371         return FALSE;
1372 }
1373
1374
1375
1376 BOOL
1377 STDCALL
1378 EnumMetaFile(
1379         HDC                     a0,
1380         HMETAFILE               a1,
1381         ENUMMETAFILEPROC        a2,
1382         LPARAM                  a3
1383         )
1384 {
1385         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1386         return FALSE;
1387 }
1388
1389
1390
1391 HENHMETAFILE
1392 STDCALL
1393 CloseEnhMetaFile(
1394         HDC     hdc
1395         )
1396 {
1397         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1398         return FALSE;
1399 }
1400
1401
1402
1403 BOOL
1404 STDCALL
1405 DeleteEnhMetaFile(
1406         HENHMETAFILE    a0
1407         )
1408 {
1409         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1410         return FALSE;
1411 }
1412
1413
1414
1415 BOOL
1416 STDCALL
1417 EnumEnhMetaFile(
1418         HDC             a0,
1419         HENHMETAFILE    a1,
1420         ENHMETAFILEPROC a2,
1421         LPVOID          a3,
1422         CONST RECT      *a4
1423         )
1424 {
1425         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1426         return FALSE;
1427 }
1428
1429
1430
1431 UINT
1432 STDCALL
1433 GetEnhMetaFileBits(
1434         HENHMETAFILE    a0,
1435         UINT            a1,
1436         LPBYTE          a2
1437         )
1438 {
1439         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1440         return 0;
1441 }
1442
1443
1444
1445 UINT
1446 STDCALL
1447 GetEnhMetaFileHeader(
1448         HENHMETAFILE    a0,
1449         UINT            a1,
1450         LPENHMETAHEADER a2
1451         )
1452 {
1453         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1454         return 0;
1455 }
1456
1457
1458
1459 UINT
1460 STDCALL
1461 GetEnhMetaFilePaletteEntries(
1462         HENHMETAFILE    a0,
1463         UINT            a1,
1464         LPPALETTEENTRY  a2
1465         )
1466 {
1467         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1468         return 0;
1469 }
1470
1471
1472
1473 UINT
1474 STDCALL
1475 GetEnhMetaFilePixelFormat(
1476         HENHMETAFILE                    a0,
1477         DWORD                           a1,
1478         CONST PIXELFORMATDESCRIPTOR     *a2
1479         )
1480 {
1481         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1482         return 0;
1483 }
1484
1485
1486
1487 UINT
1488 STDCALL
1489 GetWinMetaFileBits(
1490         HENHMETAFILE    a0,
1491         UINT            a1,
1492         LPBYTE          a2,
1493         INT             a3,
1494         HDC             a4
1495         )
1496 {
1497         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1498         return 0;
1499 }
1500
1501
1502
1503 BOOL
1504 STDCALL
1505 PlayEnhMetaFile(
1506         HDC             a0,
1507         HENHMETAFILE    a1,
1508         CONST RECT      *a2
1509         )
1510 {
1511         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1512         return FALSE;
1513 }
1514
1515
1516
1517 BOOL
1518 STDCALL
1519 PlayEnhMetaFileRecord(
1520         HDC                     a0,
1521         LPHANDLETABLE           a1,
1522         CONST ENHMETARECORD     *a2,
1523         UINT                    a3
1524         )
1525 {
1526         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1527         return FALSE;
1528 }
1529
1530
1531
1532 HENHMETAFILE
1533 STDCALL
1534 SetEnhMetaFileBits(
1535         UINT            a0,
1536         CONST BYTE      *a1
1537         )
1538 {
1539         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1540         return 0;
1541 }
1542
1543
1544
1545 HENHMETAFILE
1546 STDCALL
1547 SetWinMetaFileBits(
1548         UINT                    a0,
1549         CONST BYTE              *a1,
1550         HDC                     a2,
1551 //      CONST METAFILEPICT      *a3
1552                    PVOID a3
1553         )
1554 {
1555         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1556         return 0;
1557 }
1558
1559
1560
1561 BOOL
1562 STDCALL
1563 GdiComment(
1564         HDC             a0,
1565         UINT            a1,
1566         CONST BYTE      *a2
1567         )
1568 {
1569         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1570         return FALSE;
1571 }
1572
1573
1574
1575 BOOL
1576 STDCALL
1577 AngleArc(
1578         HDC     hdc,
1579         int     a1,
1580         int     a2,
1581         DWORD   a3,
1582         FLOAT   a4,
1583         FLOAT   a5
1584         )
1585 {
1586         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1587         return FALSE;
1588 }
1589
1590
1591
1592 BOOL
1593 STDCALL
1594 PolyPolyline(
1595         HDC             hdc,
1596         CONST POINT     *a1,
1597         CONST DWORD     *a2,
1598         DWORD           a3
1599         )
1600 {
1601         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1602         return FALSE;
1603 }
1604
1605
1606
1607 BOOL
1608 STDCALL
1609 GetWorldTransform(
1610         HDC             hdc,
1611         LPXFORM         a1
1612         )
1613 {
1614         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1615         return FALSE;
1616 }
1617
1618
1619
1620 BOOL
1621 STDCALL
1622 SetWorldTransform(
1623         HDC             a0,
1624         CONST XFORM     *a1
1625         )
1626 {
1627         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1628         return FALSE;
1629 }
1630
1631
1632
1633 BOOL
1634 STDCALL
1635 ModifyWorldTransform(
1636         HDC             a0,
1637         CONST XFORM     *a1,
1638         DWORD           a2
1639         )
1640 {
1641         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1642         return FALSE;
1643 }
1644
1645
1646
1647 BOOL
1648 STDCALL
1649 CombineTransform(
1650         LPXFORM         a0,
1651         CONST XFORM     *a1,
1652         CONST XFORM     *a2
1653         )
1654 {
1655         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1656         return FALSE;
1657 }
1658
1659
1660
1661 UINT
1662 STDCALL
1663 GetDIBColorTable(
1664         HDC             hdc,
1665         UINT            a1,
1666         UINT            a2,
1667         RGBQUAD         *a3
1668         )
1669 {
1670         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1671         return 0;
1672 }
1673
1674
1675
1676 UINT
1677 STDCALL
1678 SetDIBColorTable(
1679         HDC             hdc,
1680         UINT            a1,
1681         UINT            a2,
1682         CONST RGBQUAD   *a3
1683         )
1684 {
1685         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1686         return 0;
1687 }
1688
1689
1690
1691 BOOL
1692 STDCALL
1693 SetColorAdjustment(
1694         HDC                     hdc,
1695         CONST COLORADJUSTMENT   *a1
1696         )
1697 {
1698         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1699         return FALSE;
1700 }
1701
1702
1703
1704 BOOL
1705 STDCALL
1706 GetColorAdjustment(
1707         HDC                     hdc,
1708         LPCOLORADJUSTMENT       a1
1709         )
1710 {
1711         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1712         return FALSE;
1713 }
1714
1715
1716
1717 HPALETTE
1718 STDCALL
1719 CreateHalftonePalette(
1720         HDC     hdc
1721         )
1722 {
1723         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1724         return 0;
1725 }
1726
1727
1728
1729 int
1730 STDCALL
1731 EndDoc(
1732         HDC     hdc
1733         )
1734 {
1735         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1736         return 0;
1737 }
1738
1739
1740
1741 int
1742 STDCALL
1743 StartPage(
1744         HDC     hdc
1745         )
1746 {
1747         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1748         return 0;
1749 }
1750
1751
1752
1753 int
1754 STDCALL
1755 EndPage(
1756         HDC     hdc
1757         )
1758 {
1759         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1760         return 0;
1761 }
1762
1763
1764
1765 int
1766 STDCALL
1767 AbortDoc(
1768         HDC     hdc
1769         )
1770 {
1771         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1772         return 0;
1773 }
1774
1775
1776
1777 int
1778 STDCALL
1779 SetAbortProc(
1780         HDC             hdc,
1781         ABORTPROC       a1
1782         )
1783 {
1784         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1785         return 0;
1786 }
1787
1788
1789
1790 BOOL
1791 STDCALL
1792 AbortPath(
1793         HDC     hdc
1794         )
1795 {
1796         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1797         return FALSE;
1798 }
1799
1800
1801
1802 BOOL
1803 STDCALL
1804 ArcTo(
1805         HDC     hdc,
1806         int     a1,
1807         int     a2,
1808         int     a3,
1809         int     a4,
1810         int     a5,
1811         int     a6,
1812         int     a7,
1813         int     a8
1814         )
1815 {
1816         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1817         return FALSE;
1818 }
1819
1820
1821
1822 BOOL
1823 STDCALL
1824 BeginPath(
1825         HDC     hdc
1826         )
1827 {
1828         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1829         return FALSE;
1830 }
1831
1832
1833
1834 BOOL
1835 STDCALL
1836 CloseFigure(
1837         HDC     hdc
1838         )
1839 {
1840         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1841         return FALSE;
1842 }
1843
1844
1845
1846 BOOL
1847 STDCALL
1848 EndPath(
1849         HDC     hdc
1850         )
1851 {
1852         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1853         return FALSE;
1854 }
1855
1856
1857
1858 BOOL
1859 STDCALL
1860 FillPath(
1861         HDC     hdc
1862         )
1863 {
1864         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1865         return FALSE;
1866 }
1867
1868
1869
1870 BOOL
1871 STDCALL
1872 FlattenPath(
1873         HDC     hdc
1874         )
1875 {
1876         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1877         return FALSE;
1878 }
1879
1880
1881
1882 int
1883 STDCALL
1884 GetPath(
1885         HDC             hdc,
1886         LPPOINT         a1,
1887         LPBYTE          a2,
1888         int             a3
1889         )
1890 {
1891         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1892         return 0;
1893 }
1894
1895
1896
1897 HRGN
1898 STDCALL
1899 PathToRegion(
1900         HDC     hdc
1901         )
1902 {
1903         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1904         return 0;
1905 }
1906
1907
1908
1909 BOOL
1910 STDCALL
1911 PolyDraw(
1912         HDC             hdc,
1913         CONST POINT     *a1,
1914         CONST BYTE      *a2,
1915         int             a3
1916         )
1917 {
1918         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1919         return FALSE;
1920 }
1921
1922
1923
1924 BOOL
1925 STDCALL
1926 SelectClipPath(
1927         HDC     hdc,
1928         int     a1
1929         )
1930 {
1931         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1932         return FALSE;
1933 }
1934
1935
1936
1937 int
1938 STDCALL
1939 SetArcDirection(
1940         HDC     hdc,
1941         int     a1
1942         )
1943 {
1944         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1945         return 0;
1946 }
1947
1948
1949
1950 BOOL
1951 STDCALL
1952 SetMiterLimit(
1953         HDC     hdc,
1954         FLOAT   a1,
1955         PFLOAT  a2
1956         )
1957 {
1958         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1959         return FALSE;
1960 }
1961
1962
1963
1964 BOOL
1965 STDCALL
1966 StrokeAndFillPath(
1967         HDC     hdc
1968         )
1969 {
1970         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1971         return FALSE;
1972 }
1973
1974
1975
1976 BOOL
1977 STDCALL
1978 StrokePath(
1979         HDC     hdc
1980         )
1981 {
1982         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1983         return FALSE;
1984 }
1985
1986
1987
1988 BOOL
1989 STDCALL
1990 WidenPath(
1991         HDC     hdc
1992         )
1993 {
1994         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1995         return FALSE;
1996 }
1997
1998
1999
2000 HPEN
2001 STDCALL
2002 ExtCreatePen(
2003         DWORD           a0,
2004         DWORD           a1,
2005         CONST LOGBRUSH  *a2,
2006         DWORD           a3,
2007         CONST DWORD     *a4
2008         )
2009 {
2010         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2011         return 0;
2012 }
2013
2014
2015
2016 BOOL
2017 STDCALL
2018 GetMiterLimit(
2019         HDC     hdc,
2020         PFLOAT  a1
2021         )
2022 {
2023         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2024         return FALSE;
2025 }
2026
2027
2028
2029 int
2030 STDCALL
2031 GetArcDirection(
2032         HDC     hdc
2033         )
2034 {
2035         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2036         return 0;
2037 }
2038
2039
2040
2041 HRGN
2042 STDCALL
2043 CreatePolygonRgn(
2044         CONST POINT     *a0,
2045         int             a1,
2046         int             a2
2047         )
2048 {
2049         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2050         return 0;
2051 }
2052
2053
2054
2055 BOOL
2056 STDCALL
2057 DPtoLP(
2058         HDC     a0,
2059         LPPOINT a1,
2060         int     a2
2061         )
2062 {
2063         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2064         return FALSE;
2065 }
2066
2067
2068
2069 BOOL
2070 STDCALL
2071 PolyBezier(
2072         HDC             a0,
2073         CONST POINT     *a1,
2074         DWORD           a2
2075         )
2076 {
2077         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2078         return FALSE;
2079 }
2080
2081
2082
2083 BOOL
2084 STDCALL
2085 PolyBezierTo(
2086         HDC             a0,
2087         CONST POINT     *a1,
2088         DWORD           a2
2089         )
2090 {
2091         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2092         return FALSE;
2093 }
2094
2095
2096
2097 BOOL
2098 STDCALL
2099 PolylineTo(
2100         HDC             a0,
2101         CONST POINT     *a1,
2102         DWORD           a2
2103         )
2104 {
2105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2106         return FALSE;
2107 }
2108
2109
2110
2111 BOOL
2112 STDCALL
2113 SetViewportExtEx(
2114         HDC     a0,
2115         int     a1,
2116         int     a2,
2117         LPSIZE  a3
2118         )
2119 {
2120         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2121         return FALSE;
2122 }
2123
2124
2125
2126 BOOL
2127 STDCALL
2128 SetWindowExtEx(
2129         HDC     a0,
2130         int     a1,
2131         int     a2,
2132         LPSIZE  a3
2133         )
2134 {
2135         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2136         return FALSE;
2137 }
2138
2139
2140
2141
2142 BOOL
2143 STDCALL
2144 OffsetViewportOrgEx(
2145         HDC     a0,
2146         int     a1,
2147         int     a2,
2148         LPPOINT a3
2149         )
2150 {
2151         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2152         return FALSE;
2153 }
2154
2155
2156
2157 BOOL
2158 STDCALL
2159 OffsetWindowOrgEx(
2160         HDC     a0,
2161         int     a1,
2162         int     a2,
2163         LPPOINT a3
2164         )
2165 {
2166         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2167         return FALSE;
2168 }
2169
2170
2171
2172 BOOL
2173 STDCALL
2174 ScaleViewportExtEx(
2175         HDC     a0,
2176         int     a1,
2177         int     a2,
2178         int     a3,
2179         int     a4,
2180         LPSIZE  a5
2181         )
2182 {
2183         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2184         return FALSE;
2185 }
2186
2187
2188
2189 BOOL
2190 STDCALL
2191 ScaleWindowExtEx(
2192         HDC     a0,
2193         int     a1,
2194         int     a2,
2195         int     a3,
2196         int     a4,
2197         LPSIZE  a5
2198         )
2199 {
2200         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2201         return FALSE;
2202 }
2203
2204
2205
2206 BOOL
2207 STDCALL
2208 SetBitmapDimensionEx(
2209         HBITMAP a0,
2210         int     a1,
2211         int     a2,
2212         LPSIZE  a3
2213         )
2214 {
2215         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2216         return FALSE;
2217 }
2218
2219
2220
2221 BOOL
2222 STDCALL
2223 SetBrushOrgEx(
2224         HDC     a0,
2225         int     a1,
2226         int     a2,
2227         LPPOINT a3
2228         )
2229 {
2230         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2231         return FALSE;
2232 }
2233
2234
2235
2236 BOOL
2237 STDCALL
2238 GetDCOrgEx(
2239         HDC     a0,
2240         LPPOINT a1
2241         )
2242 {
2243         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2244         return FALSE;
2245 }
2246
2247
2248
2249 BOOL
2250 STDCALL
2251 FixBrushOrgEx(
2252         HDC     a0,
2253         int     a1,
2254         int     a2,
2255         LPPOINT a3
2256         )
2257 {
2258         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2259         return FALSE;
2260 }
2261
2262
2263
2264 BOOL
2265 STDCALL
2266 UnrealizeObject(
2267         HGDIOBJ a0
2268         )
2269 {
2270         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2271         return FALSE;
2272 }
2273
2274
2275
2276 BOOL
2277 STDCALL
2278 GdiFlush()
2279 {
2280         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2281         return FALSE;
2282 }
2283
2284
2285
2286 DWORD
2287 STDCALL
2288 GdiSetBatchLimit(
2289         DWORD   a0
2290         )
2291 {
2292         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2293         return 0;
2294 }
2295
2296
2297
2298 DWORD
2299 STDCALL
2300 GdiGetBatchLimit()
2301 {
2302         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2303         return 0;
2304 }
2305
2306
2307 int
2308 STDCALL
2309 SetICMMode(
2310         HDC     a0,
2311         int     a1
2312         )
2313 {
2314         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2315         return 0;
2316 }
2317
2318
2319 BOOL
2320 STDCALL
2321 CheckColorsInGamut(
2322         HDC     a0,
2323         LPVOID  a1,
2324         LPVOID  a2,
2325         DWORD   a3
2326         )
2327 {
2328         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2329         return FALSE;
2330 }
2331
2332
2333 HANDLE
2334 STDCALL
2335 GetColorSpace(
2336         HDC     hDc
2337         )
2338 {
2339         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2340         return 0;
2341 }
2342
2343
2344 BOOL
2345 STDCALL
2346 SetColorSpace(
2347         HDC             a0,
2348         HCOLORSPACE     a1
2349         )
2350 {
2351         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2352         return FALSE;
2353 }
2354
2355
2356 BOOL
2357 STDCALL
2358 DeleteColorSpace(
2359         HCOLORSPACE     a0
2360         )
2361 {
2362         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2363         return FALSE;
2364 }
2365
2366
2367 BOOL
2368 STDCALL
2369 GetDeviceGammaRamp(
2370         HDC     a0,
2371         LPVOID  a1
2372         )
2373 {
2374         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2375         return FALSE;
2376 }
2377
2378
2379 BOOL
2380 STDCALL
2381 SetDeviceGammaRamp(
2382         HDC     a0,
2383         LPVOID  a1
2384         )
2385 {
2386         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2387         return FALSE;
2388 }
2389
2390
2391 BOOL
2392 STDCALL
2393 ColorMatchToTarget(
2394         HDC     a0,
2395         HDC     a1,
2396         DWORD   a2
2397         )
2398 {
2399         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2400         return FALSE;
2401 }
2402
2403
2404 BOOL
2405 STDCALL
2406 wglCopyContext(
2407         HGLRC   a0,
2408         HGLRC   a1,
2409         UINT    a2
2410         )
2411 {
2412         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2413         return FALSE;
2414 }
2415
2416
2417
2418 HGLRC
2419 STDCALL
2420 wglCreateContext(
2421         HDC     hDc
2422         )
2423 {
2424         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2425         return 0;
2426 }
2427
2428
2429
2430 HGLRC
2431 STDCALL
2432 wglCreateLayerContext(
2433         HDC     hDc,
2434         int     a1
2435         )
2436 {
2437         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2438         return 0;
2439 }
2440
2441
2442
2443 BOOL
2444 STDCALL
2445 wglDeleteContext(
2446         HGLRC   a
2447         )
2448 {
2449         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2450         return FALSE;
2451 }
2452
2453
2454
2455 HGLRC
2456 STDCALL
2457 wglGetCurrentContext(VOID)
2458 {
2459         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2460         return 0;
2461 }
2462
2463
2464
2465 HDC
2466 STDCALL
2467 wglGetCurrentDC(VOID)
2468 {
2469         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2470         return 0;
2471 }
2472
2473
2474
2475 PROC
2476 STDCALL
2477 wglGetProcAddress(
2478         LPCSTR          a0
2479         )
2480 {
2481         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2482         return 0;
2483 }
2484
2485
2486
2487 BOOL
2488 STDCALL
2489 wglMakeCurrent(
2490         HDC     a0,
2491         HGLRC   a1
2492         )
2493 {
2494         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2495         return FALSE;
2496 }
2497
2498
2499
2500 BOOL
2501 STDCALL
2502 wglShareLists(
2503         HGLRC   a0,
2504         HGLRC   a1
2505         )
2506 {
2507         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2508         return FALSE;
2509 }
2510
2511
2512 BOOL
2513 STDCALL
2514 SwapBuffers(
2515         HDC     a0
2516         )
2517 {
2518         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2519         return FALSE;
2520 }
2521
2522
2523
2524 BOOL
2525 STDCALL
2526 wglDescribeLayerPlane(
2527         HDC                     a0,
2528         int                     a1,
2529         int                     a2,
2530         UINT                    a3,
2531         LPLAYERPLANEDESCRIPTOR  a4
2532         )
2533 {
2534         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2535         return FALSE;
2536 }
2537
2538
2539 int
2540 STDCALL
2541 wglSetLayerPaletteEntries(
2542         HDC             a0,
2543         int             a1,
2544         int             a2,
2545         int             a3,
2546         CONST COLORREF  *a4
2547         )
2548 {
2549         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2550         return 0;
2551 }
2552
2553
2554 int
2555 STDCALL
2556 wglGetLayerPaletteEntries(
2557         HDC             a0,
2558         int             a1,
2559         int             a2,
2560         int             a3,
2561         CONST COLORREF  *a4
2562         )
2563 {
2564         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2565         return 0;
2566 }
2567
2568
2569 BOOL
2570 STDCALL
2571 wglRealizeLayerPalette(
2572         HDC             a0,
2573         int             a1,
2574         BOOL            a2
2575         )
2576 {
2577         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2578         return FALSE;
2579 }
2580
2581
2582 BOOL
2583 STDCALL
2584 wglSwapLayerBuffers(
2585         HDC             a0,
2586         UINT            a1
2587         )
2588 {
2589         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2590         return FALSE;
2591 }
2592
2593
2594 /* === AFTER THIS POINT I GUESS... =========
2595  * (based on stack size in Norlander's .def)
2596  * === WHERE ARE THEY DEFINED? =============
2597  */
2598
2599
2600 DWORD
2601 STDCALL
2602 GdiPlayDCScript(
2603         DWORD   a0,
2604         DWORD   a1,
2605         DWORD   a2,
2606         DWORD   a3,
2607         DWORD   a4,
2608         DWORD   a5
2609         )
2610 {
2611         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2612         return 0;
2613 }
2614
2615
2616 DWORD
2617 STDCALL
2618 GdiPlayJournal(
2619         DWORD   a0,
2620         DWORD   a1,
2621         DWORD   a2,
2622         DWORD   a3,
2623         DWORD   a4
2624         )
2625 {
2626         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2627         return 0;
2628 }
2629
2630
2631 DWORD
2632 STDCALL
2633 GdiPlayScript(
2634         DWORD   a0,
2635         DWORD   a1,
2636         DWORD   a2,
2637         DWORD   a3,
2638         DWORD   a4,
2639         DWORD   a5,
2640         DWORD   a6
2641         )
2642 {
2643         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2644         return 0;
2645 }
2646
2647
2648 DWORD
2649 STDCALL
2650 GetGlyphOutlineWow(
2651         DWORD   a0,
2652         DWORD   a1,
2653         DWORD   a2,
2654         DWORD   a3,
2655         DWORD   a4,
2656         DWORD   a5,
2657         DWORD   a6
2658         )
2659 {
2660         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2661         return 0;
2662 }
2663
2664
2665 DWORD
2666 STDCALL
2667 GetRandomRgn(
2668         DWORD   a0,
2669         DWORD   a1,
2670         DWORD   a2
2671         )
2672 {
2673         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2674         return 0;
2675 }
2676
2677
2678 DWORD
2679 STDCALL
2680 GetRelAbs(
2681         DWORD   a0,
2682         DWORD   a1
2683         )
2684 {
2685         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2686         return 0;
2687 }
2688
2689
2690
2691 DWORD
2692 STDCALL
2693 SelectBrushLocal(
2694         DWORD   a0,
2695         DWORD   a1
2696         )
2697 {
2698         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2699         return 0;
2700 }
2701
2702
2703
2704 DWORD
2705 STDCALL
2706 SelectFontLocal(
2707         DWORD   a0,
2708         DWORD   a1
2709         )
2710 {
2711         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2712         return 0;
2713 }
2714
2715
2716 DWORD
2717 STDCALL
2718 SetFontEnumeration(
2719         DWORD   a0
2720         )
2721 {
2722         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2723         return 0;
2724 }
2725
2726
2727 DWORD
2728 STDCALL
2729 SetRelAbs(
2730         DWORD   a0,
2731         DWORD   a1
2732         )
2733 {
2734         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2735         return 0;
2736 }
2737
2738
2739 DWORD
2740 STDCALL
2741 gdiPlaySpoolStream(
2742         DWORD   a0,
2743         DWORD   a1,
2744         DWORD   a2,
2745         DWORD   a3,
2746         DWORD   a4,
2747         DWORD   a5
2748         )
2749 {
2750         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2751         return 0;
2752 }
2753
2754
2755 DWORD
2756 STDCALL
2757 GetFontResourceInfo(
2758         DWORD   a0,
2759         DWORD   a1,
2760         DWORD   a2,
2761         DWORD   a3
2762         )
2763 {
2764         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2765         return 0;
2766 }
2767
2768
2769 /* EOF */