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