reactos/dll/win32/gdi32/misc/stubs.c

   1 /* $Id$
   2  *
   3  * reactos/lib/gdi32/misc/stubs.c
   4  *
   5  * GDI32.DLL Stubs
   6  *
   7  * When you implement one of these functions,
   8  * remove its stub from this file.
   9  *
  10  */
  11
  12 #include "precomp.h"
  13
  14 #define SIZEOF_DEVMODEA_300 124
  15 #define SIZEOF_DEVMODEA_400 148
  16 #define SIZEOF_DEVMODEA_500 156
  17 #define SIZEOF_DEVMODEW_300 188
  18 #define SIZEOF_DEVMODEW_400 212
  19 #define SIZEOF_DEVMODEW_500 220
  20
  21 #define UNIMPLEMENTED DbgPrint("GDI32: %s is unimplemented, please try again later.\n", __FUNCTION__);
  22
  23 /*
  24  * @unimplemented
  25  */
  26 BOOL
  27 STDCALL
  28 CancelDC(
  29         HDC     a0
  30         )
  31 {
  32         UNIMPLEMENTED;
  33         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  34         return FALSE;
  35 }
  36
  37
  38 /*
  39  * @unimplemented
  40  */
  41 int
  42 STDCALL
  43 DrawEscape(
  44         HDC             a0,
  45         int             a1,
  46         int             a2,
  47         LPCSTR          a3
  48         )
  49 {
  50         UNIMPLEMENTED;
  51         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  52         return 0;
  53 }
  54
  55
  56 /*
  57  * @unimplemented
  58  */
  59 int
  60 STDCALL
  61 EnumObjects(
  62         HDC             a0,
  63         int             a1,
  64         GOBJENUMPROC    a2,
  65         LPARAM          a3
  66         )
  67 {
  68         UNIMPLEMENTED;
  69         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  70         return 0;
  71 }
  72
  73 /*
  74  * @unimplemented
  75  */
  76 int
  77 STDCALL
  78 Escape(HDC hdc, INT escape, INT in_count, LPCSTR in_data, LPVOID out_data)
  79 {
  80         UNIMPLEMENTED;
  81         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  82         return 0;
  83 }
  84
  85 /*
  86  * @unimplemented
  87  */
  88 HRGN
  89 STDCALL
  90 ExtCreateRegion(
  91         CONST XFORM *   a0,
  92         DWORD           a1,
  93         CONST RGNDATA * a2
  94         )
  95 {
  96         UNIMPLEMENTED;
  97         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
  98         return 0;
  99 }
 100
 101
 102 /*
 103  * @unimplemented
 104  */
 105 UINT
 106 STDCALL
 107 GetBoundsRect(
 108         HDC     a0,
 109         LPRECT  a1,
 110         UINT    a2
 111         )
 112 {
 113         UNIMPLEMENTED;
 114         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 115         return 0;
 116 }
 117
 118
 119 /*
 120  * @unimplemented
 121  */
 122 int
 123 STDCALL
 124 GetMetaRgn(
 125         HDC     a0,
 126         HRGN    a1
 127         )
 128 {
 129         UNIMPLEMENTED;
 130         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 131         return 0;
 132 }
 133
 134
 135 /*
 136  * @unimplemented
 137  */
 138 UINT
 139 STDCALL
 140 GetMetaFileBitsEx(
 141         HMETAFILE       a0,
 142         UINT            a1,
 143         LPVOID          a2
 144         )
 145 {
 146         UNIMPLEMENTED;
 147         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 148         return 0;
 149 }
 150
 151
 152 /*
 153  * @unimplemented
 154  */
 155 BOOL
 156 STDCALL
 157 GetRasterizerCaps(
 158         LPRASTERIZER_STATUS     a0,
 159         UINT                    a1
 160         )
 161 {
 162         UNIMPLEMENTED;
 163         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 164         return FALSE;
 165 }
 166
 167 /*
 168  * @unimplemented
 169  */
 170 UINT
 171 STDCALL
 172 GetSystemPaletteUse(HDC hDc)
 173 {
 174     return NtGdiGetSystemPaletteUse(hDc);
 175 }
 176
 177
 178 /*
 179  * @unimplemented
 180  */
 181 DWORD
 182 STDCALL
 183 GetFontLanguageInfo(
 184         HDC     hDc
 185         )
 186 {
 187         UNIMPLEMENTED;
 188         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 189         return 0;
 190 }
 191
 192
 193 /*
 194  * @unimplemented
 195  */
 196 BOOL
 197 STDCALL
 198 PlayMetaFile(
 199         HDC             a0,
 200         HMETAFILE       a1
 201         )
 202 {
 203         UNIMPLEMENTED;
 204         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 205         return FALSE;
 206 }
 207
 208
 209 /*
 210  * @unimplemented
 211  */
 212 BOOL
 213 STDCALL
 214 ResizePalette(
 215         HPALETTE        a0,
 216         UINT            a1
 217         )
 218 {
 219         UNIMPLEMENTED;
 220         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 221         return FALSE;
 222 }
 223
 224
 225 /*
 226  * @unimplemented
 227  */
 228 int
 229 STDCALL
 230 SetMetaRgn(
 231         HDC     hdc
 232         )
 233 {
 234         UNIMPLEMENTED;
 235         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 236         return 0;
 237 }
 238
 239
 240 /*
 241  * @unimplemented
 242  */
 243 UINT
 244 STDCALL
 245 SetBoundsRect(
 246         HDC             a0,
 247         CONST RECT      *a1,
 248         UINT            a2
 249         )
 250 {
 251         UNIMPLEMENTED;
 252         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 253         return 0;
 254 }
 255
 256
 257 /*
 258  * @unimplemented
 259  */
 260 DWORD
 261 STDCALL
 262 SetMapperFlags(
 263         HDC     a0,
 264         DWORD   a1
 265         )
 266 {
 267         UNIMPLEMENTED;
 268         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 269         return 0;
 270 }
 271
 272
 273 /*
 274  * @unimplemented
 275  */
 276 HMETAFILE
 277 STDCALL
 278 SetMetaFileBitsEx(
 279         UINT            a0,
 280         CONST BYTE      *a1
 281         )
 282 {
 283         UNIMPLEMENTED;
 284         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 285         return 0;
 286 }
 287
 288
 289 /*
 290  * @unimplemented
 291  */
 292 UINT
 293 STDCALL
 294 SetSystemPaletteUse(
 295         HDC     a0,
 296         UINT    a1
 297         )
 298 {
 299         UNIMPLEMENTED;
 300         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 301         return 0;
 302 }
 303
 304
 305 /*
 306  * @unimplemented
 307  */
 308 BOOL
 309 STDCALL
 310 SetTextJustification(
 311         HDC     a0,
 312         int     a1,
 313         int     a2
 314         )
 315 {
 316         UNIMPLEMENTED;
 317         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 318         return FALSE;
 319 }
 320
 321
 322 /*
 323  * @unimplemented
 324  */
 325 BOOL
 326 STDCALL
 327 UpdateColors(
 328         HDC     hdc
 329         )
 330 {
 331         UNIMPLEMENTED;
 332         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 333         return FALSE;
 334 }
 335
 336
 337 /*
 338  * @unimplemented
 339  */
 340 BOOL
 341 STDCALL
 342 PlayMetaFileRecord(
 343         HDC             a0,
 344         LPHANDLETABLE   a1,
 345         LPMETARECORD    a2,
 346         UINT            a3
 347         )
 348 {
 349         UNIMPLEMENTED;
 350         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 351         return FALSE;
 352 }
 353
 354
 355 /*
 356  * @unimplemented
 357  */
 358 BOOL
 359 STDCALL
 360 EnumMetaFile(
 361         HDC                     a0,
 362         HMETAFILE               a1,
 363         MFENUMPROC              a2,
 364         LPARAM                  a3
 365         )
 366 {
 367         UNIMPLEMENTED;
 368         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 369         return FALSE;
 370 }
 371
 372
 373
 374
 375
 376 /*
 377  * @unimplemented
 378  */
 379 BOOL
 380 STDCALL
 381 DeleteEnhMetaFile(
 382         HENHMETAFILE    a0
 383         )
 384 {
 385         UNIMPLEMENTED;
 386         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 387         return FALSE;
 388 }
 389
 390
 391 /*
 392  * @unimplemented
 393  */
 394 BOOL
 395 STDCALL
 396 EnumEnhMetaFile(
 397         HDC             a0,
 398         HENHMETAFILE    a1,
 399         ENHMFENUMPROC   a2,
 400         LPVOID          a3,
 401         CONST RECT      *a4
 402         )
 403 {
 404         UNIMPLEMENTED;
 405         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 406         return FALSE;
 407 }
 408
 409
 410 /*
 411  * @unimplemented
 412  */
 413 UINT
 414 STDCALL
 415 GetEnhMetaFileBits(
 416         HENHMETAFILE    a0,
 417         UINT            a1,
 418         LPBYTE          a2
 419         )
 420 {
 421         UNIMPLEMENTED;
 422         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 423         return 0;
 424 }
 425
 426
 427 /*
 428  * @unimplemented
 429  */
 430 UINT
 431 STDCALL
 432 GetEnhMetaFileHeader(
 433         HENHMETAFILE    a0,
 434         UINT            a1,
 435         LPENHMETAHEADER a2
 436         )
 437 {
 438         UNIMPLEMENTED;
 439         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 440         return 0;
 441 }
 442
 443
 444 /*
 445  * @unimplemented
 446  */
 447 UINT
 448 STDCALL
 449 GetEnhMetaFilePaletteEntries(
 450         HENHMETAFILE    a0,
 451         UINT            a1,
 452         LPPALETTEENTRY  a2
 453         )
 454 {
 455         UNIMPLEMENTED;
 456         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 457         return 0;
 458 }
 459
 460
 461 /*
 462  * @unimplemented
 463  */
 464 UINT
 465 STDCALL
 466 GetWinMetaFileBits(
 467         HENHMETAFILE    a0,
 468         UINT            a1,
 469         LPBYTE          a2,
 470         INT             a3,
 471         HDC             a4
 472         )
 473 {
 474         UNIMPLEMENTED;
 475         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 476         return 0;
 477 }
 478
 479
 480 /*
 481  * @unimplemented
 482  */
 483 BOOL
 484 STDCALL
 485 PlayEnhMetaFile(
 486         HDC             a0,
 487         HENHMETAFILE    a1,
 488         CONST RECT      *a2
 489         )
 490 {
 491         UNIMPLEMENTED;
 492         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 493         return FALSE;
 494 }
 495
 496
 497 /*
 498  * @unimplemented
 499  */
 500 BOOL
 501 STDCALL
 502 PlayEnhMetaFileRecord(
 503         HDC                     a0,
 504         LPHANDLETABLE           a1,
 505         CONST ENHMETARECORD     *a2,
 506         UINT                    a3
 507         )
 508 {
 509         UNIMPLEMENTED;
 510         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 511         return FALSE;
 512 }
 513
 514
 515 /*
 516  * @unimplemented
 517  */
 518 HENHMETAFILE
 519 STDCALL
 520 SetEnhMetaFileBits(
 521         UINT            a0,
 522         CONST BYTE      *a1
 523         )
 524 {
 525         UNIMPLEMENTED;
 526         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 527         return 0;
 528 }
 529
 530
 531 /*
 532  * @unimplemented
 533  */
 534 HENHMETAFILE
 535 STDCALL
 536 SetWinMetaFileBits(
 537         UINT                    a0,
 538         CONST BYTE              *a1,
 539         HDC                     a2,
 540         CONST METAFILEPICT      *a3)
 541 {
 542         UNIMPLEMENTED;
 543         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 544         return 0;
 545 }
 546
 547
 548 /*
 549  * @unimplemented
 550  */
 551 BOOL
 552 STDCALL
 553 GdiComment(
 554         HDC             hDC,
 555         UINT            bytes,
 556         CONST BYTE      *buffer
 557         )
 558 {
 559 #if 0
 560   if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF)
 561   {
 562      PLDC pLDC = GdiGetLDC(hDC);
 563      if ( !pLDC )
 564      {
 565         SetLastError(ERROR_INVALID_HANDLE);
 566         return FALSE;
 567      }
 568      if (pLDC->iType == LDC_EMFLDC)
 569      {          // Wine port
 570          return EMFDRV_GdiComment( hDC, bytes, buffer );
 571      }
 572   }
 573 #endif
 574   return FALSE;
 575 }
 576
 577
 578 /*
 579  * @unimplemented
 580  */
 581 BOOL
 582 STDCALL
 583 AngleArc(
 584         HDC     hdc,
 585         int     a1,
 586         int     a2,
 587         DWORD   a3,
 588         FLOAT   a4,
 589         FLOAT   a5
 590         )
 591 {
 592         UNIMPLEMENTED;
 593         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 594         return FALSE;
 595 }
 596
 597
 598 /*
 599  * @unimplemented
 600  */
 601 BOOL
 602 STDCALL
 603 SetColorAdjustment(
 604         HDC                     hdc,
 605         CONST COLORADJUSTMENT   *a1
 606         )
 607 {
 608         UNIMPLEMENTED;
 609         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 610         return FALSE;
 611 }
 612
 613
 614 /*
 615  * @unimplemented
 616  */
 617 BOOL
 618 STDCALL
 619 GetColorAdjustment(
 620         HDC                     hdc,
 621         LPCOLORADJUSTMENT       a1
 622         )
 623 {
 624         UNIMPLEMENTED;
 625         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 626         return FALSE;
 627 }
 628
 629
 630 /*
 631  * @unimplemented
 632  */
 633 int
 634 STDCALL
 635 EndDoc(
 636         HDC     hdc
 637         )
 638 {
 639         UNIMPLEMENTED;
 640         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 641         return 0;
 642 }
 643
 644
 645 /*
 646  * @unimplemented
 647  */
 648 int
 649 STDCALL
 650 StartPage(
 651         HDC     hdc
 652         )
 653 {
 654         UNIMPLEMENTED;
 655         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 656         return 0;
 657 }
 658
 659
 660 /*
 661  * @unimplemented
 662  */
 663 int
 664 STDCALL
 665 EndPage(
 666         HDC     hdc
 667         )
 668 {
 669         UNIMPLEMENTED;
 670         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 671         return 0;
 672 }
 673
 674
 675 /*
 676  * @unimplemented
 677  */
 678 int
 679 STDCALL
 680 AbortDoc(
 681         HDC     hdc
 682         )
 683 {
 684         UNIMPLEMENTED;
 685         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 686         return 0;
 687 }
 688
 689
 690 /*
 691  * @unimplemented
 692  */
 693 int
 694 STDCALL
 695 SetAbortProc(
 696         HDC             hdc,
 697         ABORTPROC       a1
 698         )
 699 {
 700         UNIMPLEMENTED;
 701         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 702         return 0;
 703 }
 704
 705
 706 /*
 707  * @unimplemented
 708  */
 709 BOOL
 710 STDCALL
 711 ScaleViewportExtEx(
 712         HDC     a0,
 713         int     a1,
 714         int     a2,
 715         int     a3,
 716         int     a4,
 717         LPSIZE  a5
 718         )
 719 {
 720         UNIMPLEMENTED;
 721         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 722         return FALSE;
 723 }
 724
 725
 726 /*
 727  * @unimplemented
 728  */
 729 BOOL
 730 STDCALL
 731 ScaleWindowExtEx(
 732         HDC     a0,
 733         int     a1,
 734         int     a2,
 735         int     a3,
 736         int     a4,
 737         LPSIZE  a5
 738         )
 739 {
 740         UNIMPLEMENTED;
 741         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 742         return FALSE;
 743 }
 744
 745
 746 /*
 747  * @implemented
 748  */
 749 BOOL
 750 STDCALL
 751 UnrealizeObject(
 752         HGDIOBJ a0
 753         )
 754 {
 755         return NtGdiUnrealizeObject(a0);
 756 }
 757
 758
 759 /*
 760  * @unimplemented
 761  */
 762 BOOL
 763 STDCALL
 764 GdiFlush()
 765 {
 766         /*
 767          * Although GdiFlush is unimplemented, it's safe to return
 768          * TRUE, because we don't have GDI engine surface caching
 769          * implemented yet.
 770          */
 771         return TRUE;
 772 }
 773
 774
 775 /*
 776  * @unimplemented
 777  */
 778 int
 779 STDCALL
 780 SetICMMode(
 781         HDC     a0,
 782         int     a1
 783         )
 784 {
 785         UNIMPLEMENTED;
 786         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 787         return 0;
 788 }
 789
 790
 791 /*
 792  * @unimplemented
 793  */
 794 BOOL
 795 STDCALL
 796 CheckColorsInGamut(
 797         HDC     a0,
 798         LPVOID  a1,
 799         LPVOID  a2,
 800         DWORD   a3
 801         )
 802 {
 803         UNIMPLEMENTED;
 804         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 805         return FALSE;
 806 }
 807
 808
 809 /*
 810  * @unimplemented
 811  */
 812 HCOLORSPACE
 813 STDCALL
 814 GetColorSpace(
 815         HDC     hDc
 816         )
 817 {
 818         UNIMPLEMENTED;
 819         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 820         return 0;
 821 }
 822
 823
 824 /*
 825  * @unimplemented
 826  */
 827 HCOLORSPACE
 828 STDCALL
 829 SetColorSpace(
 830         HDC             a0,
 831         HCOLORSPACE     a1
 832         )
 833 {
 834         UNIMPLEMENTED;
 835         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 836         return FALSE;
 837 }
 838
 839
 840 /*
 841  * @unimplemented
 842  */
 843 BOOL
 844 STDCALL
 845 DeleteColorSpace(
 846         HCOLORSPACE     a0
 847         )
 848 {
 849         UNIMPLEMENTED;
 850         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 851         return FALSE;
 852 }
 853
 854
 855 /*
 856  * @unimplemented
 857  */
 858 BOOL
 859 STDCALL
 860 GetDeviceGammaRamp(
 861         HDC     a0,
 862         LPVOID  a1
 863         )
 864 {
 865         UNIMPLEMENTED;
 866         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 867         return FALSE;
 868 }
 869
 870
 871 /*
 872  * @unimplemented
 873  */
 874 BOOL
 875 STDCALL
 876 SetDeviceGammaRamp(
 877         HDC     a0,
 878         LPVOID  a1
 879         )
 880 {
 881         UNIMPLEMENTED;
 882         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 883         return FALSE;
 884 }
 885
 886
 887 /*
 888  * @unimplemented
 889  */
 890 BOOL
 891 STDCALL
 892 ColorMatchToTarget(
 893         HDC     a0,
 894         HDC     a1,
 895         DWORD   a2
 896         )
 897 {
 898         UNIMPLEMENTED;
 899         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 900         return FALSE;
 901 }
 902
 903
 904 /*
 905  * @unimplemented
 906  */
 907 BOOL
 908 STDCALL
 909 wglCopyContext(
 910         HGLRC   a0,
 911         HGLRC   a1,
 912         UINT    a2
 913         )
 914 {
 915         UNIMPLEMENTED;
 916         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 917         return FALSE;
 918 }
 919
 920
 921 /*
 922  * @unimplemented
 923  */
 924 HGLRC
 925 STDCALL
 926 wglCreateContext(
 927         HDC     hDc
 928         )
 929 {
 930         UNIMPLEMENTED;
 931         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 932         return 0;
 933 }
 934
 935
 936 /*
 937  * @unimplemented
 938  */
 939 HGLRC
 940 STDCALL
 941 wglCreateLayerContext(
 942         HDC     hDc,
 943         int     a1
 944         )
 945 {
 946         UNIMPLEMENTED;
 947         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 948         return 0;
 949 }
 950
 951
 952 /*
 953  * @unimplemented
 954  */
 955 BOOL
 956 STDCALL
 957 wglDeleteContext(
 958         HGLRC   a
 959         )
 960 {
 961         UNIMPLEMENTED;
 962         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 963         return FALSE;
 964 }
 965
 966
 967 /*
 968  * @unimplemented
 969  */
 970 HGLRC
 971 STDCALL
 972 wglGetCurrentContext(VOID)
 973 {
 974         UNIMPLEMENTED;
 975         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 976         return 0;
 977 }
 978
 979
 980 /*
 981  * @unimplemented
 982  */
 983 HDC
 984 STDCALL
 985 wglGetCurrentDC(VOID)
 986 {
 987         UNIMPLEMENTED;
 988         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 989         return 0;
 990 }
 991
 992
 993 /*
 994  * @unimplemented
 995  */
 996 PROC
 997 STDCALL
 998 wglGetProcAddress(
 999         LPCSTR          a0
1000         )
1001 {
1002         UNIMPLEMENTED;
1003         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1004         return 0;
1005 }
1006
1007
1008 /*
1009  * @unimplemented
1010  */
1011 BOOL
1012 STDCALL
1013 wglMakeCurrent(
1014         HDC     a0,
1015         HGLRC   a1
1016         )
1017 {
1018         UNIMPLEMENTED;
1019         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1020         return FALSE;
1021 }
1022
1023
1024 /*
1025  * @unimplemented
1026  */
1027 BOOL
1028 STDCALL
1029 wglShareLists(
1030         HGLRC   a0,
1031         HGLRC   a1
1032         )
1033 {
1034         UNIMPLEMENTED;
1035         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1036         return FALSE;
1037 }
1038
1039
1040 /*
1041  * @unimplemented
1042  */
1043 BOOL
1044 STDCALL
1045 wglDescribeLayerPlane(
1046         HDC                     a0,
1047         int                     a1,
1048         int                     a2,
1049         UINT                    a3,
1050         LPLAYERPLANEDESCRIPTOR  a4
1051         )
1052 {
1053         UNIMPLEMENTED;
1054         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1055         return FALSE;
1056 }
1057
1058
1059 /*
1060  * @unimplemented
1061  */
1062 int
1063 STDCALL
1064 wglSetLayerPaletteEntries(
1065         HDC             a0,
1066         int             a1,
1067         int             a2,
1068         int             a3,
1069         CONST COLORREF  *a4
1070         )
1071 {
1072         UNIMPLEMENTED;
1073         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1074         return 0;
1075 }
1076
1077
1078 /*
1079  * @unimplemented
1080  */
1081 int
1082 STDCALL
1083 wglGetLayerPaletteEntries(
1084         HDC             a0,
1085         int             a1,
1086         int             a2,
1087         int             a3,
1088         COLORREF        *a4
1089         )
1090 {
1091         UNIMPLEMENTED;
1092         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1093         return 0;
1094 }
1095
1096
1097 /*
1098  * @unimplemented
1099  */
1100 BOOL
1101 STDCALL
1102 wglRealizeLayerPalette(
1103         HDC             a0,
1104         int             a1,
1105         BOOL            a2
1106         )
1107 {
1108         UNIMPLEMENTED;
1109         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1110         return FALSE;
1111 }
1112
1113
1114 /*
1115  * @unimplemented
1116  */
1117 BOOL
1118 STDCALL
1119 wglSwapLayerBuffers(
1120         HDC             a0,
1121         UINT            a1
1122         )
1123 {
1124         UNIMPLEMENTED;
1125         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1126         return FALSE;
1127 }
1128
1129
1130 /* === AFTER THIS POINT I GUESS... =========
1131  * (based on stack size in Norlander's .def)
1132  * === WHERE ARE THEY DEFINED? =============
1133  */
1134
1135
1136 /*
1137  * @unimplemented
1138  */
1139 DWORD
1140 STDCALL
1141 GdiPlayDCScript(
1142         DWORD   a0,
1143         DWORD   a1,
1144         DWORD   a2,
1145         DWORD   a3,
1146         DWORD   a4,
1147         DWORD   a5
1148         )
1149 {
1150         UNIMPLEMENTED;
1151         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1152         return 0;
1153 }
1154
1155
1156 /*
1157  * @unimplemented
1158  */
1159 DWORD
1160 STDCALL
1161 GdiPlayJournal(
1162         DWORD   a0,
1163         DWORD   a1,
1164         DWORD   a2,
1165         DWORD   a3,
1166         DWORD   a4
1167         )
1168 {
1169         UNIMPLEMENTED;
1170         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1171         return 0;
1172 }
1173
1174
1175 /*
1176  * @unimplemented
1177  */
1178 DWORD
1179 STDCALL
1180 GdiPlayScript(
1181         DWORD   a0,
1182         DWORD   a1,
1183         DWORD   a2,
1184         DWORD   a3,
1185         DWORD   a4,
1186         DWORD   a5,
1187         DWORD   a6
1188         )
1189 {
1190         UNIMPLEMENTED;
1191         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1192         return 0;
1193 }
1194
1195
1196 /*
1197  * @unimplemented
1198  */
1199 DWORD
1200 STDCALL
1201 GetGlyphOutlineWow(
1202         DWORD   a0,
1203         DWORD   a1,
1204         DWORD   a2,
1205         DWORD   a3,
1206         DWORD   a4,
1207         DWORD   a5,
1208         DWORD   a6
1209         )
1210 {
1211         UNIMPLEMENTED;
1212         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1213         return 0;
1214 }
1215
1216
1217
1218
1219 /*
1220  * @unimplemented
1221  */
1222 DWORD
1223 STDCALL
1224 SelectBrushLocal(
1225         DWORD   a0,
1226         DWORD   a1
1227         )
1228 {
1229         UNIMPLEMENTED;
1230         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1231         return 0;
1232 }
1233
1234
1235 /*
1236  * @unimplemented
1237  */
1238 DWORD
1239 STDCALL
1240 SelectFontLocal(
1241         DWORD   a0,
1242         DWORD   a1
1243         )
1244 {
1245         UNIMPLEMENTED;
1246         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1247         return 0;
1248 }
1249
1250
1251 /*
1252  * @unimplemented
1253  */
1254 DWORD
1255 STDCALL
1256 SetFontEnumeration(
1257         DWORD   a0
1258         )
1259 {
1260         UNIMPLEMENTED;
1261         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1262         return 0;
1263 }
1264
1265
1266 /*
1267  * @unimplemented
1268  */
1269 DWORD
1270 STDCALL
1271 gdiPlaySpoolStream(
1272         DWORD   a0,
1273         DWORD   a1,
1274         DWORD   a2,
1275         DWORD   a3,
1276         DWORD   a4,
1277         DWORD   a5
1278         )
1279 {
1280         UNIMPLEMENTED;
1281         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1282         return 0;
1283 }
1284
1285 /*
1286  * @unimplemented
1287  */
1288 HANDLE
1289 STDCALL
1290 AddFontMemResourceEx(
1291         PVOID pbFont,
1292         DWORD cbFont,
1293         PVOID pdv,
1294         DWORD *pcFonts
1295 )
1296 {
1297         UNIMPLEMENTED;
1298         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1299         return 0;
1300 }
1301
1302 /*
1303  * @unimplemented
1304  */
1305 int
1306 STDCALL
1307 AddFontResourceTracking(
1308         LPCSTR lpString,
1309         int unknown
1310 )
1311 {
1312         UNIMPLEMENTED;
1313         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1314         return 0;
1315 }
1316
1317
1318
1319 /*
1320  * @unimplemented
1321  */
1322 HBITMAP
1323 STDCALL
1324 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1325 {
1326         UNIMPLEMENTED;
1327         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1328         return 0;
1329 }
1330
1331 /*
1332  * @unimplemented
1333  */
1334 HBRUSH
1335 STDCALL
1336 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1337 {
1338         UNIMPLEMENTED;
1339         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1340         return 0;
1341 }
1342
1343 /*
1344  * @unimplemented
1345  */
1346 BOOL
1347 STDCALL
1348 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
1349 {
1350         UNIMPLEMENTED;
1351         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1352         return 0;
1353 }
1354
1355 /*
1356  * @unimplemented
1357  */
1358 BOOL
1359 STDCALL
1360 EnableEUDC(BOOL enable)
1361 {
1362         UNIMPLEMENTED;
1363         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1364         return 0;
1365 }
1366
1367 /*
1368  * @unimplemented
1369  */
1370 int
1371 STDCALL
1372 EndFormPage(HDC hdc)
1373 {
1374         UNIMPLEMENTED;
1375         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1376         return 0;
1377 }
1378
1379 /*
1380  * @unimplemented
1381  */
1382 BOOL
1383 STDCALL
1384 FontIsLinked(HDC hdc)
1385 {
1386         UNIMPLEMENTED;
1387         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1388         return 0;
1389 }
1390
1391 /*
1392  * @unimplemented
1393  */
1394 DWORD
1395 STDCALL
1396 GdiAddGlsBounds(HDC hdc,LPRECT prc)
1397 {
1398         UNIMPLEMENTED;
1399         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1400         return 0;
1401 }
1402
1403 /*
1404  * @unimplemented
1405  */
1406 BOOL
1407 STDCALL
1408 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
1409 {
1410         UNIMPLEMENTED;
1411         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1412         return 0;
1413 }
1414
1415 /*
1416  * @unimplemented
1417  */
1418 BOOL
1419 STDCALL
1420 GdiCleanCacheDC(HDC hdc)
1421 {
1422         UNIMPLEMENTED;
1423         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1424         return 0;
1425 }
1426
1427 /*
1428  * @unimplemented
1429  */
1430 HDC
1431 STDCALL
1432 GdiConvertAndCheckDC(HDC hdc)
1433 {
1434         UNIMPLEMENTED;
1435         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1436         return 0;
1437 }
1438
1439 /*
1440  * @unimplemented
1441  */
1442 HBITMAP
1443 STDCALL
1444 GdiConvertBitmap(HBITMAP hbm)
1445 {
1446         UNIMPLEMENTED;
1447         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1448         return 0;
1449 }
1450
1451 /*
1452  * @unimplemented
1453  */
1454 HBRUSH
1455 STDCALL
1456 GdiConvertBrush(HBRUSH hbr)
1457 {
1458         UNIMPLEMENTED;
1459         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1460         return 0;
1461 }
1462
1463 /*
1464  * @unimplemented
1465  */
1466 HDC
1467 STDCALL
1468 GdiConvertDC(HDC hdc)
1469 {
1470         UNIMPLEMENTED;
1471         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1472         return 0;
1473 }
1474
1475 /*
1476  * @unimplemented
1477  */
1478 HFONT
1479 STDCALL
1480 GdiConvertFont(HFONT hfont)
1481 {
1482         UNIMPLEMENTED;
1483         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1484         return 0;
1485 }
1486
1487 /*
1488  * @unimplemented
1489  */
1490 HPALETTE
1491 STDCALL
1492 GdiConvertPalette(HPALETTE hpal)
1493 {
1494         UNIMPLEMENTED;
1495         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1496         return 0;
1497 }
1498
1499 /*
1500  * @unimplemented
1501  */
1502 HRGN
1503 STDCALL
1504 GdiConvertRegion(HRGN hregion)
1505 {
1506         UNIMPLEMENTED;
1507         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1508         return 0;
1509 }
1510
1511 /*
1512  * @unimplemented
1513  */
1514 HENHMETAFILE
1515 STDCALL
1516 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
1517 {
1518         UNIMPLEMENTED;
1519         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1520         return 0;
1521 }
1522
1523 /*
1524  * @unimplemented
1525  */
1526 BOOL
1527 STDCALL
1528 GdiDeleteLocalDC(HDC hdc)
1529 {
1530         UNIMPLEMENTED;
1531         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1532         return 0;
1533 }
1534
1535 /*
1536  * @unimplemented
1537  */
1538 int
1539 STDCALL
1540 GdiDescribePixelFormat(HDC hdc,int ipfd,UINT cjpfd,PPIXELFORMATDESCRIPTOR ppfd)
1541 {
1542         UNIMPLEMENTED;
1543         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1544         return 0;
1545 }
1546
1547 /*
1548  * @unimplemented
1549  */
1550 BOOL
1551 STDCALL
1552 GdiDrawStream(HDC dc, ULONG l, VOID *v)
1553 {
1554         UNIMPLEMENTED;
1555         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1556         return 0;
1557 }
1558
1559 /*
1560  * @unimplemented
1561  */
1562 DWORD
1563 STDCALL
1564 GdiGetCodePage(HDC hdc)
1565 {
1566         UNIMPLEMENTED;
1567         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1568         return 0;
1569 }
1570
1571 /*
1572  * @unimplemented
1573  */
1574 HBRUSH
1575 STDCALL
1576 GdiGetLocalBrush(HBRUSH hbr)
1577 {
1578         UNIMPLEMENTED;
1579         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1580         return 0;
1581 }
1582
1583 /*
1584  * @unimplemented
1585  */
1586 HDC
1587 STDCALL
1588 GdiGetLocalDC(HDC hdc)
1589 {
1590         UNIMPLEMENTED;
1591         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1592         return 0;
1593 }
1594
1595 /*
1596  * @unimplemented
1597  */
1598 HFONT
1599 STDCALL
1600 GdiGetLocalFont(HFONT hfont)
1601 {
1602         UNIMPLEMENTED;
1603         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1604         return 0;
1605 }
1606
1607 /*
1608  * @unimplemented
1609  */
1610 BOOL
1611 STDCALL
1612 GdiIsMetaFileDC(HDC hdc)
1613 {
1614         UNIMPLEMENTED;
1615         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1616         return 0;
1617 }
1618
1619 /*
1620  * @unimplemented
1621  */
1622 BOOL
1623 STDCALL
1624 GdiIsMetaPrintDC(HDC hdc)
1625 {
1626         UNIMPLEMENTED;
1627         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1628         return 0;
1629 }
1630
1631 /*
1632  * @unimplemented
1633  */
1634 BOOL
1635 STDCALL
1636 GdiIsPlayMetafileDC(HDC hdc)
1637 {
1638         UNIMPLEMENTED;
1639         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1640         return 0;
1641 }
1642
1643 /*
1644  * @unimplemented
1645  */
1646 BOOL
1647 STDCALL
1648 GdiSetAttrs(HDC hdc)
1649 {
1650         UNIMPLEMENTED;
1651         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1652         return 0;
1653 }
1654
1655 /*
1656  * @unimplemented
1657  */
1658 VOID
1659 STDCALL
1660 GdiSetLastError(DWORD dwErrCode)
1661 {
1662         UNIMPLEMENTED;
1663         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1664 }
1665
1666 /*
1667  * @unimplemented
1668  */
1669 BOOL
1670 STDCALL
1671 GdiSetPixelFormat(HDC hdc,int ipfd)
1672 {
1673         UNIMPLEMENTED;
1674         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1675         return 0;
1676 }
1677
1678 /*
1679  * @unimplemented
1680  */
1681 BOOL
1682 STDCALL
1683 GdiValidateHandle(HGDIOBJ hobj)
1684 {
1685         UNIMPLEMENTED;
1686         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1687         return 0;
1688 }
1689
1690 /*
1691  * @unimplemented
1692  */
1693 BOOL
1694 STDCALL
1695 GdiSwapBuffers(HDC hdc)
1696 {
1697         UNIMPLEMENTED;
1698         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1699         return 0;
1700 }
1701
1702 /*
1703  * @unimplemented
1704  */
1705 VOID
1706 STDCALL
1707 GdiSetServerAttr(HDC hdc,DWORD attr)
1708 {
1709         UNIMPLEMENTED;
1710         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1711 }
1712
1713 /*
1714  * @unimplemented
1715  */
1716 DWORD
1717 STDCALL
1718 GetBitmapAttributes(HBITMAP hbm)
1719 {
1720         UNIMPLEMENTED;
1721         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1722         return 0;
1723 }
1724
1725 /*
1726  * @unimplemented
1727  */
1728 DWORD
1729 STDCALL
1730 GetBrushAttributes(HBRUSH hbr)
1731 {
1732         UNIMPLEMENTED;
1733         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1734         return 0;
1735 }
1736
1737 /*
1738  * @unimplemented
1739  */
1740 BOOL
1741 STDCALL
1742 GetCharABCWidthsI(
1743         HDC hdc,
1744         UINT giFirst,
1745         UINT cgi,
1746         LPWORD pgi,
1747         LPABC lpabc
1748 )
1749 {
1750         UNIMPLEMENTED;
1751         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1752         return 0;
1753 }
1754
1755 /*
1756  * @unimplemented
1757  */
1758 BOOL
1759 STDCALL
1760 GetCharWidthI(
1761         HDC hdc,
1762         UINT giFirst,
1763         UINT cgi,
1764         LPWORD pgi,
1765         LPINT lpBuffer
1766 )
1767 {
1768         UNIMPLEMENTED;
1769         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1770         return 0;
1771 }
1772
1773 /*
1774  * @unimplemented
1775  */
1776 DWORD
1777 STDCALL
1778 GetFontUnicodeRanges(
1779         HDC hdc,
1780         LPGLYPHSET lpgs
1781 )
1782 {
1783         UNIMPLEMENTED;
1784         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1785         return 0;
1786 }
1787
1788 /*
1789  * @unimplemented
1790  */
1791 ULONG
1792 STDCALL
1793 GetEUDCTimeStamp(VOID)
1794 {
1795         UNIMPLEMENTED;
1796         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1797         return 0;
1798 }
1799
1800 /*
1801  * @unimplemented
1802  */
1803 ULONG
1804 STDCALL
1805 GetFontAssocStatus(HDC hdc)
1806 {
1807         UNIMPLEMENTED;
1808         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1809         return 0;
1810 }
1811
1812 /*
1813  * @unimplemented
1814  */
1815 HFONT
1816 STDCALL
1817 GetHFONT(HDC dc)
1818 {
1819         UNIMPLEMENTED;
1820         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1821         return 0;
1822 }
1823
1824 /*
1825  * @unimplemented
1826  */
1827 DWORD
1828 STDCALL
1829 GetLayout(
1830         HDC hdc
1831 )
1832 {
1833         UNIMPLEMENTED;
1834         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1835         return 0;
1836 }
1837
1838 /*
1839  * @unimplemented
1840  */
1841 BOOL
1842 STDCALL
1843 GetTextExtentExPointWPri(HDC hdc,LPWSTR lpwsz,ULONG cwc,ULONG dxMax,ULONG *pcCh,PULONG pdxOut,LPSIZE psize)
1844 {
1845         UNIMPLEMENTED;
1846         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1847         return 0;
1848 }
1849
1850 /*
1851  * @unimplemented
1852  */
1853 int
1854 STDCALL
1855 GetTextFaceAliasW(HDC hdc,int cChar,LPWSTR pszOut)
1856 {
1857         UNIMPLEMENTED;
1858         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1859         return 0;
1860 }
1861
1862 /*
1863  * @unimplemented
1864  */
1865 LONG
1866 STDCALL
1867 HT_Get8BPPFormatPalette(LPPALETTEENTRY pPaletteEntry, USHORT RedGamma,USHORT GreenGamma, USHORT BlueGamma)
1868 {
1869         UNIMPLEMENTED;
1870         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1871         return 0;
1872 }
1873
1874 /*
1875  * @unimplemented
1876  */
1877 LONG
1878 STDCALL
1879 HT_Get8BPPMaskPalette(LPPALETTEENTRY pPaletteEntry, BOOL Use8BPPMaskPal,BYTE CMYMask, USHORT RedGamma, USHORT GreenGamma, USHORT BlueGamma)
1880 {
1881         UNIMPLEMENTED;
1882         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1883         return 0;
1884 }
1885
1886 /*
1887  * @unimplemented
1888  */
1889 BOOL
1890 STDCALL
1891 MirrorRgn(HWND hwnd,HRGN hrgn)
1892 {
1893         UNIMPLEMENTED;
1894         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1895         return 0;
1896 }
1897
1898 /*
1899  * @unimplemented
1900  */
1901 int
1902 STDCALL
1903 NamedEscape(HDC hdc,PWCHAR pDriver,int nDriver,int iEsc,int cjIn,LPSTR pjIn,int cjOut,LPSTR pjOut)
1904 {
1905         UNIMPLEMENTED;
1906         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1907         return 0;
1908 }
1909
1910 /*
1911  * @unimplemented
1912  */
1913 DWORD
1914 STDCALL
1915 QueryFontAssocStatus(VOID)
1916 {
1917         UNIMPLEMENTED;
1918         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1919         return 0;
1920 }
1921
1922 /*
1923  * @unimplemented
1924  */
1925 BOOL
1926 STDCALL
1927 RemoveFontMemResourceEx(
1928         HANDLE fh
1929 )
1930 {
1931         UNIMPLEMENTED;
1932         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1933         return 0;
1934 }
1935
1936 /*
1937  * @unimplemented
1938  */
1939 int
1940 STDCALL
1941 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1942 {
1943         UNIMPLEMENTED;
1944         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1945         return 0;
1946 }
1947
1948 /*
1949  * @unimplemented
1950  */
1951 HBITMAP
1952 STDCALL
1953 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1954 {
1955         UNIMPLEMENTED;
1956         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1957         return 0;
1958 }
1959
1960 /*
1961  * @unimplemented
1962  */
1963 HBRUSH
1964 STDCALL
1965 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1966 {
1967         UNIMPLEMENTED;
1968         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1969         return 0;
1970 }
1971
1972 /*
1973  * @unimplemented
1974  */
1975 DWORD
1976 STDCALL
1977 SetLayout(
1978         HDC hdc,
1979         DWORD dwLayout
1980 )
1981 {
1982         UNIMPLEMENTED;
1983         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1984         return 0;
1985 }
1986
1987 /*
1988  * @unimplemented
1989  */
1990 DWORD
1991 STDCALL
1992 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
1993 {
1994         UNIMPLEMENTED;
1995         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1996         return 0;
1997 }
1998
1999 /*
2000  * @unimplemented
2001  */
2002 BOOL
2003 STDCALL
2004 SetMagicColors(HDC hdc,PALETTEENTRY peMagic,ULONG Index)
2005 {
2006         UNIMPLEMENTED;
2007         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2008         return 0;
2009 }
2010
2011 /*
2012  * @unimplemented
2013  */
2014 BOOL
2015 STDCALL
2016 SetVirtualResolution(HDC hdc, int cxVirtualDevicePixel,int cyVirtualDevicePixel,int cxVirtualDeviceMm, int cyVirtualDeviceMm)
2017 {
2018         UNIMPLEMENTED;
2019         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2020         return 0;
2021 }
2022
2023 /*
2024  * @unimplemented
2025  */
2026 int
2027 STDCALL
2028 StartFormPage(HDC hdc)
2029 {
2030         UNIMPLEMENTED;
2031         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2032         return 0;
2033 }
2034
2035 /*
2036  * @unimplemented
2037  */
2038 VOID
2039 STDCALL
2040 UnloadNetworkFonts(DWORD unknown)
2041 {
2042         UNIMPLEMENTED;
2043         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2044 }
2045
2046 /*
2047  * @unimplemented
2048  */
2049 BOOL
2050 STDCALL
2051 GetTextExtentExPointI(
2052         HDC hdc,
2053         LPWORD pgiIn,
2054         int cgi,
2055         int nMaxExtent,
2056         LPINT lpnFit,
2057         LPINT alpDx,
2058         LPSIZE lpSize
2059 )
2060 {
2061         UNIMPLEMENTED;
2062         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2063         return 0;
2064 }
2065
2066 /*
2067  * @unimplemented
2068  */
2069 BOOL
2070 STDCALL
2071 GetTextExtentPointI(
2072         HDC hdc,
2073         LPWORD pgiIn,
2074         int cgi,
2075         LPSIZE lpSize
2076 )
2077 {
2078         UNIMPLEMENTED;
2079         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2080         return 0;
2081 }
2082
2083 /*
2084  * @unimplemented
2085  */
2086 NTSTATUS
2087 STDCALL
2088 GdiFullscreenControl(FULLSCREENCONTROL FullscreenCommand,PVOID FullscreenInput,
2089                                         DWORD FullscreenInputLength,PVOID FullscreenOutput,
2090                                         PULONG FullscreenOutputLength)
2091 {
2092         UNIMPLEMENTED;
2093         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2094         return 0;
2095 }
2096
2097 /*
2098  * @unimplemented
2099  */
2100 INT
2101 STDCALL
2102 GdiQueryFonts(PUNIVERSAL_FONT_ID pufiFontList,ULONG nBufferSize,PLARGE_INTEGER pTimeStamp )
2103 {
2104         UNIMPLEMENTED;
2105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2106         return 0;
2107 }
2108
2109 /*
2110  * @unimplemented
2111  */
2112 BOOL
2113 STDCALL
2114 GdiRealizationInfo(HDC hdc, PREALIZATION_INFO pri)
2115 {
2116         UNIMPLEMENTED;
2117         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2118         return 0;
2119 }
2120
2121 /*
2122  * @unimplemented
2123  */
2124 BOOL
2125 STDCALL
2126 GetCharWidthInfo(HDC hdc,PCHWIDTHINFO pChWidthInfo)
2127 {
2128         UNIMPLEMENTED;
2129         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2130         return 0;
2131 }
2132
2133 /*
2134  * @unimplemented
2135  */
2136 BOOL
2137 STDCALL
2138 GetETM(HDC hdc,EXTTEXTMETRIC *petm)
2139 {
2140         UNIMPLEMENTED;
2141         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2142         return 0;
2143 }
2144
2145 /*
2146  * @unimplemented
2147  */
2148 BOOL
2149 STDCALL
2150 GdiAddGlsRecord(HDC hdc,DWORD unknown1,LPCSTR unknown2,LPRECT unknown3)
2151 {
2152         UNIMPLEMENTED;
2153         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2154         return 0;
2155 }
2156
2157 /*
2158  * @unimplemented
2159  */
2160 HANDLE
2161 STDCALL
2162 GdiConvertMetaFilePict(HGLOBAL hMem)
2163 {
2164         UNIMPLEMENTED;
2165         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2166         return 0;
2167 }
2168
2169 /*
2170  * @implemented
2171  */
2172 DEVMODEW *
2173 STDCALL
2174 GdiConvertToDevmodeW(DEVMODEA *dm)
2175 {
2176   LPDEVMODEW dmw;
2177
2178   dmw = HEAP_alloc(sizeof(DEVMODEW));
2179 #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
2180 #define COPYN(f) dmw->f = dm->f
2181   COPYS(dmDeviceName, CCHDEVICENAME );
2182   COPYN(dmSpecVersion);
2183   COPYN(dmDriverVersion);
2184   switch ( dm->dmSize )
2185     {
2186     case SIZEOF_DEVMODEA_300:
2187       dmw->dmSize = SIZEOF_DEVMODEW_300;
2188       break;
2189     case SIZEOF_DEVMODEA_400:
2190       dmw->dmSize = SIZEOF_DEVMODEW_400;
2191       break;
2192     case SIZEOF_DEVMODEA_500:
2193     default: /* FIXME what to do??? */
2194       dmw->dmSize = SIZEOF_DEVMODEW_500;
2195       break;
2196     }
2197   COPYN(dmDriverExtra);
2198   COPYN(dmFields);
2199   COPYN(dmPosition.x);
2200   COPYN(dmPosition.y);
2201   COPYN(dmScale);
2202   COPYN(dmCopies);
2203   COPYN(dmDefaultSource);
2204   COPYN(dmPrintQuality);
2205   COPYN(dmColor);
2206   COPYN(dmDuplex);
2207   COPYN(dmYResolution);
2208   COPYN(dmTTOption);
2209   COPYN(dmCollate);
2210   COPYS(dmFormName,CCHFORMNAME);
2211   COPYN(dmLogPixels);
2212   COPYN(dmBitsPerPel);
2213   COPYN(dmPelsWidth);
2214   COPYN(dmPelsHeight);
2215   COPYN(dmDisplayFlags); // aka dmNup
2216   COPYN(dmDisplayFrequency);
2217
2218   if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
2219     return dmw; // we're done with 0x300 fields
2220
2221   COPYN(dmICMMethod);
2222   COPYN(dmICMIntent);
2223   COPYN(dmMediaType);
2224   COPYN(dmDitherType);
2225   COPYN(dmReserved1);
2226   COPYN(dmReserved2);
2227
2228   if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
2229     return dmw; // we're done with 0x400 fields
2230
2231   COPYN(dmPanningWidth);
2232   COPYN(dmPanningHeight);
2233
2234   return dmw;
2235
2236 #undef COPYN
2237 #undef COPYS
2238 }
2239
2240 /*
2241  * @unimplemented
2242  */
2243 HENHMETAFILE
2244 STDCALL
2245 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
2246 {
2247         UNIMPLEMENTED;
2248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2249         return 0;
2250 }
2251
2252 /*
2253  * @unimplemented
2254  */
2255 METAFILEPICT *
2256 STDCALL
2257 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
2258 {
2259         UNIMPLEMENTED;
2260         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2261         return 0;
2262 }
2263
2264
2265 /*
2266  * @unimplemented
2267  */
2268 HANDLE
2269 STDCALL
2270 GdiGetSpoolFileHandle(
2271         LPWSTR          pwszPrinterName,
2272         LPDEVMODEW      pDevmode,
2273         LPWSTR          pwszDocName)
2274 {
2275         UNIMPLEMENTED;
2276         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2277         return 0;
2278 }
2279
2280 /*
2281  * @unimplemented
2282  */
2283 BOOL
2284 STDCALL
2285 GdiDeleteSpoolFileHandle(
2286         HANDLE  SpoolFileHandle)
2287 {
2288         UNIMPLEMENTED;
2289         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2290         return 0;
2291 }
2292
2293 /*
2294  * @unimplemented
2295  */
2296 DWORD
2297 STDCALL
2298 GdiGetPageCount(
2299         HANDLE  SpoolFileHandle)
2300 {
2301         UNIMPLEMENTED;
2302         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2303         return 0;
2304 }
2305
2306 /*
2307  * @unimplemented
2308  */
2309 HDC
2310 STDCALL
2311 GdiGetDC(
2312         HANDLE  SpoolFileHandle)
2313 {
2314         UNIMPLEMENTED;
2315         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2316         return 0;
2317 }
2318
2319 /*
2320  * @unimplemented
2321  */
2322 HANDLE
2323 STDCALL
2324 GdiGetPageHandle(
2325         HANDLE  SpoolFileHandle,
2326         DWORD   Page,
2327         LPDWORD pdwPageType)
2328 {
2329         UNIMPLEMENTED;
2330         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2331         return 0;
2332 }
2333
2334 /*
2335  * @unimplemented
2336  */
2337 BOOL
2338 STDCALL
2339 GdiStartDocEMF(
2340         HANDLE          SpoolFileHandle,
2341         DOCINFOW        *pDocInfo)
2342 {
2343         UNIMPLEMENTED;
2344         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2345         return 0;
2346 }
2347
2348 /*
2349  * @unimplemented
2350  */
2351 BOOL
2352 STDCALL
2353 GdiStartPageEMF(
2354         HANDLE  SpoolFileHandle)
2355 {
2356         UNIMPLEMENTED;
2357         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2358         return 0;
2359 }
2360
2361 /*
2362  * @unimplemented
2363  */
2364 BOOL
2365 STDCALL
2366 GdiPlayPageEMF(
2367         HANDLE  SpoolFileHandle,
2368         HANDLE  hemf,
2369         RECT    *prectDocument,
2370         RECT    *prectBorder,
2371         RECT    *prectClip)
2372 {
2373         UNIMPLEMENTED;
2374         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2375         return 0;
2376 }
2377
2378 /*
2379  * @unimplemented
2380  */
2381 BOOL
2382 STDCALL
2383 GdiEndPageEMF(
2384         HANDLE  SpoolFileHandle,
2385         DWORD   dwOptimization)
2386 {
2387         UNIMPLEMENTED;
2388         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2389         return 0;
2390 }
2391
2392 /*
2393  * @unimplemented
2394  */
2395 BOOL
2396 STDCALL
2397 GdiEndDocEMF(
2398         HANDLE  SpoolFileHandle)
2399 {
2400         UNIMPLEMENTED;
2401         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2402         return 0;
2403 }
2404
2405 /*
2406  * @unimplemented
2407  */
2408 BOOL
2409 STDCALL
2410 GdiGetDevmodeForPage(
2411         HANDLE          SpoolFileHandle,
2412         DWORD           dwPageNumber,
2413         PDEVMODEW       *pCurrDM,
2414         PDEVMODEW       *pLastDM)
2415 {
2416         UNIMPLEMENTED;
2417         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2418         return 0;
2419 }
2420
2421 /*
2422  * @unimplemented
2423  */
2424 BOOL
2425 STDCALL
2426 GdiResetDCEMF(
2427         HANDLE          SpoolFileHandle,
2428         PDEVMODEW       pCurrDM)
2429 {
2430         UNIMPLEMENTED;
2431         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2432         return 0;
2433 }
2434
2435
2436
2437 /*
2438  * @unimplemented
2439  */
2440 VOID
2441 STDCALL
2442 EngAcquireSemaphore ( IN HSEMAPHORE hsem )
2443 {
2444    RtlEnterCriticalSection((PRTL_CRITICAL_SECTION)hsem);
2445 }
2446
2447
2448 /*
2449  * @unimplemented
2450  */
2451 BOOL STDCALL
2452 EngAssociateSurface(IN HSURF Surface,
2453                     IN HDEV Dev,
2454                     IN ULONG Hooks)
2455 {
2456         UNIMPLEMENTED;
2457         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2458         return 0;
2459 }
2460
2461
2462
2463 /*
2464  * @unimplemented
2465  */
2466 BOOL STDCALL
2467 EngCheckAbort(SURFOBJ *pso)
2468 {
2469         UNIMPLEMENTED;
2470         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2471         return 0;
2472 }
2473
2474 /*
2475  * @unimplemented
2476  */
2477 FD_GLYPHSET* STDCALL
2478 EngComputeGlyphSet(INT nCodePage,INT nFirstChar,INT cChars)
2479 {
2480         UNIMPLEMENTED;
2481         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2482         return 0;
2483 }
2484
2485 /*
2486  * @unimplemented
2487  */
2488 BOOL STDCALL
2489 EngCopyBits(SURFOBJ *Dest,
2490             SURFOBJ *Source,
2491             CLIPOBJ *Clip,
2492             XLATEOBJ *ColorTranslation,
2493             RECTL *DestRect,
2494             POINTL *SourcePoint)
2495 {
2496         UNIMPLEMENTED;
2497         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2498         return 0;
2499 }
2500
2501 /*
2502  * @unimplemented
2503  */
2504 HBITMAP STDCALL
2505 EngCreateBitmap(IN SIZEL Size,
2506                 IN LONG Width,
2507                 IN ULONG Format,
2508                 IN ULONG Flags,
2509                 IN PVOID Bits)
2510 {
2511         UNIMPLEMENTED;
2512         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2513         return 0;
2514 }
2515
2516 /*
2517  * @unimplemented
2518  */
2519 CLIPOBJ* STDCALL
2520 EngCreateClip(VOID)
2521 {
2522         UNIMPLEMENTED;
2523         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2524         return 0;
2525 }
2526
2527 /*
2528  * @unimplemented
2529  */
2530 HBITMAP STDCALL
2531 EngCreateDeviceBitmap(IN DHSURF Surface,
2532                       IN SIZEL Size,
2533                       IN ULONG Format)
2534 {
2535         UNIMPLEMENTED;
2536         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2537         return 0;
2538 }
2539
2540 /*
2541  * @unimplemented
2542  */
2543 HSURF STDCALL
2544 EngCreateDeviceSurface(IN DHSURF Surface,
2545                        IN SIZEL Size,
2546                        IN ULONG FormatVersion)
2547 {
2548         UNIMPLEMENTED;
2549         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2550         return 0;
2551 }
2552
2553 /*
2554  * @unimplemented
2555  */
2556 HPALETTE STDCALL
2557 EngCreatePalette(IN ULONG Mode,
2558                  IN ULONG NumColors,
2559                  IN ULONG *Colors,
2560                  IN ULONG Red,
2561                  IN ULONG Green,
2562                  IN ULONG Blue)
2563 {
2564         UNIMPLEMENTED;
2565         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2566         return 0;
2567 }
2568
2569 /*
2570  * @unimplemented
2571  */
2572 HSEMAPHORE
2573 STDCALL
2574 EngCreateSemaphore ( VOID )
2575 {
2576   PRTL_CRITICAL_SECTION CritSect = RtlAllocateHeap(GetProcessHeap(), 0, sizeof(RTL_CRITICAL_SECTION));
2577   if (!CritSect) return NULL;
2578   RtlInitializeCriticalSection( CritSect );
2579   return (HSEMAPHORE)CritSect;
2580 }
2581
2582 /*
2583  * @unimplemented
2584  */
2585 VOID STDCALL
2586 EngDeleteClip(CLIPOBJ *ClipRegion)
2587 {
2588         UNIMPLEMENTED;
2589         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2590 }
2591
2592 /*
2593  * @unimplemented
2594  */
2595 BOOL STDCALL
2596 EngDeletePalette(IN HPALETTE Palette)
2597 {
2598         UNIMPLEMENTED;
2599         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2600         return 0;
2601 }
2602
2603 /*
2604  * @unimplemented
2605  */
2606 VOID STDCALL
2607 EngDeletePath(PATHOBJ *ppo)
2608 {
2609         UNIMPLEMENTED;
2610         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2611 }
2612
2613 /*
2614  * @unimplemented
2615  */
2616 VOID
2617 STDCALL
2618 EngDeleteSemaphore ( IN HSEMAPHORE hsem )
2619 {
2620  if (!hsem) return;
2621
2622  RtlDeleteCriticalSection( (PRTL_CRITICAL_SECTION) hsem );
2623  RtlFreeHeap( GetProcessHeap(), 0, hsem );
2624 }
2625
2626 /*
2627  * @unimplemented
2628  */
2629 BOOL STDCALL
2630 EngDeleteSurface(IN HSURF Surface)
2631 {
2632         UNIMPLEMENTED;
2633         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2634         return 0;
2635 }
2636
2637 /*
2638  * @unimplemented
2639  */
2640 BOOL STDCALL
2641 EngEraseSurface(SURFOBJ *Surface,
2642                 RECTL *Rect,
2643                 ULONG iColor)
2644 {
2645         UNIMPLEMENTED;
2646         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2647         return 0;
2648 }
2649
2650 /*
2651  * @unimplemented
2652  */
2653 BOOL STDCALL
2654 EngFillPath(SURFOBJ *pso,PATHOBJ *ppo,CLIPOBJ *pco,BRUSHOBJ *pbo,POINTL *pptlBrushOrg,MIX mix,FLONG flOptions)
2655 {
2656         UNIMPLEMENTED;
2657         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2658         return 0;
2659 }
2660
2661 /*
2662  * @unimplemented
2663  */
2664 PVOID STDCALL
2665 EngFindResource(HANDLE h,
2666                 int iName,
2667                 int iType,
2668                 PULONG pulSize)
2669 {
2670  HRSRC HRSrc;
2671  DWORD Size;
2672  HGLOBAL Hg;
2673  LPVOID Lock;
2674
2675  if (!(HRSrc = FindResourceW( (HMODULE) h,
2676                        MAKEINTRESOURCEW(iName),
2677                        MAKEINTRESOURCEW(iType)
2678                           )))
2679                                return NULL;
2680  if (!(Size = SizeofResource( (HMODULE) h, HRSrc ))) return NULL;
2681  if (!(Hg   = LoadResource(   (HMODULE) h, HRSrc ))) return NULL;
2682  Lock = LockResource( Hg );
2683  pulSize = (PULONG) Size;
2684  return (PVOID) Lock;
2685 }
2686
2687 /*
2688  * @unimplemented
2689  */
2690 VOID STDCALL
2691 EngFreeModule(HANDLE h)
2692 {
2693   LdrUnloadDll(h);
2694 }
2695
2696 /*
2697  * @unimplemented
2698  */
2699 VOID STDCALL
2700 EngGetCurrentCodePage(OUT PUSHORT OemCodePage,
2701                       OUT PUSHORT AnsiCodePage)
2702 {
2703    OemCodePage  = (PUSHORT) GetOEMCP();
2704    AnsiCodePage = (PUSHORT) GetACP();
2705 }
2706
2707 /*
2708  * @unimplemented
2709  */
2710 LPWSTR STDCALL
2711 EngGetDriverName(HDEV hdev)
2712 {
2713         UNIMPLEMENTED;
2714         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2715         return 0;
2716 }
2717
2718 /*
2719  * @unimplemented
2720  */
2721 LPWSTR STDCALL
2722 EngGetPrinterDataFileName(HDEV hdev)
2723 {
2724         UNIMPLEMENTED;
2725         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2726         return 0;
2727 }
2728
2729 /*
2730  * @unimplemented
2731  */
2732 BOOL STDCALL
2733 EngGradientFill(SURFOBJ *psoDest,CLIPOBJ *pco,XLATEOBJ *pxlo,TRIVERTEX *pVertex,ULONG nVertex,PVOID pMesh,ULONG nMesh,RECTL *prclExtents,POINTL *pptlDitherOrg,ULONG ulMode)
2734 {
2735         UNIMPLEMENTED;
2736         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2737         return 0;
2738 }
2739
2740 /*
2741  * @unimplemented
2742  */
2743 BOOL STDCALL
2744 EngLineTo(SURFOBJ *Surface,
2745           CLIPOBJ *Clip,
2746           BRUSHOBJ *Brush,
2747           LONG x1,
2748           LONG y1,
2749           LONG x2,
2750           LONG y2,
2751           RECTL *RectBounds,
2752           MIX mix)
2753 {
2754         UNIMPLEMENTED;
2755         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2756         return 0;
2757 }
2758
2759 /*
2760  * @unimplemented
2761  */
2762 HANDLE STDCALL
2763 EngLoadModule(LPWSTR pwsz)
2764 {
2765    return LoadLibraryExW ( pwsz, NULL, LOAD_LIBRARY_AS_DATAFILE);
2766 }
2767
2768
2769 /*
2770  * @unimplemented
2771  */
2772 BOOL STDCALL
2773 EngMarkBandingSurface(HSURF hsurf)
2774 {
2775         UNIMPLEMENTED;
2776         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2777         return 0;
2778 }
2779
2780 /*
2781  * @unimplemented
2782  */
2783 VOID STDCALL
2784 EngMultiByteToUnicodeN(OUT LPWSTR UnicodeString,
2785                        IN ULONG MaxBytesInUnicodeString,
2786                        OUT PULONG BytesInUnicodeString,
2787                        IN PCHAR MultiByteString,
2788                        IN ULONG BytesInMultiByteString)
2789 {
2790   RtlMultiByteToUnicodeN(
2791                      UnicodeString,
2792                      MaxBytesInUnicodeString,
2793                      BytesInUnicodeString,
2794                      MultiByteString,
2795                      BytesInMultiByteString
2796                         );
2797 }
2798
2799 /*
2800  * @unimplemented
2801  */
2802 INT STDCALL
2803 EngMultiByteToWideChar(UINT CodePage,
2804                        LPWSTR WideCharString,
2805                        INT BytesInWideCharString,
2806                        LPSTR MultiByteString,
2807                        INT BytesInMultiByteString)
2808 {
2809   return MultiByteToWideChar(
2810                          CodePage,
2811                          0,
2812                          MultiByteString,
2813                          BytesInMultiByteString,
2814                          WideCharString,
2815                         (BytesInWideCharString/sizeof(WCHAR)) /* Bytes to (in WCHARs) */
2816                             );
2817 }
2818
2819 /*
2820  * @unimplemented
2821  */
2822 BOOL STDCALL
2823 EngPaint(IN SURFOBJ *Surface,
2824          IN CLIPOBJ *ClipRegion,
2825          IN BRUSHOBJ *Brush,
2826          IN POINTL *BrushOrigin,
2827          IN MIX  Mix)
2828 {
2829         UNIMPLEMENTED;
2830         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2831         return 0;
2832 }
2833
2834 /*
2835  * @unimplemented
2836  */
2837 BOOL STDCALL
2838 EngPlgBlt(SURFOBJ *psoTrg,SURFOBJ *psoSrc,SURFOBJ *psoMsk,CLIPOBJ *pco,XLATEOBJ *pxlo,COLORADJUSTMENT *pca,POINTL *pptlBrushOrg,POINTFIX *pptfx,RECTL *prcl,POINTL *pptl,ULONG iMode)
2839 {
2840         UNIMPLEMENTED;
2841         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2842         return 0;
2843 }
2844
2845 /*
2846  * @implemented
2847  * Obsolete GDI Function
2848  * http://www.osronline.com/DDKx/graphics/gdioview_20tj.htm
2849  */
2850 BOOL STDCALL
2851 EngQueryEMFInfo(HDEV hdev,EMFINFO *pEMFInfo)
2852 {
2853   return FALSE;
2854 }
2855
2856 /*
2857  * @unimplemented
2858  */
2859 VOID STDCALL
2860 EngQueryLocalTime(PENG_TIME_FIELDS etf)
2861 {
2862   SYSTEMTIME SystemTime;
2863   GetLocalTime( &SystemTime );
2864   etf->usYear    = SystemTime.wYear;
2865   etf->usMonth   = SystemTime.wMonth;
2866   etf->usWeekday = SystemTime.wDayOfWeek;
2867   etf->usDay     = SystemTime.wDay;
2868   etf->usHour    = SystemTime.wHour;
2869   etf->usMinute  = SystemTime.wMinute;
2870   etf->usSecond  = SystemTime.wSecond;
2871   etf->usMilliseconds = SystemTime.wMilliseconds;
2872 }
2873
2874 /*
2875  * @unimplemented
2876  */
2877 VOID
2878 STDCALL
2879 EngReleaseSemaphore ( IN HSEMAPHORE hsem )
2880 {
2881   RtlLeaveCriticalSection( (PRTL_CRITICAL_SECTION) hsem);
2882 }
2883
2884
2885
2886 /*
2887  * @unimplemented
2888  */
2889 BOOL STDCALL
2890 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)
2891 {
2892         UNIMPLEMENTED;
2893         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2894         return 0;
2895 }
2896
2897 /*
2898  * @unimplemented
2899  */
2900 BOOL STDCALL
2901 EngStrokeAndFillPath(SURFOBJ *pso,PATHOBJ *ppo,CLIPOBJ *pco,XFORMOBJ *pxo,BRUSHOBJ *pboStroke,LINEATTRS *plineattrs,BRUSHOBJ *pboFill,POINTL *pptlBrushOrg,MIX mixFill,FLONG flOptions)
2902 {
2903         UNIMPLEMENTED;
2904         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2905         return 0;
2906 }
2907
2908 /*
2909  * @unimplemented
2910  */
2911 BOOL STDCALL
2912 EngStrokePath(SURFOBJ *pso,PATHOBJ *ppo,CLIPOBJ *pco,XFORMOBJ *pxo,BRUSHOBJ *pbo,POINTL *pptlBrushOrg,LINEATTRS *plineattrs,MIX mix)
2913 {
2914         UNIMPLEMENTED;
2915         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2916         return 0;
2917 }
2918
2919 /*
2920  * @unimplemented
2921  */
2922 BOOL STDCALL
2923 EngTextOut(SURFOBJ *pso,STROBJ *pstro,FONTOBJ *pfo,CLIPOBJ *pco,RECTL *prclExtra,RECTL *prclOpaque,BRUSHOBJ *pboFore,BRUSHOBJ *pboOpaque,POINTL *pptlOrg,MIX mix)
2924 {
2925         UNIMPLEMENTED;
2926         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2927         return 0;
2928 }
2929
2930 /*
2931  * @unimplemented
2932  */
2933 BOOL STDCALL
2934 EngTransparentBlt(IN SURFOBJ *Dest,
2935                   IN SURFOBJ *Source,
2936                   IN CLIPOBJ *Clip,
2937                   IN XLATEOBJ *ColorTranslation,
2938                   IN PRECTL DestRect,
2939                   IN PRECTL SourceRect,
2940                   IN ULONG TransparentColor,
2941                   IN ULONG Reserved)
2942 {
2943         UNIMPLEMENTED;
2944         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2945         return 0;
2946 }
2947
2948 /*
2949  * @unimplemented
2950  */
2951 VOID STDCALL
2952 EngUnicodeToMultiByteN(OUT PCHAR MultiByteString,
2953                        IN ULONG  MaxBytesInMultiByteString,
2954                        OUT PULONG  BytesInMultiByteString,
2955                        IN PWSTR  UnicodeString,
2956                        IN ULONG  BytesInUnicodeString)
2957 {
2958    RtlUnicodeToMultiByteN(
2959                        MultiByteString,
2960                        MaxBytesInMultiByteString,
2961                        BytesInMultiByteString,
2962                        UnicodeString,
2963                        BytesInUnicodeString
2964                          );
2965 }
2966
2967 /*
2968  * @unimplemented
2969  */
2970 VOID STDCALL
2971 EngUnlockSurface(SURFOBJ *pso)
2972 {
2973         UNIMPLEMENTED;
2974         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2975 }
2976
2977 /*
2978  * @unimplemented
2979  */
2980 INT STDCALL
2981 EngWideCharToMultiByte( UINT CodePage,
2982                         LPWSTR WideCharString,
2983                         INT BytesInWideCharString,
2984                         LPSTR MultiByteString,
2985                         INT BytesInMultiByteString)
2986 {
2987   return WideCharToMultiByte(
2988                          CodePage,
2989                          0,
2990                          WideCharString,
2991                         (BytesInWideCharString/sizeof(WCHAR)), /* Bytes to (in WCHARs) */
2992                          MultiByteString,
2993                          BytesInMultiByteString,
2994                          NULL,
2995                          NULL);
2996 }
2997
2998 /*
2999  * @unimplemented
3000  */
3001 ULONG
3002 STDCALL
3003 FONTOBJ_cGetAllGlyphHandles(IN FONTOBJ *FontObj,
3004                             IN HGLYPH  *Glyphs)
3005 {
3006         UNIMPLEMENTED;
3007         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3008         return 0;
3009 }
3010
3011 /*
3012  * @unimplemented
3013  */
3014 ULONG
3015 STDCALL
3016 FONTOBJ_cGetGlyphs(IN FONTOBJ *FontObj,
3017                    IN ULONG    Mode,
3018                    IN ULONG    NumGlyphs,
3019                    IN HGLYPH  *GlyphHandles,
3020                    IN PVOID   *OutGlyphs)
3021 {
3022         UNIMPLEMENTED;
3023         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3024         return 0;
3025 }
3026
3027 /*
3028  * @unimplemented
3029  */
3030 PFD_GLYPHATTR STDCALL
3031 FONTOBJ_pQueryGlyphAttrs(FONTOBJ *pfo,ULONG iMode)
3032 {
3033         UNIMPLEMENTED;
3034         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3035         return 0;
3036 }
3037
3038 /*
3039  * @unimplemented
3040  */
3041 FD_GLYPHSET *STDCALL
3042 FONTOBJ_pfdg(FONTOBJ *pfo)
3043 {
3044         UNIMPLEMENTED;
3045         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3046         return 0;
3047 }
3048
3049 /*
3050  * @unimplemented
3051  */
3052 IFIMETRICS*
3053 STDCALL
3054 FONTOBJ_pifi(IN FONTOBJ  *FontObj)
3055 {
3056         UNIMPLEMENTED;
3057         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3058         return 0;
3059 }
3060
3061 /*
3062  * @unimplemented
3063  */
3064 PVOID
3065 STDCALL
3066 FONTOBJ_pvTrueTypeFontFile(IN FONTOBJ  *FontObj,
3067                            IN ULONG    *FileSize)
3068 {
3069         UNIMPLEMENTED;
3070         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3071         return 0;
3072 }
3073
3074 /*
3075  * @unimplemented
3076  */
3077 XFORMOBJ*
3078 STDCALL
3079 FONTOBJ_pxoGetXform(IN FONTOBJ  *FontObj)
3080 {
3081         UNIMPLEMENTED;
3082         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3083         return 0;
3084 }
3085
3086 /*
3087  * @unimplemented
3088  */
3089 VOID
3090 STDCALL
3091 FONTOBJ_vGetInfo(IN  FONTOBJ   *FontObj,
3092                  IN  ULONG      InfoSize,
3093                  OUT PFONTINFO  FontInfo)
3094 {
3095         UNIMPLEMENTED;
3096         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3097 }
3098
3099 /*
3100  * @unimplemented
3101  */
3102 BOOL STDCALL
3103 PATHOBJ_bEnum(PATHOBJ *ppo,PATHDATA *ppd)
3104 {
3105         UNIMPLEMENTED;
3106         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3107         return 0;
3108 }
3109
3110 /*
3111  * @unimplemented
3112  */
3113 BOOL STDCALL
3114 PATHOBJ_bEnumClipLines(PATHOBJ *ppo,ULONG cb,CLIPLINE *pcl)
3115 {
3116         UNIMPLEMENTED;
3117         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3118         return 0;
3119 }
3120
3121 /*
3122  * @unimplemented
3123  */
3124 VOID STDCALL
3125 PATHOBJ_vEnumStart(PATHOBJ *ppo)
3126 {
3127         UNIMPLEMENTED;
3128         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3129 }
3130
3131 /*
3132  * @unimplemented
3133  */
3134 VOID STDCALL
3135 PATHOBJ_vEnumStartClipLines(PATHOBJ *ppo,CLIPOBJ *pco,SURFOBJ *pso,LINEATTRS *pla)
3136 {
3137         UNIMPLEMENTED;
3138         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3139 }
3140
3141 /*
3142  * @unimplemented
3143  */
3144 VOID STDCALL
3145 PATHOBJ_vGetBounds(PATHOBJ *ppo,PRECTFX prectfx)
3146 {
3147         UNIMPLEMENTED;
3148         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3149 }
3150
3151 /*
3152  * @unimplemented
3153  */
3154 BOOL STDCALL
3155 STROBJ_bEnum(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
3156 {
3157         UNIMPLEMENTED;
3158         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3159         return 0;
3160 }
3161
3162 /*
3163  * @unimplemented
3164  */
3165 BOOL STDCALL
3166 STROBJ_bEnumPositionsOnly(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
3167 {
3168         UNIMPLEMENTED;
3169         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3170         return 0;
3171 }
3172
3173 /*
3174  * @unimplemented
3175  */
3176 BOOL STDCALL
3177 STROBJ_bGetAdvanceWidths(STROBJ *pso,ULONG iFirst,ULONG c,POINTQF *pptqD)
3178 {
3179         UNIMPLEMENTED;
3180         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3181         return 0;
3182 }
3183
3184 /*
3185  * @unimplemented
3186  */
3187 DWORD STDCALL
3188 STROBJ_dwGetCodePage(STROBJ  *pstro)
3189 {
3190         UNIMPLEMENTED;
3191         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3192         return 0;
3193 }
3194
3195 /*
3196  * @unimplemented
3197  */
3198 VOID STDCALL
3199 STROBJ_vEnumStart(STROBJ *pstro)
3200 {
3201         UNIMPLEMENTED;
3202         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3203 }
3204
3205 /*
3206  * @unimplemented
3207  */
3208 BOOL STDCALL
3209 XFORMOBJ_bApplyXform(XFORMOBJ *pxo,ULONG iMode,ULONG cPoints,PVOID pvIn,PVOID pvOut)
3210 {
3211         UNIMPLEMENTED;
3212         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3213         return 0;
3214 }
3215
3216 /*
3217  * @unimplemented
3218  */
3219 ULONG STDCALL
3220 XFORMOBJ_iGetXform(XFORMOBJ *pxo,XFORML *pxform)
3221 {
3222         UNIMPLEMENTED;
3223         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3224         return 0;
3225 }
3226
3227 /*
3228  * @unimplemented
3229  */
3230 ULONG STDCALL
3231 XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj,
3232                      ULONG PalOutType,
3233                      ULONG cPal,
3234                      ULONG *OutPal)
3235 {
3236         UNIMPLEMENTED;
3237         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3238         return 0;
3239 }
3240
3241 /*
3242  * @unimplemented
3243  */
3244 HANDLE STDCALL
3245 XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo)
3246 {
3247         UNIMPLEMENTED;
3248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3249         return 0;
3250 }
3251
3252 /*
3253  * @unimplemented
3254  */
3255 ULONG STDCALL
3256 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
3257                 ULONG Color)
3258 {
3259         UNIMPLEMENTED;
3260         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3261         return 0;
3262 }
3263
3264 /*
3265  * @unimplemented
3266  */
3267 ULONG * STDCALL
3268 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
3269 {
3270   return XlateObj->pulXlate;
3271 }
3272
3273 /*
3274  * @unimplemented
3275  */
3276 BOOL
3277 STDCALL
3278 GdiPlayEMF
3279 (
3280         LPWSTR     pwszPrinterName,
3281         LPDEVMODEW pDevmode,
3282         LPWSTR     pwszDocName,
3283         EMFPLAYPROC pfnEMFPlayFn,
3284         HANDLE     hPageQuery
3285 )
3286 {
3287         UNIMPLEMENTED;
3288         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3289         return 0;
3290 }
3291
3292 /*
3293  * @unimplemented
3294  */
3295 BOOL
3296 STDCALL
3297 GdiInitSpool(VOID)
3298 {
3299         UNIMPLEMENTED;
3300         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3301         return 0;
3302 }
3303
3304 /*
3305  * @unimplemented
3306  */
3307 BOOL
3308 STDCALL
3309 GdiPlayPrivatePageEMF
3310 (
3311         HANDLE  SpoolFileHandle,
3312         DWORD   unknown,
3313         RECT    *prectDocument
3314 )
3315 {
3316         UNIMPLEMENTED;
3317         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3318         return 0;
3319 }
3320
3321 /*
3322  * @unimplemented
3323  */
3324 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
3325 {
3326         UNIMPLEMENTED;
3327         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3328 }