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