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