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  * @unimplemented
1668  */
1669 DWORD
1670 STDCALL
1671 GetFontUnicodeRanges(
1672         HDC hdc,
1673         LPGLYPHSET lpgs
1674 )
1675 {
1676         UNIMPLEMENTED;
1677         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1678         return 0;
1679 }
1680
1681 /*
1682  * @implemented
1683  */
1684 ULONG
1685 STDCALL
1686 GetEUDCTimeStamp(VOID)
1687 {
1688     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1689 }
1690
1691 /*
1692  * @implemented
1693  */
1694 ULONG
1695 STDCALL
1696 GetFontAssocStatus(HDC hdc)
1697 {
1698     ULONG retValue = 0;
1699
1700     if (hdc)
1701     {
1702         retValue = NtGdiQueryFontAssocInfo(hdc);
1703     }
1704
1705     return retValue;
1706 }
1707
1708 /*
1709  * @unimplemented
1710  */
1711 HFONT
1712 STDCALL
1713 GetHFONT(HDC dc)
1714 {
1715         UNIMPLEMENTED;
1716         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1717         return 0;
1718 }
1719
1720 /*
1721  * @unimplemented
1722  */
1723 DWORD
1724 STDCALL
1725 GetLayout(
1726         HDC hdc
1727 )
1728 {
1729         UNIMPLEMENTED;
1730         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1731         return 0;
1732 }
1733
1734 /*
1735  * @unimplemented
1736  */
1737 BOOL
1738 STDCALL
1739 GetTextExtentExPointWPri(HDC hdc,LPWSTR lpwsz,ULONG cwc,ULONG dxMax,ULONG *pcCh,PULONG pdxOut,LPSIZE psize)
1740 {
1741         UNIMPLEMENTED;
1742         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1743         return 0;
1744 }
1745
1746 /*
1747  * @unimplemented
1748  */
1749 int
1750 STDCALL
1751 GetTextFaceAliasW(HDC hdc,int cChar,LPWSTR pszOut)
1752 {
1753         UNIMPLEMENTED;
1754         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1755         return 0;
1756 }
1757
1758 /*
1759  * @unimplemented
1760  */
1761 LONG
1762 STDCALL
1763 HT_Get8BPPFormatPalette(LPPALETTEENTRY pPaletteEntry, USHORT RedGamma,USHORT GreenGamma, USHORT BlueGamma)
1764 {
1765         UNIMPLEMENTED;
1766         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1767         return 0;
1768 }
1769
1770 /*
1771  * @unimplemented
1772  */
1773 LONG
1774 STDCALL
1775 HT_Get8BPPMaskPalette(LPPALETTEENTRY pPaletteEntry, BOOL Use8BPPMaskPal,BYTE CMYMask, USHORT RedGamma, USHORT GreenGamma, USHORT BlueGamma)
1776 {
1777         UNIMPLEMENTED;
1778         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1779         return 0;
1780 }
1781
1782 /*
1783  * @unimplemented
1784  */
1785 BOOL
1786 STDCALL
1787 MirrorRgn(HWND hwnd,HRGN hrgn)
1788 {
1789         UNIMPLEMENTED;
1790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1791         return 0;
1792 }
1793
1794 /*
1795  * @unimplemented
1796  */
1797 int
1798 STDCALL
1799 NamedEscape(HDC hdc,PWCHAR pDriver,int nDriver,int iEsc,int cjIn,LPSTR pjIn,int cjOut,LPSTR pjOut)
1800 {
1801         UNIMPLEMENTED;
1802         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1803         return 0;
1804 }
1805
1806 /*
1807  * @unimplemented
1808  */
1809 DWORD
1810 STDCALL
1811 QueryFontAssocStatus(VOID)
1812 {
1813         UNIMPLEMENTED;
1814         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1815         return 0;
1816 }
1817
1818 /*
1819  * @unimplemented
1820  */
1821 BOOL
1822 STDCALL
1823 RemoveFontMemResourceEx(
1824         HANDLE fh
1825 )
1826 {
1827         UNIMPLEMENTED;
1828         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1829         return 0;
1830 }
1831
1832 /*
1833  * @unimplemented
1834  */
1835 int
1836 STDCALL
1837 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1838 {
1839         UNIMPLEMENTED;
1840         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1841         return 0;
1842 }
1843
1844 /*
1845  * @unimplemented
1846  */
1847 HBITMAP
1848 STDCALL
1849 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1850 {
1851         UNIMPLEMENTED;
1852         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1853         return 0;
1854 }
1855
1856 /*
1857  * @unimplemented
1858  */
1859 HBRUSH
1860 STDCALL
1861 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1862 {
1863         UNIMPLEMENTED;
1864         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1865         return 0;
1866 }
1867
1868 /*
1869  * @unimplemented
1870  */
1871 DWORD
1872 STDCALL
1873 SetLayout(
1874         HDC hdc,
1875         DWORD dwLayout
1876 )
1877 {
1878         UNIMPLEMENTED;
1879         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1880         return 0;
1881 }
1882
1883 /*
1884  * @unimplemented
1885  */
1886 DWORD
1887 STDCALL
1888 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
1889 {
1890         UNIMPLEMENTED;
1891         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1892         return 0;
1893 }
1894
1895 /*
1896  * @unimplemented
1897  */
1898 BOOL
1899 STDCALL
1900 SetMagicColors(HDC hdc,PALETTEENTRY peMagic,ULONG Index)
1901 {
1902         UNIMPLEMENTED;
1903         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1904         return 0;
1905 }
1906
1907 /*
1908  * @unimplemented
1909  */
1910 BOOL
1911 STDCALL
1912 SetVirtualResolution(HDC hdc, int cxVirtualDevicePixel,int cyVirtualDevicePixel,int cxVirtualDeviceMm, int cyVirtualDeviceMm)
1913 {
1914         UNIMPLEMENTED;
1915         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1916         return 0;
1917 }
1918
1919 /*
1920  * @unimplemented
1921  */
1922 int
1923 STDCALL
1924 StartFormPage(HDC hdc)
1925 {
1926         UNIMPLEMENTED;
1927         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1928         return 0;
1929 }
1930
1931 /*
1932  * @unimplemented
1933  */
1934 VOID
1935 STDCALL
1936 UnloadNetworkFonts(DWORD unknown)
1937 {
1938         UNIMPLEMENTED;
1939         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1940 }
1941
1942 /*
1943  * @unimplemented
1944  */
1945 BOOL
1946 STDCALL
1947 GetTextExtentExPointI(
1948         HDC hdc,
1949         LPWORD pgiIn,
1950         int cgi,
1951         int nMaxExtent,
1952         LPINT lpnFit,
1953         LPINT alpDx,
1954         LPSIZE lpSize
1955 )
1956 {
1957         UNIMPLEMENTED;
1958         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1959         return 0;
1960 }
1961
1962 /*
1963  * @unimplemented
1964  */
1965 BOOL
1966 STDCALL
1967 GetTextExtentPointI(
1968         HDC hdc,
1969         LPWORD pgiIn,
1970         int cgi,
1971         LPSIZE lpSize
1972 )
1973 {
1974         UNIMPLEMENTED;
1975         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1976         return 0;
1977 }
1978
1979
1980
1981
1982
1983 /*
1984  * @unimplemented
1985  */
1986 BOOL
1987 STDCALL
1988 GdiRealizationInfo(HDC hdc, PREALIZATION_INFO pri)
1989 {
1990         UNIMPLEMENTED;
1991         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1992         return 0;
1993 }
1994
1995
1996
1997 /*
1998  * @unimplemented
1999  */
2000 BOOL
2001 STDCALL
2002 GetETM(HDC hdc,EXTTEXTMETRIC *petm)
2003 {
2004         UNIMPLEMENTED;
2005         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2006         return 0;
2007 }
2008
2009 /*
2010  * @unimplemented
2011  */
2012 BOOL
2013 STDCALL
2014 GdiAddGlsRecord(HDC hdc,DWORD unknown1,LPCSTR unknown2,LPRECT unknown3)
2015 {
2016         UNIMPLEMENTED;
2017         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2018         return 0;
2019 }
2020
2021 /*
2022  * @unimplemented
2023  */
2024 HANDLE
2025 STDCALL
2026 GdiConvertMetaFilePict(HGLOBAL hMem)
2027 {
2028         UNIMPLEMENTED;
2029         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2030         return 0;
2031 }
2032
2033 /*
2034  * @implemented
2035  */
2036 DEVMODEW *
2037 STDCALL
2038 GdiConvertToDevmodeW(DEVMODEA *dm)
2039 {
2040   LPDEVMODEW dmw;
2041
2042   dmw = HEAP_alloc(sizeof(DEVMODEW));
2043 #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
2044 #define COPYN(f) dmw->f = dm->f
2045   COPYS(dmDeviceName, CCHDEVICENAME );
2046   COPYN(dmSpecVersion);
2047   COPYN(dmDriverVersion);
2048   switch ( dm->dmSize )
2049     {
2050     case SIZEOF_DEVMODEA_300:
2051       dmw->dmSize = SIZEOF_DEVMODEW_300;
2052       break;
2053     case SIZEOF_DEVMODEA_400:
2054       dmw->dmSize = SIZEOF_DEVMODEW_400;
2055       break;
2056     case SIZEOF_DEVMODEA_500:
2057     default: /* FIXME what to do??? */
2058       dmw->dmSize = SIZEOF_DEVMODEW_500;
2059       break;
2060     }
2061   COPYN(dmDriverExtra);
2062   COPYN(dmFields);
2063   COPYN(dmPosition.x);
2064   COPYN(dmPosition.y);
2065   COPYN(dmScale);
2066   COPYN(dmCopies);
2067   COPYN(dmDefaultSource);
2068   COPYN(dmPrintQuality);
2069   COPYN(dmColor);
2070   COPYN(dmDuplex);
2071   COPYN(dmYResolution);
2072   COPYN(dmTTOption);
2073   COPYN(dmCollate);
2074   COPYS(dmFormName,CCHFORMNAME);
2075   COPYN(dmLogPixels);
2076   COPYN(dmBitsPerPel);
2077   COPYN(dmPelsWidth);
2078   COPYN(dmPelsHeight);
2079   COPYN(dmDisplayFlags); // aka dmNup
2080   COPYN(dmDisplayFrequency);
2081
2082   if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
2083     return dmw; // we're done with 0x300 fields
2084
2085   COPYN(dmICMMethod);
2086   COPYN(dmICMIntent);
2087   COPYN(dmMediaType);
2088   COPYN(dmDitherType);
2089   COPYN(dmReserved1);
2090   COPYN(dmReserved2);
2091
2092   if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
2093     return dmw; // we're done with 0x400 fields
2094
2095   COPYN(dmPanningWidth);
2096   COPYN(dmPanningHeight);
2097
2098   return dmw;
2099
2100 #undef COPYN
2101 #undef COPYS
2102 }
2103
2104 /*
2105  * @unimplemented
2106  */
2107 HENHMETAFILE
2108 STDCALL
2109 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
2110 {
2111         UNIMPLEMENTED;
2112         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2113         return 0;
2114 }
2115
2116 /*
2117  * @unimplemented
2118  */
2119 METAFILEPICT *
2120 STDCALL
2121 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
2122 {
2123         UNIMPLEMENTED;
2124         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2125         return 0;
2126 }
2127
2128
2129 /*
2130  * @unimplemented
2131  */
2132 HANDLE
2133 STDCALL
2134 GdiGetSpoolFileHandle(
2135         LPWSTR          pwszPrinterName,
2136         LPDEVMODEW      pDevmode,
2137         LPWSTR          pwszDocName)
2138 {
2139         UNIMPLEMENTED;
2140         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2141         return 0;
2142 }
2143
2144 /*
2145  * @unimplemented
2146  */
2147 BOOL
2148 STDCALL
2149 GdiDeleteSpoolFileHandle(
2150         HANDLE  SpoolFileHandle)
2151 {
2152         UNIMPLEMENTED;
2153         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2154         return 0;
2155 }
2156
2157 /*
2158  * @unimplemented
2159  */
2160 DWORD
2161 STDCALL
2162 GdiGetPageCount(
2163         HANDLE  SpoolFileHandle)
2164 {
2165         UNIMPLEMENTED;
2166         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2167         return 0;
2168 }
2169
2170 /*
2171  * @unimplemented
2172  */
2173 HDC
2174 STDCALL
2175 GdiGetDC(
2176         HANDLE  SpoolFileHandle)
2177 {
2178         UNIMPLEMENTED;
2179         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2180         return 0;
2181 }
2182
2183 /*
2184  * @unimplemented
2185  */
2186 HANDLE
2187 STDCALL
2188 GdiGetPageHandle(
2189         HANDLE  SpoolFileHandle,
2190         DWORD   Page,
2191         LPDWORD pdwPageType)
2192 {
2193         UNIMPLEMENTED;
2194         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2195         return 0;
2196 }
2197
2198 /*
2199  * @unimplemented
2200  */
2201 BOOL
2202 STDCALL
2203 GdiStartDocEMF(
2204         HANDLE          SpoolFileHandle,
2205         DOCINFOW        *pDocInfo)
2206 {
2207         UNIMPLEMENTED;
2208         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2209         return 0;
2210 }
2211
2212 /*
2213  * @unimplemented
2214  */
2215 BOOL
2216 STDCALL
2217 GdiStartPageEMF(
2218         HANDLE  SpoolFileHandle)
2219 {
2220         UNIMPLEMENTED;
2221         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2222         return 0;
2223 }
2224
2225 /*
2226  * @unimplemented
2227  */
2228 BOOL
2229 STDCALL
2230 GdiPlayPageEMF(
2231         HANDLE  SpoolFileHandle,
2232         HANDLE  hemf,
2233         RECT    *prectDocument,
2234         RECT    *prectBorder,
2235         RECT    *prectClip)
2236 {
2237         UNIMPLEMENTED;
2238         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2239         return 0;
2240 }
2241
2242 /*
2243  * @unimplemented
2244  */
2245 BOOL
2246 STDCALL
2247 GdiEndPageEMF(
2248         HANDLE  SpoolFileHandle,
2249         DWORD   dwOptimization)
2250 {
2251         UNIMPLEMENTED;
2252         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2253         return 0;
2254 }
2255
2256 /*
2257  * @unimplemented
2258  */
2259 BOOL
2260 STDCALL
2261 GdiEndDocEMF(
2262         HANDLE  SpoolFileHandle)
2263 {
2264         UNIMPLEMENTED;
2265         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2266         return 0;
2267 }
2268
2269 /*
2270  * @unimplemented
2271  */
2272 BOOL
2273 STDCALL
2274 GdiGetDevmodeForPage(
2275         HANDLE          SpoolFileHandle,
2276         DWORD           dwPageNumber,
2277         PDEVMODEW       *pCurrDM,
2278         PDEVMODEW       *pLastDM)
2279 {
2280         UNIMPLEMENTED;
2281         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2282         return 0;
2283 }
2284
2285 /*
2286  * @unimplemented
2287  */
2288 BOOL
2289 STDCALL
2290 GdiResetDCEMF(
2291         HANDLE          SpoolFileHandle,
2292         PDEVMODEW       pCurrDM)
2293 {
2294         UNIMPLEMENTED;
2295         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2296         return 0;
2297 }
2298
2299
2300 HBITMAP
2301 STDCALL
2302 CreateDIBitmap(HDC
2303         hDc, const BITMAPINFOHEADER *Header,
2304         DWORD Init, LPCVOID Bits, const BITMAPINFO *Data,
2305         UINT ColorUse)
2306 {
2307         /* FIMXE we need do more thing in user mode */
2308         return NtGdiCreateDIBitmap(hDc, Header, Init, Bits, Data,  ColorUse);
2309 }
2310
2311 /*
2312  * @unimplemented
2313  */
2314 INT
2315 STDCALL
2316 CombineRgn(HRGN  hDest,
2317                     HRGN  hSrc1,
2318                     HRGN  hSrc2,
2319                     INT  CombineMode)
2320 {
2321     /* FIXME some part should be done in user mode */
2322     return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
2323 }
2324
2325 /*
2326  * @unimplemented
2327  */
2328 HBITMAP STDCALL
2329 CreateBitmap(
2330     INT  Width,
2331     INT  Height,
2332     UINT  Planes,
2333     UINT  BitsPixel,
2334     PCVOID pUnsafeBits)
2335 {
2336     /* FIXME some part should be done in user mode */
2337     return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
2338 }
2339
2340
2341
2342
2343 /*
2344  * @unimplemented
2345  */
2346 LPWSTR STDCALL
2347 EngGetDriverName(HDEV hdev)
2348 {
2349         UNIMPLEMENTED;
2350         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2351         return 0;
2352 }
2353
2354 /*
2355  * @unimplemented
2356  * wrong info it is not Obsolete GDI Function as http://www.osronline.com/DDKx/graphics/gdioview_20tj.htm say
2357  */
2358 BOOL STDCALL
2359 EngQueryEMFInfo(HDEV hdev,EMFINFO *pEMFInfo)
2360 {
2361 #if 0
2362     BOOL retValue = FALSE;
2363     DHPDEV Dhpdev;
2364
2365     if ((!hdev) && (!pEMFInfo))
2366     {
2367         if ((Dhpdev = NtGdiGetDhpdev(hdev)))
2368         {
2369             /* FIXME check if it support or if it is pEMFInfo we got */
2370             /* FIXME copy the data from Dhpdev to pEMFInfo           */
2371         }
2372     }
2373     return retValue;
2374 #else
2375     return FALSE;
2376 #endif
2377 }
2378
2379
2380
2381
2382 /*
2383  * @implemented
2384  */
2385 BOOL
2386 STDCALL
2387 Ellipse(
2388   HDC hdc,
2389   int nLeftRect,
2390   int nTopRect,
2391   int nRightRect,
2392   int nBottomRect)
2393 {
2394     /* FIXME some parts need be done in user mode */
2395     return NtGdiEllipse(hdc,nLeftRect,nTopRect,nRightRect,nBottomRect);
2396 }
2397
2398
2399 /*
2400  * @unimplemented
2401  */
2402 INT STDCALL
2403 EngWideCharToMultiByte( UINT CodePage,
2404                         LPWSTR WideCharString,
2405                         INT BytesInWideCharString,
2406                         LPSTR MultiByteString,
2407                         INT BytesInMultiByteString)
2408 {
2409   return WideCharToMultiByte(
2410                          CodePage,
2411                          0,
2412                          WideCharString,
2413                         (BytesInWideCharString/sizeof(WCHAR)), /* Bytes to (in WCHARs) */
2414                          MultiByteString,
2415                          BytesInMultiByteString,
2416                          NULL,
2417                          NULL);
2418 }
2419
2420
2421 /*
2422  * @unimplemented
2423  */
2424 BOOL STDCALL
2425 PATHOBJ_bEnum(PATHOBJ *ppo,PATHDATA *ppd)
2426 {
2427         UNIMPLEMENTED;
2428         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2429         return 0;
2430 }
2431
2432 /*
2433  * @unimplemented
2434  */
2435 BOOL STDCALL
2436 PATHOBJ_bEnumClipLines(PATHOBJ *ppo,ULONG cb,CLIPLINE *pcl)
2437 {
2438         UNIMPLEMENTED;
2439         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2440         return 0;
2441 }
2442
2443 /*
2444  * @unimplemented
2445  */
2446 VOID STDCALL
2447 PATHOBJ_vEnumStart(PATHOBJ *ppo)
2448 {
2449         UNIMPLEMENTED;
2450         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2451 }
2452
2453 /*
2454  * @unimplemented
2455  */
2456 VOID STDCALL
2457 PATHOBJ_vEnumStartClipLines(PATHOBJ *ppo,CLIPOBJ *pco,SURFOBJ *pso,LINEATTRS *pla)
2458 {
2459         UNIMPLEMENTED;
2460         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2461 }
2462
2463 /*
2464  * @unimplemented
2465  */
2466 VOID STDCALL
2467 PATHOBJ_vGetBounds(PATHOBJ *ppo,PRECTFX prectfx)
2468 {
2469         UNIMPLEMENTED;
2470         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2471 }
2472
2473 /*
2474  * @unimplemented
2475  */
2476 BOOL STDCALL
2477 STROBJ_bEnum(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
2478 {
2479         UNIMPLEMENTED;
2480         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2481         return 0;
2482 }
2483
2484 /*
2485  * @unimplemented
2486  */
2487 BOOL STDCALL
2488 STROBJ_bEnumPositionsOnly(STROBJ *pstro,ULONG *pc,PGLYPHPOS *ppgpos)
2489 {
2490         UNIMPLEMENTED;
2491         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2492         return 0;
2493 }
2494
2495 /*
2496  * @unimplemented
2497  */
2498 BOOL STDCALL
2499 STROBJ_bGetAdvanceWidths(STROBJ *pso,ULONG iFirst,ULONG c,POINTQF *pptqD)
2500 {
2501         UNIMPLEMENTED;
2502         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2503         return 0;
2504 }
2505
2506 /*
2507  * @unimplemented
2508  */
2509 DWORD STDCALL
2510 STROBJ_dwGetCodePage(STROBJ  *pstro)
2511 {
2512         UNIMPLEMENTED;
2513         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2514         return 0;
2515 }
2516
2517 /*
2518  * @unimplemented
2519  */
2520 VOID STDCALL
2521 STROBJ_vEnumStart(STROBJ *pstro)
2522 {
2523         UNIMPLEMENTED;
2524         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2525 }
2526
2527 /*
2528  * @unimplemented
2529  */
2530 BOOL STDCALL
2531 XFORMOBJ_bApplyXform(XFORMOBJ *pxo,ULONG iMode,ULONG cPoints,PVOID pvIn,PVOID pvOut)
2532 {
2533         UNIMPLEMENTED;
2534         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2535         return 0;
2536 }
2537
2538 /*
2539  * @unimplemented
2540  */
2541 ULONG STDCALL
2542 XFORMOBJ_iGetXform(XFORMOBJ *pxo,XFORML *pxform)
2543 {
2544         UNIMPLEMENTED;
2545         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2546         return 0;
2547 }
2548
2549 /*
2550  * @unimplemented
2551  */
2552 ULONG STDCALL
2553 XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj,
2554                      ULONG PalOutType,
2555                      ULONG cPal,
2556                      ULONG *OutPal)
2557 {
2558         UNIMPLEMENTED;
2559         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2560         return 0;
2561 }
2562
2563 /*
2564  * @unimplemented
2565  */
2566 HANDLE STDCALL
2567 XLATEOBJ_hGetColorTransform(XLATEOBJ *pxlo)
2568 {
2569         UNIMPLEMENTED;
2570         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2571         return 0;
2572 }
2573
2574 /*
2575  * @unimplemented
2576  */
2577 ULONG STDCALL
2578 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
2579                 ULONG Color)
2580 {
2581         UNIMPLEMENTED;
2582         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2583         return 0;
2584 }
2585
2586 /*
2587  * @unimplemented
2588  */
2589 ULONG * STDCALL
2590 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
2591 {
2592   return XlateObj->pulXlate;
2593 }
2594
2595 /*
2596  * @unimplemented
2597  */
2598 BOOL
2599 STDCALL
2600 GdiPlayEMF
2601 (
2602         LPWSTR     pwszPrinterName,
2603         LPDEVMODEW pDevmode,
2604         LPWSTR     pwszDocName,
2605         EMFPLAYPROC pfnEMFPlayFn,
2606         HANDLE     hPageQuery
2607 )
2608 {
2609         UNIMPLEMENTED;
2610         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2611         return 0;
2612 }
2613
2614
2615
2616 /*
2617  * @unimplemented
2618  */
2619 BOOL
2620 STDCALL
2621 GdiPlayPrivatePageEMF
2622 (
2623         HANDLE  SpoolFileHandle,
2624         DWORD   unknown,
2625         RECT    *prectDocument
2626 )
2627 {
2628         UNIMPLEMENTED;
2629         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2630         return 0;
2631 }
2632
2633 /*
2634  * @unimplemented
2635  */
2636 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
2637 {
2638         UNIMPLEMENTED;
2639         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2640 }
2641
2642
2643 /*
2644  * @implemented
2645  */
2646 INT
2647 STDCALL
2648 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
2649 {
2650         /* FIXME some part need be done on user mode size */
2651         return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
2652 }
2653
2654 /*
2655  * @implemented
2656  */
2657 INT
2658 STDCALL
2659 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
2660 {
2661         /* FIXME some part need be done on user mode size */
2662         return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
2663 }
2664
2665 /*
2666  * @implemented
2667  */
2668 BOOL
2669 STDCALL
2670 FillRgn( IN HDC hdc, IN HRGN hrgn, IN HBRUSH hbrush)
2671 {
2672         /* FIXME some part need be done on user mode size */
2673         return NtGdiFillRgn( hdc, hrgn, hbrush);
2674 }
2675
2676 /*
2677  * @implemented
2678  */
2679 BOOL
2680 STDCALL
2681 GdiGradientFill(
2682     IN HDC hdc,
2683     IN PTRIVERTEX pVertex,
2684     IN ULONG nVertex,
2685     IN PVOID pMesh,
2686     IN ULONG nMesh,
2687     IN ULONG ulMode)
2688 {
2689     /* FIXME some part need be done in user mode */
2690     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
2691 }
2692
2693
2694 /*
2695  * @implemented
2696  */
2697 BOOL
2698 STDCALL
2699 FrameRgn(
2700     IN HDC hdc,
2701     IN HRGN hrgn,
2702     IN HBRUSH hbrush,
2703     IN INT xWidth,
2704     IN INT yHeight)
2705 {
2706     /* FIXME some part need be done in user mode */
2707     return NtGdiFrameRgn(hdc, hrgn, hbrush, xWidth, yHeight);
2708 }
2709
2710 /*
2711  * @implemented
2712  */
2713 BOOL
2714 STDCALL
2715 GdiTransparentBlt(
2716     IN HDC hdcDst,
2717     IN INT xDst,
2718     IN INT yDst,
2719     IN INT cxDst,
2720     IN INT cyDst,
2721     IN HDC hdcSrc,
2722     IN INT xSrc,
2723     IN INT ySrc,
2724     IN INT cxSrc,
2725     IN INT cySrc,
2726     IN COLORREF TransColor
2727 )
2728 {
2729     /* FIXME some part need be done in user mode */
2730     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
2731 }
2732
2733 /*
2734  * @unimplemented
2735  */
2736 BOOL
2737 STDCALL
2738 GdiPrinterThunk(
2739     IN HUMPD humpd,
2740     DWORD *status,
2741     DWORD unuse)
2742 {
2743     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
2744     /* status contain some form of return value that being save, what it is I do not known */
2745     /* unsue seam have zero effect, what it is for I do not known */
2746
2747     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
2748     return FALSE;
2749 }
2750
2751 /*
2752  * @unimplemented
2753  *
2754  */
2755 HBITMAP
2756 STDCALL
2757 GdiConvertBitmapV5(
2758     HBITMAP in_format_BitMap,
2759     HBITMAP src_BitMap,
2760     INT bpp,
2761     INT unuse)
2762 {
2763     /* FIXME guessing the prototypes */
2764
2765     /*
2766      * it have create a new bitmap with desired in format,
2767      * then convert it src_bitmap to new format
2768      * and return it as HBITMAP
2769      */
2770
2771     return FALSE;
2772 }
2773
2774
2775 /*
2776  * @implemented
2777  *
2778  */
2779 COLORREF
2780 STDCALL
2781 GetBkColor(HDC hdc)
2782 {
2783     /* FIXME some part are done in user mode */
2784     return NtGdiGetBkColor(hdc);
2785 }
2786
2787 /*
2788  * @implemented
2789  *
2790  */
2791 int
2792 STDCALL
2793 GetBkMode(HDC hdc)
2794 {
2795     /* FIXME some part are done in user mode */
2796     return NtGdiGetBkMode(hdc);
2797 }
2798
2799 /*
2800  * @implemented
2801  *
2802  */
2803 BOOL
2804 STDCALL
2805 GetBrushOrgEx(HDC hdc,LPPOINT pt)
2806 {
2807     /* FIXME some part are done in user mode */
2808     return NtGdiGetBrushOrgEx(hdc,pt);
2809 }
2810
2811 /*
2812  * @implemented
2813  *
2814  */
2815 BOOL
2816 STDCALL
2817 GetCharABCWidthsFloatW(HDC hdc,UINT FirstChar,UINT LastChar,LPABCFLOAT abcF)
2818 {
2819     /* FIXME some part are done in user mode */
2820     return NtGdiGetCharABCWidthsFloat(hdc, FirstChar, LastChar, abcF);
2821 }
2822
2823 /*
2824  * @implemented
2825  *
2826  */
2827 int
2828 STDCALL
2829 GetDeviceCaps(HDC hdc,
2830               int i)
2831 {
2832     /* FIXME some part need be done in user mode */
2833     return NtGdiGetDeviceCaps(hdc,i);
2834 }
2835
2836
2837 /*
2838  * @implemented
2839  *
2840  */
2841 BOOL
2842 STDCALL
2843 GetCurrentPositionEx(HDC hdc,
2844                      LPPOINT lpPoint)
2845 {
2846     /* FIXME some part need be done in user mode */
2847     return  NtGdiGetCurrentPositionEx(hdc, lpPoint);
2848 }
2849
2850 /*
2851  * @implemented
2852  *
2853  */
2854 HGDIOBJ
2855 STDCALL
2856 GetCurrentObject(HDC hdc,
2857                  UINT uObjectType)
2858 {
2859     /* FIXME some part need be done in user mode */
2860     return  NtGdiGetCurrentObject(hdc, uObjectType);
2861 }
2862
2863 /*
2864  * @implemented
2865  *
2866  */
2867 int
2868 STDCALL
2869 GetClipBox(HDC hdc,
2870            LPRECT lprc)
2871 {
2872     /* FIXME some part need be done in user mode */
2873     return  NtGdiGetClipBox(hdc, lprc);
2874 }
2875
2876 /*
2877  * @implemented
2878  *
2879  */
2880 BOOL
2881 STDCALL
2882 GetCharWidthFloatW(HDC hdc,
2883                    UINT iFirstChar,
2884                    UINT iLastChar,
2885                    PFLOAT pxBuffer)
2886 {
2887     /* FIXME some part need be done in user mode */
2888     return NtGdiGetCharWidthFloat(hdc, iFirstChar, iLastChar, pxBuffer);
2889 }
2890
2891 /*
2892  * @implemented
2893  *
2894  */
2895 BOOL
2896 STDCALL
2897 GetCharWidth32W(HDC hdc,
2898                UINT iFirstChar,
2899                UINT iLastChar,
2900                LPINT lpBuffer)
2901 {
2902     /* FIXME some part need be done in user mode */
2903     return NtGdiGetCharWidth32(hdc, iFirstChar, iLastChar, lpBuffer);
2904 }
2905
2906 /*
2907  * @implemented
2908  *
2909  */
2910 BOOL
2911 STDCALL
2912 GetCharABCWidths(HDC hdc,
2913                  UINT uFirstChar,
2914                  UINT uLastChar,
2915                  LPABC lpabc)
2916 {
2917     /* FIXME some part need be done in user mode */
2918     return NtGdiGetCharABCWidths(hdc, uFirstChar, uLastChar, lpabc);
2919 }
2920
2921
2922 /*
2923  * @implemented
2924  *
2925  */
2926 DWORD
2927 STDCALL
2928 GetFontData(HDC hdc,
2929             DWORD dwTable,
2930             DWORD dwOffset,
2931             LPVOID lpvBuffer,
2932             DWORD cbData)
2933 {
2934     if (!lpvBuffer)
2935     {
2936        cbData = 0;
2937     }
2938     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2939 }