reactos/lib/gdi32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.36 2003/09/12 17:51:47 vizzini Exp $
   2  *
   3  * reactos/lib/gdi32/misc/stubs.c
   4  *
   5  * GDI32.DLL Stubs
   6  *
   7  * When you implement one of these functions,
   8  * remove its stub from this file.
   9  *
  10  */
  11 #ifdef UNICODE
  12 #undef UNICODE
  13 #endif
  14 #include <windows.h>
  15 #include <ddentry.h>
  16
  17 /*
  18  * @unimplemented
  19  */
  20 BOOL
  21 STDCALL
  22 AnimatePalette(
  23         HPALETTE                a0,
  24         UINT                    a1,
  25         UINT                    a2,
  26         CONST PALETTEENTRY      *a3
  27         )
  28 {
  29         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  30         return FALSE;
  31 }
  32
  33
  34
  35 /*
  36  * @unimplemented
  37  */
  38 BOOL
  39 STDCALL
  40 CancelDC(
  41         HDC     a0
  42         )
  43 {
  44         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  45         return FALSE;
  46 }
  47
  48
  49 /*
  50  * @unimplemented
  51  */
  52 BOOL
  53 STDCALL
  54 Chord(
  55         HDC     a0,
  56         int     a1,
  57         int     a2,
  58         int     a3,
  59         int     a4,
  60         int     a5,
  61         int     a6,
  62         int     a7,
  63         int     a8
  64         )
  65 {
  66         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  67         return FALSE;
  68 }
  69
  70
  71 /*
  72  * @unimplemented
  73  */
  74 HMETAFILE
  75 STDCALL
  76 CloseMetaFile(
  77         HDC     a0
  78         )
  79 {
  80         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  81         return 0;
  82 }
  83
  84 /*
  85  * @unimplemented
  86  */
  87 HBRUSH
  88 STDCALL
  89 CreateDIBPatternBrush(
  90         HGLOBAL                 a0,
  91         UINT                    a1
  92         )
  93 {
  94         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  95         return 0;
  96 }
  97
  98
  99 /*
 100  * @unimplemented
 101  */
 102 HRGN
 103 STDCALL
 104 CreateEllipticRgn(
 105         int                     a0,
 106         int                     a1,
 107         int                     a2,
 108         int                     a3
 109         )
 110 {
 111         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 112         return 0;
 113 }
 114
 115
 116 /*
 117  * @unimplemented
 118  */
 119 HRGN
 120 STDCALL
 121 CreateEllipticRgnIndirect(
 122         CONST RECT              *a0
 123         )
 124 {
 125         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 126         return 0;
 127 }
 128
 129
 130 /*
 131  * @unimplemented
 132  */
 133 BOOL
 134 STDCALL
 135 DeleteMetaFile(
 136         HMETAFILE       a0
 137         )
 138 {
 139         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 140         return FALSE;
 141 }
 142
 143
 144 /*
 145  * @unimplemented
 146  */
 147 int
 148 STDCALL
 149 DrawEscape(
 150         HDC             a0,
 151         int             a1,
 152         int             a2,
 153         LPCSTR          a3
 154         )
 155 {
 156         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 157         return 0;
 158 }
 159
 160
 161 /*
 162  * @unimplemented
 163  */
 164 BOOL
 165 STDCALL
 166 Ellipse(
 167         HDC             a0,
 168         int             a1,
 169         int             a2,
 170         int             a3,
 171         int             a4
 172         )
 173 {
 174         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 175         return FALSE;
 176 }
 177
 178
 179 /*
 180  * @unimplemented
 181  */
 182 int
 183 STDCALL
 184 EnumObjects(
 185         HDC             a0,
 186         int             a1,
 187         ENUMOBJECTSPROC a2,
 188         LPARAM          a3
 189         )
 190 {
 191         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 192         return 0;
 193 }
 194
 195
 196 /*
 197  * @unimplemented
 198  */
 199 int
 200 STDCALL
 201 Escape(
 202         HDC             a0,
 203         int             a1,
 204         int             a2,
 205         LPCSTR          a3,
 206         LPVOID          a4
 207         )
 208 {
 209         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 210         return 0;
 211 }
 212
 213
 214 /*
 215  * @unimplemented
 216  */
 217 int
 218 STDCALL
 219 ExtEscape(
 220         HDC             a0,
 221         int             a1,
 222         int             a2,
 223         LPCSTR          a3,
 224         int             a4,
 225         LPSTR           a5
 226         )
 227 {
 228         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 229         return 0;
 230 }
 231
 232
 233 /*
 234  * @unimplemented
 235  */
 236 int
 237 STDCALL
 238 ExcludeClipRect(
 239         HDC     a0,
 240         int     a1,
 241         int     a2,
 242         int     a3,
 243         int     a4
 244         )
 245 {
 246         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 247         return 0;
 248 }
 249
 250
 251 /*
 252  * @unimplemented
 253  */
 254 HRGN
 255 STDCALL
 256 ExtCreateRegion(
 257         CONST XFORM *   a0,
 258         DWORD           a1,
 259         CONST RGNDATA * a2
 260         )
 261 {
 262         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 263         return 0;
 264 }
 265
 266
 267 /*
 268  * @unimplemented
 269  */
 270 BOOL
 271 STDCALL
 272 ExtFloodFill(
 273         HDC             a0,
 274         int             a1,
 275         int             a2,
 276         COLORREF        a3,
 277         UINT            a4
 278         )
 279 {
 280         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 281         return FALSE;
 282 }
 283
 284
 285
 286 /*
 287  * @unimplemented
 288  */
 289 BOOL
 290 STDCALL
 291 FloodFill(
 292         HDC             a0,
 293         int             a1,
 294         int             a2,
 295         COLORREF        a3
 296         )
 297 {
 298         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 299         return FALSE;
 300 }
 301
 302
 303 /*
 304  * @unimplemented
 305  */
 306 BOOL
 307 STDCALL
 308 FrameRgn(
 309         HDC     a0,
 310         HRGN    a1,
 311         HBRUSH  a2,
 312         int     a3,
 313         int     a4
 314         )
 315 {
 316         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 317         return FALSE;
 318 }
 319
 320
 321 /*
 322  * @unimplemented
 323  */
 324 BOOL
 325 STDCALL
 326 GetAspectRatioFilterEx(
 327         HDC     a0,
 328         LPSIZE  a1
 329         )
 330 {
 331         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 332         return FALSE;
 333 }
 334
 335
 336 /*
 337  * @unimplemented
 338  */
 339 UINT
 340 STDCALL
 341 GetBoundsRect(
 342         HDC     a0,
 343         LPRECT  a1,
 344         UINT    a2
 345         )
 346 {
 347         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 348         return 0;
 349 }
 350
 351
 352 /*
 353  * @unimplemented
 354  */
 355 int
 356 STDCALL
 357 GetMetaRgn(
 358         HDC     a0,
 359         HRGN    a1
 360         )
 361 {
 362         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 363         return 0;
 364 }
 365
 366
 367 /*
 368  * @unimplemented
 369  */
 370 HGDIOBJ
 371 STDCALL
 372 GetCurrentObject(
 373         HDC     a0,
 374         UINT    a1
 375         )
 376 {
 377         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 378         return 0;
 379 }
 380
 381
 382 /*
 383  * @unimplemented
 384  */
 385 DWORD
 386 STDCALL
 387 GetFontData(
 388         HDC     a0,
 389         DWORD   a1,
 390         DWORD   a2,
 391         LPVOID  a3,
 392         DWORD   a4
 393         )
 394 {
 395         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 396         return 0;
 397 }
 398
 399
 400 /*
 401  * @unimplemented
 402  */
 403 UINT
 404 STDCALL
 405 GetMetaFileBitsEx(
 406         HMETAFILE       a0,
 407         UINT            a1,
 408         LPVOID          a2
 409         )
 410 {
 411         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 412         return 0;
 413 }
 414
 415 /*
 416  * @unimplemented
 417  */
 418 COLORREF
 419 STDCALL
 420 GetPixel(
 421         HDC     a0,
 422         int     a1,
 423         int     a2
 424         )
 425 {
 426         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 427         return 0;
 428 }
 429
 430
 431 /*
 432  * @unimplemented
 433  */
 434 BOOL
 435 STDCALL
 436 GetRasterizerCaps(
 437         LPRASTERIZER_STATUS     a0,
 438         UINT                    a1
 439         )
 440 {
 441         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 442         return FALSE;
 443 }
 444
 445 /*
 446  * @unimplemented
 447  */
 448 UINT
 449 STDCALL
 450 GetSystemPaletteUse(
 451         HDC     hDc
 452         )
 453 {
 454         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 455         return 0;
 456 }
 457
 458
 459 /*
 460  * @unimplemented
 461  */
 462 int
 463 STDCALL
 464 GetTextCharacterExtra(
 465         HDC     hDc
 466         )
 467 {
 468         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 469         return 0;
 470 }
 471
 472
 473 /*
 474  * @unimplemented
 475  */
 476 int
 477 STDCALL
 478 GetTextCharset(
 479         HDC     hdc
 480         )
 481 {
 482         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 483         return 0;
 484 }
 485
 486
 487 /*
 488  * @unimplemented
 489  */
 490 int
 491 STDCALL
 492 GetTextCharsetInfo(
 493         HDC             hdc,
 494         LPFONTSIGNATURE lpSig,
 495         DWORD           dwFlags
 496         )
 497 {
 498         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 499         return 0;
 500 }
 501
 502
 503 /*
 504  * @unimplemented
 505  */
 506 BOOL
 507 STDCALL
 508 TranslateCharsetInfo(
 509         DWORD FAR       *lpSrc,
 510         LPCHARSETINFO   lpCs,
 511         DWORD           dwFlags
 512         )
 513 {
 514         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 515         return FALSE;
 516 }
 517
 518
 519 /*
 520  * @unimplemented
 521  */
 522 DWORD
 523 STDCALL
 524 GetFontLanguageInfo(
 525         HDC     hDc
 526         )
 527 {
 528         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 529         return 0;
 530 }
 531
 532
 533 /*
 534  * @unimplemented
 535  */
 536 int
 537 STDCALL
 538 IntersectClipRect(
 539         HDC             hDc,
 540         int             a1,
 541         int             a2,
 542         int             a3,
 543         int             a4
 544         )
 545 {
 546         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 547         return 0;
 548 }
 549
 550
 551 /*
 552  * @unimplemented
 553  */
 554 BOOL
 555 STDCALL
 556 InvertRgn(
 557         HDC     hDc,
 558         HRGN    hRgn
 559         )
 560 {
 561         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 562         return FALSE;
 563 }
 564
 565
 566 /*
 567  * @unimplemented
 568  */
 569 BOOL
 570 STDCALL
 571 LineDDA(
 572         int             a0,
 573         int             a1,
 574         int             a2,
 575         int             a3,
 576         LINEDDAPROC     a4,
 577         LPARAM          a5
 578         )
 579 {
 580         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 581         return FALSE;
 582 }
 583
 584
 585 /*
 586  * @unimplemented
 587  */
 588 BOOL
 589 STDCALL
 590 Pie(
 591         HDC     a0,
 592         int     a1,
 593         int     a2,
 594         int     a3,
 595         int     a4,
 596         int     a5,
 597         int     a6,
 598         int     a7,
 599         int     a8
 600         )
 601 {
 602         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 603         return FALSE;
 604 }
 605
 606
 607 /*
 608  * @unimplemented
 609  */
 610 BOOL
 611 STDCALL
 612 PlayMetaFile(
 613         HDC             a0,
 614         HMETAFILE       a1
 615         )
 616 {
 617         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 618         return FALSE;
 619 }
 620
 621
 622 /*
 623  * @unimplemented
 624  */
 625 BOOL
 626 STDCALL
 627 PtVisible(
 628         HDC     a0,
 629         int     a1,
 630         int     a2
 631         )
 632 {
 633         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 634         return FALSE;
 635 }
 636
 637
 638 /*
 639  * @unimplemented
 640  */
 641 BOOL
 642 STDCALL
 643 RectVisible(
 644         HDC             a0,
 645         CONST RECT      *a1
 646         )
 647 {
 648         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 649         return FALSE;
 650 }
 651
 652
 653 /*
 654  * @unimplemented
 655  */
 656 BOOL
 657 STDCALL
 658 ResizePalette(
 659         HPALETTE        a0,
 660         UINT            a1
 661         )
 662 {
 663         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 664         return FALSE;
 665 }
 666
 667 /*
 668  * @unimplemented
 669  */
 670 int
 671 STDCALL
 672 ExtSelectClipRgn(
 673         HDC     a0,
 674         HRGN    a1,
 675         int     a2
 676         )
 677 {
 678         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 679         return 0;
 680 }
 681
 682
 683 /*
 684  * @unimplemented
 685  */
 686 int
 687 STDCALL
 688 SetMetaRgn(
 689         HDC     hdc
 690         )
 691 {
 692         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 693         return 0;
 694 }
 695
 696
 697 /*
 698  * @unimplemented
 699  */
 700 UINT
 701 STDCALL
 702 SetBoundsRect(
 703         HDC             a0,
 704         CONST RECT      *a1,
 705         UINT            a2
 706         )
 707 {
 708         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 709         return 0;
 710 }
 711
 712
 713 /*
 714  * @unimplemented
 715  */
 716 DWORD
 717 STDCALL
 718 SetMapperFlags(
 719         HDC     a0,
 720         DWORD   a1
 721         )
 722 {
 723         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 724         return 0;
 725 }
 726
 727
 728 /*
 729  * @unimplemented
 730  */
 731 HMETAFILE
 732 STDCALL
 733 SetMetaFileBitsEx(
 734         UINT            a0,
 735         CONST BYTE      *a1
 736         )
 737 {
 738         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 739         return 0;
 740 }
 741
 742
 743 /*
 744  * @unimplemented
 745  */
 746 BOOL
 747 STDCALL
 748 SetPixelV(
 749         HDC             a0,
 750         int             a1,
 751         int             a2,
 752         COLORREF        a3
 753         )
 754 {
 755         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 756         return FALSE;
 757 }
 758
 759
 760 /*
 761  * @unimplemented
 762  */
 763 UINT
 764 STDCALL
 765 SetSystemPaletteUse(
 766         HDC     a0,
 767         UINT    a1
 768         )
 769 {
 770         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 771         return 0;
 772 }
 773
 774
 775 /*
 776  * @unimplemented
 777  */
 778 int
 779 STDCALL
 780 SetTextCharacterExtra(
 781         HDC     a0,
 782         int     a1
 783         )
 784 {
 785         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 786         return 0;
 787 }
 788
 789
 790 /*
 791  * @unimplemented
 792  */
 793 BOOL
 794 STDCALL
 795 SetTextJustification(
 796         HDC     a0,
 797         int     a1,
 798         int     a2
 799         )
 800 {
 801         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 802         return FALSE;
 803 }
 804
 805
 806 /*
 807  * @unimplemented
 808  */
 809 BOOL
 810 STDCALL
 811 UpdateColors(
 812         HDC     hdc
 813         )
 814 {
 815         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 816         return FALSE;
 817 }
 818
 819
 820 /*
 821  * @unimplemented
 822  */
 823 BOOL
 824 STDCALL
 825 PlayMetaFileRecord(
 826         HDC             a0,
 827         LPHANDLETABLE   a1,
 828         LPMETARECORD    a2,
 829         UINT            a3
 830         )
 831 {
 832         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 833         return FALSE;
 834 }
 835
 836
 837 /*
 838  * @unimplemented
 839  */
 840 BOOL
 841 STDCALL
 842 EnumMetaFile(
 843         HDC                     a0,
 844         HMETAFILE               a1,
 845         ENUMMETAFILEPROC        a2,
 846         LPARAM                  a3
 847         )
 848 {
 849         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 850         return FALSE;
 851 }
 852
 853
 854 /*
 855  * @unimplemented
 856  */
 857 HENHMETAFILE
 858 STDCALL
 859 CloseEnhMetaFile(
 860         HDC     hdc
 861         )
 862 {
 863         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 864         return FALSE;
 865 }
 866
 867
 868 /*
 869  * @unimplemented
 870  */
 871 BOOL
 872 STDCALL
 873 DeleteEnhMetaFile(
 874         HENHMETAFILE    a0
 875         )
 876 {
 877         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 878         return FALSE;
 879 }
 880
 881
 882 /*
 883  * @unimplemented
 884  */
 885 BOOL
 886 STDCALL
 887 EnumEnhMetaFile(
 888         HDC             a0,
 889         HENHMETAFILE    a1,
 890         ENHMETAFILEPROC a2,
 891         LPVOID          a3,
 892         CONST RECT      *a4
 893         )
 894 {
 895         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 896         return FALSE;
 897 }
 898
 899
 900 /*
 901  * @unimplemented
 902  */
 903 UINT
 904 STDCALL
 905 GetEnhMetaFileBits(
 906         HENHMETAFILE    a0,
 907         UINT            a1,
 908         LPBYTE          a2
 909         )
 910 {
 911         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 912         return 0;
 913 }
 914
 915
 916 /*
 917  * @unimplemented
 918  */
 919 UINT
 920 STDCALL
 921 GetEnhMetaFileHeader(
 922         HENHMETAFILE    a0,
 923         UINT            a1,
 924         LPENHMETAHEADER a2
 925         )
 926 {
 927         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 928         return 0;
 929 }
 930
 931
 932 /*
 933  * @unimplemented
 934  */
 935 UINT
 936 STDCALL
 937 GetEnhMetaFilePaletteEntries(
 938         HENHMETAFILE    a0,
 939         UINT            a1,
 940         LPPALETTEENTRY  a2
 941         )
 942 {
 943         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 944         return 0;
 945 }
 946
 947
 948 /*
 949  * @unimplemented
 950  */
 951 UINT
 952 STDCALL
 953 GetWinMetaFileBits(
 954         HENHMETAFILE    a0,
 955         UINT            a1,
 956         LPBYTE          a2,
 957         INT             a3,
 958         HDC             a4
 959         )
 960 {
 961         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 962         return 0;
 963 }
 964
 965
 966 /*
 967  * @unimplemented
 968  */
 969 BOOL
 970 STDCALL
 971 PlayEnhMetaFile(
 972         HDC             a0,
 973         HENHMETAFILE    a1,
 974         CONST RECT      *a2
 975         )
 976 {
 977         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 978         return FALSE;
 979 }
 980
 981
 982 /*
 983  * @unimplemented
 984  */
 985 BOOL
 986 STDCALL
 987 PlayEnhMetaFileRecord(
 988         HDC                     a0,
 989         LPHANDLETABLE           a1,
 990         CONST ENHMETARECORD     *a2,
 991         UINT                    a3
 992         )
 993 {
 994         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 995         return FALSE;
 996 }
 997
 998
 999 /*
1000  * @unimplemented
1001  */
1002 HENHMETAFILE
1003 STDCALL
1004 SetEnhMetaFileBits(
1005         UINT            a0,
1006         CONST BYTE      *a1
1007         )
1008 {
1009         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1010         return 0;
1011 }
1012
1013
1014 /*
1015  * @unimplemented
1016  */
1017 HENHMETAFILE
1018 STDCALL
1019 SetWinMetaFileBits(
1020         UINT                    a0,
1021         CONST BYTE              *a1,
1022         HDC                     a2,
1023 //      CONST METAFILEPICT      *a3
1024                    PVOID a3
1025         )
1026 {
1027         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1028         return 0;
1029 }
1030
1031
1032 /*
1033  * @unimplemented
1034  */
1035 BOOL
1036 STDCALL
1037 GdiComment(
1038         HDC             a0,
1039         UINT            a1,
1040         CONST BYTE      *a2
1041         )
1042 {
1043         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1044         return FALSE;
1045 }
1046
1047
1048 /*
1049  * @unimplemented
1050  */
1051 BOOL
1052 STDCALL
1053 AngleArc(
1054         HDC     hdc,
1055         int     a1,
1056         int     a2,
1057         DWORD   a3,
1058         FLOAT   a4,
1059         FLOAT   a5
1060         )
1061 {
1062         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1063         return FALSE;
1064 }
1065
1066
1067 /*
1068  * @unimplemented
1069  */
1070 UINT
1071 STDCALL
1072 GetDIBColorTable(
1073         HDC             hdc,
1074         UINT            a1,
1075         UINT            a2,
1076         RGBQUAD         *a3
1077         )
1078 {
1079         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1080         return 0;
1081 }
1082
1083 /*
1084  * @unimplemented
1085  */
1086 BOOL
1087 STDCALL
1088 SetColorAdjustment(
1089         HDC                     hdc,
1090         CONST COLORADJUSTMENT   *a1
1091         )
1092 {
1093         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1094         return FALSE;
1095 }
1096
1097
1098 /*
1099  * @unimplemented
1100  */
1101 BOOL
1102 STDCALL
1103 GetColorAdjustment(
1104         HDC                     hdc,
1105         LPCOLORADJUSTMENT       a1
1106         )
1107 {
1108         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1109         return FALSE;
1110 }
1111
1112
1113 /*
1114  * @unimplemented
1115  */
1116 int
1117 STDCALL
1118 EndDoc(
1119         HDC     hdc
1120         )
1121 {
1122         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1123         return 0;
1124 }
1125
1126
1127 /*
1128  * @unimplemented
1129  */
1130 int
1131 STDCALL
1132 StartPage(
1133         HDC     hdc
1134         )
1135 {
1136         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1137         return 0;
1138 }
1139
1140
1141 /*
1142  * @unimplemented
1143  */
1144 int
1145 STDCALL
1146 EndPage(
1147         HDC     hdc
1148         )
1149 {
1150         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1151         return 0;
1152 }
1153
1154
1155 /*
1156  * @unimplemented
1157  */
1158 int
1159 STDCALL
1160 AbortDoc(
1161         HDC     hdc
1162         )
1163 {
1164         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1165         return 0;
1166 }
1167
1168
1169 /*
1170  * @unimplemented
1171  */
1172 int
1173 STDCALL
1174 SetAbortProc(
1175         HDC             hdc,
1176         ABORTPROC       a1
1177         )
1178 {
1179         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1180         return 0;
1181 }
1182
1183
1184 /*
1185  * @unimplemented
1186  */
1187 BOOL
1188 STDCALL
1189 AbortPath(
1190         HDC     hdc
1191         )
1192 {
1193         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194         return FALSE;
1195 }
1196
1197
1198 /*
1199  * @unimplemented
1200  */
1201 BOOL
1202 STDCALL
1203 BeginPath(
1204         HDC     hdc
1205         )
1206 {
1207         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1208         return FALSE;
1209 }
1210
1211
1212 /*
1213  * @unimplemented
1214  */
1215 BOOL
1216 STDCALL
1217 CloseFigure(
1218         HDC     hdc
1219         )
1220 {
1221         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1222         return FALSE;
1223 }
1224
1225
1226 /*
1227  * @unimplemented
1228  */
1229 BOOL
1230 STDCALL
1231 EndPath(
1232         HDC     hdc
1233         )
1234 {
1235         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1236         return FALSE;
1237 }
1238
1239
1240 /*
1241  * @unimplemented
1242  */
1243 BOOL
1244 STDCALL
1245 FillPath(
1246         HDC     hdc
1247         )
1248 {
1249         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1250         return FALSE;
1251 }
1252
1253
1254 /*
1255  * @unimplemented
1256  */
1257 BOOL
1258 STDCALL
1259 FlattenPath(
1260         HDC     hdc
1261         )
1262 {
1263         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1264         return FALSE;
1265 }
1266
1267
1268 /*
1269  * @unimplemented
1270  */
1271 int
1272 STDCALL
1273 GetPath(
1274         HDC             hdc,
1275         LPPOINT         a1,
1276         LPBYTE          a2,
1277         int             a3
1278         )
1279 {
1280         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1281         return 0;
1282 }
1283
1284
1285 /*
1286  * @unimplemented
1287  */
1288 HRGN
1289 STDCALL
1290 PathToRegion(
1291         HDC     hdc
1292         )
1293 {
1294         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1295         return 0;
1296 }
1297
1298
1299 /*
1300  * @unimplemented
1301  */
1302 BOOL
1303 STDCALL
1304 PolyDraw(
1305         HDC             hdc,
1306         CONST POINT     *a1,
1307         CONST BYTE      *a2,
1308         int             a3
1309         )
1310 {
1311         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1312         return FALSE;
1313 }
1314
1315
1316 /*
1317  * @unimplemented
1318  */
1319 BOOL
1320 STDCALL
1321 SelectClipPath(
1322         HDC     hdc,
1323         int     a1
1324         )
1325 {
1326         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1327         return FALSE;
1328 }
1329
1330
1331 /*
1332  * @unimplemented
1333  */
1334 BOOL
1335 STDCALL
1336 SetMiterLimit(
1337         HDC     hdc,
1338         FLOAT   a1,
1339         PFLOAT  a2
1340         )
1341 {
1342         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1343         return FALSE;
1344 }
1345
1346
1347 /*
1348  * @unimplemented
1349  */
1350 BOOL
1351 STDCALL
1352 StrokeAndFillPath(
1353         HDC     hdc
1354         )
1355 {
1356         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1357         return FALSE;
1358 }
1359
1360
1361 /*
1362  * @unimplemented
1363  */
1364 BOOL
1365 STDCALL
1366 StrokePath(
1367         HDC     hdc
1368         )
1369 {
1370         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1371         return FALSE;
1372 }
1373
1374
1375 /*
1376  * @unimplemented
1377  */
1378 BOOL
1379 STDCALL
1380 WidenPath(
1381         HDC     hdc
1382         )
1383 {
1384         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1385         return FALSE;
1386 }
1387
1388
1389 /*
1390  * @unimplemented
1391  */
1392 HPEN
1393 STDCALL
1394 ExtCreatePen(
1395         DWORD           a0,
1396         DWORD           a1,
1397         CONST LOGBRUSH  *a2,
1398         DWORD           a3,
1399         CONST DWORD     *a4
1400         )
1401 {
1402         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1403         return 0;
1404 }
1405
1406
1407 /*
1408  * @unimplemented
1409  */
1410 BOOL
1411 STDCALL
1412 GetMiterLimit(
1413         HDC     hdc,
1414         PFLOAT  a1
1415         )
1416 {
1417         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1418         return FALSE;
1419 }
1420
1421
1422 /*
1423  * @unimplemented
1424  */
1425 HRGN
1426 STDCALL
1427 CreatePolygonRgn(
1428         CONST POINT     *a0,
1429         int             a1,
1430         int             a2
1431         )
1432 {
1433         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1434         return 0;
1435 }
1436
1437 /*
1438  * @unimplemented
1439  */
1440 BOOL
1441 STDCALL
1442 ScaleViewportExtEx(
1443         HDC     a0,
1444         int     a1,
1445         int     a2,
1446         int     a3,
1447         int     a4,
1448         LPSIZE  a5
1449         )
1450 {
1451         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1452         return FALSE;
1453 }
1454
1455
1456 /*
1457  * @unimplemented
1458  */
1459 BOOL
1460 STDCALL
1461 ScaleWindowExtEx(
1462         HDC     a0,
1463         int     a1,
1464         int     a2,
1465         int     a3,
1466         int     a4,
1467         LPSIZE  a5
1468         )
1469 {
1470         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1471         return FALSE;
1472 }
1473
1474
1475 /*
1476  * @unimplemented
1477  */
1478 BOOL
1479 STDCALL
1480 SetBrushOrgEx(
1481         HDC     a0,
1482         int     a1,
1483         int     a2,
1484         LPPOINT a3
1485         )
1486 {
1487         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1488         return FALSE;
1489 }
1490
1491
1492 /*
1493  * @unimplemented
1494  */
1495 BOOL
1496 STDCALL
1497 FixBrushOrgEx(
1498         HDC     a0,
1499         int     a1,
1500         int     a2,
1501         LPPOINT a3
1502         )
1503 {
1504         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1505         return FALSE;
1506 }
1507
1508
1509 /*
1510  * @unimplemented
1511  */
1512 BOOL
1513 STDCALL
1514 UnrealizeObject(
1515         HGDIOBJ a0
1516         )
1517 {
1518         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1519         return FALSE;
1520 }
1521
1522
1523 /*
1524  * @unimplemented
1525  */
1526 BOOL
1527 STDCALL
1528 GdiFlush()
1529 {
1530         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1531         return FALSE;
1532 }
1533
1534
1535 /*
1536  * @unimplemented
1537  */
1538 DWORD
1539 STDCALL
1540 GdiSetBatchLimit(
1541         DWORD   a0
1542         )
1543 {
1544         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1545         return 0;
1546 }
1547
1548
1549 /*
1550  * @unimplemented
1551  */
1552 DWORD
1553 STDCALL
1554 GdiGetBatchLimit()
1555 {
1556         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1557         return 0;
1558 }
1559
1560
1561 /*
1562  * @unimplemented
1563  */
1564 int
1565 STDCALL
1566 SetICMMode(
1567         HDC     a0,
1568         int     a1
1569         )
1570 {
1571         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1572         return 0;
1573 }
1574
1575
1576 /*
1577  * @unimplemented
1578  */
1579 BOOL
1580 STDCALL
1581 CheckColorsInGamut(
1582         HDC     a0,
1583         LPVOID  a1,
1584         LPVOID  a2,
1585         DWORD   a3
1586         )
1587 {
1588         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1589         return FALSE;
1590 }
1591
1592
1593 /*
1594  * @unimplemented
1595  */
1596 HANDLE
1597 STDCALL
1598 GetColorSpace(
1599         HDC     hDc
1600         )
1601 {
1602         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1603         return 0;
1604 }
1605
1606
1607 /*
1608  * @unimplemented
1609  */
1610 BOOL
1611 STDCALL
1612 SetColorSpace(
1613         HDC             a0,
1614         HCOLORSPACE     a1
1615         )
1616 {
1617         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1618         return FALSE;
1619 }
1620
1621
1622 /*
1623  * @unimplemented
1624  */
1625 BOOL
1626 STDCALL
1627 DeleteColorSpace(
1628         HCOLORSPACE     a0
1629         )
1630 {
1631         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1632         return FALSE;
1633 }
1634
1635
1636 /*
1637  * @unimplemented
1638  */
1639 BOOL
1640 STDCALL
1641 GetDeviceGammaRamp(
1642         HDC     a0,
1643         LPVOID  a1
1644         )
1645 {
1646         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1647         return FALSE;
1648 }
1649
1650
1651 /*
1652  * @unimplemented
1653  */
1654 BOOL
1655 STDCALL
1656 SetDeviceGammaRamp(
1657         HDC     a0,
1658         LPVOID  a1
1659         )
1660 {
1661         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1662         return FALSE;
1663 }
1664
1665
1666 /*
1667  * @unimplemented
1668  */
1669 BOOL
1670 STDCALL
1671 ColorMatchToTarget(
1672         HDC     a0,
1673         HDC     a1,
1674         DWORD   a2
1675         )
1676 {
1677         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1678         return FALSE;
1679 }
1680
1681
1682 /*
1683  * @unimplemented
1684  */
1685 BOOL
1686 STDCALL
1687 wglCopyContext(
1688         HGLRC   a0,
1689         HGLRC   a1,
1690         UINT    a2
1691         )
1692 {
1693         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1694         return FALSE;
1695 }
1696
1697
1698 /*
1699  * @unimplemented
1700  */
1701 HGLRC
1702 STDCALL
1703 wglCreateContext(
1704         HDC     hDc
1705         )
1706 {
1707         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1708         return 0;
1709 }
1710
1711
1712 /*
1713  * @unimplemented
1714  */
1715 HGLRC
1716 STDCALL
1717 wglCreateLayerContext(
1718         HDC     hDc,
1719         int     a1
1720         )
1721 {
1722         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1723         return 0;
1724 }
1725
1726
1727 /*
1728  * @unimplemented
1729  */
1730 BOOL
1731 STDCALL
1732 wglDeleteContext(
1733         HGLRC   a
1734         )
1735 {
1736         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1737         return FALSE;
1738 }
1739
1740
1741 /*
1742  * @unimplemented
1743  */
1744 HGLRC
1745 STDCALL
1746 wglGetCurrentContext(VOID)
1747 {
1748         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1749         return 0;
1750 }
1751
1752
1753 /*
1754  * @unimplemented
1755  */
1756 HDC
1757 STDCALL
1758 wglGetCurrentDC(VOID)
1759 {
1760         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1761         return 0;
1762 }
1763
1764
1765 /*
1766  * @unimplemented
1767  */
1768 PROC
1769 STDCALL
1770 wglGetProcAddress(
1771         LPCSTR          a0
1772         )
1773 {
1774         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1775         return 0;
1776 }
1777
1778
1779 /*
1780  * @unimplemented
1781  */
1782 BOOL
1783 STDCALL
1784 wglMakeCurrent(
1785         HDC     a0,
1786         HGLRC   a1
1787         )
1788 {
1789         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1790         return FALSE;
1791 }
1792
1793
1794 /*
1795  * @unimplemented
1796  */
1797 BOOL
1798 STDCALL
1799 wglShareLists(
1800         HGLRC   a0,
1801         HGLRC   a1
1802         )
1803 {
1804         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1805         return FALSE;
1806 }
1807
1808
1809 /*
1810  * @unimplemented
1811  */
1812 BOOL
1813 STDCALL
1814 wglDescribeLayerPlane(
1815         HDC                     a0,
1816         int                     a1,
1817         int                     a2,
1818         UINT                    a3,
1819         LPLAYERPLANEDESCRIPTOR  a4
1820         )
1821 {
1822         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1823         return FALSE;
1824 }
1825
1826
1827 /*
1828  * @unimplemented
1829  */
1830 int
1831 STDCALL
1832 wglSetLayerPaletteEntries(
1833         HDC             a0,
1834         int             a1,
1835         int             a2,
1836         int             a3,
1837         CONST COLORREF  *a4
1838         )
1839 {
1840         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1841         return 0;
1842 }
1843
1844
1845 /*
1846  * @unimplemented
1847  */
1848 int
1849 STDCALL
1850 wglGetLayerPaletteEntries(
1851         HDC             a0,
1852         int             a1,
1853         int             a2,
1854         int             a3,
1855         CONST COLORREF  *a4
1856         )
1857 {
1858         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1859         return 0;
1860 }
1861
1862
1863 /*
1864  * @unimplemented
1865  */
1866 BOOL
1867 STDCALL
1868 wglRealizeLayerPalette(
1869         HDC             a0,
1870         int             a1,
1871         BOOL            a2
1872         )
1873 {
1874         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1875         return FALSE;
1876 }
1877
1878
1879 /*
1880  * @unimplemented
1881  */
1882 BOOL
1883 STDCALL
1884 wglSwapLayerBuffers(
1885         HDC             a0,
1886         UINT            a1
1887         )
1888 {
1889         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1890         return FALSE;
1891 }
1892
1893
1894 /* === AFTER THIS POINT I GUESS... =========
1895  * (based on stack size in Norlander's .def)
1896  * === WHERE ARE THEY DEFINED? =============
1897  */
1898
1899
1900 /*
1901  * @unimplemented
1902  */
1903 DWORD
1904 STDCALL
1905 GdiPlayDCScript(
1906         DWORD   a0,
1907         DWORD   a1,
1908         DWORD   a2,
1909         DWORD   a3,
1910         DWORD   a4,
1911         DWORD   a5
1912         )
1913 {
1914         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1915         return 0;
1916 }
1917
1918
1919 /*
1920  * @unimplemented
1921  */
1922 DWORD
1923 STDCALL
1924 GdiPlayJournal(
1925         DWORD   a0,
1926         DWORD   a1,
1927         DWORD   a2,
1928         DWORD   a3,
1929         DWORD   a4
1930         )
1931 {
1932         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1933         return 0;
1934 }
1935
1936
1937 /*
1938  * @unimplemented
1939  */
1940 DWORD
1941 STDCALL
1942 GdiPlayScript(
1943         DWORD   a0,
1944         DWORD   a1,
1945         DWORD   a2,
1946         DWORD   a3,
1947         DWORD   a4,
1948         DWORD   a5,
1949         DWORD   a6
1950         )
1951 {
1952         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1953         return 0;
1954 }
1955
1956
1957 /*
1958  * @unimplemented
1959  */
1960 DWORD
1961 STDCALL
1962 GetGlyphOutlineWow(
1963         DWORD   a0,
1964         DWORD   a1,
1965         DWORD   a2,
1966         DWORD   a3,
1967         DWORD   a4,
1968         DWORD   a5,
1969         DWORD   a6
1970         )
1971 {
1972         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1973         return 0;
1974 }
1975
1976
1977 /*
1978  * @unimplemented
1979  */
1980 DWORD
1981 STDCALL
1982 GetRandomRgn(
1983         DWORD   a0,
1984         DWORD   a1,
1985         DWORD   a2
1986         )
1987 {
1988         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1989         return 0;
1990 }
1991
1992
1993 /*
1994  * @unimplemented
1995  */
1996 DWORD
1997 STDCALL
1998 SelectBrushLocal(
1999         DWORD   a0,
2000         DWORD   a1
2001         )
2002 {
2003         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2004         return 0;
2005 }
2006
2007
2008 /*
2009  * @unimplemented
2010  */
2011 DWORD
2012 STDCALL
2013 SelectFontLocal(
2014         DWORD   a0,
2015         DWORD   a1
2016         )
2017 {
2018         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2019         return 0;
2020 }
2021
2022
2023 /*
2024  * @unimplemented
2025  */
2026 DWORD
2027 STDCALL
2028 SetFontEnumeration(
2029         DWORD   a0
2030         )
2031 {
2032         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2033         return 0;
2034 }
2035
2036
2037 /*
2038  * @unimplemented
2039  */
2040 DWORD
2041 STDCALL
2042 SetRelAbs(
2043         DWORD   a0,
2044         DWORD   a1
2045         )
2046 {
2047         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2048         return 0;
2049 }
2050
2051
2052 /*
2053  * @unimplemented
2054  */
2055 DWORD
2056 STDCALL
2057 gdiPlaySpoolStream(
2058         DWORD   a0,
2059         DWORD   a1,
2060         DWORD   a2,
2061         DWORD   a3,
2062         DWORD   a4,
2063         DWORD   a5
2064         )
2065 {
2066         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2067         return 0;
2068 }
2069
2070
2071 /*
2072  * @unimplemented
2073  */
2074 DWORD
2075 STDCALL
2076 GetFontResourceInfo(
2077         DWORD   a0,
2078         DWORD   a1,
2079         DWORD   a2,
2080         DWORD   a3
2081         )
2082 {
2083         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2084         return 0;
2085 }
2086
2087 /*
2088  * @unimplemented
2089  */
2090 HANDLE
2091 STDCALL
2092 AddFontMemResourceEx(
2093         PVOID pbFont,
2094         DWORD cbFont,
2095         PVOID pdv,
2096         DWORD *pcFonts
2097 )
2098 {
2099         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2100         return 0;
2101 }
2102
2103 /*
2104  * @unimplemented
2105  */
2106 int
2107 STDCALL
2108 AddFontResourceTracking(
2109         LPCSTR lpString,
2110         int unknown
2111 )
2112 {
2113         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2114         return 0;
2115 }
2116
2117 /*
2118  * @unimplemented
2119  */
2120 WINBOOL
2121 STDCALL
2122 AnyLinkedFonts(VOID)
2123 {
2124         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2125         return 0;
2126 }
2127
2128 /*
2129  * @unimplemented
2130  */
2131 HBITMAP
2132 STDCALL
2133 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
2134 {
2135         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2136         return 0;
2137 }
2138
2139 /*
2140  * @unimplemented
2141  */
2142 HBRUSH
2143 STDCALL
2144 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
2145 {
2146         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2147         return 0;
2148 }
2149
2150 /*
2151  * @unimplemented
2152  */
2153 WINBOOL
2154 STDCALL
2155 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
2156 {
2157         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2158         return 0;
2159 }
2160
2161 /*
2162  * @unimplemented
2163  */
2164 WINBOOL
2165 STDCALL
2166 EnableEUDC(WINBOOL enable)
2167 {
2168         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2169         return 0;
2170 }
2171
2172 /*
2173  * @unimplemented
2174  */
2175 int
2176 STDCALL
2177 EndFormPage(HDC hdc)
2178 {
2179         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2180         return 0;
2181 }
2182
2183 /*
2184  * @unimplemented
2185  */
2186 WINBOOL
2187 STDCALL
2188 EudcLoadLinkW(LPCWSTR pBaseFaceName,LPCWSTR pEudcFontPath,INT iPriority,INT iFontLinkType)
2189 {
2190         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2191         return 0;
2192 }
2193
2194 /*
2195  * @unimplemented
2196  */
2197 WINBOOL
2198 STDCALL
2199 EudcUnloadLinkW(LPCWSTR pBaseFaceName,LPCWSTR pEudcFontPath)
2200 {
2201         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2202         return 0;
2203 }
2204
2205 /*
2206  * @unimplemented
2207  */
2208 WINBOOL
2209 STDCALL
2210 FontIsLinked(HDC hdc)
2211 {
2212         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2213         return 0;
2214 }
2215
2216 /*
2217  * @unimplemented
2218  */
2219 int
2220 STDCALL
2221 GdiAddFontResourceW(LPCWSTR filename,FLONG f,DESIGNVECTOR *pdv)
2222 {
2223         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2224         return 0;
2225 }
2226
2227 /*
2228  * @unimplemented
2229  */
2230 DWORD
2231 STDCALL
2232 GdiAddGlsBounds(HDC hdc,LPRECT prc)
2233 {
2234         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2235         return 0;
2236 }
2237
2238 /*
2239  * @unimplemented
2240  */
2241 WINBOOL
2242 STDCALL
2243 GdiAlphaBlend(HDC hdcDst,LONG DstX,LONG DstY,LONG DstCx,LONG DstCy,HDC hdcSrc,LONG SrcX,LONG SrcY,LONG SrcCx,LONG SrcCy,BLENDFUNCTION BlendFunction)
2244 {
2245         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2246         return 0;
2247 }
2248
2249 /*
2250  * @unimplemented
2251  */
2252 WINBOOL
2253 STDCALL
2254 GdiArtificialDecrementDriver(LPWSTR pDriverName,WINBOOL unknown)
2255 {
2256         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2257         return 0;
2258 }
2259
2260 /*
2261  * @unimplemented
2262  */
2263 WINBOOL
2264 STDCALL
2265 GdiCleanCacheDC(HDC hdc)
2266 {
2267         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2268         return 0;
2269 }
2270
2271 /*
2272  * @unimplemented
2273  */
2274 WINBOOL
2275 STDCALL
2276 GdiConsoleTextOut(HDC hdc, POLYTEXTW *lpto,UINT nStrings, RECTL *prclBounds)
2277 {
2278         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2279         return 0;
2280 }
2281
2282 /*
2283  * @unimplemented
2284  */
2285 HDC
2286 STDCALL
2287 GdiConvertAndCheckDC(HDC hdc)
2288 {
2289         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2290         return 0;
2291 }
2292
2293 /*
2294  * @unimplemented
2295  */
2296 HBITMAP
2297 STDCALL
2298 GdiConvertBitmap(HBITMAP hbm)
2299 {
2300         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2301         return 0;
2302 }
2303
2304 /*
2305  * @unimplemented
2306  */
2307 HBRUSH
2308 STDCALL
2309 GdiConvertBrush(HBRUSH hbr)
2310 {
2311         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2312         return 0;
2313 }
2314
2315 /*
2316  * @unimplemented
2317  */
2318 HDC
2319 STDCALL
2320 GdiConvertDC(HDC hdc)
2321 {
2322         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2323         return 0;
2324 }
2325
2326 /*
2327  * @unimplemented
2328  */
2329 HFONT
2330 STDCALL
2331 GdiConvertFont(HFONT hfont)
2332 {
2333         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2334         return 0;
2335 }
2336
2337 /*
2338  * @unimplemented
2339  */
2340 HPALETTE
2341 STDCALL
2342 GdiConvertPalette(HPALETTE hpal)
2343 {
2344         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2345         return 0;
2346 }
2347
2348 /*
2349  * @unimplemented
2350  */
2351 HRGN
2352 STDCALL
2353 GdiConvertRegion(HRGN hregion)
2354 {
2355         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2356         return 0;
2357 }
2358
2359 /*
2360  * @unimplemented
2361  */
2362 HENHMETAFILE
2363 STDCALL
2364 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
2365 {
2366         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2367         return 0;
2368 }
2369
2370 /*
2371  * @unimplemented
2372  */
2373 WINBOOL
2374 STDCALL
2375 GdiDeleteLocalDC(HDC hdc)
2376 {
2377         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2378         return 0;
2379 }
2380
2381 /*
2382  * @unimplemented
2383  */
2384 int
2385 STDCALL
2386 GdiDescribePixelFormat(HDC hdc,int ipfd,UINT cjpfd,PPIXELFORMATDESCRIPTOR ppfd)
2387 {
2388         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2389         return 0;
2390 }
2391
2392 /*
2393  * @unimplemented
2394  */
2395 WINBOOL
2396 STDCALL
2397 GdiDrawStream(HDC dc, ULONG l, VOID *v)
2398 {
2399         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2400         return 0;
2401 }
2402
2403 /*
2404  * @unimplemented
2405  */
2406 HGDIOBJ
2407 STDCALL
2408 GdiFixUpHandle(HGDIOBJ hobj)
2409 {
2410         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2411         return 0;
2412 }
2413
2414 /*
2415  * @unimplemented
2416  */
2417 DWORD
2418 STDCALL
2419 GdiGetCodePage(HDC hdc)
2420 {
2421         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2422         return 0;
2423 }
2424
2425 /*
2426  * @unimplemented
2427  */
2428 HBRUSH
2429 STDCALL
2430 GdiGetLocalBrush(HBRUSH hbr)
2431 {
2432         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2433         return 0;
2434 }
2435
2436 /*
2437  * @unimplemented
2438  */
2439 HDC
2440 STDCALL
2441 GdiGetLocalDC(HDC hdc)
2442 {
2443         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2444         return 0;
2445 }
2446
2447 /*
2448  * @unimplemented
2449  */
2450 HFONT
2451 STDCALL
2452 GdiGetLocalFont(HFONT hfont)
2453 {
2454         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2455         return 0;
2456 }
2457
2458 /*
2459  * @unimplemented
2460  */
2461 WINBOOL
2462 STDCALL
2463 GdiGradientFill(HDC hdc,PTRIVERTEX pVertex,ULONG uVertex,PVOID pMesh,ULONG uMesh,ULONG ulMode)
2464 {
2465         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2466         return 0;
2467 }
2468
2469 /*
2470  * @unimplemented
2471  */
2472 WINBOOL
2473 STDCALL
2474 GdiIsMetaFileDC(HDC hdc)
2475 {
2476         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2477         return 0;
2478 }
2479
2480 /*
2481  * @unimplemented
2482  */
2483 WINBOOL
2484 STDCALL
2485 GdiIsMetaPrintDC(HDC hdc)
2486 {
2487         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2488         return 0;
2489 }
2490
2491 /*
2492  * @unimplemented
2493  */
2494 WINBOOL
2495 STDCALL
2496 GdiIsPlayMetafileDC(HDC hdc)
2497 {
2498         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2499         return 0;
2500 }
2501
2502 /*
2503  * @unimplemented
2504  */
2505 WINBOOL
2506 STDCALL
2507 GdiReleaseDC(HDC hdc)
2508 {
2509         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2510         return 0;
2511 }
2512
2513 /*
2514  * @unimplemented
2515  */
2516 WINBOOL
2517 STDCALL
2518 GdiReleaseLocalDC(HDC hdc)
2519 {
2520         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2521         return 0;
2522 }
2523
2524 /*
2525  * @unimplemented
2526  */
2527 WINBOOL
2528 STDCALL
2529 GdiSetAttrs(HDC hdc)
2530 {
2531         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2532         return 0;
2533 }
2534
2535 /*
2536  * @unimplemented
2537  */
2538 VOID
2539 STDCALL
2540 GdiSetLastError(DWORD dwErrCode)
2541 {
2542         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2543 }
2544
2545 /*
2546  * @unimplemented
2547  */
2548 WINBOOL
2549 STDCALL
2550 GdiSetPixelFormat(HDC hdc,int ipfd)
2551 {
2552         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2553         return 0;
2554 }
2555
2556 /*
2557  * @unimplemented
2558  */
2559 WINBOOL
2560 STDCALL
2561 GdiTransparentBlt(HDC hdcDst, int xDst, int yDst, int cxDst, int cyDst,HDC hdcSrc, int xSrc, int ySrc, int cxSrc, int cySrc,COLORREF TransColor)
2562 {
2563         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2564         return 0;
2565 }
2566
2567 /*
2568  * @unimplemented
2569  */
2570 WINBOOL
2571 STDCALL
2572 GdiValidateHandle(HGDIOBJ hobj)
2573 {
2574         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2575         return 0;
2576 }
2577
2578 /*
2579  * @unimplemented
2580  */
2581 WINBOOL
2582 STDCALL
2583 GdiSwapBuffers(HDC hdc)
2584 {
2585         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2586         return 0;
2587 }
2588
2589 /*
2590  * @unimplemented
2591  */
2592 VOID
2593 STDCALL
2594 GdiSetServerAttr(HDC hdc,DWORD attr)
2595 {
2596         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2597 }
2598
2599 /*
2600  * @unimplemented
2601  */
2602 DWORD
2603 STDCALL
2604 GetBitmapAttributes(HBITMAP hbm)
2605 {
2606         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2607         return 0;
2608 }
2609
2610 /*
2611  * @unimplemented
2612  */
2613 DWORD
2614 STDCALL
2615 GetBrushAttributes(HBRUSH hbr)
2616 {
2617         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2618         return 0;
2619 }
2620
2621 /*
2622  * @unimplemented
2623  */
2624 WINBOOL
2625 STDCALL
2626 GetCharABCWidthsI(
2627         HDC hdc,
2628         UINT giFirst,
2629         UINT cgi,
2630         LPWORD pgi,
2631         LPABC lpabc
2632 )
2633 {
2634         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2635         return 0;
2636 }
2637
2638 /*
2639  * @unimplemented
2640  */
2641 WINBOOL
2642 STDCALL
2643 GetCharWidthI(
2644         HDC hdc,
2645         UINT giFirst,
2646         UINT cgi,
2647         LPWORD pgi,
2648         LPINT lpBuffer
2649 )
2650 {
2651         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2652         return 0;
2653 }
2654
2655 /*
2656  * @unimplemented
2657  */
2658 COLORREF
2659 STDCALL
2660 GetDCBrushColor(
2661         HDC hdc
2662 )
2663 {
2664         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2665         return 0;
2666 }
2667
2668 /*
2669  * @unimplemented
2670  */
2671 COLORREF
2672 STDCALL
2673 GetDCPenColor(
2674         HDC hdc
2675 )
2676 {
2677         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2678         return 0;
2679 }
2680
2681 /*
2682  * @unimplemented
2683  */
2684 DWORD
2685 STDCALL
2686 GetFontUnicodeRanges(
2687         HDC hdc,
2688         LPGLYPHSET lpgs
2689 )
2690 {
2691         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2692         return 0;
2693 }
2694
2695 /*
2696  * @unimplemented
2697  */
2698 ULONG
2699 STDCALL
2700 GetEUDCTimeStamp(VOID)
2701 {
2702         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2703         return 0;
2704 }
2705
2706 /*
2707  * @unimplemented
2708  */
2709 DWORD
2710 STDCALL
2711 GetEUDCTimeStampExW(LPCWSTR str)
2712 {
2713         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2714         return 0;
2715 }
2716
2717 /*
2718  * @unimplemented
2719  */
2720 ULONG
2721 STDCALL
2722 GetFontAssocStatus(HDC hdc)
2723 {
2724         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2725         return 0;
2726 }
2727
2728 /*
2729  * @unimplemented
2730  */
2731 HFONT
2732 STDCALL
2733 GetHFONT(HDC dc)
2734 {
2735         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2736         return 0;
2737 }
2738
2739 /*
2740  * @unimplemented
2741  */
2742 DWORD
2743 STDCALL
2744 GetLayout(
2745         HDC hdc
2746 )
2747 {
2748         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2749         return 0;
2750 }
2751
2752 /*
2753  * @unimplemented
2754  */
2755 WINBOOL
2756 STDCALL
2757 GetTextExtentExPointWPri(HDC hdc,LPWSTR lpwsz,ULONG cwc,ULONG dxMax,ULONG *pcCh,PULONG pdxOut,LPSIZE psize)
2758 {
2759         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2760         return 0;
2761 }
2762
2763 /*
2764  * @unimplemented
2765  */
2766 int
2767 STDCALL
2768 GetTextFaceAliasW(HDC hdc,int cChar,LPWSTR pszOut)
2769 {
2770         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2771         return 0;
2772 }
2773
2774 /*
2775  * @unimplemented
2776  */
2777 WINBOOL
2778 STDCALL
2779 GetTransform(HDC hdc, DWORD iXform, LPXFORM pxf)
2780 {
2781         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2782         return 0;
2783 }
2784
2785 /*
2786  * @unimplemented
2787  */
2788 LONG
2789 STDCALL
2790 HT_Get8BPPFormatPalette(LPPALETTEENTRY pPaletteEntry, USHORT RedGamma,USHORT GreenGamma, USHORT BlueGamma)
2791 {
2792         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2793         return 0;
2794 }
2795
2796 /*
2797  * @unimplemented
2798  */
2799 LONG
2800 STDCALL
2801 HT_Get8BPPMaskPalette(LPPALETTEENTRY pPaletteEntry, WINBOOL Use8BPPMaskPal,BYTE CMYMask, USHORT RedGamma, USHORT GreenGamma, USHORT BlueGamma)
2802 {
2803         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2804         return 0;
2805 }
2806
2807 /*
2808  * @unimplemented
2809  */
2810 WINBOOL
2811 STDCALL
2812 MirrorRgn(HWND hwnd,HRGN hrgn)
2813 {
2814         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2815         return 0;
2816 }
2817
2818 /*
2819  * @unimplemented
2820  */
2821 int
2822 STDCALL
2823 NamedEscape(HDC hdc,PWCHAR pDriver,int nDriver,int iEsc,int cjIn,LPSTR pjIn,int cjOut,LPSTR pjOut)
2824 {
2825         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2826         return 0;
2827 }
2828
2829 /*
2830  * @unimplemented
2831  */
2832 DWORD
2833 STDCALL
2834 QueryFontAssocStatus(VOID)
2835 {
2836         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2837         return 0;
2838 }
2839
2840 /*
2841  * @unimplemented
2842  */
2843 WINBOOL
2844 STDCALL
2845 RemoveFontMemResourceEx(
2846         HANDLE fh
2847 )
2848 {
2849         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2850         return 0;
2851 }
2852
2853 /*
2854  * @unimplemented
2855  */
2856 WINBOOL
2857 STDCALL
2858 RemoveFontResourceExA(
2859         LPCSTR lpFileName,
2860         DWORD fl,
2861         PVOID pdv
2862 )
2863 {
2864         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2865         return 0;
2866 }
2867
2868 /*
2869  * @unimplemented
2870  */
2871 WINBOOL
2872 STDCALL
2873 RemoveFontResourceExW(
2874         LPCWSTR lpFileName,
2875         DWORD fl,
2876         PVOID pdv
2877 )
2878 {
2879         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2880         return 0;
2881 }
2882
2883 /*
2884  * @unimplemented
2885  */
2886 int
2887 STDCALL
2888 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
2889 {
2890         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2891         return 0;
2892 }
2893
2894 /*
2895  * @unimplemented
2896  */
2897 HBITMAP
2898 STDCALL
2899 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
2900 {
2901         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2902         return 0;
2903 }
2904
2905 /*
2906  * @unimplemented
2907  */
2908 HBRUSH
2909 STDCALL
2910 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
2911 {
2912         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2913         return 0;
2914 }
2915
2916 /*
2917  * @unimplemented
2918  */
2919 COLORREF
2920 STDCALL
2921 SetDCBrushColor(
2922         HDC hdc,
2923         COLORREF crColor
2924 )
2925 {
2926         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2927         return 0;
2928 }
2929
2930 /*
2931  * @unimplemented
2932  */
2933 COLORREF
2934 STDCALL
2935 SetDCPenColor(
2936         HDC hdc,
2937         COLORREF crColor
2938 )
2939 {
2940         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2941         return 0;
2942 }
2943
2944 /*
2945  * @unimplemented
2946  */
2947 DWORD
2948 STDCALL
2949 SetLayout(
2950         HDC hdc,
2951         DWORD dwLayout
2952 )
2953 {
2954         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2955         return 0;
2956 }
2957
2958 /*
2959  * @unimplemented
2960  */
2961 DWORD
2962 STDCALL
2963 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
2964 {
2965         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2966         return 0;
2967 }
2968
2969 /*
2970  * @unimplemented
2971  */
2972 WINBOOL
2973 STDCALL
2974 SetMagicColors(HDC hdc,PALETTEENTRY peMagic,ULONG Index)
2975 {
2976         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2977         return 0;
2978 }
2979
2980 /*
2981  * @unimplemented
2982  */
2983 WINBOOL
2984 STDCALL
2985 SetVirtualResolution(HDC hdc, int cxVirtualDevicePixel,int cyVirtualDevicePixel,int cxVirtualDeviceMm, int cyVirtualDeviceMm)
2986 {
2987         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2988         return 0;
2989 }
2990
2991 /*
2992  * @unimplemented
2993  */
2994 int
2995 STDCALL
2996 StartFormPage(HDC hdc)
2997 {
2998         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2999         return 0;
3000 }
3001
3002 /*
3003  * @unimplemented
3004  */
3005 VOID
3006 STDCALL
3007 UnloadNetworkFonts(DWORD unknown)
3008 {
3009         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3010 }
3011
3012 /*
3013  * @unimplemented
3014  */
3015 WINBOOL
3016 STDCALL
3017 bInitSystemAndFontsDirectoriesW(LPWSTR *SystemDir,LPWSTR *FontsDir)
3018 {
3019         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3020         return 0;
3021 }
3022
3023 /*
3024  * @unimplemented
3025  */
3026 WINBOOL
3027 STDCALL
3028 bMakePathNameW(LPWSTR lpBuffer,LPCWSTR lpFileName,LPWSTR *lpFilePart,DWORD unknown)
3029 {
3030         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3031         return 0;
3032 }
3033
3034 /*
3035  * @unimplemented
3036  */
3037 HFONT
3038 STDCALL
3039 CreateFontIndirectExA(const ENUMLOGFONTEXDVA *elfexd)
3040 {
3041         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3042         return 0;
3043 }
3044
3045 /*
3046  * @unimplemented
3047  */
3048 DWORD
3049 STDCALL
3050 GetGlyphIndicesA(
3051         HDC hdc,
3052         LPCSTR lpstr,
3053         int c,
3054         LPWORD pgi,
3055         DWORD fl
3056 )
3057 {
3058         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3059         return 0;
3060 }
3061
3062 /*
3063  * @unimplemented
3064  */
3065 UINT
3066 STDCALL
3067 GetStringBitmapA(HDC hdc,LPSTR psz,WINBOOL unknown,UINT cj,BYTE *lpSB)
3068 {
3069         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3070         return 0;
3071 }
3072
3073 /*
3074  * @unimplemented
3075  */
3076 WINBOOL
3077 STDCALL
3078 GetTextExtentExPointI(
3079         HDC hdc,
3080         LPWORD pgiIn,
3081         int cgi,
3082         int nMaxExtent,
3083         LPINT lpnFit,
3084         LPINT alpDx,
3085         LPSIZE lpSize
3086 )
3087 {
3088         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3089         return 0;
3090 }
3091
3092 /*
3093  * @unimplemented
3094  */
3095 HFONT
3096 STDCALL
3097 CreateFontIndirectExW(const ENUMLOGFONTEXDVW *elfexd)
3098 {
3099         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3100         return 0;
3101 }
3102
3103 /*
3104  * @unimplemented
3105  */
3106 DWORD
3107 STDCALL
3108 GetGlyphIndicesW(
3109         HDC hdc,
3110         LPCWSTR lpstr,
3111         int c,
3112         LPWORD pgi,
3113         DWORD fl
3114 )
3115 {
3116         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3117         return 0;
3118 }
3119
3120 /*
3121  * @unimplemented
3122  */
3123 UINT
3124 STDCALL
3125 GetStringBitmapW(HDC hdc,LPWSTR pwsz,WINBOOL unknown,UINT cj,BYTE *lpSB)
3126 {
3127         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3128         return 0;
3129 }
3130
3131 /*
3132  * @unimplemented
3133  */
3134 WINBOOL
3135 STDCALL
3136 GetTextExtentPointI(
3137         HDC hdc,
3138         LPWORD pgiIn,
3139         int cgi,
3140         LPSIZE lpSize
3141 )
3142 {
3143         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3144         return 0;
3145 }
3146
3147 /*
3148  * @unimplemented
3149  */
3150 NTSTATUS
3151 STDCALL
3152 GdiFullscreenControl(FULLSCREENCONTROL FullscreenCommand,PVOID FullscreenInput,
3153                                         DWORD FullscreenInputLength,PVOID FullscreenOutput,
3154                                         PULONG FullscreenOutputLength)
3155 {
3156         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3157         return 0;
3158 }
3159
3160 /*
3161  * @unimplemented
3162  */
3163 INT
3164 STDCALL
3165 GdiQueryFonts(PUNIVERSAL_FONT_ID pufiFontList,ULONG nBufferSize,PLARGE_INTEGER pTimeStamp )
3166 {
3167         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3168         return 0;
3169 }
3170
3171 /*
3172  * @unimplemented
3173  */
3174 WINBOOL
3175 STDCALL
3176 GdiRealizationInfo(HDC hdc, PREALIZATION_INFO pri)
3177 {
3178         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3179         return 0;
3180 }
3181
3182 /*
3183  * @unimplemented
3184  */
3185 WINBOOL
3186 STDCALL
3187 GetCharWidthInfo(HDC hdc,PCHWIDTHINFO pChWidthInfo)
3188 {
3189         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3190         return 0;
3191 }
3192
3193 /*
3194  * @unimplemented
3195  */
3196 WINBOOL
3197 STDCALL
3198 GetETM(HDC hdc,EXTTEXTMETRIC *petm)
3199 {
3200         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3201         return 0;
3202 }
3203
3204 /*
3205  * @unimplemented
3206  */
3207 WINBOOL
3208 STDCALL
3209 GdiAddGlsRecord(HDC hdc,DWORD unknown1,LPCSTR unknown2,LPRECT unknown3)
3210 {
3211         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3212         return 0;
3213 }
3214
3215 /*
3216  * @unimplemented
3217  */
3218 HANDLE
3219 STDCALL
3220 GdiConvertMetaFilePict(HGLOBAL hMem)
3221 {
3222         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3223         return 0;
3224 }
3225
3226 /*
3227  * @unimplemented
3228  */
3229 DEVMODEW *
3230 STDCALL
3231 GdiConvertToDevmodeW(DEVMODEA *dm)
3232 {
3233         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3234         return 0;
3235 }
3236
3237 /*
3238  * @unimplemented
3239  */
3240 HENHMETAFILE
3241 STDCALL
3242 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
3243 {
3244         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3245         return 0;
3246 }
3247
3248 /*
3249  * @unimplemented
3250  */
3251 METAFILEPICT *
3252 STDCALL
3253 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
3254 {
3255         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3256         return 0;
3257 }
3258
3259 /*
3260  * @unimplemented
3261  */
3262 DWORD
3263 STDCALL
3264 GdiGetCharDimensions(HDC hdc,LPTEXTMETRICW lptm,BOOL unk)
3265 {
3266         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3267         return 0;
3268 }
3269
3270 /*
3271  * @unimplemented
3272  */
3273 PSHAREDHANDLETABLE
3274 STDCALL
3275 GdiQueryTable(VOID)
3276 {
3277         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3278         return 0;
3279 }
3280
3281 /*
3282  * @unimplemented
3283  */
3284 HANDLE
3285 STDCALL
3286 GdiGetSpoolFileHandle(
3287         LPWSTR          pwszPrinterName,
3288         LPDEVMODEW      pDevmode,
3289         LPWSTR          pwszDocName)
3290 {
3291         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3292         return 0;
3293 }
3294
3295 /*
3296  * @unimplemented
3297  */
3298 WINBOOL
3299 STDCALL
3300 GdiDeleteSpoolFileHandle(
3301         HANDLE  SpoolFileHandle)
3302 {
3303         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3304         return 0;
3305 }
3306
3307 /*
3308  * @unimplemented
3309  */
3310 DWORD
3311 STDCALL
3312 GdiGetPageCount(
3313         HANDLE  SpoolFileHandle)
3314 {
3315         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3316         return 0;
3317 }
3318
3319 /*
3320  * @unimplemented
3321  */
3322 HDC
3323 STDCALL
3324 GdiGetDC(
3325         HANDLE  SpoolFileHandle)
3326 {
3327         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3328         return 0;
3329 }
3330
3331 /*
3332  * @unimplemented
3333  */
3334 HANDLE
3335 STDCALL
3336 GdiGetPageHandle(
3337         HANDLE  SpoolFileHandle,
3338         DWORD   Page,
3339         LPDWORD pdwPageType)
3340 {
3341         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3342         return 0;
3343 }
3344
3345 /*
3346  * @unimplemented
3347  */
3348 WINBOOL
3349 STDCALL
3350 GdiStartDocEMF(
3351         HANDLE          SpoolFileHandle,
3352         DOCINFOW        *pDocInfo)
3353 {
3354         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3355         return 0;
3356 }
3357
3358 /*
3359  * @unimplemented
3360  */
3361 WINBOOL
3362 STDCALL
3363 GdiStartPageEMF(
3364         HANDLE  SpoolFileHandle)
3365 {
3366         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3367         return 0;
3368 }
3369
3370 /*
3371  * @unimplemented
3372  */
3373 WINBOOL
3374 STDCALL
3375 GdiPlayPageEMF(
3376         HANDLE  SpoolFileHandle,
3377         HANDLE  hemf,
3378         RECT    *prectDocument,
3379         RECT    *prectBorder,
3380         RECT    *prectClip)
3381 {
3382         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3383         return 0;
3384 }
3385
3386 /*
3387  * @unimplemented
3388  */
3389 WINBOOL
3390 STDCALL
3391 GdiEndPageEMF(
3392         HANDLE  SpoolFileHandle,
3393         DWORD   dwOptimization)
3394 {
3395         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3396         return 0;
3397 }
3398
3399 /*
3400  * @unimplemented
3401  */
3402 WINBOOL
3403 STDCALL
3404 GdiEndDocEMF(
3405         HANDLE  SpoolFileHandle)
3406 {
3407         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3408         return 0;
3409 }
3410
3411 /*
3412  * @unimplemented
3413  */
3414 WINBOOL
3415 STDCALL
3416 GdiGetDevmodeForPage(
3417         HANDLE          SpoolFileHandle,
3418         DWORD           dwPageNumber,
3419         PDEVMODEW       *pCurrDM,
3420         PDEVMODEW       *pLastDM)
3421 {
3422         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3423         return 0;
3424 }
3425
3426 /*
3427  * @unimplemented
3428  */
3429 WINBOOL
3430 STDCALL
3431 GdiResetDCEMF(
3432         HANDLE          SpoolFileHandle,
3433         PDEVMODEW       pCurrDM)
3434 {
3435         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3436         return 0;
3437 }
3438
3439 /*
3440  * @unimplemented
3441  */
3442 HANDLE STDCALL
3443 BRUSHOBJ_hGetColorTransform(BRUSHOBJ *pbo)
3444 {
3445         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3446         return 0;
3447 }
3448
3449 /*
3450  * @unimplemented
3451  */
3452 PVOID STDCALL
3453 BRUSHOBJ_pvAllocRbrush(IN PBRUSHOBJ BrushObj,
3454                        IN ULONG ObjSize)
3455 {
3456         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3457         return 0;
3458 }
3459
3460 /*
3461  * @unimplemented
3462  */
3463 PVOID STDCALL
3464 BRUSHOBJ_pvGetRbrush(IN PBRUSHOBJ BrushObj)
3465 {
3466         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3467         return 0;
3468 }
3469
3470 /*
3471  * @unimplemented
3472  */
3473 ULONG STDCALL
3474 BRUSHOBJ_ulGetBrushColor(BRUSHOBJ *pbo)
3475 {
3476         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3477         return 0;
3478 }
3479
3480 /*
3481  * @unimplemented
3482  */
3483 BOOL STDCALL
3484 CLIPOBJ_bEnum(IN PCLIPOBJ ClipObj,
3485               IN ULONG ObjSize,
3486               OUT ULONG *EnumRects)
3487 {
3488         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3489         return 0;
3490 }
3491
3492 /*
3493  * @unimplemented
3494  */
3495 ULONG STDCALL
3496 CLIPOBJ_cEnumStart(IN PCLIPOBJ ClipObj,
3497                    IN BOOL ShouldDoAll,
3498                    IN ULONG ClipType,
3499                    IN ULONG BuildOrder,
3500                    IN ULONG MaxRects)
3501 {
3502         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3503         return 0;
3504 }
3505
3506 /*
3507  * @unimplemented
3508  */
3509 PPATHOBJ STDCALL
3510 CLIPOBJ_ppoGetPath(PCLIPOBJ ClipObj)
3511 {
3512         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3513         return 0;
3514 }
3515
3516 /*
3517  * @unimplemented
3518  */
3519 VOID
3520 STDCALL
3521 EngAcquireSemaphore ( IN HSEMAPHORE hsem )
3522 {
3523         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3524 }
3525
3526 /*
3527  * @unimplemented
3528  */
3529 BOOL STDCALL
3530 EngAlphaBlend(SURFOBJ *psoDest,SURFOBJ *psoSrc,CLIPOBJ *pco,XLATEOBJ *pxlo,RECTL *prclDest,RECTL *prclSrc,BLENDOBJ *pBlendObj)
3531 {
3532         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3533         return 0;
3534 }
3535
3536 /*
3537  * @unimplemented
3538  */
3539 BOOL STDCALL
3540 EngAssociateSurface(IN HSURF Surface,
3541                     IN HDEV Dev,
3542                     IN ULONG Hooks)
3543 {
3544         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3545         return 0;
3546 }
3547
3548 /*
3549  * @unimplemented
3550  */
3551 BOOL STDCALL
3552 EngBitBlt(SURFOBJ *Dest,
3553           SURFOBJ *Source,
3554           SURFOBJ *Mask,
3555           CLIPOBJ *ClipRegion,
3556           XLATEOBJ *ColorTranslation,
3557           RECTL *DestRect,
3558           POINTL *SourcePoint,
3559           POINTL *MaskRect,
3560           BRUSHOBJ *Brush,
3561           POINTL *BrushOrigin,
3562           ROP4 rop4)
3563 {
3564         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3565         return 0;
3566 }
3567
3568 /*
3569  * @unimplemented
3570  */
3571 BOOL STDCALL
3572 EngCheckAbort(SURFOBJ *pso)
3573 {
3574         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3575         return 0;
3576 }
3577
3578 /*
3579  * @unimplemented
3580  */
3581 FD_GLYPHSET* STDCALL
3582 EngComputeGlyphSet(INT nCodePage,INT nFirstChar,INT cChars)
3583 {
3584         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3585         return 0;
3586 }
3587
3588 /*
3589  * @unimplemented
3590  */
3591 BOOL STDCALL
3592 EngCopyBits(SURFOBJ *Dest,
3593             SURFOBJ *Source,
3594             CLIPOBJ *Clip,
3595             XLATEOBJ *ColorTranslation,
3596             RECTL *DestRect,
3597             POINTL *SourcePoint)
3598 {
3599         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3600         return 0;
3601 }
3602
3603 /*
3604  * @unimplemented
3605  */
3606 HBITMAP STDCALL
3607 EngCreateBitmap(IN SIZEL Size,
3608                 IN LONG Width,
3609                 IN ULONG Format,
3610                 IN ULONG Flags,
3611                 IN PVOID Bits)
3612 {
3613         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3614         return 0;
3615 }
3616
3617 /*
3618  * @unimplemented
3619  */
3620 PCLIPOBJ STDCALL
3621 EngCreateClip(VOID)
3622 {
3623         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3624         return 0;
3625 }
3626
3627 /*
3628  * @unimplemented
3629  */
3630 HBITMAP STDCALL
3631 EngCreateDeviceBitmap(IN DHSURF Surface,
3632                       IN SIZEL Size,
3633                       IN ULONG Format)
3634 {
3635         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3636         return 0;
3637 }
3638
3639 /*
3640  * @unimplemented
3641  */
3642 HSURF STDCALL
3643 EngCreateDeviceSurface(IN DHSURF Surface,
3644                        IN SIZEL Size,
3645                        IN ULONG FormatVersion)
3646 {
3647         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3648         return 0;
3649 }
3650
3651 /*
3652  * @unimplemented
3653  */
3654 HPALETTE STDCALL
3655 EngCreatePalette(IN ULONG Mode,
3656                  IN ULONG NumColors,
3657                  IN ULONG *Colors,
3658                  IN ULONG Red,
3659                  IN ULONG Green,
3660                  IN ULONG Blue)
3661 {
3662         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3663         return 0;
3664 }
3665
3666 /*
3667  * @unimplemented
3668  */
3669 HSEMAPHORE
3670 STDCALL
3671 EngCreateSemaphore ( VOID )
3672 {
3673         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3674         return 0;
3675 }
3676
3677 /*
3678  * @unimplemented
3679  */
3680 VOID STDCALL
3681 EngDeleteClip(CLIPOBJ *ClipRegion)
3682 {
3683         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3684 }
3685
3686 /*
3687  * @unimplemented
3688  */
3689 BOOL STDCALL
3690 EngDeletePalette(IN HPALETTE Palette)
3691 {
3692         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3693         return 0;
3694 }
3695
3696 /*
3697  * @unimplemented
3698  */
3699 VOID STDCALL
3700 EngDeletePath(PATHOBJ *ppo)
3701 {
3702         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3703 }
3704
3705 /*
3706  * @unimplemented
3707  */
3708 VOID
3709 STDCALL
3710 EngDeleteSemaphore ( IN HSEMAPHORE hsem )
3711 {
3712         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3713 }
3714
3715 /*
3716  * @unimplemented
3717  */
3718 BOOL STDCALL
3719 EngDeleteSurface(IN HSURF Surface)
3720 {
3721         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3722         return 0;
3723 }
3724
3725 /*
3726  * @unimplemented
3727  */
3728 BOOL STDCALL
3729 EngEraseSurface(SURFOBJ *Surface,
3730                 RECTL *Rect,
3731                 ULONG iColor)
3732 {
3733         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3734         return 0;
3735 }
3736
3737 /*
3738  * @unimplemented
3739  */
3740 BOOL STDCALL
3741 EngFillPath(SURFOBJ *pso,PATHOBJ *ppo,CLIPOBJ *pco,BRUSHOBJ *pbo,POINTL *pptlBrushOrg,MIX mix,FLONG flOptions)
3742 {
3743         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3744         return 0;
3745 }
3746
3747 /*
3748  * @unimplemented
3749  */
3750 PVOID STDCALL
3751 EngFindResource(HANDLE h,int iName,int iType,PULONG pulSize)
3752 {
3753         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3754         return 0;
3755 }
3756
3757 /*
3758  * @unimplemented
3759  */
3760 VOID STDCALL
3761 EngFreeModule(HANDLE h)
3762 {
3763         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3764 }
3765
3766 /*
3767  * @unimplemented
3768  */
3769 VOID STDCALL
3770 EngGetCurrentCodePage(OUT PUSHORT OemCodePage,
3771                       OUT PUSHORT AnsiCodePage)
3772 {
3773         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3774 }
3775
3776 /*
3777  * @unimplemented
3778  */
3779 LPWSTR STDCALL
3780 EngGetDriverName(HDEV hdev)
3781 {
3782         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3783         return 0;
3784 }
3785
3786 /*
3787  * @unimplemented
3788  */
3789 LPWSTR STDCALL
3790 EngGetPrinterDataFileName(HDEV hdev)
3791 {
3792         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3793         return 0;
3794 }
3795
3796 /*
3797  * @unimplemented
3798  */
3799 BOOL STDCALL
3800 EngGradientFill(SURFOBJ *psoDest,CLIPOBJ *pco,XLATEOBJ *pxlo,TRIVERTEX *pVertex,ULONG nVertex,PVOID pMesh,ULONG nMesh,RECTL *prclExtents,POINTL *pptlDitherOrg,ULONG ulMode)
3801 {
3802         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3803         return 0;
3804 }
3805
3806 /*
3807  * @unimplemented
3808  */
3809 BOOL STDCALL
3810 EngLineTo(SURFOBJ *Surface,
3811           CLIPOBJ *Clip,
3812           BRUSHOBJ *Brush,
3813           LONG x1,
3814           LONG y1,
3815           LONG x2,
3816           LONG y2,
3817           RECTL *RectBounds,
3818           MIX mix)
3819 {
3820         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3821         return 0;
3822 }
3823
3824 /*
3825  * @unimplemented
3826  */
3827 HANDLE STDCALL
3828 EngLoadModule(LPWSTR pwsz)
3829 {
3830         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3831         return 0;
3832 }
3833
3834 /*
3835  * @unimplemented
3836  */
3837 SURFOBJ * STDCALL
3838 EngLockSurface(IN HSURF Surface)
3839 {
3840         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3841         return 0;
3842 }
3843
3844 /*
3845  * @unimplemented
3846  */
3847 BOOL STDCALL
3848 EngMarkBandingSurface(HSURF hsurf)
3849 {
3850         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3851         return 0;
3852 }
3853
3854 /*
3855  * @unimplemented
3856  */
3857 VOID STDCALL
3858 EngMultiByteToUnicodeN(OUT LPWSTR UnicodeString,
3859                        IN ULONG MaxBytesInUnicodeString,
3860                        OUT PULONG BytesInUnicodeString,
3861                        IN PCHAR MultiByteString,
3862                        IN ULONG BytesInMultiByteString)
3863 {
3864         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3865 }
3866
3867 /*
3868  * @unimplemented
3869  */
3870 INT STDCALL
3871 EngMultiByteToWideChar(UINT CodePage,LPWSTR WideCharString,INT BytesInWideCharString,LPSTR MultiByteString,INT BytesInMultiByteString)
3872 {
3873         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3874         return 0;
3875 }
3876
3877 /*
3878  * @unimplemented
3879  */
3880 BOOL STDCALL
3881 EngPaint(IN SURFOBJ *Surface,
3882          IN CLIPOBJ *ClipRegion,
3883          IN BRUSHOBJ *Brush,
3884          IN POINTL *BrushOrigin,
3885          IN MIX  Mix)
3886 {
3887         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3888         return 0;
3889 }
3890
3891 /*
3892  * @unimplemented
3893  */
3894 BOOL STDCALL
3895 EngPlgBlt(SURFOBJ *psoTrg,SURFOBJ *psoSrc,SURFOBJ *psoMsk,CLIPOBJ *pco,XLATEOBJ *pxlo,COLORADJUSTMENT *pca,POINTL *pptlBrushOrg,POINTFIX *pptfx,RECTL *prcl,POINTL *pptl,ULONG iMode)
3896 {
3897         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3898         return 0;
3899 }
3900
3901 /*
3902  * @unimplemented
3903  */
3904 BOOL STDCALL
3905 EngQueryEMFInfo(HDEV hdev,EMFINFO *pEMFInfo)
3906 {
3907         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3908         return 0;
3909 }
3910
3911 /*
3912  * @unimplemented
3913  */
3914 VOID STDCALL
3915 EngQueryLocalTime(PENG_TIME_FIELDS etf)
3916 {
3917         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3918 }
3919
3920 /*
3921  * @unimplemented
3922  */
3923 VOID
3924 STDCALL
3925 EngReleaseSemaphore ( IN HSEMAPHORE hsem )
3926 {
3927         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3928 }
3929
3930 /*
3931  * @unimplemented
3932  */
3933 BOOL STDCALL
3934 EngStretchBlt(SURFOBJ *psoDest,SURFOBJ *psoSrc,SURFOBJ *psoMask,CLIPOBJ *pco,XLATEOBJ *pxlo,COLORADJUSTMENT *pca,POINTL *pptlHTOrg,RECTL *prclDest,RECTL *prclSrc,POINTL *pptlMask,ULONG iMode)
3935 {
3936         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3937         return 0;
3938 }
3939
3940 /*
3941  * @unimplemented
3942  */
3943 BOOL STDCALL
3944 EngStretchBltROP(SURFOBJ *psoDest,SURFOBJ *psoSrc,SURFOBJ *psoMask,CLIPOBJ *pco,XLATEOBJ *pxlo,COLORADJUSTMENT *pca,POINTL *pptlHTOrg,RECTL *prclDest,RECTL *prclSrc,POINTL *pptlMask,ULONG iMode,BRUSHOBJ *pbo,DWORD rop4)
3945 {
3946         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3947         return 0;
3948 }
3949
3950 /*
3951  * @unimplemented
3952  */
3953 BOOL STDCALL
3954 EngStrokeAndFillPath(SURFOBJ *pso,PATHOBJ *ppo,CLIPOBJ *pco,XFORMOBJ *pxo,BRUSHOBJ *pboStroke,LINEATTRS *plineattrs,BRUSHOBJ *pboFill,POINTL *pptlBrushOrg,MIX mixFill,FLONG flOptions)
3955 {
3956         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3957         return 0;
3958 }
3959
3960 /*
3961  * @unimplemented
3962  */
3963 BOOL STDCALL
3964 EngStrokePath(SURFOBJ *pso,PATHOBJ *ppo,CLIPOBJ *pco,XFORMOBJ *pxo,BRUSHOBJ *pbo,POINTL *pptlBrushOrg,LINEATTRS *plineattrs,MIX mix)
3965 {
3966         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3967         return 0;
3968 }
3969
3970 /*
3971  * @unimplemented
3972  */
3973 BOOL STDCALL
3974 EngTextOut(SURFOBJ *pso,STROBJ *pstro,FONTOBJ *pfo,CLIPOBJ *pco,RECTL *prclExtra,RECTL *prclOpaque,BRUSHOBJ *pboFore,BRUSHOBJ *pboOpaque,POINTL *pptlOrg,MIX mix)
3975 {
3976         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3977         return 0;
3978 }
3979
3980 /*
3981  * @unimplemented
3982  */
3983 BOOL STDCALL
3984 EngTransparentBlt(IN PSURFOBJ Dest,
3985                   IN PSURFOBJ Source,
3986                   IN PCLIPOBJ Clip,
3987                   IN PXLATEOBJ ColorTranslation,
3988                   IN PRECTL DestRect,
3989                   IN PRECTL SourceRect,
3990                   IN ULONG TransparentColor,
3991                   IN ULONG Reserved)
3992 {
3993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3994         return 0;
3995 }
3996
3997 /*
3998  * @unimplemented
3999  */
4000 VOID STDCALL
4001 EngUnicodeToMultiByteN(OUT PCHAR MultiByteString,
4002                        IN ULONG  MaxBytesInMultiByteString,
4003                        OUT PULONG  BytesInMultiByteString,
4004                        IN PWSTR  UnicodeString,
4005                        IN ULONG  BytesInUnicodeString)
4006 {
4007         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4008 }
4009
4010 /*
4011  * @unimplemented
4012  */
4013 VOID STDCALL
4014 EngUnlockSurface(SURFOBJ *pso)
4015 {
4016         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4017 }
4018
4019 /*
4020  * @unimplemented
4021  */
4022 INT STDCALL
4023 EngWideCharToMultiByte(UINT CodePage,LPWSTR WideCharString,INT BytesInWideCharString,LPSTR MultiByteString,INT BytesInMultiByteString)
4024 {
4025         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4026         return 0;
4027 }
4028
4029 /*
4030  * @unimplemented
4031  */
4032 ULONG
4033 STDCALL
4034 FONTOBJ_cGetAllGlyphHandles(IN PFONTOBJ  FontObj,
4035                             IN HGLYPH  *Glyphs)
4036 {
4037         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4038         return 0;
4039 }
4040
4041 /*
4042  * @unimplemented
4043  */
4044 ULONG
4045 STDCALL
4046 FONTOBJ_cGetGlyphs(IN PFONTOBJ FontObj,
4047                    IN ULONG    Mode,
4048                    IN ULONG    NumGlyphs,
4049                    IN HGLYPH  *GlyphHandles,
4050                    IN PVOID   *OutGlyphs)
4051 {
4052         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4053         return 0;
4054 }
4055
4056 /*
4057  * @unimplemented
4058  */
4059 PFD_GLYPHATTR STDCALL
4060 FONTOBJ_pQueryGlyphAttrs(FONTOBJ *pfo,ULONG iMode)
4061 {
4062         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4063         return 0;
4064 }
4065
4066 /*
4067  * @unimplemented
4068  */
4069 FD_GLYPHSET *STDCALL
4070 FONTOBJ_pfdg(FONTOBJ *pfo)
4071 {
4072         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4073         return 0;
4074 }
4075
4076 /*
4077  * @unimplemented
4078  */
4079 IFIMETRICS*
4080 STDCALL
4081 FONTOBJ_pifi(IN PFONTOBJ  FontObj)
4082 {
4083         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4084         return 0;
4085 }
4086
4087 /*
4088  * @unimplemented
4089  */
4090 PVOID
4091 STDCALL
4092 FONTOBJ_pvTrueTypeFontFile(IN PFONTOBJ  FontObj,
4093                            IN ULONG    *FileSize)
4094 {
4095         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4096         return 0;
4097 }
4098
4099 /*
4100  * @unimplemented
4101  */
4102 XFORMOBJ*
4103 STDCALL
4104 FONTOBJ_pxoGetXform(IN PFONTOBJ  FontObj)
4105 {
4106         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4107         return 0;
4108 }
4109
4110 /*
4111  * @unimplemented
4112  */
4113 VOID
4114 STDCALL
4115 FONTOBJ_vGetInfo(IN  PFONTOBJ   FontObj,
4116                  IN  ULONG      InfoSize,
4117                  OUT PFONTINFO  FontInfo)
4118 {
4119         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4120 }
4121
4122 /*
4123  * @unimplemented
4124  */
4125 BOOL STDCALL
4126 PATHOBJ_bEnum(PATHOBJ *ppo,PATHDATA *ppd)
4127 {
4128         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4129         return 0;
4130 }
4131
4132 /*
4133  * @unimplemented
4134  */
4135 BOOL STDCALL
4136 PATHOBJ_bEnumClipLines(PATHOBJ *ppo,ULONG cb,CLIPLINE *pcl)
4137 {
4138         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4139         return 0;
4140 }
4141
4142 /*
4143  * @unimplemented
4144  */
4145 VOID STDCALL
4146 PATHOBJ_vEnumStart(PATHOBJ *ppo)
4147 {
4148         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4149 }
4150
4151 /*
4152  * @unimplemented
4153  */
4154 VOID STDCALL
4155 PATHOBJ_vEnumStartClipLines(PATHOBJ *ppo,CLIPOBJ *pco,SURFOBJ *pso,LINEATTRS *pla)
4156 {
4157         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4158 }
4159
4160 /*
4161  * @unimplemented
4162  */
4163 VOID STDCALL
4164 PATHOBJ_vGetBounds(PATHOBJ *ppo,PRECTFX prectfx)
4165 {
4166         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4167 }
4168
4169 /*
4170  * @unimplemented
4171  */
4172 BOOL STDCALL
4173 STROBJ_bEnum(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
4174 {
4175         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4176         return 0;
4177 }
4178
4179 /*
4180  * @unimplemented
4181  */
4182 BOOL STDCALL
4183 STROBJ_bEnumPositionsOnly(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
4184 {
4185         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4186         return 0;
4187 }
4188
4189 /*
4190  * @unimplemented
4191  */
4192 BOOL STDCALL
4193 STROBJ_bGetAdvanceWidths(STROBJ *pso,ULONG iFirst,ULONG c,POINTQF *pptqD)
4194 {
4195         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4196         return 0;
4197 }
4198
4199 /*
4200  * @unimplemented
4201  */
4202 DWORD STDCALL
4203 STROBJ_dwGetCodePage(STROBJ  *pstro)
4204 {
4205         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4206         return 0;
4207 }
4208
4209 /*
4210  * @unimplemented
4211  */
4212 VOID STDCALL
4213 STROBJ_vEnumStart(STROBJ *pstro)
4214 {
4215         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4216 }
4217
4218 /*
4219  * @unimplemented
4220  */
4221 BOOL STDCALL
4222 XFORMOBJ_bApplyXform(XFORMOBJ *pxo,ULONG iMode,ULONG cPoints,PVOID pvIn,PVOID pvOut)
4223 {
4224         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4225         return 0;
4226 }
4227
4228 /*
4229  * @unimplemented
4230  */
4231 ULONG STDCALL
4232 XFORMOBJ_iGetXform(XFORMOBJ *pxo,XFORML *pxform)
4233 {
4234         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4235         return 0;
4236 }
4237
4238 /*
4239  * @unimplemented
4240  */
4241 ULONG STDCALL
4242 XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj,
4243                      ULONG PalOutType,
4244                      ULONG cPal,
4245                      ULONG *OutPal)
4246 {
4247         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4248         return 0;
4249 }
4250
4251 /*
4252  * @unimplemented
4253  */
4254 HANDLE STDCALL
4255 XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo)
4256 {
4257         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4258         return 0;
4259 }
4260
4261 /*
4262  * @unimplemented
4263  */
4264 ULONG STDCALL
4265 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
4266                 ULONG Color)
4267 {
4268         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4269         return 0;
4270 }
4271
4272 /*
4273  * @unimplemented
4274  */
4275 ULONG * STDCALL
4276 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
4277 {
4278         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4279         return 0;
4280 }
4281
4282 /*
4283  * @unimplemented
4284  */
4285 BOOL STDCALL DdCreateDirectDrawObject(
4286 LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
4287 HDC hdc
4288 )
4289 {
4290         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4291         return 0;
4292 }
4293
4294 /*
4295  * @unimplemented
4296  */
4297 BOOL STDCALL DdQueryDirectDrawObject(
4298 LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
4299 LPDDHALINFO pHalInfo,
4300 LPDDHAL_DDCALLBACKS pDDCallbacks,
4301 LPDDHAL_DDSURFACECALLBACKS pDDSurfaceCallbacks,
4302 LPDDHAL_DDPALETTECALLBACKS pDDPaletteCallbacks,
4303 LPD3DHAL_CALLBACKS pD3dCallbacks,
4304 LPD3DHAL_GLOBALDRIVERDATA pD3dDriverData,
4305 LPDDHAL_DDEXEBUFCALLBACKS pD3dBufferCallbacks,
4306 LPDDSURFACEDESC pD3dTextureFormats,
4307 LPDWORD pdwFourCC,
4308 LPVIDMEM pvmList
4309 )
4310 {
4311         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4312         return 0;
4313 }
4314
4315 /*
4316  * @unimplemented
4317  */
4318 BOOL STDCALL DdDeleteDirectDrawObject(
4319 LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal
4320 )
4321 {
4322         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4323         return 0;
4324 }
4325
4326 /*
4327  * @unimplemented
4328  */
4329 BOOL STDCALL DdCreateSurfaceObject(
4330 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
4331 BOOL bPrimarySurface
4332 )
4333 {
4334         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4335         return 0;
4336 }
4337
4338 /*
4339  * @unimplemented
4340  */
4341 BOOL STDCALL DdDeleteSurfaceObject(
4342 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
4343 )
4344 {
4345         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4346         return 0;
4347 }
4348
4349 /*
4350  * @unimplemented
4351  */
4352 BOOL STDCALL DdResetVisrgn(
4353 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
4354 HWND hWnd
4355 )
4356 {
4357         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4358         return 0;
4359 }
4360
4361 /*
4362  * @unimplemented
4363  */
4364 BOOL STDCALL DdGetDC(
4365 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal,
4366 LPPALETTEENTRY pColorTable
4367 )
4368 {
4369         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4370         return 0;
4371 }
4372
4373 /*
4374  * @unimplemented
4375  */
4376 BOOL STDCALL DdReleaseDC(
4377 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceLocal
4378 )
4379 {
4380         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4381         return 0;
4382 }
4383
4384 /*
4385  * @unimplemented
4386  */
4387 HBITMAP STDCALL DdCreateDIBSection(
4388 HDC hdc,
4389 CONST BITMAPINFO *pbmi,
4390 UINT iUsage,
4391 VOID **ppvBits,
4392 HANDLE hSectionApp,
4393 DWORD dwOffset
4394 )
4395 {
4396         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4397         return 0;
4398 }
4399
4400 /*
4401  * @unimplemented
4402  */
4403 BOOL STDCALL DdReenableDirectDrawObject(
4404 LPDDRAWI_DIRECTDRAW_GBL pDirectDrawGlobal,
4405 BOOL *pbNewMode
4406 )
4407 {
4408         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4409         return 0;
4410 }
4411
4412 /*
4413  * @unimplemented
4414  */
4415 BOOL STDCALL DdAttachSurface(
4416 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceFrom,
4417 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceTo
4418 )
4419 {
4420         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4421         return 0;
4422 }
4423
4424 /*
4425  * @unimplemented
4426  */
4427 VOID STDCALL DdUnattachSurface(
4428 LPDDRAWI_DDRAWSURFACE_LCL pSurface,
4429 LPDDRAWI_DDRAWSURFACE_LCL pSurfaceAttached
4430 )
4431 {
4432         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4433 }
4434
4435 /*
4436  * @unimplemented
4437  */
4438 ULONG STDCALL DdQueryDisplaySettingsUniqueness(VOID)
4439 {
4440         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4441         return 0;
4442 }
4443
4444 /*
4445  * @unimplemented
4446  */
4447 HANDLE STDCALL DdGetDxHandle(
4448 LPDDRAWI_DIRECTDRAW_LCL pDDraw,
4449 LPDDRAWI_DDRAWSURFACE_LCL pSurface,
4450 BOOL bRelease
4451 )
4452 {
4453         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4454         return 0;
4455 }
4456
4457 /*
4458  * @unimplemented
4459  */
4460 BOOL STDCALL DdSetGammaRamp(
4461 LPDDRAWI_DIRECTDRAW_LCL pDDraw,
4462 HDC hdc,
4463 LPVOID lpGammaRamp
4464 )
4465 {
4466         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4467         return 0;
4468 }
4469
4470 /*
4471  * @unimplemented
4472  */
4473 DWORD STDCALL DdSwapTextureHandles(
4474 LPDDRAWI_DIRECTDRAW_LCL pDDraw,
4475 LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl1,
4476 LPDDRAWI_DDRAWSURFACE_LCL pDDSLcl2
4477 )
4478 {
4479         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4480         return 0;
4481 }
4482
4483 /*
4484  * @unimplemented
4485  */
4486 DWORD STDCALL DxgGenericThunk(ULONG_PTR ulIndex,
4487 ULONG_PTR ulHandle,
4488 SIZE_T *pdwSizeOfPtr1,
4489 PVOID pvPtr1,
4490 SIZE_T *pdwSizeOfPtr2,
4491 PVOID pvPtr2)
4492 {
4493         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4494         return 0;
4495 }
4496
4497 /*
4498  * @unimplemented
4499  */
4500 BOOL STDCALL D3DContextCreate(
4501 HANDLE hDirectDrawLocal,
4502 HANDLE hSurfColor,
4503 HANDLE hSurfZ,
4504 D3DNTHAL_CONTEXTCREATEI *pdcci
4505 )
4506 {
4507         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4508         return 0;
4509 }
4510
4511 /*
4512  * @unimplemented
4513  */
4514 DWORD STDCALL D3DContextDestroy(
4515 LPD3DNTHAL_CONTEXTDESTROYDATA pContextDestroyData
4516 )
4517 {
4518         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4519         return 0;
4520 }
4521
4522 /*
4523  * @unimplemented
4524  */
4525 DWORD STDCALL D3DContextDestroyAll(VOID)
4526 {
4527         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4528         return 0;
4529 }
4530
4531 /*
4532  * @unimplemented
4533  */
4534 DWORD STDCALL D3DValidateTextureStageState(
4535 LPD3DNTHAL_VALIDATETEXTURESTAGESTATEDATA pData
4536 )
4537 {
4538         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4539         return 0;
4540 }
4541
4542 /*
4543  * @unimplemented
4544  */
4545 DWORD STDCALL D3DDrawPrimitives2(
4546 HANDLE hCmdBuf,
4547 HANDLE hVBuf,
4548 LPD3DNTHAL_DRAWPRIMITIVES2DATA pded,
4549 FLATPTR *pfpVidMemCmd,
4550 DWORD *pdwSizeCmd,
4551 FLATPTR *pfpVidMemVtx,
4552 DWORD *pdwSizeVtx
4553 )
4554 {
4555         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4556         return 0;
4557 }
4558
4559 /*
4560  * @unimplemented
4561  */
4562 DWORD STDCALL D3DGetDriverState(
4563 PDD_GETDRIVERSTATEDATA pdata
4564 )
4565 {
4566         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4567         return 0;
4568 }
4569
4570 /*
4571  * @unimplemented
4572  */
4573 DWORD STDCALL DdAddAttachedSurface(
4574 HANDLE hSurface,
4575 HANDLE hSurfaceAttached,
4576 PDD_ADDATTACHEDSURFACEDATA puAddAttachedSurfaceData
4577 )
4578 {
4579         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4580         return 0;
4581 }
4582
4583 /*
4584  * @unimplemented
4585  */
4586 DWORD STDCALL DdAlphaBlt(
4587 HANDLE hSurfaceDest,
4588 HANDLE hSurfaceSrc,
4589 PDD_BLTDATA puBltData)
4590 {
4591         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4592         return 0;
4593 }
4594
4595 /*
4596  * @unimplemented
4597  */
4598 BOOL STDCALL DdDdAttachSurface( /*rename it so it doesnt conflict */
4599 HANDLE hSurfaceFrom,
4600 HANDLE hSurfaceTo
4601 )
4602 {
4603         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4604         return 0;
4605 }
4606
4607 /*
4608  * @unimplemented
4609  */
4610 DWORD STDCALL DdBeginMoCompFrame(
4611 HANDLE hMoComp,
4612 PDD_BEGINMOCOMPFRAMEDATA puBeginFrameData
4613 )
4614 {
4615         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4616         return 0;
4617 }
4618
4619 /*
4620  * @unimplemented
4621  */
4622 DWORD STDCALL DdBlt(
4623 HANDLE hSurfaceDest,
4624 HANDLE hSurfaceSrc,
4625 PDD_BLTDATA puBltData
4626 )
4627 {
4628         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4629         return 0;
4630 }
4631
4632 /*
4633  * @unimplemented
4634  */
4635 DWORD STDCALL DdCanCreateSurface(
4636 HANDLE hDirectDraw,
4637 PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
4638 )
4639 {
4640         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4641         return 0;
4642 }
4643
4644 /*
4645  * @unimplemented
4646  */
4647 DWORD STDCALL DdCanCreateD3DBuffer(
4648 HANDLE hDirectDraw,
4649 PDD_CANCREATESURFACEDATA puCanCreateSurfaceData
4650 )
4651 {
4652         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4653         return 0;
4654 }
4655
4656 /*
4657  * @unimplemented
4658  */
4659 DWORD STDCALL DdColorControl(
4660 HANDLE hSurface,
4661 PDD_COLORCONTROLDATA puColorControlData
4662 )
4663 {
4664         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4665         return 0;
4666 }
4667
4668 /*
4669  * @unimplemented
4670  */
4671 HANDLE STDCALL DdDdCreateDirectDrawObject( /*rename it so it doesnt conflict */
4672 HDC hdc
4673 )
4674 {
4675         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4676         return 0;
4677 }
4678
4679 /*
4680  * @unimplemented
4681  */
4682 DWORD STDCALL DdCreateSurface(
4683 HANDLE hDirectDraw,
4684 HANDLE *hSurface,
4685 DDSURFACEDESC *puSurfaceDescription,
4686 DD_SURFACE_GLOBAL *puSurfaceGlobalData,
4687 DD_SURFACE_LOCAL *puSurfaceLocalData,
4688 DD_SURFACE_MORE *puSurfaceMoreData,
4689 DD_CREATESURFACEDATA *puCreateSurfaceData,
4690 HANDLE *puhSurface
4691 )
4692 {
4693         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4694         return 0;
4695 }
4696
4697 /*
4698  * @unimplemented
4699  */
4700 DWORD STDCALL DdCreateD3DBuffer(
4701 HANDLE hDirectDraw,
4702 HANDLE *hSurface,
4703 DDSURFACEDESC *puSurfaceDescription,
4704 DD_SURFACE_GLOBAL *puSurfaceGlobalData,
4705 DD_SURFACE_LOCAL *puSurfaceLocalData,
4706 DD_SURFACE_MORE *puSurfaceMoreData,
4707 DD_CREATESURFACEDATA *puCreateSurfaceData,
4708 HANDLE *puhSurface
4709 )
4710 {
4711         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4712         return 0;
4713 }
4714
4715 /*
4716  * @unimplemented
4717  */
4718 HANDLE STDCALL DdCreateMoComp(
4719 HANDLE hDirectDraw,
4720 PDD_CREATEMOCOMPDATA puCreateMoCompData
4721 )
4722 {
4723         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4724         return 0;
4725 }
4726
4727 /*
4728  * @unimplemented
4729  */
4730 HANDLE STDCALL DdDdCreateSurfaceObject( /*rename it so it doesnt conflict */
4731 HANDLE hDirectDrawLocal,
4732 HANDLE hSurface,
4733 PDD_SURFACE_LOCAL puSurfaceLocal,
4734 PDD_SURFACE_MORE puSurfaceMore,
4735 PDD_SURFACE_GLOBAL puSurfaceGlobal,
4736 BOOL bComplete
4737 )
4738 {
4739         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4740         return 0;
4741 }
4742
4743 /*
4744  * @unimplemented
4745  */
4746 BOOL STDCALL DdDdDeleteDirectDrawObject( /*rename it so it doesnt conflict */
4747 HANDLE hDirectDrawLocal
4748 )
4749 {
4750         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4751         return 0;
4752 }
4753
4754 /*
4755  * @unimplemented
4756  */
4757 BOOL STDCALL DdDdDeleteSurfaceObject( /*rename it so it doesnt conflict */
4758 HANDLE hSurface
4759 )
4760 {
4761         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4762         return 0;
4763 }
4764
4765 /*
4766  * @unimplemented
4767  */
4768 DWORD STDCALL DdDestroyMoComp(
4769 HANDLE hMoComp,
4770 PDD_DESTROYMOCOMPDATA puBeginFrameData
4771 )
4772 {
4773         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4774         return 0;
4775 }
4776
4777 /*
4778  * @unimplemented
4779  */
4780 DWORD STDCALL DdDestroySurface(
4781 HANDLE hSurface,
4782 BOOL bRealDestroy
4783 )
4784 {
4785         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4786         return 0;
4787 }
4788
4789 /*
4790  * @unimplemented
4791  */
4792 DWORD STDCALL DdDestroyD3DBuffer(
4793 HANDLE hSurface
4794 )
4795 {
4796         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4797         return 0;
4798 }
4799
4800 /*
4801  * @unimplemented
4802  */
4803 DWORD STDCALL DdEndMoCompFrame(
4804 HANDLE hMoComp,
4805 PDD_ENDMOCOMPFRAMEDATA puEndFrameData
4806 )
4807 {
4808         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4809         return 0;
4810 }
4811
4812 /*
4813  * @unimplemented
4814  */
4815 DWORD STDCALL DdFlip(
4816 HANDLE hSurfaceCurrent,
4817 HANDLE hSurfaceTarget,
4818 HANDLE hSurfaceCurrentLeft,
4819 HANDLE hSurfaceTargetLeft,
4820 PDD_FLIPDATA puFlipData
4821 )
4822 {
4823         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4824         return 0;
4825 }
4826
4827 /*
4828  * @unimplemented
4829  */
4830 DWORD STDCALL DdFlipToGDISurface(
4831 HANDLE hDirectDraw,
4832 PDD_FLIPTOGDISURFACEDATA puFlipToGDISurfaceData
4833 )
4834 {
4835         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4836         return 0;
4837 }
4838
4839 /*
4840  * @unimplemented
4841  */
4842 DWORD STDCALL DdGetAvailDriverMemory(
4843 HANDLE hDirectDraw,
4844 PDD_GETAVAILDRIVERMEMORYDATA puGetAvailDriverMemoryData
4845 )
4846 {
4847         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4848         return 0;
4849 }
4850
4851 /*
4852  * @unimplemented
4853  */
4854 DWORD STDCALL DdGetBltStatus(
4855 HANDLE hSurface,
4856 PDD_GETBLTSTATUSDATA puGetBltStatusData
4857 )
4858 {
4859         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4860         return 0;
4861 }
4862
4863 /*
4864  * @unimplemented
4865  */
4866 HDC STDCALL DdDdGetDC( /*rename it so it doesnt conflict */
4867 HANDLE hSurface,
4868 PALETTEENTRY *puColorTable
4869 )
4870 {
4871         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4872         return 0;
4873 }
4874
4875 /*
4876  * @unimplemented
4877  */
4878 DWORD STDCALL DdGetDriverInfo(
4879 HANDLE hDirectDraw,
4880 PDD_GETDRIVERINFODATA puGetDriverInfoData
4881 )
4882 {
4883         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4884         return 0;
4885 }
4886
4887 /*
4888  * @unimplemented
4889  */
4890 DWORD STDCALL DdDdGetDxHandle( /*rename it so it doesnt conflict */
4891 HANDLE hDirectDraw,
4892 HANDLE hSurface,
4893 BOOL bRelease
4894 )
4895 {
4896         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4897         return 0;
4898 }
4899
4900 /*
4901  * @unimplemented
4902  */
4903 DWORD STDCALL DdGetFlipStatus(
4904 HANDLE hSurface,
4905 PDD_GETFLIPSTATUSDATA puGetFlipStatusData
4906 )
4907 {
4908         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4909         return 0;
4910 }
4911
4912 /*
4913  * @unimplemented
4914  */
4915 DWORD STDCALL DdGetInternalMoCompInfo(
4916 HANDLE hDirectDraw,
4917 PDD_GETINTERNALMOCOMPDATA puGetInternalData
4918 )
4919 {
4920         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4921         return 0;
4922 }
4923
4924 /*
4925  * @unimplemented
4926  */
4927 DWORD STDCALL DdGetMoCompBuffInfo(
4928 HANDLE hDirectDraw,
4929 PDD_GETMOCOMPCOMPBUFFDATA puGetBuffData
4930 )
4931 {
4932         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4933         return 0;
4934 }
4935
4936 /*
4937  * @unimplemented
4938  */
4939 DWORD STDCALL DdGetMoCompGuids(
4940 HANDLE hDirectDraw,
4941 PDD_GETMOCOMPGUIDSDATA puGetMoCompGuidsData
4942 )
4943 {
4944         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4945         return 0;
4946 }
4947
4948 /*
4949  * @unimplemented
4950  */
4951 DWORD STDCALL DdGetMoCompFormats(
4952 HANDLE hDirectDraw,
4953 PDD_GETMOCOMPFORMATSDATA puGetMoCompFormatsData
4954 )
4955 {
4956         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4957         return 0;
4958 }
4959
4960 /*
4961  * @unimplemented
4962  */
4963 DWORD STDCALL DdGetScanLine(
4964 HANDLE hDirectDraw,
4965 PDD_GETSCANLINEDATA puGetScanLineData
4966 )
4967 {
4968         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4969         return 0;
4970 }
4971
4972 /*
4973  * @unimplemented
4974  */
4975 DWORD STDCALL DdLock(
4976 HANDLE hSurface,
4977 PDD_LOCKDATA puLockData,
4978 HDC hdcClip
4979 )
4980 {
4981         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4982         return 0;
4983 }
4984
4985 /*
4986  * @unimplemented
4987  */
4988 DWORD STDCALL DdLockD3D(
4989 HANDLE hSurface,
4990 PDD_LOCKDATA puLockData
4991 )
4992 {
4993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
4994         return 0;
4995 }
4996
4997 /*
4998  * @unimplemented
4999  */
5000 BOOL STDCALL DdDdQueryDirectDrawObject(  /*rename it so it doesnt conflict */
5001 HANDLE hDirectDrawLocal,
5002 DD_HALINFO *pHalInfo,
5003 DWORD *pCallBackFlags,
5004 LPD3DNTHAL_CALLBACKS puD3dCallbacks,
5005 LPD3DNTHAL_GLOBALDRIVERDATA puD3dDriverData,
5006 PDD_D3DBUFCALLBACKS puD3dBufferCallbacks,
5007 LPDDSURFACEDESC puD3dTextureFormats,
5008 DWORD *puNumHeaps,
5009 VIDEOMEMORY *puvmList,
5010 DWORD *puNumFourCC,
5011 DWORD *puFourCC
5012 )
5013 {
5014         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5015         return 0;
5016 }
5017
5018 /*
5019  * @unimplemented
5020  */
5021 DWORD STDCALL DdQueryMoCompStatus(
5022 HANDLE hMoComp,
5023 PDD_QUERYMOCOMPSTATUSDATA puQueryMoCompStatusData
5024 )
5025 {
5026         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5027         return 0;
5028 }
5029
5030 /*
5031  * @unimplemented
5032  */
5033 BOOL STDCALL DdDdReenableDirectDrawObject( /*rename it so it doesnt conflict */
5034 HANDLE hDirectDrawLocal,
5035 BOOL *pubNewMode
5036 )
5037 {
5038         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5039         return 0;
5040 }
5041
5042 /*
5043  * @unimplemented
5044  */
5045 BOOL STDCALL DdDdReleaseDC( /*rename it so it doesnt conflict */
5046 HANDLE hSurface
5047 )
5048 {
5049         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5050         return 0;
5051 }
5052
5053 /*
5054  * @unimplemented
5055  */
5056 DWORD STDCALL DdRenderMoComp(
5057 HANDLE hMoComp,
5058 PDD_RENDERMOCOMPDATA puRenderMoCompData
5059 )
5060 {
5061         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5062         return 0;
5063 }
5064
5065 /*
5066  * @unimplemented
5067  */
5068 BOOL STDCALL DdDdResetVisrgn( /*rename it so it doesnt conflict */
5069 HANDLE hSurface,
5070 HWND hwnd
5071 )
5072 {
5073         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5074         return 0;
5075 }
5076
5077 /*
5078  * @unimplemented
5079  */
5080 DWORD STDCALL DdSetColorKey(
5081 HANDLE hSurface,
5082 PDD_SETCOLORKEYDATA puSetColorKeyData
5083 )
5084 {
5085         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5086         return 0;
5087 }
5088
5089 /*
5090  * @unimplemented
5091  */
5092 DWORD STDCALL DdSetExclusiveMode(
5093 HANDLE hDirectDraw,
5094 PDD_SETEXCLUSIVEMODEDATA puSetExclusiveModeData
5095 )
5096 {
5097         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5098         return 0;
5099 }
5100
5101 /*
5102  * @unimplemented
5103  */
5104 BOOL STDCALL DdDdSetGammaRamp( /*rename it so it doesnt conflict */
5105 HANDLE hDirectDraw,
5106 HDC hdc,
5107 LPVOID lpGammaRamp
5108 )
5109 {
5110         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5111         return 0;
5112 }
5113
5114 /*
5115  * @unimplemented
5116  */
5117 DWORD STDCALL DdCreateSurfaceEx(
5118 HANDLE hDirectDraw,
5119 HANDLE hSurface,
5120 DWORD dwSurfaceHandle
5121 )
5122 {
5123         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5124         return 0;
5125 }
5126
5127 /*
5128  * @unimplemented
5129  */
5130 DWORD STDCALL DdSetOverlayPosition(
5131 HANDLE hSurfaceSource,
5132 HANDLE hSurfaceDestination,
5133 PDD_SETOVERLAYPOSITIONDATA puSetOverlayPositionData
5134 )
5135 {
5136         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5137         return 0;
5138 }
5139
5140 /*
5141  * @unimplemented
5142  */
5143 VOID STDCALL DdDdUnattachSurface( /*rename it so it doesnt conflict */
5144 HANDLE hSurface,
5145 HANDLE hSurfaceAttached
5146 )
5147 {
5148         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5149 }
5150
5151 /*
5152  * @unimplemented
5153  */
5154 DWORD STDCALL DdUnlock(
5155 HANDLE hSurface,
5156 PDD_UNLOCKDATA puUnlockData
5157 )
5158 {
5159         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5160         return 0;
5161 }
5162
5163 /*
5164  * @unimplemented
5165  */
5166 DWORD STDCALL DdUnlockD3D(
5167 HANDLE hSurface,
5168 PDD_UNLOCKDATA puUnlockData
5169 )
5170 {
5171         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5172         return 0;
5173 }
5174
5175 /*
5176  * @unimplemented
5177  */
5178 DWORD STDCALL DdUpdateOverlay(
5179 HANDLE hSurfaceDestination,
5180 HANDLE hSurfaceSource,
5181 PDD_UPDATEOVERLAYDATA puUpdateOverlayData
5182 )
5183 {
5184         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5185         return 0;
5186 }
5187
5188 /*
5189  * @unimplemented
5190  */
5191 DWORD STDCALL DdWaitForVerticalBlank(
5192 HANDLE hDirectDraw,
5193 PDD_WAITFORVERTICALBLANKDATA puWaitForVerticalBlankData
5194 )
5195 {
5196         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5197         return 0;
5198 }
5199
5200 /*
5201  * @unimplemented
5202  */
5203 WINBOOL
5204 STDCALL
5205 GdiPlayEMF
5206 (
5207         LPWSTR     pwszPrinterName,
5208         LPDEVMODEW pDevmode,
5209         LPWSTR     pwszDocName,
5210         EMFPLAYPROC pfnEMFPlayFn,
5211         HANDLE     hPageQuery
5212 )
5213 {
5214         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5215         return 0;
5216 }
5217
5218 /*
5219  * @unimplemented
5220  */
5221 WINBOOL
5222 STDCALL
5223 GdiInitSpool(VOID)
5224 {
5225         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5226         return 0;
5227 }
5228
5229 /*
5230  * @unimplemented
5231  */
5232 WINBOOL
5233 STDCALL
5234 GdiPlayPrivatePageEMF
5235 (
5236         HANDLE  SpoolFileHandle,
5237         DWORD   unknown,
5238         RECT    *prectDocument
5239 )
5240 {
5241         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5242         return 0;
5243 }
5244
5245 /*
5246  * @unimplemented
5247  */
5248 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
5249 {
5250         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
5251 }