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 int
 669 STDCALL
 670 GetPolyFillMode(
 671         HDC     a0
 672         )
 673 {
 674         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 675         return 0;
 676 }
 677
 678
 679
 680 BOOL
 681 STDCALL
 682 GetRasterizerCaps(
 683         LPRASTERIZER_STATUS     a0,
 684         UINT                    a1
 685         )
 686 {
 687         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 688         return FALSE;
 689 }
 690
 691
 692
 693
 694
 695
 696 int
 697 STDCALL
 698 GetStretchBltMode(
 699         HDC     a0
 700         )
 701 {
 702         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 703         return 0;
 704 }
 705
 706
 707
 708 UINT
 709 STDCALL
 710 GetSystemPaletteEntries(
 711         HDC             a0,
 712         UINT            a1,
 713         UINT            a2,
 714         LPPALETTEENTRY  a3
 715         )
 716 {
 717         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 718         return 0;
 719 }
 720
 721
 722
 723 UINT
 724 STDCALL
 725 GetSystemPaletteUse(
 726         HDC     hDc
 727         )
 728 {
 729         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 730         return 0;
 731 }
 732
 733
 734
 735 int
 736 STDCALL
 737 GetTextCharacterExtra(
 738         HDC     hDc
 739         )
 740 {
 741         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 742         return 0;
 743 }
 744
 745
 746
 747 UINT
 748 STDCALL
 749 GetTextAlign(
 750         HDC     hDc
 751         )
 752 {
 753         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 754         return 0;
 755 }
 756
 757
 758
 759 COLORREF
 760 STDCALL
 761 GetTextColor(
 762         HDC     hDc
 763         )
 764 {
 765         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 766         return 0;
 767 }
 768
 769
 770 int
 771 STDCALL
 772 GetTextCharset(
 773         HDC     hdc
 774         )
 775 {
 776         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 777         return 0;
 778 }
 779
 780
 781
 782 int
 783 STDCALL
 784 GetTextCharsetInfo(
 785         HDC             hdc,
 786         LPFONTSIGNATURE lpSig,
 787         DWORD           dwFlags
 788         )
 789 {
 790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 791         return 0;
 792 }
 793
 794
 795
 796 BOOL
 797 STDCALL
 798 TranslateCharsetInfo(
 799         DWORD FAR       *lpSrc,
 800         LPCHARSETINFO   lpCs,
 801         DWORD           dwFlags
 802         )
 803 {
 804         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 805         return FALSE;
 806 }
 807
 808
 809
 810 DWORD
 811 STDCALL
 812 GetFontLanguageInfo(
 813         HDC     hDc
 814         )
 815 {
 816         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 817         return 0;
 818 }
 819
 820
 821 BOOL
 822 STDCALL
 823 GetViewportExtEx(
 824         HDC     hDc,
 825         LPSIZE  lpSize
 826         )
 827 {
 828         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 829         return FALSE;
 830 }
 831
 832
 833
 834 BOOL
 835 STDCALL
 836 GetViewportOrgEx(
 837         HDC             hDc,
 838         LPPOINT         lpPoint
 839         )
 840 {
 841         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 842         return FALSE;
 843 }
 844
 845
 846
 847 BOOL
 848 STDCALL
 849 GetWindowExtEx(
 850         HDC             hDc,
 851         LPSIZE          lpSize
 852         )
 853 {
 854         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 855         return FALSE;
 856 }
 857
 858
 859
 860 BOOL
 861 STDCALL
 862 GetWindowOrgEx(
 863         HDC             hDc,
 864         LPPOINT         lpPoint
 865         )
 866 {
 867         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 868         return FALSE;
 869 }
 870
 871
 872
 873 int
 874 STDCALL
 875 IntersectClipRect(
 876         HDC             hDc,
 877         int             a1,
 878         int             a2,
 879         int             a3,
 880         int             a4
 881         )
 882 {
 883         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 884         return 0;
 885 }
 886
 887
 888
 889 BOOL
 890 STDCALL
 891 InvertRgn(
 892         HDC     hDc,
 893         HRGN    hRgn
 894         )
 895 {
 896         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 897         return FALSE;
 898 }
 899
 900
 901
 902 BOOL
 903 STDCALL
 904 LineDDA(
 905         int             a0,
 906         int             a1,
 907         int             a2,
 908         int             a3,
 909         LINEDDAPROC     a4,
 910         LPARAM          a5
 911         )
 912 {
 913         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 914         return FALSE;
 915 }
 916
 917
 918
 919
 920 int
 921 STDCALL
 922 OffsetClipRgn(
 923         HDC     a0,
 924         int     a1,
 925         int     a2
 926         )
 927 {
 928         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 929         return 0;
 930 }
 931
 932
 933
 934
 935
 936 BOOL
 937 STDCALL
 938 Pie(
 939         HDC     a0,
 940         int     a1,
 941         int     a2,
 942         int     a3,
 943         int     a4,
 944         int     a5,
 945         int     a6,
 946         int     a7,
 947         int     a8
 948         )
 949 {
 950         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 951         return FALSE;
 952 }
 953
 954
 955
 956 BOOL
 957 STDCALL
 958 PlayMetaFile(
 959         HDC             a0,
 960         HMETAFILE       a1
 961         )
 962 {
 963         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 964         return FALSE;
 965 }
 966
 967
 968
 969
 970
 971
 972 BOOL
 973 STDCALL
 974 PolyPolygon(
 975         HDC             a0,
 976         CONST POINT     *a1,
 977         CONST INT       *a2,
 978         int             a3
 979         )
 980 {
 981         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 982         return FALSE;
 983 }
 984
 985
 986
 987 BOOL
 988 STDCALL
 989 PtInRegion(
 990         HRGN    a0,
 991         int     a1,
 992         int     a2
 993         )
 994 {
 995         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 996         return FALSE;
 997 }
 998
 999
1000
1001 BOOL
1002 STDCALL
1003 PtVisible(
1004         HDC     a0,
1005         int     a1,
1006         int     a2
1007         )
1008 {
1009         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1010         return FALSE;
1011 }
1012
1013
1014
1015 BOOL
1016 STDCALL
1017 RectInRegion(
1018         HRGN            a0,
1019         CONST RECT      *a1
1020         )
1021 {
1022         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1023         return FALSE;
1024 }
1025
1026
1027
1028 BOOL
1029 STDCALL
1030 RectVisible(
1031         HDC             a0,
1032         CONST RECT      *a1
1033         )
1034 {
1035         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1036         return FALSE;
1037 }
1038
1039
1040
1041 BOOL
1042 STDCALL
1043 RestoreDC(
1044         HDC     a0,
1045         int     a1
1046         )
1047 {
1048         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1049         return FALSE;
1050 }
1051
1052
1053 BOOL
1054 STDCALL
1055 RoundRect(
1056         HDC     a0,
1057         int     a1,
1058         int     a2,
1059         int     a3,
1060         int     a4,
1061         int     a5,
1062         int     a6
1063         )
1064 {
1065         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1066         return FALSE;
1067 }
1068
1069
1070
1071 BOOL
1072 STDCALL
1073 ResizePalette(
1074         HPALETTE        a0,
1075         UINT            a1
1076         )
1077 {
1078         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1079         return FALSE;
1080 }
1081
1082
1083
1084 int
1085 STDCALL
1086 SaveDC(
1087         HDC     a0
1088         )
1089 {
1090         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1091         return 0;
1092 }
1093
1094
1095
1096 int
1097 STDCALL
1098 SelectClipRgn(
1099         HDC     a0,
1100         HRGN    a1
1101         )
1102 {
1103         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1104         return 0;
1105 }
1106
1107
1108
1109 int
1110 STDCALL
1111 ExtSelectClipRgn(
1112         HDC     a0,
1113         HRGN    a1,
1114         int     a2
1115         )
1116 {
1117         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1118         return 0;
1119 }
1120
1121
1122
1123 int
1124 STDCALL
1125 SetMetaRgn(
1126         HDC     hdc
1127         )
1128 {
1129         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1130         return 0;
1131 }
1132
1133
1134
1135 COLORREF
1136 STDCALL
1137 SetBkColor(
1138         HDC             a0,
1139         COLORREF        a1
1140         )
1141 {
1142         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1143         return 0;
1144 }
1145
1146
1147
1148 int
1149 STDCALL
1150 SetBkMode(
1151         HDC     a0,
1152         int     a1
1153         )
1154 {
1155         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1156         return 0;
1157 }
1158
1159
1160
1161 UINT
1162 STDCALL
1163 SetBoundsRect(
1164         HDC             a0,
1165         CONST RECT      *a1,
1166         UINT            a2
1167         )
1168 {
1169         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1170         return 0;
1171 }
1172
1173
1174
1175 DWORD
1176 STDCALL
1177 SetMapperFlags(
1178         HDC     a0,
1179         DWORD   a1
1180         )
1181 {
1182         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1183         return 0;
1184 }
1185
1186
1187
1188 int
1189 STDCALL
1190 SetGraphicsMode(
1191         HDC     hdc,
1192         int     iMode
1193         )
1194 {
1195         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1196         return 0;
1197 }
1198
1199
1200
1201 HMETAFILE
1202 STDCALL
1203 SetMetaFileBitsEx(
1204         UINT            a0,
1205         CONST BYTE      *a1
1206         )
1207 {
1208         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1209         return 0;
1210 }
1211
1212
1213
1214 UINT
1215 STDCALL
1216 SetPaletteEntries(
1217         HPALETTE                a0,
1218         UINT                    a1,
1219         UINT                    a2,
1220         CONST PALETTEENTRY      *a3
1221         )
1222 {
1223         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1224         return 0;
1225 }
1226
1227
1228
1229 BOOL
1230 STDCALL
1231 SetPixelV(
1232         HDC             a0,
1233         int             a1,
1234         int             a2,
1235         COLORREF        a3
1236         )
1237 {
1238         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1239         return FALSE;
1240 }
1241
1242
1243
1244 BOOL
1245 STDCALL
1246 SetPixelFormat(
1247         HDC                             a0,
1248         int                             a1,
1249         CONST PIXELFORMATDESCRIPTOR     *a2
1250         )
1251 {
1252         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1253         return FALSE;
1254 }
1255
1256
1257
1258 int
1259 STDCALL
1260 SetPolyFillMode(
1261         HDC     a0,
1262         int     a1
1263         )
1264 {
1265         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1266         return 0;
1267 }
1268
1269
1270
1271 BOOL
1272 STDCALL
1273 StretchBlt(
1274         HDC     a0,
1275         int     a1,
1276         int     a2,
1277         int     a3,
1278         int     a4,
1279         HDC     a5,
1280         int     a6,
1281         int     a7,
1282         int     a8,
1283         int     a9,
1284         DWORD   a10
1285         )
1286 {
1287         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1288         return FALSE;
1289 }
1290
1291
1292
1293 int
1294 STDCALL
1295 SetROP2(
1296         HDC     a0,
1297         int     a1
1298         )
1299 {
1300         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1301         return 0;
1302 }
1303
1304
1305
1306 int
1307 STDCALL
1308 SetStretchBltMode(
1309         HDC     a0,
1310         int     a1
1311         )
1312 {
1313         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1314         return 0;
1315 }
1316
1317
1318
1319 UINT
1320 STDCALL
1321 SetSystemPaletteUse(
1322         HDC     a0,
1323         UINT    a1
1324         )
1325 {
1326         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1327         return 0;
1328 }
1329
1330
1331
1332 int
1333 STDCALL
1334 SetTextCharacterExtra(
1335         HDC     a0,
1336         int     a1
1337         )
1338 {
1339         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1340         return 0;
1341 }
1342
1343
1344
1345 UINT
1346 STDCALL
1347 SetTextAlign(
1348         HDC     a0,
1349         UINT    a1
1350         )
1351 {
1352         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1353         return 0;
1354 }
1355
1356
1357
1358 BOOL
1359 STDCALL
1360 SetTextJustification(
1361         HDC     a0,
1362         int     a1,
1363         int     a2
1364         )
1365 {
1366         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1367         return FALSE;
1368 }
1369
1370
1371
1372 BOOL
1373 STDCALL
1374 UpdateColors(
1375         HDC     hdc
1376         )
1377 {
1378         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1379         return FALSE;
1380 }
1381
1382
1383
1384 BOOL
1385 STDCALL
1386 PlayMetaFileRecord(
1387         HDC             a0,
1388         LPHANDLETABLE   a1,
1389         LPMETARECORD    a2,
1390         UINT            a3
1391         )
1392 {
1393         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1394         return FALSE;
1395 }
1396
1397
1398
1399 BOOL
1400 STDCALL
1401 EnumMetaFile(
1402         HDC                     a0,
1403         HMETAFILE               a1,
1404         ENUMMETAFILEPROC        a2,
1405         LPARAM                  a3
1406         )
1407 {
1408         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1409         return FALSE;
1410 }
1411
1412
1413
1414 HENHMETAFILE
1415 STDCALL
1416 CloseEnhMetaFile(
1417         HDC     hdc
1418         )
1419 {
1420         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421         return FALSE;
1422 }
1423
1424
1425
1426 BOOL
1427 STDCALL
1428 DeleteEnhMetaFile(
1429         HENHMETAFILE    a0
1430         )
1431 {
1432         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1433         return FALSE;
1434 }
1435
1436
1437
1438 BOOL
1439 STDCALL
1440 EnumEnhMetaFile(
1441         HDC             a0,
1442         HENHMETAFILE    a1,
1443         ENHMETAFILEPROC a2,
1444         LPVOID          a3,
1445         CONST RECT      *a4
1446         )
1447 {
1448         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1449         return FALSE;
1450 }
1451
1452
1453
1454 UINT
1455 STDCALL
1456 GetEnhMetaFileBits(
1457         HENHMETAFILE    a0,
1458         UINT            a1,
1459         LPBYTE          a2
1460         )
1461 {
1462         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1463         return 0;
1464 }
1465
1466
1467
1468 UINT
1469 STDCALL
1470 GetEnhMetaFileHeader(
1471         HENHMETAFILE    a0,
1472         UINT            a1,
1473         LPENHMETAHEADER a2
1474         )
1475 {
1476         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1477         return 0;
1478 }
1479
1480
1481
1482 UINT
1483 STDCALL
1484 GetEnhMetaFilePaletteEntries(
1485         HENHMETAFILE    a0,
1486         UINT            a1,
1487         LPPALETTEENTRY  a2
1488         )
1489 {
1490         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1491         return 0;
1492 }
1493
1494
1495
1496 UINT
1497 STDCALL
1498 GetEnhMetaFilePixelFormat(
1499         HENHMETAFILE                    a0,
1500         DWORD                           a1,
1501         CONST PIXELFORMATDESCRIPTOR     *a2
1502         )
1503 {
1504         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1505         return 0;
1506 }
1507
1508
1509
1510 UINT
1511 STDCALL
1512 GetWinMetaFileBits(
1513         HENHMETAFILE    a0,
1514         UINT            a1,
1515         LPBYTE          a2,
1516         INT             a3,
1517         HDC             a4
1518         )
1519 {
1520         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1521         return 0;
1522 }
1523
1524
1525
1526 BOOL
1527 STDCALL
1528 PlayEnhMetaFile(
1529         HDC             a0,
1530         HENHMETAFILE    a1,
1531         CONST RECT      *a2
1532         )
1533 {
1534         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1535         return FALSE;
1536 }
1537
1538
1539
1540 BOOL
1541 STDCALL
1542 PlayEnhMetaFileRecord(
1543         HDC                     a0,
1544         LPHANDLETABLE           a1,
1545         CONST ENHMETARECORD     *a2,
1546         UINT                    a3
1547         )
1548 {
1549         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1550         return FALSE;
1551 }
1552
1553
1554
1555 HENHMETAFILE
1556 STDCALL
1557 SetEnhMetaFileBits(
1558         UINT            a0,
1559         CONST BYTE      *a1
1560         )
1561 {
1562         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1563         return 0;
1564 }
1565
1566
1567
1568 HENHMETAFILE
1569 STDCALL
1570 SetWinMetaFileBits(
1571         UINT                    a0,
1572         CONST BYTE              *a1,
1573         HDC                     a2,
1574 //      CONST METAFILEPICT      *a3
1575                    PVOID a3
1576         )
1577 {
1578         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1579         return 0;
1580 }
1581
1582
1583
1584 BOOL
1585 STDCALL
1586 GdiComment(
1587         HDC             a0,
1588         UINT            a1,
1589         CONST BYTE      *a2
1590         )
1591 {
1592         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1593         return FALSE;
1594 }
1595
1596
1597
1598 BOOL
1599 STDCALL
1600 AngleArc(
1601         HDC     hdc,
1602         int     a1,
1603         int     a2,
1604         DWORD   a3,
1605         FLOAT   a4,
1606         FLOAT   a5
1607         )
1608 {
1609         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1610         return FALSE;
1611 }
1612
1613
1614
1615 BOOL
1616 STDCALL
1617 PolyPolyline(
1618         HDC             hdc,
1619         CONST POINT     *a1,
1620         CONST DWORD     *a2,
1621         DWORD           a3
1622         )
1623 {
1624         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1625         return FALSE;
1626 }
1627
1628
1629
1630 BOOL
1631 STDCALL
1632 GetWorldTransform(
1633         HDC             hdc,
1634         LPXFORM         a1
1635         )
1636 {
1637         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1638         return FALSE;
1639 }
1640
1641
1642
1643 BOOL
1644 STDCALL
1645 SetWorldTransform(
1646         HDC             a0,
1647         CONST XFORM     *a1
1648         )
1649 {
1650         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1651         return FALSE;
1652 }
1653
1654
1655
1656 BOOL
1657 STDCALL
1658 ModifyWorldTransform(
1659         HDC             a0,
1660         CONST XFORM     *a1,
1661         DWORD           a2
1662         )
1663 {
1664         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1665         return FALSE;
1666 }
1667
1668
1669
1670 BOOL
1671 STDCALL
1672 CombineTransform(
1673         LPXFORM         a0,
1674         CONST XFORM     *a1,
1675         CONST XFORM     *a2
1676         )
1677 {
1678         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1679         return FALSE;
1680 }
1681
1682
1683
1684 UINT
1685 STDCALL
1686 GetDIBColorTable(
1687         HDC             hdc,
1688         UINT            a1,
1689         UINT            a2,
1690         RGBQUAD         *a3
1691         )
1692 {
1693         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1694         return 0;
1695 }
1696
1697
1698
1699 UINT
1700 STDCALL
1701 SetDIBColorTable(
1702         HDC             hdc,
1703         UINT            a1,
1704         UINT            a2,
1705         CONST RGBQUAD   *a3
1706         )
1707 {
1708         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1709         return 0;
1710 }
1711
1712
1713
1714 BOOL
1715 STDCALL
1716 SetColorAdjustment(
1717         HDC                     hdc,
1718         CONST COLORADJUSTMENT   *a1
1719         )
1720 {
1721         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1722         return FALSE;
1723 }
1724
1725
1726
1727 BOOL
1728 STDCALL
1729 GetColorAdjustment(
1730         HDC                     hdc,
1731         LPCOLORADJUSTMENT       a1
1732         )
1733 {
1734         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1735         return FALSE;
1736 }
1737
1738
1739
1740 HPALETTE
1741 STDCALL
1742 CreateHalftonePalette(
1743         HDC     hdc
1744         )
1745 {
1746         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1747         return 0;
1748 }
1749
1750
1751
1752 int
1753 STDCALL
1754 EndDoc(
1755         HDC     hdc
1756         )
1757 {
1758         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1759         return 0;
1760 }
1761
1762
1763
1764 int
1765 STDCALL
1766 StartPage(
1767         HDC     hdc
1768         )
1769 {
1770         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1771         return 0;
1772 }
1773
1774
1775
1776 int
1777 STDCALL
1778 EndPage(
1779         HDC     hdc
1780         )
1781 {
1782         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1783         return 0;
1784 }
1785
1786
1787
1788 int
1789 STDCALL
1790 AbortDoc(
1791         HDC     hdc
1792         )
1793 {
1794         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1795         return 0;
1796 }
1797
1798
1799
1800 int
1801 STDCALL
1802 SetAbortProc(
1803         HDC             hdc,
1804         ABORTPROC       a1
1805         )
1806 {
1807         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1808         return 0;
1809 }
1810
1811
1812
1813 BOOL
1814 STDCALL
1815 AbortPath(
1816         HDC     hdc
1817         )
1818 {
1819         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1820         return FALSE;
1821 }
1822
1823
1824
1825 BOOL
1826 STDCALL
1827 ArcTo(
1828         HDC     hdc,
1829         int     a1,
1830         int     a2,
1831         int     a3,
1832         int     a4,
1833         int     a5,
1834         int     a6,
1835         int     a7,
1836         int     a8
1837         )
1838 {
1839         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1840         return FALSE;
1841 }
1842
1843
1844
1845 BOOL
1846 STDCALL
1847 BeginPath(
1848         HDC     hdc
1849         )
1850 {
1851         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1852         return FALSE;
1853 }
1854
1855
1856
1857 BOOL
1858 STDCALL
1859 CloseFigure(
1860         HDC     hdc
1861         )
1862 {
1863         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1864         return FALSE;
1865 }
1866
1867
1868
1869 BOOL
1870 STDCALL
1871 EndPath(
1872         HDC     hdc
1873         )
1874 {
1875         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1876         return FALSE;
1877 }
1878
1879
1880
1881 BOOL
1882 STDCALL
1883 FillPath(
1884         HDC     hdc
1885         )
1886 {
1887         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1888         return FALSE;
1889 }
1890
1891
1892
1893 BOOL
1894 STDCALL
1895 FlattenPath(
1896         HDC     hdc
1897         )
1898 {
1899         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1900         return FALSE;
1901 }
1902
1903
1904
1905 int
1906 STDCALL
1907 GetPath(
1908         HDC             hdc,
1909         LPPOINT         a1,
1910         LPBYTE          a2,
1911         int             a3
1912         )
1913 {
1914         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1915         return 0;
1916 }
1917
1918
1919
1920 HRGN
1921 STDCALL
1922 PathToRegion(
1923         HDC     hdc
1924         )
1925 {
1926         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1927         return 0;
1928 }
1929
1930
1931
1932 BOOL
1933 STDCALL
1934 PolyDraw(
1935         HDC             hdc,
1936         CONST POINT     *a1,
1937         CONST BYTE      *a2,
1938         int             a3
1939         )
1940 {
1941         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1942         return FALSE;
1943 }
1944
1945
1946
1947 BOOL
1948 STDCALL
1949 SelectClipPath(
1950         HDC     hdc,
1951         int     a1
1952         )
1953 {
1954         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1955         return FALSE;
1956 }
1957
1958
1959
1960 int
1961 STDCALL
1962 SetArcDirection(
1963         HDC     hdc,
1964         int     a1
1965         )
1966 {
1967         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1968         return 0;
1969 }
1970
1971
1972
1973 BOOL
1974 STDCALL
1975 SetMiterLimit(
1976         HDC     hdc,
1977         FLOAT   a1,
1978         PFLOAT  a2
1979         )
1980 {
1981         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1982         return FALSE;
1983 }
1984
1985
1986
1987 BOOL
1988 STDCALL
1989 StrokeAndFillPath(
1990         HDC     hdc
1991         )
1992 {
1993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1994         return FALSE;
1995 }
1996
1997
1998
1999 BOOL
2000 STDCALL
2001 StrokePath(
2002         HDC     hdc
2003         )
2004 {
2005         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2006         return FALSE;
2007 }
2008
2009
2010
2011 BOOL
2012 STDCALL
2013 WidenPath(
2014         HDC     hdc
2015         )
2016 {
2017         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2018         return FALSE;
2019 }
2020
2021
2022
2023 HPEN
2024 STDCALL
2025 ExtCreatePen(
2026         DWORD           a0,
2027         DWORD           a1,
2028         CONST LOGBRUSH  *a2,
2029         DWORD           a3,
2030         CONST DWORD     *a4
2031         )
2032 {
2033         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2034         return 0;
2035 }
2036
2037
2038
2039 BOOL
2040 STDCALL
2041 GetMiterLimit(
2042         HDC     hdc,
2043         PFLOAT  a1
2044         )
2045 {
2046         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2047         return FALSE;
2048 }
2049
2050
2051
2052 int
2053 STDCALL
2054 GetArcDirection(
2055         HDC     hdc
2056         )
2057 {
2058         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2059         return 0;
2060 }
2061
2062
2063
2064 HRGN
2065 STDCALL
2066 CreatePolygonRgn(
2067         CONST POINT     *a0,
2068         int             a1,
2069         int             a2
2070         )
2071 {
2072         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2073         return 0;
2074 }
2075
2076
2077
2078 BOOL
2079 STDCALL
2080 DPtoLP(
2081         HDC     a0,
2082         LPPOINT a1,
2083         int     a2
2084         )
2085 {
2086         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2087         return FALSE;
2088 }
2089
2090
2091
2092 BOOL
2093 STDCALL
2094 LPtoDP(
2095         HDC     a0,
2096         LPPOINT a1,
2097         int     a2
2098         )
2099 {
2100         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2101         return FALSE;
2102 }
2103
2104
2105
2106 BOOL
2107 STDCALL
2108 Polygon(
2109         HDC             a0,
2110         CONST POINT     *a1,
2111         int             a2
2112         )
2113 {
2114         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2115         return FALSE;
2116 }
2117
2118
2119
2120 BOOL
2121 STDCALL
2122 Polyline(
2123         HDC             a0,
2124         CONST POINT     *a1,
2125         int             a2
2126         )
2127 {
2128         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2129         return FALSE;
2130 }
2131
2132
2133
2134 BOOL
2135 STDCALL
2136 PolyBezier(
2137         HDC             a0,
2138         CONST POINT     *a1,
2139         DWORD           a2
2140         )
2141 {
2142         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2143         return FALSE;
2144 }
2145
2146
2147
2148 BOOL
2149 STDCALL
2150 PolyBezierTo(
2151         HDC             a0,
2152         CONST POINT     *a1,
2153         DWORD           a2
2154         )
2155 {
2156         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2157         return FALSE;
2158 }
2159
2160
2161
2162 BOOL
2163 STDCALL
2164 PolylineTo(
2165         HDC             a0,
2166         CONST POINT     *a1,
2167         DWORD           a2
2168         )
2169 {
2170         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2171         return FALSE;
2172 }
2173
2174
2175
2176 BOOL
2177 STDCALL
2178 SetViewportExtEx(
2179         HDC     a0,
2180         int     a1,
2181         int     a2,
2182         LPSIZE  a3
2183         )
2184 {
2185         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2186         return FALSE;
2187 }
2188
2189
2190
2191 BOOL
2192 STDCALL
2193 SetWindowExtEx(
2194         HDC     a0,
2195         int     a1,
2196         int     a2,
2197         LPSIZE  a3
2198         )
2199 {
2200         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2201         return FALSE;
2202 }
2203
2204
2205
2206
2207 BOOL
2208 STDCALL
2209 OffsetViewportOrgEx(
2210         HDC     a0,
2211         int     a1,
2212         int     a2,
2213         LPPOINT a3
2214         )
2215 {
2216         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2217         return FALSE;
2218 }
2219
2220
2221
2222 BOOL
2223 STDCALL
2224 OffsetWindowOrgEx(
2225         HDC     a0,
2226         int     a1,
2227         int     a2,
2228         LPPOINT a3
2229         )
2230 {
2231         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2232         return FALSE;
2233 }
2234
2235
2236
2237 BOOL
2238 STDCALL
2239 ScaleViewportExtEx(
2240         HDC     a0,
2241         int     a1,
2242         int     a2,
2243         int     a3,
2244         int     a4,
2245         LPSIZE  a5
2246         )
2247 {
2248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2249         return FALSE;
2250 }
2251
2252
2253
2254 BOOL
2255 STDCALL
2256 ScaleWindowExtEx(
2257         HDC     a0,
2258         int     a1,
2259         int     a2,
2260         int     a3,
2261         int     a4,
2262         LPSIZE  a5
2263         )
2264 {
2265         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2266         return FALSE;
2267 }
2268
2269
2270
2271 BOOL
2272 STDCALL
2273 SetBitmapDimensionEx(
2274         HBITMAP a0,
2275         int     a1,
2276         int     a2,
2277         LPSIZE  a3
2278         )
2279 {
2280         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2281         return FALSE;
2282 }
2283
2284
2285
2286 BOOL
2287 STDCALL
2288 SetBrushOrgEx(
2289         HDC     a0,
2290         int     a1,
2291         int     a2,
2292         LPPOINT a3
2293         )
2294 {
2295         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2296         return FALSE;
2297 }
2298
2299
2300
2301 BOOL
2302 STDCALL
2303 GetDCOrgEx(
2304         HDC     a0,
2305         LPPOINT a1
2306         )
2307 {
2308         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2309         return FALSE;
2310 }
2311
2312
2313
2314 BOOL
2315 STDCALL
2316 FixBrushOrgEx(
2317         HDC     a0,
2318         int     a1,
2319         int     a2,
2320         LPPOINT a3
2321         )
2322 {
2323         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2324         return FALSE;
2325 }
2326
2327
2328
2329 BOOL
2330 STDCALL
2331 UnrealizeObject(
2332         HGDIOBJ a0
2333         )
2334 {
2335         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2336         return FALSE;
2337 }
2338
2339
2340
2341 BOOL
2342 STDCALL
2343 GdiFlush()
2344 {
2345         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2346         return FALSE;
2347 }
2348
2349
2350
2351 DWORD
2352 STDCALL
2353 GdiSetBatchLimit(
2354         DWORD   a0
2355         )
2356 {
2357         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2358         return 0;
2359 }
2360
2361
2362
2363 DWORD
2364 STDCALL
2365 GdiGetBatchLimit()
2366 {
2367         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2368         return 0;
2369 }
2370
2371
2372 int
2373 STDCALL
2374 SetICMMode(
2375         HDC     a0,
2376         int     a1
2377         )
2378 {
2379         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2380         return 0;
2381 }
2382
2383
2384 BOOL
2385 STDCALL
2386 CheckColorsInGamut(
2387         HDC     a0,
2388         LPVOID  a1,
2389         LPVOID  a2,
2390         DWORD   a3
2391         )
2392 {
2393         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2394         return FALSE;
2395 }
2396
2397
2398 HANDLE
2399 STDCALL
2400 GetColorSpace(
2401         HDC     hDc
2402         )
2403 {
2404         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2405         return 0;
2406 }
2407
2408
2409 BOOL
2410 STDCALL
2411 SetColorSpace(
2412         HDC             a0,
2413         HCOLORSPACE     a1
2414         )
2415 {
2416         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2417         return FALSE;
2418 }
2419
2420
2421 BOOL
2422 STDCALL
2423 DeleteColorSpace(
2424         HCOLORSPACE     a0
2425         )
2426 {
2427         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2428         return FALSE;
2429 }
2430
2431
2432 BOOL
2433 STDCALL
2434 GetDeviceGammaRamp(
2435         HDC     a0,
2436         LPVOID  a1
2437         )
2438 {
2439         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2440         return FALSE;
2441 }
2442
2443
2444 BOOL
2445 STDCALL
2446 SetDeviceGammaRamp(
2447         HDC     a0,
2448         LPVOID  a1
2449         )
2450 {
2451         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2452         return FALSE;
2453 }
2454
2455
2456 BOOL
2457 STDCALL
2458 ColorMatchToTarget(
2459         HDC     a0,
2460         HDC     a1,
2461         DWORD   a2
2462         )
2463 {
2464         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2465         return FALSE;
2466 }
2467
2468
2469 BOOL
2470 STDCALL
2471 wglCopyContext(
2472         HGLRC   a0,
2473         HGLRC   a1,
2474         UINT    a2
2475         )
2476 {
2477         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2478         return FALSE;
2479 }
2480
2481
2482
2483 HGLRC
2484 STDCALL
2485 wglCreateContext(
2486         HDC     hDc
2487         )
2488 {
2489         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2490         return 0;
2491 }
2492
2493
2494
2495 HGLRC
2496 STDCALL
2497 wglCreateLayerContext(
2498         HDC     hDc,
2499         int     a1
2500         )
2501 {
2502         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2503         return 0;
2504 }
2505
2506
2507
2508 BOOL
2509 STDCALL
2510 wglDeleteContext(
2511         HGLRC   a
2512         )
2513 {
2514         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2515         return FALSE;
2516 }
2517
2518
2519
2520 HGLRC
2521 STDCALL
2522 wglGetCurrentContext(VOID)
2523 {
2524         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2525         return 0;
2526 }
2527
2528
2529
2530 HDC
2531 STDCALL
2532 wglGetCurrentDC(VOID)
2533 {
2534         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2535         return 0;
2536 }
2537
2538
2539
2540 PROC
2541 STDCALL
2542 wglGetProcAddress(
2543         LPCSTR          a0
2544         )
2545 {
2546         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2547         return 0;
2548 }
2549
2550
2551
2552 BOOL
2553 STDCALL
2554 wglMakeCurrent(
2555         HDC     a0,
2556         HGLRC   a1
2557         )
2558 {
2559         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2560         return FALSE;
2561 }
2562
2563
2564
2565 BOOL
2566 STDCALL
2567 wglShareLists(
2568         HGLRC   a0,
2569         HGLRC   a1
2570         )
2571 {
2572         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2573         return FALSE;
2574 }
2575
2576
2577 BOOL
2578 STDCALL
2579 SwapBuffers(
2580         HDC     a0
2581         )
2582 {
2583         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2584         return FALSE;
2585 }
2586
2587
2588
2589 BOOL
2590 STDCALL
2591 wglDescribeLayerPlane(
2592         HDC                     a0,
2593         int                     a1,
2594         int                     a2,
2595         UINT                    a3,
2596         LPLAYERPLANEDESCRIPTOR  a4
2597         )
2598 {
2599         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2600         return FALSE;
2601 }
2602
2603
2604 int
2605 STDCALL
2606 wglSetLayerPaletteEntries(
2607         HDC             a0,
2608         int             a1,
2609         int             a2,
2610         int             a3,
2611         CONST COLORREF  *a4
2612         )
2613 {
2614         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2615         return 0;
2616 }
2617
2618
2619 int
2620 STDCALL
2621 wglGetLayerPaletteEntries(
2622         HDC             a0,
2623         int             a1,
2624         int             a2,
2625         int             a3,
2626         CONST COLORREF  *a4
2627         )
2628 {
2629         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2630         return 0;
2631 }
2632
2633
2634 BOOL
2635 STDCALL
2636 wglRealizeLayerPalette(
2637         HDC             a0,
2638         int             a1,
2639         BOOL            a2
2640         )
2641 {
2642         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2643         return FALSE;
2644 }
2645
2646
2647 BOOL
2648 STDCALL
2649 wglSwapLayerBuffers(
2650         HDC             a0,
2651         UINT            a1
2652         )
2653 {
2654         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2655         return FALSE;
2656 }
2657
2658
2659 /* === AFTER THIS POINT I GUESS... =========
2660  * (based on stack size in Norlander's .def)
2661  * === WHERE ARE THEY DEFINED? =============
2662  */
2663
2664
2665 DWORD
2666 STDCALL
2667 GdiPlayDCScript(
2668         DWORD   a0,
2669         DWORD   a1,
2670         DWORD   a2,
2671         DWORD   a3,
2672         DWORD   a4,
2673         DWORD   a5
2674         )
2675 {
2676         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2677         return 0;
2678 }
2679
2680
2681 DWORD
2682 STDCALL
2683 GdiPlayJournal(
2684         DWORD   a0,
2685         DWORD   a1,
2686         DWORD   a2,
2687         DWORD   a3,
2688         DWORD   a4
2689         )
2690 {
2691         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2692         return 0;
2693 }
2694
2695
2696 DWORD
2697 STDCALL
2698 GdiPlayScript(
2699         DWORD   a0,
2700         DWORD   a1,
2701         DWORD   a2,
2702         DWORD   a3,
2703         DWORD   a4,
2704         DWORD   a5,
2705         DWORD   a6
2706         )
2707 {
2708         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2709         return 0;
2710 }
2711
2712
2713 DWORD
2714 STDCALL
2715 GetGlyphOutlineWow(
2716         DWORD   a0,
2717         DWORD   a1,
2718         DWORD   a2,
2719         DWORD   a3,
2720         DWORD   a4,
2721         DWORD   a5,
2722         DWORD   a6
2723         )
2724 {
2725         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2726         return 0;
2727 }
2728
2729
2730 DWORD
2731 STDCALL
2732 GetRandomRgn(
2733         DWORD   a0,
2734         DWORD   a1,
2735         DWORD   a2
2736         )
2737 {
2738         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2739         return 0;
2740 }
2741
2742
2743 DWORD
2744 STDCALL
2745 GetRelAbs(
2746         DWORD   a0,
2747         DWORD   a1
2748         )
2749 {
2750         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2751         return 0;
2752 }
2753
2754
2755
2756 DWORD
2757 STDCALL
2758 SelectBrushLocal(
2759         DWORD   a0,
2760         DWORD   a1
2761         )
2762 {
2763         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2764         return 0;
2765 }
2766
2767
2768
2769 DWORD
2770 STDCALL
2771 SelectFontLocal(
2772         DWORD   a0,
2773         DWORD   a1
2774         )
2775 {
2776         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2777         return 0;
2778 }
2779
2780
2781 DWORD
2782 STDCALL
2783 SetFontEnumeration(
2784         DWORD   a0
2785         )
2786 {
2787         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2788         return 0;
2789 }
2790
2791
2792 DWORD
2793 STDCALL
2794 SetRelAbs(
2795         DWORD   a0,
2796         DWORD   a1
2797         )
2798 {
2799         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2800         return 0;
2801 }
2802
2803
2804 DWORD
2805 STDCALL
2806 gdiPlaySpoolStream(
2807         DWORD   a0,
2808         DWORD   a1,
2809         DWORD   a2,
2810         DWORD   a3,
2811         DWORD   a4,
2812         DWORD   a5
2813         )
2814 {
2815         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2816         return 0;
2817 }
2818
2819
2820 DWORD
2821 STDCALL
2822 GetFontResourceInfo(
2823         DWORD   a0,
2824         DWORD   a1,
2825         DWORD   a2,
2826         DWORD   a3
2827         )
2828 {
2829         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2830         return 0;
2831 }
2832
2833
2834 /* EOF */