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  * @unimplemented
1125  */
1126 DWORD
1127 STDCALL
1128 SelectFontLocal(
1129         DWORD   a0,
1130         DWORD   a1
1131         )
1132 {
1133         UNIMPLEMENTED;
1134         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1135         return 0;
1136 }
1137
1138
1139 /*
1140  * @unimplemented
1141  */
1142 DWORD
1143 STDCALL
1144 SetFontEnumeration(
1145         DWORD   a0
1146         )
1147 {
1148         UNIMPLEMENTED;
1149         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1150         return 0;
1151 }
1152
1153
1154 /*
1155  * @unimplemented
1156  */
1157 DWORD
1158 STDCALL
1159 gdiPlaySpoolStream(
1160         DWORD   a0,
1161         DWORD   a1,
1162         DWORD   a2,
1163         DWORD   a3,
1164         DWORD   a4,
1165         DWORD   a5
1166         )
1167 {
1168         UNIMPLEMENTED;
1169         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1170         return 0;
1171 }
1172
1173 /*
1174  * @unimplemented
1175  */
1176 HANDLE
1177 STDCALL
1178 AddFontMemResourceEx(
1179         PVOID pbFont,
1180         DWORD cbFont,
1181         PVOID pdv,
1182         DWORD *pcFonts
1183 )
1184 {
1185         UNIMPLEMENTED;
1186         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1187         return 0;
1188 }
1189
1190 /*
1191  * @unimplemented
1192  */
1193 int
1194 STDCALL
1195 AddFontResourceTracking(
1196         LPCSTR lpString,
1197         int unknown
1198 )
1199 {
1200         UNIMPLEMENTED;
1201         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1202         return 0;
1203 }
1204
1205
1206
1207 /*
1208  * @unimplemented
1209  */
1210 HBITMAP
1211 STDCALL
1212 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1213 {
1214         UNIMPLEMENTED;
1215         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1216         return 0;
1217 }
1218
1219 /*
1220  * @unimplemented
1221  */
1222 HBRUSH
1223 STDCALL
1224 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1225 {
1226         UNIMPLEMENTED;
1227         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1228         return 0;
1229 }
1230
1231 /*
1232  * @unimplemented
1233  */
1234 BOOL
1235 STDCALL
1236 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
1237 {
1238         UNIMPLEMENTED;
1239         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1240         return 0;
1241 }
1242
1243 /*
1244  * @unimplemented
1245  */
1246 int
1247 STDCALL
1248 EndFormPage(HDC hdc)
1249 {
1250         UNIMPLEMENTED;
1251         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1252         return 0;
1253 }
1254
1255
1256
1257 /*
1258  * @unimplemented
1259  */
1260 DWORD
1261 STDCALL
1262 GdiAddGlsBounds(HDC hdc,LPRECT prc)
1263 {
1264         UNIMPLEMENTED;
1265         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1266         return 0;
1267 }
1268
1269 /*
1270  * @unimplemented
1271  */
1272 BOOL
1273 STDCALL
1274 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
1275 {
1276         UNIMPLEMENTED;
1277         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1278         return 0;
1279 }
1280
1281 /*
1282  * @unimplemented
1283  */
1284 BOOL
1285 STDCALL
1286 GdiCleanCacheDC(HDC hdc)
1287 {
1288         UNIMPLEMENTED;
1289         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1290         return 0;
1291 }
1292
1293 /*
1294  * @unimplemented
1295  */
1296 HDC
1297 STDCALL
1298 GdiConvertAndCheckDC(HDC hdc)
1299 {
1300         UNIMPLEMENTED;
1301         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1302         return 0;
1303 }
1304
1305 /*
1306  * @unimplemented
1307  */
1308 HENHMETAFILE
1309 STDCALL
1310 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
1311 {
1312         UNIMPLEMENTED;
1313         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1314         return 0;
1315 }
1316
1317 /*
1318  * @unimplemented
1319  */
1320 BOOL
1321 STDCALL
1322 GdiDrawStream(HDC dc, ULONG l, VOID *v)
1323 {
1324         UNIMPLEMENTED;
1325         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1326         return 0;
1327 }
1328
1329 /*
1330  * @unimplemented
1331  */
1332 DWORD
1333 STDCALL
1334 GdiGetCodePage(HDC hdc)
1335 {
1336         UNIMPLEMENTED;
1337         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1338         return 0;
1339 }
1340
1341 /*
1342  * @unimplemented
1343  */
1344 HBRUSH
1345 STDCALL
1346 GdiGetLocalBrush(HBRUSH hbr)
1347 {
1348         UNIMPLEMENTED;
1349         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1350         return 0;
1351 }
1352
1353 /*
1354  * @unimplemented
1355  */
1356 HDC
1357 STDCALL
1358 GdiGetLocalDC(HDC hdc)
1359 {
1360         UNIMPLEMENTED;
1361         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1362         return 0;
1363 }
1364
1365 /*
1366  * @unimplemented
1367  */
1368 HFONT
1369 STDCALL
1370 GdiGetLocalFont(HFONT hfont)
1371 {
1372         UNIMPLEMENTED;
1373         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1374         return 0;
1375 }
1376
1377 /*
1378  * @unimplemented
1379  */
1380 BOOL
1381 STDCALL
1382 GdiIsMetaFileDC(HDC hdc)
1383 {
1384         UNIMPLEMENTED;
1385         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1386         return 0;
1387 }
1388
1389 /*
1390  * @unimplemented
1391  */
1392 BOOL
1393 STDCALL
1394 GdiIsMetaPrintDC(HDC hdc)
1395 {
1396         UNIMPLEMENTED;
1397         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1398         return 0;
1399 }
1400
1401 /*
1402  * @unimplemented
1403  */
1404 BOOL
1405 STDCALL
1406 GdiIsPlayMetafileDC(HDC hdc)
1407 {
1408         UNIMPLEMENTED;
1409         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1410         return 0;
1411 }
1412
1413 /*
1414  * @unimplemented
1415  */
1416 BOOL
1417 STDCALL
1418 GdiValidateHandle(HGDIOBJ hobj)
1419 {
1420         UNIMPLEMENTED;
1421         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1422         return 0;
1423 }
1424
1425 /*
1426  * @unimplemented
1427  */
1428 DWORD
1429 STDCALL
1430 GetBitmapAttributes(HBITMAP hbm)
1431 {
1432         UNIMPLEMENTED;
1433         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1434         return 0;
1435 }
1436
1437 /*
1438  * @unimplemented
1439  */
1440 DWORD
1441 STDCALL
1442 GetBrushAttributes(HBRUSH hbr)
1443 {
1444         UNIMPLEMENTED;
1445         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1446         return 0;
1447 }
1448
1449 /*
1450  * @unimplemented
1451  */
1452 BOOL
1453 STDCALL
1454 GetCharABCWidthsI(
1455         HDC hdc,
1456         UINT giFirst,
1457         UINT cgi,
1458         LPWORD pgi,
1459         LPABC lpabc
1460 )
1461 {
1462         UNIMPLEMENTED;
1463         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1464         return 0;
1465 }
1466
1467 /*
1468  * @unimplemented
1469  */
1470 BOOL
1471 STDCALL
1472 GetCharWidthI(
1473         HDC hdc,
1474         UINT giFirst,
1475         UINT cgi,
1476         LPWORD pgi,
1477         LPINT lpBuffer
1478 )
1479 {
1480         UNIMPLEMENTED;
1481         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1482         return 0;
1483 }
1484
1485
1486
1487 /*
1488  * @implemented
1489  */
1490 ULONG
1491 STDCALL
1492 GetEUDCTimeStamp(VOID)
1493 {
1494     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1495 }
1496
1497 /*
1498  * @implemented
1499  */
1500 ULONG
1501 STDCALL
1502 GetFontAssocStatus(HDC hdc)
1503 {
1504     ULONG retValue = 0;
1505
1506     if (hdc)
1507     {
1508         retValue = NtGdiQueryFontAssocInfo(hdc);
1509     }
1510
1511     return retValue;
1512 }
1513
1514 /*
1515  * @unimplemented
1516  */
1517 HFONT
1518 STDCALL
1519 GetHFONT(HDC dc)
1520 {
1521         UNIMPLEMENTED;
1522         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1523         return 0;
1524 }
1525
1526 /*
1527  * @unimplemented
1528  */
1529 DWORD
1530 STDCALL
1531 GetLayout(
1532         HDC hdc
1533 )
1534 {
1535         UNIMPLEMENTED;
1536         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1537         return 0;
1538 }
1539
1540 /*
1541  * @implemented
1542  */
1543 BOOL
1544 STDCALL
1545 GetTextExtentExPointWPri(HDC hdc,
1546                          LPWSTR lpwsz,
1547                          ULONG cwc,
1548                          ULONG dxMax,
1549                          ULONG *pcCh,
1550                          PULONG pdxOut,
1551                          LPSIZE psize)
1552 {
1553     return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1554 }
1555
1556 /*
1557  * @implemented
1558  */
1559 INT
1560 STDCALL
1561 GetTextFaceAliasW(HDC hdc,
1562                   int cChar,
1563                   LPWSTR pszOut)
1564 {
1565     INT retValue = 0;
1566     if ((!pszOut) || (cChar))
1567     {
1568         retValue = NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE);
1569     }
1570     else
1571     {
1572         SetLastError(ERROR_INVALID_PARAMETER);
1573     }
1574     return retValue;
1575 }
1576
1577
1578
1579 /*
1580  * @unimplemented
1581  */
1582 BOOL
1583 STDCALL
1584 MirrorRgn(HWND hwnd,HRGN hrgn)
1585 {
1586         UNIMPLEMENTED;
1587         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1588         return 0;
1589 }
1590
1591
1592
1593 /*
1594  * @unimplemented
1595  */
1596 DWORD
1597 STDCALL
1598 QueryFontAssocStatus(VOID)
1599 {
1600         UNIMPLEMENTED;
1601         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1602         return 0;
1603 }
1604
1605 /*
1606  * @implemented
1607  */
1608 BOOL
1609 STDCALL
1610 RemoveFontMemResourceEx(HANDLE fh)
1611 {
1612     BOOL retValue=0;
1613
1614     if (fh)
1615     {
1616         retValue = NtGdiRemoveFontMemResourceEx(fh);
1617     }
1618     else
1619     {
1620         SetLastError(ERROR_INVALID_PARAMETER);
1621     }
1622     return retValue;
1623 }
1624
1625 /*
1626  * @unimplemented
1627  */
1628 int
1629 STDCALL
1630 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1631 {
1632         UNIMPLEMENTED;
1633         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1634         return 0;
1635 }
1636
1637 /*
1638  * @unimplemented
1639  */
1640 HBITMAP
1641 STDCALL
1642 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1643 {
1644         UNIMPLEMENTED;
1645         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1646         return 0;
1647 }
1648
1649 /*
1650  * @unimplemented
1651  */
1652 HBRUSH
1653 STDCALL
1654 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1655 {
1656         UNIMPLEMENTED;
1657         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1658         return 0;
1659 }
1660
1661 /*
1662  * @unimplemented
1663  */
1664 DWORD
1665 STDCALL
1666 SetLayout(
1667         HDC hdc,
1668         DWORD dwLayout
1669 )
1670 {
1671         UNIMPLEMENTED;
1672         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1673         return 0;
1674 }
1675
1676 /*
1677  * @unimplemented
1678  */
1679 DWORD
1680 STDCALL
1681 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
1682 {
1683         UNIMPLEMENTED;
1684         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1685         return 0;
1686 }
1687
1688 /*
1689  * @unimplemented
1690  */
1691 BOOL
1692 STDCALL
1693 SetMagicColors(HDC hdc,PALETTEENTRY peMagic,ULONG Index)
1694 {
1695         UNIMPLEMENTED;
1696         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1697         return 0;
1698 }
1699
1700 /*
1701  * @unimplemented
1702  */
1703 BOOL
1704 STDCALL
1705 SetVirtualResolution(HDC hdc, int cxVirtualDevicePixel,int cyVirtualDevicePixel,int cxVirtualDeviceMm, int cyVirtualDeviceMm)
1706 {
1707         UNIMPLEMENTED;
1708         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1709         return 0;
1710 }
1711
1712 /*
1713  * @unimplemented
1714  */
1715 int
1716 STDCALL
1717 StartFormPage(HDC hdc)
1718 {
1719         UNIMPLEMENTED;
1720         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1721         return 0;
1722 }
1723
1724 /*
1725  * @unimplemented
1726  */
1727 VOID
1728 STDCALL
1729 UnloadNetworkFonts(DWORD unknown)
1730 {
1731         UNIMPLEMENTED;
1732         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1733 }
1734
1735 /*
1736  * @implemented
1737  */
1738 BOOL
1739 STDCALL
1740 GetTextExtentExPointI(HDC hdc,
1741                       LPWORD pgiIn,
1742                       int cgi,
1743                       int nMaxExtent,
1744                       LPINT lpnFit,
1745                       LPINT alpDx,
1746                       LPSIZE lpSize)
1747 {
1748     return NtGdiGetTextExtentExW(hdc,pgiIn,cgi,nMaxExtent,(ULONG *)lpnFit, (PULONG) alpDx,lpSize,1);
1749 }
1750
1751 /*
1752  * @implemented
1753  */
1754 BOOL
1755 STDCALL
1756 GetTextExtentPointI(HDC hdc,
1757                     LPWORD pgiIn,
1758                     int cgi,
1759                     LPSIZE lpSize)
1760 {
1761     return NtGdiGetTextExtent(hdc,pgiIn,cgi,lpSize,2);
1762 }
1763
1764
1765
1766
1767
1768 /*
1769  * @unimplemented
1770  */
1771 BOOL
1772 STDCALL
1773 GdiRealizationInfo(HDC hdc, PREALIZATION_INFO pri)
1774 {
1775         UNIMPLEMENTED;
1776         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1777         return 0;
1778 }
1779
1780
1781
1782 /*
1783  * @unimplemented
1784  */
1785 BOOL
1786 STDCALL
1787 GetETM(HDC hdc,EXTTEXTMETRIC *petm)
1788 {
1789         UNIMPLEMENTED;
1790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1791         return 0;
1792 }
1793
1794 /*
1795  * @unimplemented
1796  */
1797 BOOL
1798 STDCALL
1799 GdiAddGlsRecord(HDC hdc,DWORD unknown1,LPCSTR unknown2,LPRECT unknown3)
1800 {
1801         UNIMPLEMENTED;
1802         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1803         return 0;
1804 }
1805
1806 /*
1807  * @unimplemented
1808  */
1809 HANDLE
1810 STDCALL
1811 GdiConvertMetaFilePict(HGLOBAL hMem)
1812 {
1813         UNIMPLEMENTED;
1814         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1815         return 0;
1816 }
1817
1818 /*
1819  * @implemented
1820  */
1821 DEVMODEW *
1822 STDCALL
1823 GdiConvertToDevmodeW(DEVMODEA *dm)
1824 {
1825   LPDEVMODEW dmw;
1826
1827   dmw = HEAP_alloc(sizeof(DEVMODEW));
1828 #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
1829 #define COPYN(f) dmw->f = dm->f
1830   COPYS(dmDeviceName, CCHDEVICENAME );
1831   COPYN(dmSpecVersion);
1832   COPYN(dmDriverVersion);
1833   switch ( dm->dmSize )
1834     {
1835     case SIZEOF_DEVMODEA_300:
1836       dmw->dmSize = SIZEOF_DEVMODEW_300;
1837       break;
1838     case SIZEOF_DEVMODEA_400:
1839       dmw->dmSize = SIZEOF_DEVMODEW_400;
1840       break;
1841     case SIZEOF_DEVMODEA_500:
1842     default: /* FIXME what to do??? */
1843       dmw->dmSize = SIZEOF_DEVMODEW_500;
1844       break;
1845     }
1846   COPYN(dmDriverExtra);
1847   COPYN(dmFields);
1848   COPYN(dmPosition.x);
1849   COPYN(dmPosition.y);
1850   COPYN(dmScale);
1851   COPYN(dmCopies);
1852   COPYN(dmDefaultSource);
1853   COPYN(dmPrintQuality);
1854   COPYN(dmColor);
1855   COPYN(dmDuplex);
1856   COPYN(dmYResolution);
1857   COPYN(dmTTOption);
1858   COPYN(dmCollate);
1859   COPYS(dmFormName,CCHFORMNAME);
1860   COPYN(dmLogPixels);
1861   COPYN(dmBitsPerPel);
1862   COPYN(dmPelsWidth);
1863   COPYN(dmPelsHeight);
1864   COPYN(dmDisplayFlags); // aka dmNup
1865   COPYN(dmDisplayFrequency);
1866
1867   if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
1868     return dmw; // we're done with 0x300 fields
1869
1870   COPYN(dmICMMethod);
1871   COPYN(dmICMIntent);
1872   COPYN(dmMediaType);
1873   COPYN(dmDitherType);
1874   COPYN(dmReserved1);
1875   COPYN(dmReserved2);
1876
1877   if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
1878     return dmw; // we're done with 0x400 fields
1879
1880   COPYN(dmPanningWidth);
1881   COPYN(dmPanningHeight);
1882
1883   return dmw;
1884
1885 #undef COPYN
1886 #undef COPYS
1887 }
1888
1889 /*
1890  * @unimplemented
1891  */
1892 HENHMETAFILE
1893 STDCALL
1894 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
1895 {
1896         UNIMPLEMENTED;
1897         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1898         return 0;
1899 }
1900
1901 /*
1902  * @unimplemented
1903  */
1904 METAFILEPICT *
1905 STDCALL
1906 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
1907 {
1908         UNIMPLEMENTED;
1909         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1910         return 0;
1911 }
1912
1913
1914 /*
1915  * @unimplemented
1916  */
1917 HANDLE
1918 STDCALL
1919 GdiGetSpoolFileHandle(
1920         LPWSTR          pwszPrinterName,
1921         LPDEVMODEW      pDevmode,
1922         LPWSTR          pwszDocName)
1923 {
1924         UNIMPLEMENTED;
1925         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1926         return 0;
1927 }
1928
1929 /*
1930  * @unimplemented
1931  */
1932 BOOL
1933 STDCALL
1934 GdiDeleteSpoolFileHandle(
1935         HANDLE  SpoolFileHandle)
1936 {
1937         UNIMPLEMENTED;
1938         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1939         return 0;
1940 }
1941
1942 /*
1943  * @unimplemented
1944  */
1945 DWORD
1946 STDCALL
1947 GdiGetPageCount(
1948         HANDLE  SpoolFileHandle)
1949 {
1950         UNIMPLEMENTED;
1951         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1952         return 0;
1953 }
1954
1955 /*
1956  * @unimplemented
1957  */
1958 HDC
1959 STDCALL
1960 GdiGetDC(
1961         HANDLE  SpoolFileHandle)
1962 {
1963         UNIMPLEMENTED;
1964         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1965         return 0;
1966 }
1967
1968 /*
1969  * @unimplemented
1970  */
1971 HANDLE
1972 STDCALL
1973 GdiGetPageHandle(
1974         HANDLE  SpoolFileHandle,
1975         DWORD   Page,
1976         LPDWORD pdwPageType)
1977 {
1978         UNIMPLEMENTED;
1979         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1980         return 0;
1981 }
1982
1983 /*
1984  * @unimplemented
1985  */
1986 BOOL
1987 STDCALL
1988 GdiStartDocEMF(
1989         HANDLE          SpoolFileHandle,
1990         DOCINFOW        *pDocInfo)
1991 {
1992         UNIMPLEMENTED;
1993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1994         return 0;
1995 }
1996
1997 /*
1998  * @unimplemented
1999  */
2000 BOOL
2001 STDCALL
2002 GdiStartPageEMF(
2003         HANDLE  SpoolFileHandle)
2004 {
2005         UNIMPLEMENTED;
2006         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2007         return 0;
2008 }
2009
2010 /*
2011  * @unimplemented
2012  */
2013 BOOL
2014 STDCALL
2015 GdiPlayPageEMF(
2016         HANDLE  SpoolFileHandle,
2017         HANDLE  hemf,
2018         RECT    *prectDocument,
2019         RECT    *prectBorder,
2020         RECT    *prectClip)
2021 {
2022         UNIMPLEMENTED;
2023         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2024         return 0;
2025 }
2026
2027 /*
2028  * @unimplemented
2029  */
2030 BOOL
2031 STDCALL
2032 GdiEndPageEMF(
2033         HANDLE  SpoolFileHandle,
2034         DWORD   dwOptimization)
2035 {
2036         UNIMPLEMENTED;
2037         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2038         return 0;
2039 }
2040
2041 /*
2042  * @unimplemented
2043  */
2044 BOOL
2045 STDCALL
2046 GdiEndDocEMF(
2047         HANDLE  SpoolFileHandle)
2048 {
2049         UNIMPLEMENTED;
2050         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2051         return 0;
2052 }
2053
2054 /*
2055  * @unimplemented
2056  */
2057 BOOL
2058 STDCALL
2059 GdiGetDevmodeForPage(
2060         HANDLE          SpoolFileHandle,
2061         DWORD           dwPageNumber,
2062         PDEVMODEW       *pCurrDM,
2063         PDEVMODEW       *pLastDM)
2064 {
2065         UNIMPLEMENTED;
2066         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2067         return 0;
2068 }
2069
2070 /*
2071  * @unimplemented
2072  */
2073 BOOL
2074 STDCALL
2075 GdiResetDCEMF(
2076         HANDLE          SpoolFileHandle,
2077         PDEVMODEW       pCurrDM)
2078 {
2079         UNIMPLEMENTED;
2080         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2081         return 0;
2082 }
2083
2084
2085 HBITMAP
2086 STDCALL
2087 CreateDIBitmap(HDC
2088         hDc, const BITMAPINFOHEADER *Header,
2089         DWORD Init, LPCVOID Bits, const BITMAPINFO *Data,
2090         UINT ColorUse)
2091 {
2092         /* FIMXE we need do more thing in user mode */
2093         return NtGdiCreateDIBitmap(hDc, Header, Init, Bits, Data,  ColorUse);
2094 }
2095
2096 /*
2097  * @unimplemented
2098  */
2099 INT
2100 STDCALL
2101 CombineRgn(HRGN  hDest,
2102                     HRGN  hSrc1,
2103                     HRGN  hSrc2,
2104                     INT  CombineMode)
2105 {
2106     /* FIXME some part should be done in user mode */
2107     return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
2108 }
2109
2110 /*
2111  * @unimplemented
2112  */
2113 HBITMAP STDCALL
2114 CreateBitmap(
2115     INT  Width,
2116     INT  Height,
2117     UINT  Planes,
2118     UINT  BitsPixel,
2119     PCVOID pUnsafeBits)
2120 {
2121     /* FIXME some part should be done in user mode */
2122     return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
2123 }
2124
2125
2126
2127
2128 /*
2129  * @unimplemented
2130  */
2131 LPWSTR STDCALL
2132 EngGetDriverName(HDEV hdev)
2133 {
2134         UNIMPLEMENTED;
2135         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2136         return 0;
2137 }
2138
2139 /*
2140  * @unimplemented
2141  * wrong info it is not Obsolete GDI Function as http://www.osronline.com/DDKx/graphics/gdioview_20tj.htm say
2142  */
2143 BOOL STDCALL
2144 EngQueryEMFInfo(HDEV hdev,EMFINFO *pEMFInfo)
2145 {
2146 #if 0
2147     BOOL retValue = FALSE;
2148     DHPDEV Dhpdev;
2149
2150     if ((!hdev) && (!pEMFInfo))
2151     {
2152         if ((Dhpdev = NtGdiGetDhpdev(hdev)))
2153         {
2154             /* FIXME check if it support or if it is pEMFInfo we got */
2155             /* FIXME copy the data from Dhpdev to pEMFInfo           */
2156         }
2157     }
2158     return retValue;
2159 #else
2160     return FALSE;
2161 #endif
2162 }
2163
2164
2165 /*
2166  * @unimplemented
2167  */
2168 INT STDCALL
2169 EngWideCharToMultiByte( UINT CodePage,
2170                         LPWSTR WideCharString,
2171                         INT BytesInWideCharString,
2172                         LPSTR MultiByteString,
2173                         INT BytesInMultiByteString)
2174 {
2175   return WideCharToMultiByte(
2176                          CodePage,
2177                          0,
2178                          WideCharString,
2179                         (BytesInWideCharString/sizeof(WCHAR)), /* Bytes to (in WCHARs) */
2180                          MultiByteString,
2181                          BytesInMultiByteString,
2182                          NULL,
2183                          NULL);
2184 }
2185
2186
2187
2188 /*
2189  * @unimplemented
2190  */
2191 BOOL STDCALL
2192 STROBJ_bEnum(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
2193 {
2194         UNIMPLEMENTED;
2195         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2196         return 0;
2197 }
2198
2199 /*
2200  * @unimplemented
2201  */
2202 BOOL STDCALL
2203 STROBJ_bEnumPositionsOnly(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
2204 {
2205         UNIMPLEMENTED;
2206         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2207         return 0;
2208 }
2209
2210 /*
2211  * @unimplemented
2212  */
2213 BOOL STDCALL
2214 STROBJ_bGetAdvanceWidths(STROBJ *pso,ULONG iFirst,ULONG c,POINTQF *pptqD)
2215 {
2216         UNIMPLEMENTED;
2217         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2218         return 0;
2219 }
2220
2221 /*
2222  * @unimplemented
2223  */
2224 DWORD STDCALL
2225 STROBJ_dwGetCodePage(STROBJ  *pstro)
2226 {
2227         UNIMPLEMENTED;
2228         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2229         return 0;
2230 }
2231
2232 /*
2233  * @unimplemented
2234  */
2235 VOID STDCALL
2236 STROBJ_vEnumStart(STROBJ *pstro)
2237 {
2238         UNIMPLEMENTED;
2239         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2240 }
2241
2242 /*
2243  * @unimplemented
2244  */
2245 BOOL STDCALL
2246 XFORMOBJ_bApplyXform(XFORMOBJ *pxo,ULONG iMode,ULONG cPoints,PVOID pvIn,PVOID pvOut)
2247 {
2248         UNIMPLEMENTED;
2249         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2250         return 0;
2251 }
2252
2253 /*
2254  * @unimplemented
2255  */
2256 ULONG STDCALL
2257 XFORMOBJ_iGetXform(XFORMOBJ *pxo,XFORML *pxform)
2258 {
2259         UNIMPLEMENTED;
2260         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2261         return 0;
2262 }
2263
2264 /*
2265  * @unimplemented
2266  */
2267 ULONG STDCALL
2268 XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj,
2269                      ULONG PalOutType,
2270                      ULONG cPal,
2271                      ULONG *OutPal)
2272 {
2273         UNIMPLEMENTED;
2274         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2275         return 0;
2276 }
2277
2278 /*
2279  * @unimplemented
2280  */
2281 HANDLE STDCALL
2282 XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo)
2283 {
2284         UNIMPLEMENTED;
2285         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2286         return 0;
2287 }
2288
2289 /*
2290  * @unimplemented
2291  */
2292 ULONG STDCALL
2293 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
2294                 ULONG Color)
2295 {
2296         UNIMPLEMENTED;
2297         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2298         return 0;
2299 }
2300
2301 /*
2302  * @unimplemented
2303  */
2304 ULONG * STDCALL
2305 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
2306 {
2307   return XlateObj->pulXlate;
2308 }
2309
2310 /*
2311  * @unimplemented
2312  */
2313 BOOL
2314 STDCALL
2315 GdiPlayEMF
2316 (
2317         LPWSTR     pwszPrinterName,
2318         LPDEVMODEW pDevmode,
2319         LPWSTR     pwszDocName,
2320         EMFPLAYPROC pfnEMFPlayFn,
2321         HANDLE     hPageQuery
2322 )
2323 {
2324         UNIMPLEMENTED;
2325         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2326         return 0;
2327 }
2328
2329
2330
2331 /*
2332  * @unimplemented
2333  */
2334 BOOL
2335 STDCALL
2336 GdiPlayPrivatePageEMF
2337 (
2338         HANDLE  SpoolFileHandle,
2339         DWORD   unknown,
2340         RECT    *prectDocument
2341 )
2342 {
2343         UNIMPLEMENTED;
2344         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2345         return 0;
2346 }
2347
2348 /*
2349  * @unimplemented
2350  */
2351 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
2352 {
2353         UNIMPLEMENTED;
2354         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2355 }
2356
2357
2358 /*
2359  * @implemented
2360  */
2361 INT
2362 STDCALL
2363 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
2364 {
2365         /* FIXME some part need be done on user mode size */
2366         return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
2367 }
2368
2369 /*
2370  * @implemented
2371  */
2372 INT
2373 STDCALL
2374 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
2375 {
2376         /* FIXME some part need be done on user mode size */
2377         return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
2378 }
2379
2380 /*
2381  * @implemented
2382  */
2383 BOOL
2384 STDCALL
2385 GdiGradientFill(
2386     IN HDC hdc,
2387     IN PTRIVERTEX pVertex,
2388     IN ULONG nVertex,
2389     IN PVOID pMesh,
2390     IN ULONG nMesh,
2391     IN ULONG ulMode)
2392 {
2393     /* FIXME some part need be done in user mode */
2394     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
2395 }
2396
2397
2398 /*
2399  * @implemented
2400  */
2401 BOOL
2402 STDCALL
2403 GdiTransparentBlt(
2404     IN HDC hdcDst,
2405     IN INT xDst,
2406     IN INT yDst,
2407     IN INT cxDst,
2408     IN INT cyDst,
2409     IN HDC hdcSrc,
2410     IN INT xSrc,
2411     IN INT ySrc,
2412     IN INT cxSrc,
2413     IN INT cySrc,
2414     IN COLORREF TransColor
2415 )
2416 {
2417     /* FIXME some part need be done in user mode */
2418     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
2419 }
2420
2421 /*
2422  * @unimplemented
2423  */
2424 BOOL
2425 STDCALL
2426 GdiPrinterThunk(
2427     IN HUMPD humpd,
2428     DWORD *status,
2429     DWORD unuse)
2430 {
2431     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
2432     /* status contain some form of return value that being save, what it is I do not known */
2433     /* unsue seam have zero effect, what it is for I do not known */
2434
2435     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
2436     return FALSE;
2437 }
2438
2439 /*
2440  * @unimplemented
2441  *
2442  */
2443 HBITMAP
2444 STDCALL
2445 GdiConvertBitmapV5(
2446     HBITMAP in_format_BitMap,
2447     HBITMAP src_BitMap,
2448     INT bpp,
2449     INT unuse)
2450 {
2451     /* FIXME guessing the prototypes */
2452
2453     /*
2454      * it have create a new bitmap with desired in format,
2455      * then convert it src_bitmap to new format
2456      * and return it as HBITMAP
2457      */
2458
2459     return FALSE;
2460 }
2461
2462
2463 /*
2464  * @implemented
2465  *
2466  */
2467 COLORREF
2468 STDCALL
2469 GetBkColor(HDC hdc)
2470 {
2471     /* FIXME some part are done in user mode */
2472     return NtGdiGetBkColor(hdc);
2473 }
2474
2475 /*
2476  * @implemented
2477  *
2478  */
2479 int
2480 STDCALL
2481 GetBkMode(HDC hdc)
2482 {
2483     /* FIXME some part are done in user mode */
2484     return NtGdiGetBkMode(hdc);
2485 }
2486
2487 /*
2488  * @implemented
2489  *
2490  */
2491 BOOL
2492 STDCALL
2493 GetBrushOrgEx(HDC hdc,LPPOINT pt)
2494 {
2495     /* FIXME some part are done in user mode */
2496     return NtGdiGetBrushOrgEx(hdc,pt);
2497 }
2498
2499 /*
2500  * @implemented
2501  *
2502  */
2503 BOOL
2504 STDCALL
2505 GetCharABCWidthsFloatW(HDC hdc,UINT FirstChar,UINT LastChar,LPABCFLOAT abcF)
2506 {
2507     /* FIXME some part are done in user mode */
2508     return NtGdiGetCharABCWidthsFloat(hdc, FirstChar, LastChar, abcF);
2509 }
2510
2511 /*
2512  * @implemented
2513  *
2514  */
2515 int
2516 STDCALL
2517 GetDeviceCaps(HDC hdc,
2518               int i)
2519 {
2520     /* FIXME some part need be done in user mode */
2521     return NtGdiGetDeviceCaps(hdc,i);
2522 }
2523
2524
2525 /*
2526  * @implemented
2527  *
2528  */
2529 BOOL
2530 STDCALL
2531 GetCurrentPositionEx(HDC hdc,
2532                      LPPOINT lpPoint)
2533 {
2534     /* FIXME some part need be done in user mode */
2535     return  NtGdiGetCurrentPositionEx(hdc, lpPoint);
2536 }
2537
2538 /*
2539  * @implemented
2540  *
2541  */
2542 int
2543 STDCALL
2544 GetClipBox(HDC hdc,
2545            LPRECT lprc)
2546 {
2547     /* FIXME some part need be done in user mode */
2548     return  NtGdiGetClipBox(hdc, lprc);
2549 }
2550
2551 /*
2552  * @implemented
2553  *
2554  */
2555 BOOL
2556 STDCALL
2557 GetCharWidthFloatW(HDC hdc,
2558                    UINT iFirstChar,
2559                    UINT iLastChar,
2560                    PFLOAT pxBuffer)
2561 {
2562     /* FIXME some part need be done in user mode */
2563     return NtGdiGetCharWidthFloat(hdc, iFirstChar, iLastChar, pxBuffer);
2564 }
2565
2566 /*
2567  * @implemented
2568  *
2569  */
2570 BOOL
2571 STDCALL
2572 GetCharWidth32W(HDC hdc,
2573                UINT iFirstChar,
2574                UINT iLastChar,
2575                LPINT lpBuffer)
2576 {
2577     /* FIXME some part need be done in user mode */
2578     return NtGdiGetCharWidth32(hdc, iFirstChar, iLastChar, lpBuffer);
2579 }
2580
2581 /*
2582  * @implemented
2583  *
2584  */
2585 BOOL
2586 STDCALL
2587 GetCharABCWidths(HDC hdc,
2588                  UINT uFirstChar,
2589                  UINT uLastChar,
2590                  LPABC lpabc)
2591 {
2592     /* FIXME some part need be done in user mode */
2593     return NtGdiGetCharABCWidths(hdc, uFirstChar, uLastChar, lpabc);
2594 }
2595
2596
2597 /*
2598  * @implemented
2599  *
2600  */
2601 DWORD
2602 STDCALL
2603 GetFontData(HDC hdc,
2604             DWORD dwTable,
2605             DWORD dwOffset,
2606             LPVOID lpvBuffer,
2607             DWORD cbData)
2608 {
2609     if (!lpvBuffer)
2610     {
2611        cbData = 0;
2612     }
2613     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2614 }
2615
2616
2617 /*
2618  * @implemented
2619  *
2620  */
2621 DWORD
2622 STDCALL
2623 GetRegionData(HRGN hrgn,
2624               DWORD nCount,
2625               LPRGNDATA lpRgnData)
2626 {
2627     if (!lpRgnData)
2628     {
2629         nCount = 0;
2630     }
2631
2632     return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
2633 }
2634
2635
2636 /*
2637  * @implemented
2638  *
2639  */
2640 INT
2641 STDCALL
2642 GetRgnBox(HRGN hrgn,
2643           LPRECT prcOut)
2644 {
2645     /* FIXME some stuff need be done in user mode */
2646     return NtGdiGetRgnBox(hrgn, prcOut);
2647 }
2648
2649
2650 /*
2651  * @implemented
2652  *
2653  */
2654 INT
2655 STDCALL
2656 OffsetRgn( HRGN hrgn,
2657           int nXOffset,
2658           int nYOffset)
2659 {
2660     /* FIXME some part are done in user mode */
2661     return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
2662 }
2663
2664
2665 INT
2666 STDCALL
2667 GetTextCharsetInfo(HDC hdc,
2668                    LPFONTSIGNATURE lpSig,
2669                    DWORD dwFlags)
2670 {
2671     /* FIXME some part are done in user mode */
2672     return NtGdiGetTextCharsetInfo(hdc, lpSig, dwFlags);
2673 }
2674
2675
2676
2677 INT
2678 STDCALL
2679 IntersectClipRect(HDC hdc,
2680                   int nLeftRect,
2681                   int nTopRect,
2682                   int nRightRect,
2683                   int nBottomRect)
2684 {
2685     /* FIXME some part are done in user mode */
2686     return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2687 }
2688
2689 INT
2690 STDCALL
2691 OffsetClipRgn(HDC hdc,
2692               int nXOffset,
2693               int nYOffset)
2694 {
2695     /* FIXME some part are done in user mode */
2696     return NtGdiOffsetClipRgn( hdc,  nXOffset,  nYOffset);
2697 }
2698
2699
2700 INT
2701 STDCALL
2702 NamedEscape(HDC hdc,
2703             PWCHAR pDriver,
2704             INT iEsc,
2705             INT cjIn,
2706             LPSTR pjIn,
2707             INT cjOut,
2708             LPSTR pjOut)
2709 {
2710     /* FIXME metadc, metadc are done most in user mode, and we do not support it
2711      * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
2712      * when it calls to NtGdiExtEscape from NamedEscape
2713      */
2714     return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
2715 }
2716
2717
2718 BOOL
2719 STDCALL
2720 PatBlt(HDC hdc,
2721        int nXLeft,
2722        int nYLeft,
2723        int nWidth,
2724        int nHeight,
2725        DWORD dwRop)
2726 {
2727     /* FIXME some part need be done in user mode */
2728     return NtGdiPatBlt( hdc,  nXLeft,  nYLeft,  nWidth,  nHeight,  dwRop);
2729 }
2730
2731 BOOL
2732 STDCALL
2733 PolyPatBlt(IN HDC hdc,
2734            IN DWORD rop4,
2735            IN PPOLYPATBLT pPoly,
2736            IN DWORD Count,
2737            IN DWORD Mode)
2738 {
2739     /* FIXME some part need be done in user mode */
2740     return NtGdiPolyPatBlt(hdc, rop4, pPoly,Count,Mode);
2741 }
2742
2743
2744
2745
2746
2747
2748
2749
2750