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  * @implemented
 104  */
 105 UINT
 106 STDCALL
 107 GetBoundsRect(
 108         HDC     hdc,
 109         LPRECT  lprcBounds,
 110         UINT    flags
 111         )
 112 {
 113     return NtGdiGetBoundsRect(hdc,lprcBounds,flags & DCB_RESET);
 114 }
 115
 116
 117 /*
 118  * @implemented
 119  */
 120 int
 121 STDCALL
 122 GetMetaRgn(HDC hdc,
 123            HRGN hrgn)
 124 {
 125     return NtGdiGetRandomRgn(hdc,hrgn,2);
 126 }
 127
 128
 129 /*
 130  * @unimplemented
 131  */
 132 UINT
 133 STDCALL
 134 GetMetaFileBitsEx(
 135         HMETAFILE       a0,
 136         UINT            a1,
 137         LPVOID          a2
 138         )
 139 {
 140         UNIMPLEMENTED;
 141         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 142         return 0;
 143 }
 144
 145
 146
 147 /*
 148  * @unimplemented
 149  */
 150 DWORD
 151 STDCALL
 152 GetFontLanguageInfo(
 153         HDC     hDc
 154         )
 155 {
 156         UNIMPLEMENTED;
 157         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 158         return 0;
 159 }
 160
 161 /*
 162  * @unimplemented
 163  */
 164 BOOL
 165 STDCALL
 166 PlayMetaFile(
 167         HDC             a0,
 168         HMETAFILE       a1
 169         )
 170 {
 171         UNIMPLEMENTED;
 172         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 173         return FALSE;
 174 }
 175
 176 /*
 177  * @unimplemented
 178  */
 179 BOOL
 180 STDCALL
 181 ResizePalette(
 182         HPALETTE        a0,
 183         UINT            a1
 184         )
 185 {
 186         UNIMPLEMENTED;
 187         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 188         return FALSE;
 189 }
 190
 191 /*
 192  * @unimplemented
 193  */
 194 int
 195 STDCALL
 196 SetMetaRgn(
 197         HDC     hdc
 198         )
 199 {
 200         UNIMPLEMENTED;
 201         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 202         return 0;
 203 }
 204
 205 /*
 206  * @unimplemented
 207  */
 208 UINT
 209 STDCALL
 210 SetBoundsRect(
 211         HDC             a0,
 212         CONST RECT      *a1,
 213         UINT            a2
 214         )
 215 {
 216         UNIMPLEMENTED;
 217         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 218         return 0;
 219 }
 220
 221
 222 /*
 223  * @unimplemented
 224  */
 225 DWORD
 226 STDCALL
 227 SetMapperFlags(
 228         HDC     a0,
 229         DWORD   a1
 230         )
 231 {
 232         UNIMPLEMENTED;
 233         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 234         return 0;
 235 }
 236
 237 /*
 238  * @unimplemented
 239  */
 240 HMETAFILE
 241 STDCALL
 242 SetMetaFileBitsEx(
 243         UINT            a0,
 244         CONST BYTE      *a1
 245         )
 246 {
 247         UNIMPLEMENTED;
 248         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 249         return 0;
 250 }
 251
 252 /*
 253  * @unimplemented
 254  */
 255 UINT
 256 STDCALL
 257 SetSystemPaletteUse(
 258         HDC     a0,
 259         UINT    a1
 260         )
 261 {
 262         UNIMPLEMENTED;
 263         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 264         return 0;
 265 }
 266
 267 /*
 268  * @unimplemented
 269  */
 270 BOOL
 271 STDCALL
 272 SetTextJustification(
 273         HDC     a0,
 274         int     a1,
 275         int     a2
 276         )
 277 {
 278         UNIMPLEMENTED;
 279         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 280         return FALSE;
 281 }
 282
 283 /*
 284  * @unimplemented
 285  */
 286 BOOL
 287 STDCALL
 288 UpdateColors(
 289         HDC     hdc
 290         )
 291 {
 292         UNIMPLEMENTED;
 293         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 294         return FALSE;
 295 }
 296
 297
 298 /*
 299  * @unimplemented
 300  */
 301 BOOL
 302 STDCALL
 303 PlayMetaFileRecord(
 304         HDC             a0,
 305         LPHANDLETABLE   a1,
 306         LPMETARECORD    a2,
 307         UINT            a3
 308         )
 309 {
 310         UNIMPLEMENTED;
 311         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 312         return FALSE;
 313 }
 314
 315
 316 /*
 317  * @unimplemented
 318  */
 319 BOOL
 320 STDCALL
 321 EnumMetaFile(
 322         HDC                     a0,
 323         HMETAFILE               a1,
 324         MFENUMPROC              a2,
 325         LPARAM                  a3
 326         )
 327 {
 328         UNIMPLEMENTED;
 329         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 330         return FALSE;
 331 }
 332
 333 /*
 334  * @unimplemented
 335  */
 336 BOOL
 337 STDCALL
 338 DeleteEnhMetaFile(
 339         HENHMETAFILE    a0
 340         )
 341 {
 342         UNIMPLEMENTED;
 343         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 344         return FALSE;
 345 }
 346
 347 /*
 348  * @unimplemented
 349  */
 350 BOOL
 351 STDCALL
 352 EnumEnhMetaFile(
 353         HDC             a0,
 354         HENHMETAFILE    a1,
 355         ENHMFENUMPROC   a2,
 356         LPVOID          a3,
 357         CONST RECT      *a4
 358         )
 359 {
 360         UNIMPLEMENTED;
 361         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 362         return FALSE;
 363 }
 364
 365 /*
 366  * @unimplemented
 367  */
 368 UINT
 369 STDCALL
 370 GetEnhMetaFileBits(
 371         HENHMETAFILE    a0,
 372         UINT            a1,
 373         LPBYTE          a2
 374         )
 375 {
 376         UNIMPLEMENTED;
 377         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 378         return 0;
 379 }
 380
 381
 382 /*
 383  * @unimplemented
 384  */
 385 UINT
 386 STDCALL
 387 GetEnhMetaFileHeader(
 388         HENHMETAFILE    a0,
 389         UINT            a1,
 390         LPENHMETAHEADER a2
 391         )
 392 {
 393         UNIMPLEMENTED;
 394         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 395         return 0;
 396 }
 397
 398 /*
 399  * @unimplemented
 400  */
 401 UINT
 402 STDCALL
 403 GetEnhMetaFilePaletteEntries(
 404         HENHMETAFILE    a0,
 405         UINT            a1,
 406         LPPALETTEENTRY  a2
 407         )
 408 {
 409         UNIMPLEMENTED;
 410         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 411         return 0;
 412 }
 413
 414 /*
 415  * @unimplemented
 416  */
 417 UINT
 418 STDCALL
 419 GetWinMetaFileBits(
 420         HENHMETAFILE    a0,
 421         UINT            a1,
 422         LPBYTE          a2,
 423         INT             a3,
 424         HDC             a4
 425         )
 426 {
 427         UNIMPLEMENTED;
 428         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 429         return 0;
 430 }
 431
 432
 433 /*
 434  * @unimplemented
 435  */
 436 BOOL
 437 STDCALL
 438 PlayEnhMetaFile(
 439         HDC             a0,
 440         HENHMETAFILE    a1,
 441         CONST RECT      *a2
 442         )
 443 {
 444         UNIMPLEMENTED;
 445         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 446         return FALSE;
 447 }
 448
 449
 450 /*
 451  * @unimplemented
 452  */
 453 BOOL
 454 STDCALL
 455 PlayEnhMetaFileRecord(
 456         HDC                     a0,
 457         LPHANDLETABLE           a1,
 458         CONST ENHMETARECORD     *a2,
 459         UINT                    a3
 460         )
 461 {
 462         UNIMPLEMENTED;
 463         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 464         return FALSE;
 465 }
 466
 467
 468 /*
 469  * @unimplemented
 470  */
 471 HENHMETAFILE
 472 STDCALL
 473 SetEnhMetaFileBits(
 474         UINT            a0,
 475         CONST BYTE      *a1
 476         )
 477 {
 478         UNIMPLEMENTED;
 479         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 480         return 0;
 481 }
 482
 483
 484 /*
 485  * @unimplemented
 486  */
 487 HENHMETAFILE
 488 STDCALL
 489 SetWinMetaFileBits(
 490         UINT                    a0,
 491         CONST BYTE              *a1,
 492         HDC                     a2,
 493         CONST METAFILEPICT      *a3)
 494 {
 495         UNIMPLEMENTED;
 496         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 497         return 0;
 498 }
 499
 500
 501 /*
 502  * @unimplemented
 503  */
 504 BOOL
 505 STDCALL
 506 GdiComment(
 507         HDC             hDC,
 508         UINT            bytes,
 509         CONST BYTE      *buffer
 510         )
 511 {
 512 #if 0
 513   if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF)
 514   {
 515      PLDC pLDC = GdiGetLDC(hDC);
 516      if ( !pLDC )
 517      {
 518         SetLastError(ERROR_INVALID_HANDLE);
 519         return FALSE;
 520      }
 521      if (pLDC->iType == LDC_EMFLDC)
 522      {          // Wine port
 523          return EMFDRV_GdiComment( hDC, bytes, buffer );
 524      }
 525   }
 526 #endif
 527   return FALSE;
 528 }
 529
 530
 531 /*
 532  * @unimplemented
 533  */
 534 BOOL
 535 STDCALL
 536 AngleArc(
 537         HDC     hdc,
 538         int     a1,
 539         int     a2,
 540         DWORD   a3,
 541         FLOAT   a4,
 542         FLOAT   a5
 543         )
 544 {
 545         UNIMPLEMENTED;
 546         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 547         return FALSE;
 548 }
 549
 550
 551 /*
 552  * @unimplemented
 553  */
 554 BOOL
 555 STDCALL
 556 SetColorAdjustment(
 557         HDC                     hdc,
 558         CONST COLORADJUSTMENT   *a1
 559         )
 560 {
 561         UNIMPLEMENTED;
 562         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 563         return FALSE;
 564 }
 565
 566 /*
 567  * @unimplemented
 568  */
 569 int
 570 STDCALL
 571 EndDoc(
 572         HDC     hdc
 573         )
 574 {
 575         UNIMPLEMENTED;
 576         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 577         return 0;
 578 }
 579
 580
 581 /*
 582  * @unimplemented
 583  */
 584 int
 585 STDCALL
 586 StartPage(
 587         HDC     hdc
 588         )
 589 {
 590         UNIMPLEMENTED;
 591         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 592         return 0;
 593 }
 594
 595
 596 /*
 597  * @unimplemented
 598  */
 599 int
 600 STDCALL
 601 EndPage(
 602         HDC     hdc
 603         )
 604 {
 605         UNIMPLEMENTED;
 606         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 607         return 0;
 608 }
 609
 610
 611 /*
 612  * @unimplemented
 613  */
 614 int
 615 STDCALL
 616 AbortDoc(
 617         HDC     hdc
 618         )
 619 {
 620         UNIMPLEMENTED;
 621         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 622         return 0;
 623 }
 624
 625
 626 /*
 627  * @unimplemented
 628  */
 629 int
 630 STDCALL
 631 SetAbortProc(
 632         HDC             hdc,
 633         ABORTPROC       a1
 634         )
 635 {
 636         UNIMPLEMENTED;
 637         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 638         return 0;
 639 }
 640
 641
 642 /*
 643  * @unimplemented
 644  */
 645 BOOL
 646 STDCALL
 647 ScaleViewportExtEx(
 648         HDC     a0,
 649         int     a1,
 650         int     a2,
 651         int     a3,
 652         int     a4,
 653         LPSIZE  a5
 654         )
 655 {
 656         UNIMPLEMENTED;
 657         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 658         return FALSE;
 659 }
 660
 661
 662 /*
 663  * @unimplemented
 664  */
 665 BOOL
 666 STDCALL
 667 ScaleWindowExtEx(
 668         HDC     a0,
 669         int     a1,
 670         int     a2,
 671         int     a3,
 672         int     a4,
 673         LPSIZE  a5
 674         )
 675 {
 676         UNIMPLEMENTED;
 677         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 678         return FALSE;
 679 }
 680
 681
 682 /*
 683  * @implemented
 684  */
 685 BOOL
 686 STDCALL
 687 UnrealizeObject(
 688         HGDIOBJ a0
 689         )
 690 {
 691         return NtGdiUnrealizeObject(a0);
 692 }
 693
 694
 695 /*
 696  * @implemented
 697  */
 698 BOOL
 699 STDCALL
 700 GdiFlush()
 701 {
 702     NtGdiFlush();
 703     return TRUE;
 704 }
 705
 706
 707 /*
 708  * @unimplemented
 709  */
 710 int
 711 STDCALL
 712 SetICMMode(
 713         HDC     a0,
 714         int     a1
 715         )
 716 {
 717         UNIMPLEMENTED;
 718         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 719         return 0;
 720 }
 721
 722
 723 /*
 724  * @unimplemented
 725  */
 726 BOOL
 727 STDCALL
 728 CheckColorsInGamut(
 729         HDC     a0,
 730         LPVOID  a1,
 731         LPVOID  a2,
 732         DWORD   a3
 733         )
 734 {
 735         UNIMPLEMENTED;
 736         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 737         return FALSE;
 738 }
 739
 740
 741 /*
 742  * @unimplemented
 743  */
 744 HCOLORSPACE
 745 STDCALL
 746 GetColorSpace(
 747         HDC     hDc
 748         )
 749 {
 750         UNIMPLEMENTED;
 751         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 752         return 0;
 753 }
 754
 755
 756 /*
 757  * @unimplemented
 758  */
 759 HCOLORSPACE
 760 STDCALL
 761 SetColorSpace(
 762         HDC             a0,
 763         HCOLORSPACE     a1
 764         )
 765 {
 766         UNIMPLEMENTED;
 767         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 768         return FALSE;
 769 }
 770
 771 /*
 772  * @implemented
 773  */
 774 BOOL
 775 STDCALL
 776 GetDeviceGammaRamp( HDC hdc,
 777                     LPVOID lpGammaRamp)
 778 {
 779     BOOL retValue = FALSE;
 780     if (lpGammaRamp == NULL)
 781     {
 782         SetLastError(ERROR_INVALID_PARAMETER);
 783     }
 784     else
 785     {
 786         retValue = NtGdiGetDeviceGammaRamp(hdc,lpGammaRamp);
 787     }
 788
 789     return retValue;
 790 }
 791
 792
 793
 794
 795
 796
 797 /*
 798  * @unimplemented
 799  */
 800 BOOL
 801 STDCALL
 802 SetDeviceGammaRamp(
 803         HDC     a0,
 804         LPVOID  a1
 805         )
 806 {
 807         UNIMPLEMENTED;
 808         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 809         return FALSE;
 810 }
 811
 812
 813 /*
 814  * @unimplemented
 815  */
 816 BOOL
 817 STDCALL
 818 ColorMatchToTarget(
 819         HDC     a0,
 820         HDC     a1,
 821         DWORD   a2
 822         )
 823 {
 824         UNIMPLEMENTED;
 825         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 826         return FALSE;
 827 }
 828
 829
 830 /*
 831  * @unimplemented
 832  */
 833 BOOL
 834 STDCALL
 835 wglCopyContext(
 836         HGLRC   a0,
 837         HGLRC   a1,
 838         UINT    a2
 839         )
 840 {
 841         UNIMPLEMENTED;
 842         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 843         return FALSE;
 844 }
 845
 846
 847 /*
 848  * @unimplemented
 849  */
 850 HGLRC
 851 STDCALL
 852 wglCreateContext(
 853         HDC     hDc
 854         )
 855 {
 856         UNIMPLEMENTED;
 857         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 858         return 0;
 859 }
 860
 861
 862 /*
 863  * @unimplemented
 864  */
 865 HGLRC
 866 STDCALL
 867 wglCreateLayerContext(
 868         HDC     hDc,
 869         int     a1
 870         )
 871 {
 872         UNIMPLEMENTED;
 873         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 874         return 0;
 875 }
 876
 877
 878 /*
 879  * @unimplemented
 880  */
 881 BOOL
 882 STDCALL
 883 wglDeleteContext(
 884         HGLRC   a
 885         )
 886 {
 887         UNIMPLEMENTED;
 888         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 889         return FALSE;
 890 }
 891
 892
 893 /*
 894  * @unimplemented
 895  */
 896 HGLRC
 897 STDCALL
 898 wglGetCurrentContext(VOID)
 899 {
 900         UNIMPLEMENTED;
 901         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 902         return 0;
 903 }
 904
 905
 906 /*
 907  * @unimplemented
 908  */
 909 HDC
 910 STDCALL
 911 wglGetCurrentDC(VOID)
 912 {
 913         UNIMPLEMENTED;
 914         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 915         return 0;
 916 }
 917
 918
 919 /*
 920  * @unimplemented
 921  */
 922 PROC
 923 STDCALL
 924 wglGetProcAddress(
 925         LPCSTR          a0
 926         )
 927 {
 928         UNIMPLEMENTED;
 929         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 930         return 0;
 931 }
 932
 933
 934 /*
 935  * @unimplemented
 936  */
 937 BOOL
 938 STDCALL
 939 wglMakeCurrent(
 940         HDC     a0,
 941         HGLRC   a1
 942         )
 943 {
 944         UNIMPLEMENTED;
 945         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 946         return FALSE;
 947 }
 948
 949
 950 /*
 951  * @unimplemented
 952  */
 953 BOOL
 954 STDCALL
 955 wglShareLists(
 956         HGLRC   a0,
 957         HGLRC   a1
 958         )
 959 {
 960         UNIMPLEMENTED;
 961         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 962         return FALSE;
 963 }
 964
 965
 966 /*
 967  * @unimplemented
 968  */
 969 BOOL
 970 STDCALL
 971 wglDescribeLayerPlane(
 972         HDC                     a0,
 973         int                     a1,
 974         int                     a2,
 975         UINT                    a3,
 976         LPLAYERPLANEDESCRIPTOR  a4
 977         )
 978 {
 979         UNIMPLEMENTED;
 980         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 981         return FALSE;
 982 }
 983
 984
 985 /*
 986  * @unimplemented
 987  */
 988 int
 989 STDCALL
 990 wglSetLayerPaletteEntries(
 991         HDC             a0,
 992         int             a1,
 993         int             a2,
 994         int             a3,
 995         CONST COLORREF  *a4
 996         )
 997 {
 998         UNIMPLEMENTED;
 999         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1000         return 0;
1001 }
1002
1003
1004 /*
1005  * @unimplemented
1006  */
1007 int
1008 STDCALL
1009 wglGetLayerPaletteEntries(
1010         HDC             a0,
1011         int             a1,
1012         int             a2,
1013         int             a3,
1014         COLORREF        *a4
1015         )
1016 {
1017         UNIMPLEMENTED;
1018         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1019         return 0;
1020 }
1021
1022
1023 /*
1024  * @unimplemented
1025  */
1026 BOOL
1027 STDCALL
1028 wglRealizeLayerPalette(
1029         HDC             a0,
1030         int             a1,
1031         BOOL            a2
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 wglSwapLayerBuffers(
1046         HDC             a0,
1047         UINT            a1
1048         )
1049 {
1050         UNIMPLEMENTED;
1051         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1052         return FALSE;
1053 }
1054
1055
1056 /* === AFTER THIS POINT I GUESS... =========
1057  * (based on stack size in Norlander's .def)
1058  * === WHERE ARE THEY DEFINED? =============
1059  */
1060
1061
1062
1063
1064
1065
1066
1067
1068 /*
1069  * @unimplemented
1070  */
1071 DWORD
1072 STDCALL
1073 IsValidEnhMetaRecord(
1074         DWORD   a0,
1075         DWORD   a1
1076         )
1077 {
1078         UNIMPLEMENTED;
1079         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1080         return 0;
1081
1082 }
1083
1084 /*
1085  * @unimplemented
1086  */
1087 DWORD
1088 STDCALL
1089 IsValidEnhMetaRecordOffExt(
1090         DWORD   a0,
1091         DWORD   a1,
1092         DWORD   a2,
1093         DWORD   a3
1094         )
1095 {
1096         UNIMPLEMENTED;
1097         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1098         return 0;
1099
1100 }
1101
1102 /*
1103  * @unimplemented
1104  */
1105 DWORD
1106 STDCALL
1107 GetGlyphOutlineWow(
1108         DWORD   a0,
1109         DWORD   a1,
1110         DWORD   a2,
1111         DWORD   a3,
1112         DWORD   a4,
1113         DWORD   a5,
1114         DWORD   a6
1115         )
1116 {
1117         UNIMPLEMENTED;
1118         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1119         return 0;
1120 }
1121
1122
1123
1124
1125
1126 /*
1127  * @unimplemented
1128  */
1129 DWORD
1130 STDCALL
1131 SetFontEnumeration(
1132         DWORD   a0
1133         )
1134 {
1135         UNIMPLEMENTED;
1136         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1137         return 0;
1138 }
1139
1140
1141 /*
1142  * @unimplemented
1143  */
1144 DWORD
1145 STDCALL
1146 gdiPlaySpoolStream(
1147         DWORD   a0,
1148         DWORD   a1,
1149         DWORD   a2,
1150         DWORD   a3,
1151         DWORD   a4,
1152         DWORD   a5
1153         )
1154 {
1155         UNIMPLEMENTED;
1156         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1157         return 0;
1158 }
1159
1160 /*
1161  * @unimplemented
1162  */
1163 HANDLE
1164 STDCALL
1165 AddFontMemResourceEx(
1166         PVOID pbFont,
1167         DWORD cbFont,
1168         PVOID pdv,
1169         DWORD *pcFonts
1170 )
1171 {
1172         UNIMPLEMENTED;
1173         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1174         return 0;
1175 }
1176
1177 /*
1178  * @unimplemented
1179  */
1180 int
1181 STDCALL
1182 AddFontResourceTracking(
1183         LPCSTR lpString,
1184         int unknown
1185 )
1186 {
1187         UNIMPLEMENTED;
1188         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1189         return 0;
1190 }
1191
1192
1193
1194 /*
1195  * @unimplemented
1196  */
1197 HBITMAP
1198 STDCALL
1199 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1200 {
1201         UNIMPLEMENTED;
1202         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1203         return 0;
1204 }
1205
1206 /*
1207  * @unimplemented
1208  */
1209 HBRUSH
1210 STDCALL
1211 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1212 {
1213         UNIMPLEMENTED;
1214         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1215         return 0;
1216 }
1217
1218 /*
1219  * @unimplemented
1220  */
1221 BOOL
1222 STDCALL
1223 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
1224 {
1225         UNIMPLEMENTED;
1226         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1227         return 0;
1228 }
1229
1230 /*
1231  * @unimplemented
1232  */
1233 int
1234 STDCALL
1235 EndFormPage(HDC hdc)
1236 {
1237         UNIMPLEMENTED;
1238         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1239         return 0;
1240 }
1241
1242
1243
1244 /*
1245  * @unimplemented
1246  */
1247 DWORD
1248 STDCALL
1249 GdiAddGlsBounds(HDC hdc,LPRECT prc)
1250 {
1251         UNIMPLEMENTED;
1252         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1253         return 0;
1254 }
1255
1256 /*
1257  * @unimplemented
1258  */
1259 BOOL
1260 STDCALL
1261 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
1262 {
1263         UNIMPLEMENTED;
1264         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1265         return 0;
1266 }
1267
1268 /*
1269  * @unimplemented
1270  */
1271 BOOL
1272 STDCALL
1273 GdiCleanCacheDC(HDC hdc)
1274 {
1275         UNIMPLEMENTED;
1276         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1277         return 0;
1278 }
1279
1280 /*
1281  * @unimplemented
1282  */
1283 HDC
1284 STDCALL
1285 GdiConvertAndCheckDC(HDC hdc)
1286 {
1287         UNIMPLEMENTED;
1288         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1289         return 0;
1290 }
1291
1292 /*
1293  * @unimplemented
1294  */
1295 HENHMETAFILE
1296 STDCALL
1297 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
1298 {
1299         UNIMPLEMENTED;
1300         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1301         return 0;
1302 }
1303
1304 /*
1305  * @unimplemented
1306  */
1307 BOOL
1308 STDCALL
1309 GdiDrawStream(HDC dc, ULONG l, VOID *v)
1310 {
1311         UNIMPLEMENTED;
1312         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1313         return 0;
1314 }
1315
1316 /*
1317  * @unimplemented
1318  */
1319 DWORD
1320 STDCALL
1321 GdiGetCodePage(HDC hdc)
1322 {
1323         UNIMPLEMENTED;
1324         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1325         return 0;
1326 }
1327
1328 /*
1329  * @unimplemented
1330  */
1331 HBRUSH
1332 STDCALL
1333 GdiGetLocalBrush(HBRUSH hbr)
1334 {
1335         UNIMPLEMENTED;
1336         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1337         return 0;
1338 }
1339
1340 /*
1341  * @unimplemented
1342  */
1343 HDC
1344 STDCALL
1345 GdiGetLocalDC(HDC hdc)
1346 {
1347         UNIMPLEMENTED;
1348         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1349         return 0;
1350 }
1351
1352 /*
1353  * @unimplemented
1354  */
1355 HFONT
1356 STDCALL
1357 GdiGetLocalFont(HFONT hfont)
1358 {
1359         UNIMPLEMENTED;
1360         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1361         return 0;
1362 }
1363
1364 /*
1365  * @unimplemented
1366  */
1367 BOOL
1368 STDCALL
1369 GdiIsMetaFileDC(HDC hdc)
1370 {
1371         UNIMPLEMENTED;
1372         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1373         return 0;
1374 }
1375
1376 /*
1377  * @unimplemented
1378  */
1379 BOOL
1380 STDCALL
1381 GdiIsMetaPrintDC(HDC hdc)
1382 {
1383         UNIMPLEMENTED;
1384         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1385         return 0;
1386 }
1387
1388 /*
1389  * @unimplemented
1390  */
1391 BOOL
1392 STDCALL
1393 GdiIsPlayMetafileDC(HDC hdc)
1394 {
1395         UNIMPLEMENTED;
1396         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1397         return 0;
1398 }
1399
1400 /*
1401  * @unimplemented
1402  */
1403 BOOL
1404 STDCALL
1405 GdiValidateHandle(HGDIOBJ hobj)
1406 {
1407         UNIMPLEMENTED;
1408         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1409         return 0;
1410 }
1411
1412 /*
1413  * @unimplemented
1414  */
1415 DWORD
1416 STDCALL
1417 GetBitmapAttributes(HBITMAP hbm)
1418 {
1419         UNIMPLEMENTED;
1420         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421         return 0;
1422 }
1423
1424 /*
1425  * @unimplemented
1426  */
1427 DWORD
1428 STDCALL
1429 GetBrushAttributes(HBRUSH hbr)
1430 {
1431         UNIMPLEMENTED;
1432         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1433         return 0;
1434 }
1435
1436 /*
1437  * @unimplemented
1438  */
1439 BOOL
1440 STDCALL
1441 GetCharABCWidthsI(
1442         HDC hdc,
1443         UINT giFirst,
1444         UINT cgi,
1445         LPWORD pgi,
1446         LPABC lpabc
1447 )
1448 {
1449         UNIMPLEMENTED;
1450         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1451         return 0;
1452 }
1453
1454 /*
1455  * @unimplemented
1456  */
1457 BOOL
1458 STDCALL
1459 GetCharWidthI(
1460         HDC hdc,
1461         UINT giFirst,
1462         UINT cgi,
1463         LPWORD pgi,
1464         LPINT lpBuffer
1465 )
1466 {
1467         UNIMPLEMENTED;
1468         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1469         return 0;
1470 }
1471
1472
1473
1474 /*
1475  * @implemented
1476  */
1477 ULONG
1478 STDCALL
1479 GetEUDCTimeStamp(VOID)
1480 {
1481     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1482 }
1483
1484 /*
1485  * @implemented
1486  */
1487 ULONG
1488 STDCALL
1489 GetFontAssocStatus(HDC hdc)
1490 {
1491     ULONG retValue = 0;
1492
1493     if (hdc)
1494     {
1495         retValue = NtGdiQueryFontAssocInfo(hdc);
1496     }
1497
1498     return retValue;
1499 }
1500
1501 /*
1502  * @unimplemented
1503  */
1504 HFONT
1505 STDCALL
1506 GetHFONT(HDC dc)
1507 {
1508         UNIMPLEMENTED;
1509         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1510         return 0;
1511 }
1512
1513 /*
1514  * @unimplemented
1515  */
1516 DWORD
1517 STDCALL
1518 GetLayout(
1519         HDC hdc
1520 )
1521 {
1522         UNIMPLEMENTED;
1523         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1524         return 0;
1525 }
1526
1527 /*
1528  * @implemented
1529  */
1530 BOOL
1531 STDCALL
1532 GetTextExtentExPointWPri(HDC hdc,
1533                          LPWSTR lpwsz,
1534                          ULONG cwc,
1535                          ULONG dxMax,
1536                          ULONG *pcCh,
1537                          PULONG pdxOut,
1538                          LPSIZE psize)
1539 {
1540     return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1541 }
1542
1543 /*
1544  * @implemented
1545  */
1546 INT
1547 STDCALL
1548 GetTextFaceAliasW(HDC hdc,
1549                   int cChar,
1550                   LPWSTR pszOut)
1551 {
1552     INT retValue = 0;
1553     if ((!pszOut) || (cChar))
1554     {
1555         retValue = NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE);
1556     }
1557     else
1558     {
1559         SetLastError(ERROR_INVALID_PARAMETER);
1560     }
1561     return retValue;
1562 }
1563
1564
1565
1566 /*
1567  * @unimplemented
1568  */
1569 BOOL
1570 STDCALL
1571 MirrorRgn(HWND hwnd,HRGN hrgn)
1572 {
1573         UNIMPLEMENTED;
1574         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1575         return 0;
1576 }
1577
1578
1579
1580 /*
1581  * @unimplemented
1582  */
1583 DWORD
1584 STDCALL
1585 QueryFontAssocStatus(VOID)
1586 {
1587         UNIMPLEMENTED;
1588         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1589         return 0;
1590 }
1591
1592 /*
1593  * @implemented
1594  */
1595 BOOL
1596 STDCALL
1597 RemoveFontMemResourceEx(HANDLE fh)
1598 {
1599     BOOL retValue=0;
1600
1601     if (fh)
1602     {
1603         retValue = NtGdiRemoveFontMemResourceEx(fh);
1604     }
1605     else
1606     {
1607         SetLastError(ERROR_INVALID_PARAMETER);
1608     }
1609     return retValue;
1610 }
1611
1612 /*
1613  * @unimplemented
1614  */
1615 int
1616 STDCALL
1617 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1618 {
1619         UNIMPLEMENTED;
1620         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1621         return 0;
1622 }
1623
1624 /*
1625  * @unimplemented
1626  */
1627 HBITMAP
1628 STDCALL
1629 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1630 {
1631         UNIMPLEMENTED;
1632         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1633         return 0;
1634 }
1635
1636 /*
1637  * @unimplemented
1638  */
1639 HBRUSH
1640 STDCALL
1641 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1642 {
1643         UNIMPLEMENTED;
1644         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1645         return 0;
1646 }
1647
1648 /*
1649  * @unimplemented
1650  */
1651 DWORD
1652 STDCALL
1653 SetLayout(
1654         HDC hdc,
1655         DWORD dwLayout
1656 )
1657 {
1658         UNIMPLEMENTED;
1659         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1660         return 0;
1661 }
1662
1663 /*
1664  * @unimplemented
1665  */
1666 DWORD
1667 STDCALL
1668 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
1669 {
1670         UNIMPLEMENTED;
1671         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1672         return 0;
1673 }
1674
1675 /*
1676  * @unimplemented
1677  */
1678 BOOL
1679 STDCALL
1680 SetMagicColors(HDC hdc,PALETTEENTRY peMagic,ULONG Index)
1681 {
1682         UNIMPLEMENTED;
1683         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1684         return 0;
1685 }
1686
1687 /*
1688  * @unimplemented
1689  */
1690 BOOL
1691 STDCALL
1692 SetVirtualResolution(HDC hdc, int cxVirtualDevicePixel,int cyVirtualDevicePixel,int cxVirtualDeviceMm, int cyVirtualDeviceMm)
1693 {
1694         UNIMPLEMENTED;
1695         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1696         return 0;
1697 }
1698
1699 /*
1700  * @unimplemented
1701  */
1702 int
1703 STDCALL
1704 StartFormPage(HDC hdc)
1705 {
1706         UNIMPLEMENTED;
1707         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1708         return 0;
1709 }
1710
1711 /*
1712  * @unimplemented
1713  */
1714 VOID
1715 STDCALL
1716 UnloadNetworkFonts(DWORD unknown)
1717 {
1718         UNIMPLEMENTED;
1719         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1720 }
1721
1722 /*
1723  * @implemented
1724  */
1725 BOOL
1726 STDCALL
1727 GetTextExtentExPointI(HDC hdc,
1728                       LPWORD pgiIn,
1729                       int cgi,
1730                       int nMaxExtent,
1731                       LPINT lpnFit,
1732                       LPINT alpDx,
1733                       LPSIZE lpSize)
1734 {
1735     return NtGdiGetTextExtentExW(hdc,pgiIn,cgi,nMaxExtent,(ULONG *)lpnFit, (PULONG) alpDx,lpSize,1);
1736 }
1737
1738 /*
1739  * @implemented
1740  */
1741 BOOL
1742 STDCALL
1743 GetTextExtentPointI(HDC hdc,
1744                     LPWORD pgiIn,
1745                     int cgi,
1746                     LPSIZE lpSize)
1747 {
1748     return NtGdiGetTextExtent(hdc,pgiIn,cgi,lpSize,2);
1749 }
1750
1751
1752
1753
1754
1755 /*
1756  * @unimplemented
1757  */
1758 BOOL
1759 STDCALL
1760 GdiRealizationInfo(HDC hdc, PREALIZATION_INFO pri)
1761 {
1762         UNIMPLEMENTED;
1763         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1764         return 0;
1765 }
1766
1767
1768
1769 /*
1770  * @unimplemented
1771  */
1772 BOOL
1773 STDCALL
1774 GetETM(HDC hdc,EXTTEXTMETRIC *petm)
1775 {
1776         UNIMPLEMENTED;
1777         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1778         return 0;
1779 }
1780
1781 /*
1782  * @unimplemented
1783  */
1784 BOOL
1785 STDCALL
1786 GdiAddGlsRecord(HDC hdc,DWORD unknown1,LPCSTR unknown2,LPRECT unknown3)
1787 {
1788         UNIMPLEMENTED;
1789         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1790         return 0;
1791 }
1792
1793 /*
1794  * @unimplemented
1795  */
1796 HANDLE
1797 STDCALL
1798 GdiConvertMetaFilePict(HGLOBAL hMem)
1799 {
1800         UNIMPLEMENTED;
1801         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1802         return 0;
1803 }
1804
1805 /*
1806  * @implemented
1807  */
1808 DEVMODEW *
1809 STDCALL
1810 GdiConvertToDevmodeW(DEVMODEA *dm)
1811 {
1812   LPDEVMODEW dmw;
1813
1814   dmw = HEAP_alloc(sizeof(DEVMODEW));
1815 #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
1816 #define COPYN(f) dmw->f = dm->f
1817   COPYS(dmDeviceName, CCHDEVICENAME );
1818   COPYN(dmSpecVersion);
1819   COPYN(dmDriverVersion);
1820   switch ( dm->dmSize )
1821     {
1822     case SIZEOF_DEVMODEA_300:
1823       dmw->dmSize = SIZEOF_DEVMODEW_300;
1824       break;
1825     case SIZEOF_DEVMODEA_400:
1826       dmw->dmSize = SIZEOF_DEVMODEW_400;
1827       break;
1828     case SIZEOF_DEVMODEA_500:
1829     default: /* FIXME what to do??? */
1830       dmw->dmSize = SIZEOF_DEVMODEW_500;
1831       break;
1832     }
1833   COPYN(dmDriverExtra);
1834   COPYN(dmFields);
1835   COPYN(dmPosition.x);
1836   COPYN(dmPosition.y);
1837   COPYN(dmScale);
1838   COPYN(dmCopies);
1839   COPYN(dmDefaultSource);
1840   COPYN(dmPrintQuality);
1841   COPYN(dmColor);
1842   COPYN(dmDuplex);
1843   COPYN(dmYResolution);
1844   COPYN(dmTTOption);
1845   COPYN(dmCollate);
1846   COPYS(dmFormName,CCHFORMNAME);
1847   COPYN(dmLogPixels);
1848   COPYN(dmBitsPerPel);
1849   COPYN(dmPelsWidth);
1850   COPYN(dmPelsHeight);
1851   COPYN(dmDisplayFlags); // aka dmNup
1852   COPYN(dmDisplayFrequency);
1853
1854   if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
1855     return dmw; // we're done with 0x300 fields
1856
1857   COPYN(dmICMMethod);
1858   COPYN(dmICMIntent);
1859   COPYN(dmMediaType);
1860   COPYN(dmDitherType);
1861   COPYN(dmReserved1);
1862   COPYN(dmReserved2);
1863
1864   if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
1865     return dmw; // we're done with 0x400 fields
1866
1867   COPYN(dmPanningWidth);
1868   COPYN(dmPanningHeight);
1869
1870   return dmw;
1871
1872 #undef COPYN
1873 #undef COPYS
1874 }
1875
1876 /*
1877  * @unimplemented
1878  */
1879 HENHMETAFILE
1880 STDCALL
1881 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
1882 {
1883         UNIMPLEMENTED;
1884         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1885         return 0;
1886 }
1887
1888 /*
1889  * @unimplemented
1890  */
1891 METAFILEPICT *
1892 STDCALL
1893 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
1894 {
1895         UNIMPLEMENTED;
1896         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1897         return 0;
1898 }
1899
1900
1901 /*
1902  * @unimplemented
1903  */
1904 HANDLE
1905 STDCALL
1906 GdiGetSpoolFileHandle(
1907         LPWSTR          pwszPrinterName,
1908         LPDEVMODEW      pDevmode,
1909         LPWSTR          pwszDocName)
1910 {
1911         UNIMPLEMENTED;
1912         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1913         return 0;
1914 }
1915
1916 /*
1917  * @unimplemented
1918  */
1919 BOOL
1920 STDCALL
1921 GdiDeleteSpoolFileHandle(
1922         HANDLE  SpoolFileHandle)
1923 {
1924         UNIMPLEMENTED;
1925         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1926         return 0;
1927 }
1928
1929 /*
1930  * @unimplemented
1931  */
1932 DWORD
1933 STDCALL
1934 GdiGetPageCount(
1935         HANDLE  SpoolFileHandle)
1936 {
1937         UNIMPLEMENTED;
1938         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1939         return 0;
1940 }
1941
1942 /*
1943  * @unimplemented
1944  */
1945 HDC
1946 STDCALL
1947 GdiGetDC(
1948         HANDLE  SpoolFileHandle)
1949 {
1950         UNIMPLEMENTED;
1951         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1952         return 0;
1953 }
1954
1955 /*
1956  * @unimplemented
1957  */
1958 HANDLE
1959 STDCALL
1960 GdiGetPageHandle(
1961         HANDLE  SpoolFileHandle,
1962         DWORD   Page,
1963         LPDWORD pdwPageType)
1964 {
1965         UNIMPLEMENTED;
1966         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1967         return 0;
1968 }
1969
1970 /*
1971  * @unimplemented
1972  */
1973 BOOL
1974 STDCALL
1975 GdiStartDocEMF(
1976         HANDLE          SpoolFileHandle,
1977         DOCINFOW        *pDocInfo)
1978 {
1979         UNIMPLEMENTED;
1980         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1981         return 0;
1982 }
1983
1984 /*
1985  * @unimplemented
1986  */
1987 BOOL
1988 STDCALL
1989 GdiStartPageEMF(
1990         HANDLE  SpoolFileHandle)
1991 {
1992         UNIMPLEMENTED;
1993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1994         return 0;
1995 }
1996
1997 /*
1998  * @unimplemented
1999  */
2000 BOOL
2001 STDCALL
2002 GdiPlayPageEMF(
2003         HANDLE  SpoolFileHandle,
2004         HANDLE  hemf,
2005         RECT    *prectDocument,
2006         RECT    *prectBorder,
2007         RECT    *prectClip)
2008 {
2009         UNIMPLEMENTED;
2010         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2011         return 0;
2012 }
2013
2014 /*
2015  * @unimplemented
2016  */
2017 BOOL
2018 STDCALL
2019 GdiEndPageEMF(
2020         HANDLE  SpoolFileHandle,
2021         DWORD   dwOptimization)
2022 {
2023         UNIMPLEMENTED;
2024         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2025         return 0;
2026 }
2027
2028 /*
2029  * @unimplemented
2030  */
2031 BOOL
2032 STDCALL
2033 GdiEndDocEMF(
2034         HANDLE  SpoolFileHandle)
2035 {
2036         UNIMPLEMENTED;
2037         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2038         return 0;
2039 }
2040
2041 /*
2042  * @unimplemented
2043  */
2044 BOOL
2045 STDCALL
2046 GdiGetDevmodeForPage(
2047         HANDLE          SpoolFileHandle,
2048         DWORD           dwPageNumber,
2049         PDEVMODEW       *pCurrDM,
2050         PDEVMODEW       *pLastDM)
2051 {
2052         UNIMPLEMENTED;
2053         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2054         return 0;
2055 }
2056
2057 /*
2058  * @unimplemented
2059  */
2060 BOOL
2061 STDCALL
2062 GdiResetDCEMF(
2063         HANDLE          SpoolFileHandle,
2064         PDEVMODEW       pCurrDM)
2065 {
2066         UNIMPLEMENTED;
2067         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2068         return 0;
2069 }
2070
2071
2072 HBITMAP
2073 STDCALL
2074 CreateDIBitmap(HDC
2075         hDc, const BITMAPINFOHEADER *Header,
2076         DWORD Init, LPCVOID Bits, const BITMAPINFO *Data,
2077         UINT ColorUse)
2078 {
2079         /* FIMXE we need do more thing in user mode */
2080         return NtGdiCreateDIBitmap(hDc, Header, Init, Bits, Data,  ColorUse);
2081 }
2082
2083 /*
2084  * @unimplemented
2085  */
2086 INT
2087 STDCALL
2088 CombineRgn(HRGN  hDest,
2089                     HRGN  hSrc1,
2090                     HRGN  hSrc2,
2091                     INT  CombineMode)
2092 {
2093     /* FIXME some part should be done in user mode */
2094     return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
2095 }
2096
2097 /*
2098  * @unimplemented
2099  */
2100 HBITMAP STDCALL
2101 CreateBitmap(
2102     INT  Width,
2103     INT  Height,
2104     UINT  Planes,
2105     UINT  BitsPixel,
2106     PCVOID pUnsafeBits)
2107 {
2108     /* FIXME some part should be done in user mode */
2109     return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
2110 }
2111
2112
2113
2114
2115 /*
2116  * @unimplemented
2117  */
2118 LPWSTR STDCALL
2119 EngGetDriverName(HDEV hdev)
2120 {
2121         UNIMPLEMENTED;
2122         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2123         return 0;
2124 }
2125
2126 /*
2127  * @unimplemented
2128  * wrong info it is not Obsolete GDI Function as http://www.osronline.com/DDKx/graphics/gdioview_20tj.htm say
2129  */
2130 BOOL STDCALL
2131 EngQueryEMFInfo(HDEV hdev,EMFINFO *pEMFInfo)
2132 {
2133 #if 0
2134     BOOL retValue = FALSE;
2135     DHPDEV Dhpdev;
2136
2137     if ((!hdev) && (!pEMFInfo))
2138     {
2139         if ((Dhpdev = NtGdiGetDhpdev(hdev)))
2140         {
2141             /* FIXME check if it support or if it is pEMFInfo we got */
2142             /* FIXME copy the data from Dhpdev to pEMFInfo           */
2143         }
2144     }
2145     return retValue;
2146 #else
2147     return FALSE;
2148 #endif
2149 }
2150
2151
2152 /*
2153  * @unimplemented
2154  */
2155 INT STDCALL
2156 EngWideCharToMultiByte( UINT CodePage,
2157                         LPWSTR WideCharString,
2158                         INT BytesInWideCharString,
2159                         LPSTR MultiByteString,
2160                         INT BytesInMultiByteString)
2161 {
2162   return WideCharToMultiByte(
2163                          CodePage,
2164                          0,
2165                          WideCharString,
2166                         (BytesInWideCharString/sizeof(WCHAR)), /* Bytes to (in WCHARs) */
2167                          MultiByteString,
2168                          BytesInMultiByteString,
2169                          NULL,
2170                          NULL);
2171 }
2172
2173
2174
2175 /*
2176  * @unimplemented
2177  */
2178 BOOL STDCALL
2179 STROBJ_bEnum(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
2180 {
2181         UNIMPLEMENTED;
2182         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2183         return 0;
2184 }
2185
2186 /*
2187  * @unimplemented
2188  */
2189 BOOL STDCALL
2190 STROBJ_bEnumPositionsOnly(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
2191 {
2192         UNIMPLEMENTED;
2193         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2194         return 0;
2195 }
2196
2197 /*
2198  * @unimplemented
2199  */
2200 BOOL STDCALL
2201 STROBJ_bGetAdvanceWidths(STROBJ *pso,ULONG iFirst,ULONG c,POINTQF *pptqD)
2202 {
2203         UNIMPLEMENTED;
2204         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2205         return 0;
2206 }
2207
2208 /*
2209  * @unimplemented
2210  */
2211 DWORD STDCALL
2212 STROBJ_dwGetCodePage(STROBJ  *pstro)
2213 {
2214         UNIMPLEMENTED;
2215         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2216         return 0;
2217 }
2218
2219 /*
2220  * @unimplemented
2221  */
2222 VOID STDCALL
2223 STROBJ_vEnumStart(STROBJ *pstro)
2224 {
2225         UNIMPLEMENTED;
2226         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2227 }
2228
2229 /*
2230  * @unimplemented
2231  */
2232 BOOL STDCALL
2233 XFORMOBJ_bApplyXform(XFORMOBJ *pxo,ULONG iMode,ULONG cPoints,PVOID pvIn,PVOID pvOut)
2234 {
2235         UNIMPLEMENTED;
2236         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2237         return 0;
2238 }
2239
2240 /*
2241  * @unimplemented
2242  */
2243 ULONG STDCALL
2244 XFORMOBJ_iGetXform(XFORMOBJ *pxo,XFORML *pxform)
2245 {
2246         UNIMPLEMENTED;
2247         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2248         return 0;
2249 }
2250
2251 /*
2252  * @unimplemented
2253  */
2254 ULONG STDCALL
2255 XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj,
2256                      ULONG PalOutType,
2257                      ULONG cPal,
2258                      ULONG *OutPal)
2259 {
2260         UNIMPLEMENTED;
2261         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2262         return 0;
2263 }
2264
2265 /*
2266  * @unimplemented
2267  */
2268 HANDLE STDCALL
2269 XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo)
2270 {
2271         UNIMPLEMENTED;
2272         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2273         return 0;
2274 }
2275
2276 /*
2277  * @unimplemented
2278  */
2279 ULONG STDCALL
2280 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
2281                 ULONG Color)
2282 {
2283         UNIMPLEMENTED;
2284         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2285         return 0;
2286 }
2287
2288 /*
2289  * @unimplemented
2290  */
2291 ULONG * STDCALL
2292 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
2293 {
2294   return XlateObj->pulXlate;
2295 }
2296
2297 /*
2298  * @unimplemented
2299  */
2300 BOOL
2301 STDCALL
2302 GdiPlayEMF
2303 (
2304         LPWSTR     pwszPrinterName,
2305         LPDEVMODEW pDevmode,
2306         LPWSTR     pwszDocName,
2307         EMFPLAYPROC pfnEMFPlayFn,
2308         HANDLE     hPageQuery
2309 )
2310 {
2311         UNIMPLEMENTED;
2312         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2313         return 0;
2314 }
2315
2316
2317
2318 /*
2319  * @unimplemented
2320  */
2321 BOOL
2322 STDCALL
2323 GdiPlayPrivatePageEMF
2324 (
2325         HANDLE  SpoolFileHandle,
2326         DWORD   unknown,
2327         RECT    *prectDocument
2328 )
2329 {
2330         UNIMPLEMENTED;
2331         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2332         return 0;
2333 }
2334
2335 /*
2336  * @unimplemented
2337  */
2338 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
2339 {
2340         UNIMPLEMENTED;
2341         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2342 }
2343
2344
2345 /*
2346  * @implemented
2347  */
2348 INT
2349 STDCALL
2350 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
2351 {
2352         /* FIXME some part need be done on user mode size */
2353         return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
2354 }
2355
2356 /*
2357  * @implemented
2358  */
2359 INT
2360 STDCALL
2361 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
2362 {
2363         /* FIXME some part need be done on user mode size */
2364         return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
2365 }
2366
2367 /*
2368  * @implemented
2369  */
2370 BOOL
2371 STDCALL
2372 GdiGradientFill(
2373     IN HDC hdc,
2374     IN PTRIVERTEX pVertex,
2375     IN ULONG nVertex,
2376     IN PVOID pMesh,
2377     IN ULONG nMesh,
2378     IN ULONG ulMode)
2379 {
2380     /* FIXME some part need be done in user mode */
2381     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
2382 }
2383
2384
2385 /*
2386  * @implemented
2387  */
2388 BOOL
2389 STDCALL
2390 GdiTransparentBlt(
2391     IN HDC hdcDst,
2392     IN INT xDst,
2393     IN INT yDst,
2394     IN INT cxDst,
2395     IN INT cyDst,
2396     IN HDC hdcSrc,
2397     IN INT xSrc,
2398     IN INT ySrc,
2399     IN INT cxSrc,
2400     IN INT cySrc,
2401     IN COLORREF TransColor
2402 )
2403 {
2404     /* FIXME some part need be done in user mode */
2405     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
2406 }
2407
2408 /*
2409  * @unimplemented
2410  */
2411 BOOL
2412 STDCALL
2413 GdiPrinterThunk(
2414     IN HUMPD humpd,
2415     DWORD *status,
2416     DWORD unuse)
2417 {
2418     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
2419     /* status contain some form of return value that being save, what it is I do not known */
2420     /* unsue seam have zero effect, what it is for I do not known */
2421
2422     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
2423     return FALSE;
2424 }
2425
2426 /*
2427  * @unimplemented
2428  *
2429  */
2430 HBITMAP
2431 STDCALL
2432 GdiConvertBitmapV5(
2433     HBITMAP in_format_BitMap,
2434     HBITMAP src_BitMap,
2435     INT bpp,
2436     INT unuse)
2437 {
2438     /* FIXME guessing the prototypes */
2439
2440     /*
2441      * it have create a new bitmap with desired in format,
2442      * then convert it src_bitmap to new format
2443      * and return it as HBITMAP
2444      */
2445
2446     return FALSE;
2447 }
2448
2449
2450 /*
2451  * @implemented
2452  *
2453  */
2454 COLORREF
2455 STDCALL
2456 GetBkColor(HDC hdc)
2457 {
2458     /* FIXME some part are done in user mode */
2459     return NtGdiGetBkColor(hdc);
2460 }
2461
2462 /*
2463  * @implemented
2464  *
2465  */
2466 int
2467 STDCALL
2468 GetBkMode(HDC hdc)
2469 {
2470     /* FIXME some part are done in user mode */
2471     return NtGdiGetBkMode(hdc);
2472 }
2473
2474 /*
2475  * @implemented
2476  *
2477  */
2478 BOOL
2479 STDCALL
2480 GetBrushOrgEx(HDC hdc,LPPOINT pt)
2481 {
2482     /* FIXME some part are done in user mode */
2483     return NtGdiGetBrushOrgEx(hdc,pt);
2484 }
2485
2486 /*
2487  * @implemented
2488  *
2489  */
2490 BOOL
2491 STDCALL
2492 GetCharABCWidthsFloatW(HDC hdc,UINT FirstChar,UINT LastChar,LPABCFLOAT abcF)
2493 {
2494     /* FIXME some part are done in user mode */
2495     return NtGdiGetCharABCWidthsFloat(hdc, FirstChar, LastChar, abcF);
2496 }
2497
2498 /*
2499  * @implemented
2500  *
2501  */
2502 int
2503 STDCALL
2504 GetDeviceCaps(HDC hdc,
2505               int i)
2506 {
2507     /* FIXME some part need be done in user mode */
2508     return NtGdiGetDeviceCaps(hdc,i);
2509 }
2510
2511
2512 /*
2513  * @implemented
2514  *
2515  */
2516 BOOL
2517 STDCALL
2518 GetCurrentPositionEx(HDC hdc,
2519                      LPPOINT lpPoint)
2520 {
2521     /* FIXME some part need be done in user mode */
2522     return  NtGdiGetCurrentPositionEx(hdc, lpPoint);
2523 }
2524
2525 /*
2526  * @implemented
2527  *
2528  */
2529 int
2530 STDCALL
2531 GetClipBox(HDC hdc,
2532            LPRECT lprc)
2533 {
2534     /* FIXME some part need be done in user mode */
2535     return  NtGdiGetClipBox(hdc, lprc);
2536 }
2537
2538 /*
2539  * @implemented
2540  *
2541  */
2542 BOOL
2543 STDCALL
2544 GetCharWidthFloatW(HDC hdc,
2545                    UINT iFirstChar,
2546                    UINT iLastChar,
2547                    PFLOAT pxBuffer)
2548 {
2549     /* FIXME some part need be done in user mode */
2550     return NtGdiGetCharWidthFloat(hdc, iFirstChar, iLastChar, pxBuffer);
2551 }
2552
2553 /*
2554  * @implemented
2555  *
2556  */
2557 BOOL
2558 STDCALL
2559 GetCharWidth32W(HDC hdc,
2560                UINT iFirstChar,
2561                UINT iLastChar,
2562                LPINT lpBuffer)
2563 {
2564     /* FIXME some part need be done in user mode */
2565     return NtGdiGetCharWidth32(hdc, iFirstChar, iLastChar, lpBuffer);
2566 }
2567
2568 /*
2569  * @implemented
2570  *
2571  */
2572 BOOL
2573 STDCALL
2574 GetCharABCWidths(HDC hdc,
2575                  UINT uFirstChar,
2576                  UINT uLastChar,
2577                  LPABC lpabc)
2578 {
2579     /* FIXME some part need be done in user mode */
2580     return NtGdiGetCharABCWidths(hdc, uFirstChar, uLastChar, lpabc);
2581 }
2582
2583
2584 /*
2585  * @implemented
2586  *
2587  */
2588 DWORD
2589 STDCALL
2590 GetFontData(HDC hdc,
2591             DWORD dwTable,
2592             DWORD dwOffset,
2593             LPVOID lpvBuffer,
2594             DWORD cbData)
2595 {
2596     if (!lpvBuffer)
2597     {
2598        cbData = 0;
2599     }
2600     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2601 }
2602
2603
2604 /*
2605  * @implemented
2606  *
2607  */
2608 DWORD
2609 STDCALL
2610 GetRegionData(HRGN hrgn,
2611               DWORD nCount,
2612               LPRGNDATA lpRgnData)
2613 {
2614     if (!lpRgnData)
2615     {
2616         nCount = 0;
2617     }
2618
2619     return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
2620 }
2621
2622
2623 /*
2624  * @implemented
2625  *
2626  */
2627 INT
2628 STDCALL
2629 GetRgnBox(HRGN hrgn,
2630           LPRECT prcOut)
2631 {
2632     /* FIXME some stuff need be done in user mode */
2633     return NtGdiGetRgnBox(hrgn, prcOut);
2634 }
2635
2636
2637 /*
2638  * @implemented
2639  *
2640  */
2641 INT
2642 STDCALL
2643 OffsetRgn( HRGN hrgn,
2644           int nXOffset,
2645           int nYOffset)
2646 {
2647     /* FIXME some part are done in user mode */
2648     return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
2649 }
2650
2651
2652 INT
2653 STDCALL
2654 GetTextCharsetInfo(HDC hdc,
2655                    LPFONTSIGNATURE lpSig,
2656                    DWORD dwFlags)
2657 {
2658     /* FIXME some part are done in user mode */
2659     return NtGdiGetTextCharsetInfo(hdc, lpSig, dwFlags);
2660 }
2661
2662
2663
2664 INT
2665 STDCALL
2666 IntersectClipRect(HDC hdc,
2667                   int nLeftRect,
2668                   int nTopRect,
2669                   int nRightRect,
2670                   int nBottomRect)
2671 {
2672     /* FIXME some part are done in user mode */
2673     return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2674 }
2675
2676 INT
2677 STDCALL
2678 OffsetClipRgn(HDC hdc,
2679               int nXOffset,
2680               int nYOffset)
2681 {
2682     /* FIXME some part are done in user mode */
2683     return NtGdiOffsetClipRgn( hdc,  nXOffset,  nYOffset);
2684 }
2685
2686
2687 INT
2688 STDCALL
2689 NamedEscape(HDC hdc,
2690             PWCHAR pDriver,
2691             INT iEsc,
2692             INT cjIn,
2693             LPSTR pjIn,
2694             INT cjOut,
2695             LPSTR pjOut)
2696 {
2697     /* FIXME metadc, metadc are done most in user mode, and we do not support it
2698      * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
2699      * when it calls to NtGdiExtEscape from NamedEscape
2700      */
2701     return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
2702 }
2703
2704
2705 BOOL
2706 STDCALL
2707 PatBlt(HDC hdc,
2708        int nXLeft,
2709        int nYLeft,
2710        int nWidth,
2711        int nHeight,
2712        DWORD dwRop)
2713 {
2714     /* FIXME some part need be done in user mode */
2715     return NtGdiPatBlt( hdc,  nXLeft,  nYLeft,  nWidth,  nHeight,  dwRop);
2716 }
2717
2718 BOOL
2719 STDCALL
2720 PolyPatBlt(IN HDC hdc,
2721            IN DWORD rop4,
2722            IN PPOLYPATBLT pPoly,
2723            IN DWORD Count,
2724            IN DWORD Mode)
2725 {
2726     /* FIXME some part need be done in user mode */
2727     return NtGdiPolyPatBlt(hdc, rop4, pPoly,Count,Mode);
2728 }
2729
2730
2731
2732
2733
2734
2735
2736
2737