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 /*
  25  * @unimplemented
  26  */
  27 int
  28 STDCALL
  29 StretchDIBits(HDC hdc,
  30               int XDest,
  31               int YDest,
  32               int nDestWidth,
  33               int nDestHeight,
  34               int XSrc,
  35               int YSrc,
  36               int nSrcWidth,
  37               int nSrcHeight,
  38               CONST VOID *lpBits,
  39               CONST BITMAPINFO *lpBitsInfo,
  40               UINT iUsage,
  41               DWORD dwRop)
  42
  43 {
  44     /* FIXME share memory */
  45     return NtGdiStretchDIBits(hdc, XDest, YDest, nDestWidth, nDestHeight, XSrc, YSrc,
  46                               nSrcWidth, nSrcHeight, lpBits, lpBitsInfo, iUsage, dwRop);
  47 }
  48
  49 /*
  50  * @unimplemented
  51  */
  52 int
  53 STDCALL
  54 SetDIBits(HDC hdc,
  55           HBITMAP hbmp,
  56           UINT uStartScan,
  57           UINT cScanLines,
  58           CONST VOID *lpvBits,
  59           CONST BITMAPINFO *lpbmi,
  60           UINT fuColorUse)
  61 {
  62     /* FIXME share memory */
  63     return NtGdiSetDIBits(hdc, hbmp, uStartScan, cScanLines, lpvBits, lpbmi, fuColorUse);
  64 }
  65
  66 /*
  67  * @unimplemented
  68  */
  69 BOOL
  70 STDCALL
  71 PtInRegion(IN HRGN hrgn,
  72            int x,
  73            int y)
  74 {
  75     /* FIXME some stuff at user mode need be fixed */
  76     return NtGdiPtInRegion(hrgn,x,y);
  77 }
  78
  79 /*
  80  * @unimplemented
  81  */
  82 BOOL
  83 STDCALL
  84 RectInRegion(HRGN hrgn,
  85              LPCRECT prcl)
  86 {
  87     /* FIXME some stuff at user mode need be fixed */
  88     return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
  89 }
  90
  91 /*
  92  * @unimplemented
  93  */
  94 BOOL
  95 STDCALL
  96 RestoreDC(IN HDC hdc,
  97           IN INT iLevel)
  98 {
  99     /* FIXME Sharememory */
 100     return NtGdiRestoreDC(hdc, iLevel);
 101 }
 102
 103 /*
 104  * @unimplemented
 105  */
 106 INT
 107 STDCALL
 108 SaveDC(IN HDC hdc)
 109 {
 110     /* FIXME Sharememory */
 111     return NtGdiSaveDC(hdc);
 112 }
 113
 114
 115
 116 /*
 117  * @unimplemented
 118  */
 119 BOOL
 120 STDCALL
 121 CancelDC(HDC hdc)
 122 {
 123     UNIMPLEMENTED;
 124     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 125     return FALSE;
 126 }
 127
 128
 129 /*
 130  * @unimplemented
 131  */
 132 int
 133 STDCALL
 134 DrawEscape(HDC  hdc,
 135            int a1,
 136            int a2,
 137            LPCSTR a3)
 138 {
 139     UNIMPLEMENTED;
 140     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 141     return 0;
 142 }
 143
 144
 145 /*
 146  * @unimplemented
 147  */
 148 int
 149 STDCALL
 150 EnumObjects(HDC hdc,
 151             int a1,
 152             GOBJENUMPROC a2,
 153             LPARAM a3)
 154 {
 155     UNIMPLEMENTED;
 156     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 157     return 0;
 158 }
 159
 160 /*
 161  * @unimplemented
 162  */
 163 int
 164 STDCALL
 165 Escape(HDC hdc, INT escape, INT in_count, LPCSTR in_data, LPVOID out_data)
 166 {
 167         UNIMPLEMENTED;
 168         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 169         return 0;
 170 }
 171
 172 /*
 173  * @implemented
 174  */
 175 UINT
 176 STDCALL
 177 GetBoundsRect(
 178         HDC     hdc,
 179         LPRECT  lprcBounds,
 180         UINT    flags
 181         )
 182 {
 183     return NtGdiGetBoundsRect(hdc,lprcBounds,flags & DCB_RESET);
 184 }
 185
 186
 187 /*
 188  * @unimplemented
 189  */
 190 UINT
 191 STDCALL
 192 GetMetaFileBitsEx(
 193         HMETAFILE       a0,
 194         UINT            a1,
 195         LPVOID          a2
 196         )
 197 {
 198         UNIMPLEMENTED;
 199         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 200         return 0;
 201 }
 202
 203
 204 /*
 205  * @unimplemented
 206  */
 207 DWORD
 208 STDCALL
 209 GetFontLanguageInfo(
 210         HDC     hDc
 211         )
 212 {
 213         UNIMPLEMENTED;
 214         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 215         return 0;
 216 }
 217
 218 /*
 219  * @unimplemented
 220  */
 221 BOOL
 222 STDCALL
 223 PlayMetaFile(
 224         HDC             a0,
 225         HMETAFILE       a1
 226         )
 227 {
 228         UNIMPLEMENTED;
 229         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 230         return FALSE;
 231 }
 232
 233 /*
 234  * @implemented
 235  */
 236 UINT
 237 STDCALL
 238 SetBoundsRect(HDC hdc,
 239               CONST RECT *prc,
 240               UINT flags)
 241 {
 242     /* FIXME add check for vaildate the flags */
 243     return NtGdiSetBoundsRect(hdc, (LPRECT)prc, flags);
 244 }
 245
 246
 247 /*
 248  * @unimplemented
 249  */
 250 DWORD
 251 STDCALL
 252 SetMapperFlags(
 253         HDC     a0,
 254         DWORD   a1
 255         )
 256 {
 257         UNIMPLEMENTED;
 258         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 259         return 0;
 260 }
 261
 262 /*
 263  * @unimplemented
 264  */
 265 HMETAFILE
 266 STDCALL
 267 SetMetaFileBitsEx(
 268         UINT            a0,
 269         CONST BYTE      *a1
 270         )
 271 {
 272         UNIMPLEMENTED;
 273         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 274         return 0;
 275 }
 276
 277 /*
 278  * @unimplemented
 279  */
 280 BOOL
 281 STDCALL
 282 PlayMetaFileRecord(
 283         HDC             a0,
 284         LPHANDLETABLE   a1,
 285         LPMETARECORD    a2,
 286         UINT            a3
 287         )
 288 {
 289         UNIMPLEMENTED;
 290         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 291         return FALSE;
 292 }
 293
 294
 295 /*
 296  * @unimplemented
 297  */
 298 BOOL
 299 STDCALL
 300 EnumMetaFile(
 301         HDC                     a0,
 302         HMETAFILE               a1,
 303         MFENUMPROC              a2,
 304         LPARAM                  a3
 305         )
 306 {
 307         UNIMPLEMENTED;
 308         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 309         return FALSE;
 310 }
 311
 312 /*
 313  * @unimplemented
 314  */
 315 BOOL
 316 STDCALL
 317 DeleteEnhMetaFile(
 318         HENHMETAFILE    a0
 319         )
 320 {
 321         UNIMPLEMENTED;
 322         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 323         return FALSE;
 324 }
 325
 326 /*
 327  * @unimplemented
 328  */
 329 BOOL
 330 STDCALL
 331 EnumEnhMetaFile(
 332         HDC             a0,
 333         HENHMETAFILE    a1,
 334         ENHMFENUMPROC   a2,
 335         LPVOID          a3,
 336         CONST RECT      *a4
 337         )
 338 {
 339         UNIMPLEMENTED;
 340         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 341         return FALSE;
 342 }
 343
 344 /*
 345  * @unimplemented
 346  */
 347 UINT
 348 STDCALL
 349 GetEnhMetaFileBits(
 350         HENHMETAFILE    a0,
 351         UINT            a1,
 352         LPBYTE          a2
 353         )
 354 {
 355         UNIMPLEMENTED;
 356         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 357         return 0;
 358 }
 359
 360
 361 /*
 362  * @unimplemented
 363  */
 364 UINT
 365 STDCALL
 366 GetEnhMetaFileHeader(
 367         HENHMETAFILE    a0,
 368         UINT            a1,
 369         LPENHMETAHEADER a2
 370         )
 371 {
 372         UNIMPLEMENTED;
 373         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 374         return 0;
 375 }
 376
 377 /*
 378  * @unimplemented
 379  */
 380 UINT
 381 STDCALL
 382 GetEnhMetaFilePaletteEntries(
 383         HENHMETAFILE    a0,
 384         UINT            a1,
 385         LPPALETTEENTRY  a2
 386         )
 387 {
 388         UNIMPLEMENTED;
 389         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 390         return 0;
 391 }
 392
 393 /*
 394  * @unimplemented
 395  */
 396 UINT
 397 STDCALL
 398 GetWinMetaFileBits(
 399         HENHMETAFILE    a0,
 400         UINT            a1,
 401         LPBYTE          a2,
 402         INT             a3,
 403         HDC             a4
 404         )
 405 {
 406         UNIMPLEMENTED;
 407         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 408         return 0;
 409 }
 410
 411
 412 /*
 413  * @unimplemented
 414  */
 415 BOOL
 416 STDCALL
 417 PlayEnhMetaFile(
 418         HDC             a0,
 419         HENHMETAFILE    a1,
 420         CONST RECT      *a2
 421         )
 422 {
 423         UNIMPLEMENTED;
 424         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 425         return FALSE;
 426 }
 427
 428
 429 /*
 430  * @unimplemented
 431  */
 432 BOOL
 433 STDCALL
 434 PlayEnhMetaFileRecord(
 435         HDC                     a0,
 436         LPHANDLETABLE           a1,
 437         CONST ENHMETARECORD     *a2,
 438         UINT                    a3
 439         )
 440 {
 441         UNIMPLEMENTED;
 442         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 443         return FALSE;
 444 }
 445
 446
 447 /*
 448  * @unimplemented
 449  */
 450 HENHMETAFILE
 451 STDCALL
 452 SetEnhMetaFileBits(
 453         UINT            a0,
 454         CONST BYTE      *a1
 455         )
 456 {
 457         UNIMPLEMENTED;
 458         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 459         return 0;
 460 }
 461
 462
 463 /*
 464  * @unimplemented
 465  */
 466 HENHMETAFILE
 467 STDCALL
 468 SetWinMetaFileBits(
 469         UINT                    a0,
 470         CONST BYTE              *a1,
 471         HDC                     a2,
 472         CONST METAFILEPICT      *a3)
 473 {
 474         UNIMPLEMENTED;
 475         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 476         return 0;
 477 }
 478
 479
 480 /*
 481  * @unimplemented
 482  */
 483 BOOL
 484 STDCALL
 485 GdiComment(
 486         HDC             hDC,
 487         UINT            bytes,
 488         CONST BYTE      *buffer
 489         )
 490 {
 491 #if 0
 492   if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF)
 493   {
 494      PLDC pLDC = GdiGetLDC(hDC);
 495      if ( !pLDC )
 496      {
 497         SetLastError(ERROR_INVALID_HANDLE);
 498         return FALSE;
 499      }
 500      if (pLDC->iType == LDC_EMFLDC)
 501      {          // Wine port
 502          return EMFDRV_GdiComment( hDC, bytes, buffer );
 503      }
 504   }
 505 #endif
 506   return FALSE;
 507 }
 508
 509
 510 /*
 511  * @unimplemented
 512  */
 513 BOOL
 514 STDCALL
 515 AngleArc(
 516         HDC     hdc,
 517         int     a1,
 518         int     a2,
 519         DWORD   a3,
 520         FLOAT   a4,
 521         FLOAT   a5
 522         )
 523 {
 524         UNIMPLEMENTED;
 525         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 526         return FALSE;
 527 }
 528
 529
 530 /*
 531  * @unimplemented
 532  */
 533 BOOL
 534 STDCALL
 535 SetColorAdjustment(
 536         HDC                     hdc,
 537         CONST COLORADJUSTMENT   *a1
 538         )
 539 {
 540         UNIMPLEMENTED;
 541         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 542         return FALSE;
 543 }
 544
 545 /*
 546  * @unimplemented
 547  */
 548 int
 549 STDCALL
 550 EndDoc(
 551         HDC     hdc
 552         )
 553 {
 554         UNIMPLEMENTED;
 555         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 556         return 0;
 557 }
 558
 559
 560 /*
 561  * @unimplemented
 562  */
 563 int
 564 STDCALL
 565 StartPage(
 566         HDC     hdc
 567         )
 568 {
 569         UNIMPLEMENTED;
 570         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 571         return 0;
 572 }
 573
 574
 575 /*
 576  * @unimplemented
 577  */
 578 int
 579 STDCALL
 580 EndPage(
 581         HDC     hdc
 582         )
 583 {
 584         UNIMPLEMENTED;
 585         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 586         return 0;
 587 }
 588
 589
 590 /*
 591  * @unimplemented
 592  */
 593 int
 594 STDCALL
 595 AbortDoc(
 596         HDC     hdc
 597         )
 598 {
 599         UNIMPLEMENTED;
 600         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 601         return 0;
 602 }
 603
 604
 605 /*
 606  * @unimplemented
 607  */
 608 int
 609 STDCALL
 610 SetAbortProc(
 611         HDC             hdc,
 612         ABORTPROC       a1
 613         )
 614 {
 615         UNIMPLEMENTED;
 616         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 617         return 0;
 618 }
 619
 620 /*
 621  * @implemented
 622  */
 623 BOOL
 624 STDCALL
 625 UnrealizeObject(HGDIOBJ  hgdiobj)
 626 {
 627     BOOL retValue = TRUE;
 628
 629     if (GDI_HANDLE_GET_TYPE(hgdiobj) != GDI_OBJECT_TYPE_BRUSH)
 630     {
 631         retValue = NtGdiUnrealizeObject(hgdiobj);
 632     }
 633
 634     return retValue;
 635 }
 636
 637
 638 /*
 639  * @implemented
 640  */
 641 BOOL
 642 STDCALL
 643 GdiFlush()
 644 {
 645     NtGdiFlush();
 646     return TRUE;
 647 }
 648
 649
 650 /*
 651  * @unimplemented
 652  */
 653 int
 654 STDCALL
 655 SetICMMode(
 656         HDC     a0,
 657         int     a1
 658         )
 659 {
 660         UNIMPLEMENTED;
 661         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 662         return 0;
 663 }
 664
 665
 666 /*
 667  * @unimplemented
 668  */
 669 BOOL
 670 STDCALL
 671 CheckColorsInGamut(
 672         HDC     a0,
 673         LPVOID  a1,
 674         LPVOID  a2,
 675         DWORD   a3
 676         )
 677 {
 678         UNIMPLEMENTED;
 679         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 680         return FALSE;
 681 }
 682
 683
 684 /*
 685  * @unimplemented
 686  */
 687 HCOLORSPACE
 688 STDCALL
 689 GetColorSpace(HDC hDc)
 690 {
 691     UNIMPLEMENTED;
 692     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 693     return 0;
 694 }
 695
 696
 697 /*
 698  * @unimplemented
 699  */
 700 HCOLORSPACE
 701 STDCALL
 702 SetColorSpace(
 703         HDC             a0,
 704         HCOLORSPACE     a1
 705         )
 706 {
 707         UNIMPLEMENTED;
 708         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 709         return FALSE;
 710 }
 711
 712 /*
 713  * @implemented
 714  */
 715 BOOL
 716 STDCALL
 717 GetDeviceGammaRamp( HDC hdc,
 718                     LPVOID lpGammaRamp)
 719 {
 720     BOOL retValue = FALSE;
 721     if (lpGammaRamp == NULL)
 722     {
 723         SetLastError(ERROR_INVALID_PARAMETER);
 724     }
 725     else
 726     {
 727         retValue = NtGdiGetDeviceGammaRamp(hdc,lpGammaRamp);
 728     }
 729
 730     return retValue;
 731 }
 732
 733 /*
 734  * @implemented
 735  */
 736 BOOL
 737 STDCALL
 738 SetDeviceGammaRamp(HDC hdc,
 739                    LPVOID lpGammaRamp)
 740 {
 741     BOOL retValue = FALSE;
 742
 743     if (lpGammaRamp)
 744     {
 745         retValue = NtGdiSetDeviceGammaRamp(hdc, lpGammaRamp);
 746     }
 747     else
 748     {
 749         SetLastError(ERROR_INVALID_PARAMETER);
 750     }
 751
 752     return  retValue;
 753 }
 754
 755
 756 /*
 757  * @unimplemented
 758  */
 759 BOOL
 760 STDCALL
 761 ColorMatchToTarget(
 762         HDC     a0,
 763         HDC     a1,
 764         DWORD   a2
 765         )
 766 {
 767         UNIMPLEMENTED;
 768         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 769         return FALSE;
 770 }
 771
 772
 773 /*
 774  * @unimplemented
 775  */
 776 BOOL
 777 STDCALL
 778 wglCopyContext(
 779         HGLRC   a0,
 780         HGLRC   a1,
 781         UINT    a2
 782         )
 783 {
 784         UNIMPLEMENTED;
 785         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 786         return FALSE;
 787 }
 788
 789
 790 /*
 791  * @unimplemented
 792  */
 793 HGLRC
 794 STDCALL
 795 wglCreateContext(
 796         HDC     hDc
 797         )
 798 {
 799         UNIMPLEMENTED;
 800         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 801         return 0;
 802 }
 803
 804
 805 /*
 806  * @unimplemented
 807  */
 808 HGLRC
 809 STDCALL
 810 wglCreateLayerContext(
 811         HDC     hDc,
 812         int     a1
 813         )
 814 {
 815         UNIMPLEMENTED;
 816         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 817         return 0;
 818 }
 819
 820
 821 /*
 822  * @unimplemented
 823  */
 824 BOOL
 825 STDCALL
 826 wglDeleteContext(
 827         HGLRC   a
 828         )
 829 {
 830         UNIMPLEMENTED;
 831         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 832         return FALSE;
 833 }
 834
 835
 836 /*
 837  * @unimplemented
 838  */
 839 HGLRC
 840 STDCALL
 841 wglGetCurrentContext(VOID)
 842 {
 843         UNIMPLEMENTED;
 844         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 845         return 0;
 846 }
 847
 848
 849 /*
 850  * @unimplemented
 851  */
 852 HDC
 853 STDCALL
 854 wglGetCurrentDC(VOID)
 855 {
 856         UNIMPLEMENTED;
 857         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 858         return 0;
 859 }
 860
 861
 862 /*
 863  * @unimplemented
 864  */
 865 PROC
 866 STDCALL
 867 wglGetProcAddress(
 868         LPCSTR          a0
 869         )
 870 {
 871         UNIMPLEMENTED;
 872         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 873         return 0;
 874 }
 875
 876
 877 /*
 878  * @unimplemented
 879  */
 880 BOOL
 881 STDCALL
 882 wglMakeCurrent(
 883         HDC     a0,
 884         HGLRC   a1
 885         )
 886 {
 887         UNIMPLEMENTED;
 888         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 889         return FALSE;
 890 }
 891
 892
 893 /*
 894  * @unimplemented
 895  */
 896 BOOL
 897 STDCALL
 898 wglShareLists(
 899         HGLRC   a0,
 900         HGLRC   a1
 901         )
 902 {
 903         UNIMPLEMENTED;
 904         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 905         return FALSE;
 906 }
 907
 908
 909 /*
 910  * @unimplemented
 911  */
 912 BOOL
 913 STDCALL
 914 wglDescribeLayerPlane(
 915         HDC                     a0,
 916         int                     a1,
 917         int                     a2,
 918         UINT                    a3,
 919         LPLAYERPLANEDESCRIPTOR  a4
 920         )
 921 {
 922         UNIMPLEMENTED;
 923         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 924         return FALSE;
 925 }
 926
 927
 928 /*
 929  * @unimplemented
 930  */
 931 int
 932 STDCALL
 933 wglSetLayerPaletteEntries(
 934         HDC             a0,
 935         int             a1,
 936         int             a2,
 937         int             a3,
 938         CONST COLORREF  *a4
 939         )
 940 {
 941         UNIMPLEMENTED;
 942         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 943         return 0;
 944 }
 945
 946
 947 /*
 948  * @unimplemented
 949  */
 950 int
 951 STDCALL
 952 wglGetLayerPaletteEntries(
 953         HDC             a0,
 954         int             a1,
 955         int             a2,
 956         int             a3,
 957         COLORREF        *a4
 958         )
 959 {
 960         UNIMPLEMENTED;
 961         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 962         return 0;
 963 }
 964
 965
 966 /*
 967  * @unimplemented
 968  */
 969 BOOL
 970 STDCALL
 971 wglRealizeLayerPalette(
 972         HDC             a0,
 973         int             a1,
 974         BOOL            a2
 975         )
 976 {
 977         UNIMPLEMENTED;
 978         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 979         return FALSE;
 980 }
 981
 982
 983 /*
 984  * @unimplemented
 985  */
 986 BOOL
 987 STDCALL
 988 wglSwapLayerBuffers(
 989         HDC             a0,
 990         UINT            a1
 991         )
 992 {
 993         UNIMPLEMENTED;
 994         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 995         return FALSE;
 996 }
 997
 998
 999 /* === AFTER THIS POINT I GUESS... =========
1000  * (based on stack size in Norlander's .def)
1001  * === WHERE ARE THEY DEFINED? =============
1002  */
1003
1004 /*
1005  * @unimplemented
1006  */
1007 DWORD
1008 STDCALL
1009 IsValidEnhMetaRecord(
1010         DWORD   a0,
1011         DWORD   a1
1012         )
1013 {
1014         UNIMPLEMENTED;
1015         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1016         return 0;
1017
1018 }
1019
1020 /*
1021  * @unimplemented
1022  */
1023 DWORD
1024 STDCALL
1025 IsValidEnhMetaRecordOffExt(
1026         DWORD   a0,
1027         DWORD   a1,
1028         DWORD   a2,
1029         DWORD   a3
1030         )
1031 {
1032         UNIMPLEMENTED;
1033         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1034         return 0;
1035
1036 }
1037
1038 /*
1039  * @unimplemented
1040  */
1041 DWORD
1042 STDCALL
1043 GetGlyphOutlineWow(
1044         DWORD   a0,
1045         DWORD   a1,
1046         DWORD   a2,
1047         DWORD   a3,
1048         DWORD   a4,
1049         DWORD   a5,
1050         DWORD   a6
1051         )
1052 {
1053         UNIMPLEMENTED;
1054         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1055         return 0;
1056 }
1057
1058 /*
1059  * @unimplemented
1060  */
1061 DWORD
1062 STDCALL
1063 gdiPlaySpoolStream(
1064         DWORD   a0,
1065         DWORD   a1,
1066         DWORD   a2,
1067         DWORD   a3,
1068         DWORD   a4,
1069         DWORD   a5
1070         )
1071 {
1072         UNIMPLEMENTED;
1073         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1074         return 0;
1075 }
1076
1077 /*
1078  * @unimplemented
1079  */
1080 HANDLE
1081 STDCALL
1082 AddFontMemResourceEx(
1083         PVOID pbFont,
1084         DWORD cbFont,
1085         PVOID pdv,
1086         DWORD *pcFonts
1087 )
1088 {
1089         UNIMPLEMENTED;
1090         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1091         return 0;
1092 }
1093
1094 /*
1095  * @unimplemented
1096  */
1097 int
1098 STDCALL
1099 AddFontResourceTracking(
1100         LPCSTR lpString,
1101         int unknown
1102 )
1103 {
1104         UNIMPLEMENTED;
1105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1106         return 0;
1107 }
1108
1109
1110
1111 /*
1112  * @unimplemented
1113  */
1114 HBITMAP
1115 STDCALL
1116 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1117 {
1118         UNIMPLEMENTED;
1119         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1120         return 0;
1121 }
1122
1123 /*
1124  * @unimplemented
1125  */
1126 HBRUSH
1127 STDCALL
1128 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1129 {
1130         UNIMPLEMENTED;
1131         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1132         return 0;
1133 }
1134
1135 /*
1136  * @unimplemented
1137  */
1138 BOOL
1139 STDCALL
1140 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
1141 {
1142         UNIMPLEMENTED;
1143         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1144         return 0;
1145 }
1146
1147 /*
1148  * @unimplemented
1149  */
1150 int
1151 STDCALL
1152 EndFormPage(HDC hdc)
1153 {
1154         UNIMPLEMENTED;
1155         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1156         return 0;
1157 }
1158
1159
1160
1161 /*
1162  * @unimplemented
1163  */
1164 DWORD
1165 STDCALL
1166 GdiAddGlsBounds(HDC hdc,LPRECT prc)
1167 {
1168         UNIMPLEMENTED;
1169         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1170         return 0;
1171 }
1172
1173 /*
1174  * @unimplemented
1175  */
1176 BOOL
1177 STDCALL
1178 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
1179 {
1180         UNIMPLEMENTED;
1181         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1182         return 0;
1183 }
1184
1185 /*
1186  * @unimplemented
1187  */
1188 BOOL
1189 STDCALL
1190 GdiCleanCacheDC(HDC hdc)
1191 {
1192         UNIMPLEMENTED;
1193         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194         return 0;
1195 }
1196
1197 /*
1198  * @unimplemented
1199  */
1200 HDC
1201 STDCALL
1202 GdiConvertAndCheckDC(HDC hdc)
1203 {
1204         UNIMPLEMENTED;
1205         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1206         return 0;
1207 }
1208
1209 /*
1210  * @unimplemented
1211  */
1212 HENHMETAFILE
1213 STDCALL
1214 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
1215 {
1216     UNIMPLEMENTED;
1217     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1218     return 0;
1219 }
1220
1221 /*
1222  * @unimplemented
1223  */
1224 BOOL
1225 STDCALL
1226 GdiDrawStream(HDC dc, ULONG l, VOID *v)
1227 {
1228     UNIMPLEMENTED;
1229     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1230     return 0;
1231 }
1232
1233 /*
1234  * @unimplemented
1235  */
1236 BOOL
1237 STDCALL
1238 GdiIsMetaFileDC(HDC hdc)
1239 {
1240     UNIMPLEMENTED;
1241     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1242     return 0;
1243 }
1244
1245 /*
1246  * @unimplemented
1247  */
1248 BOOL
1249 STDCALL
1250 GdiIsMetaPrintDC(HDC hdc)
1251 {
1252     UNIMPLEMENTED;
1253     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1254     return 0;
1255 }
1256
1257 /*
1258  * @unimplemented
1259  */
1260 BOOL
1261 STDCALL
1262 GdiIsPlayMetafileDC(HDC hdc)
1263 {
1264     UNIMPLEMENTED;
1265     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1266     return 0;
1267 }
1268
1269 /*
1270  * @unimplemented
1271  */
1272 BOOL
1273 STDCALL
1274 GdiValidateHandle(HGDIOBJ hobj)
1275 {
1276     UNIMPLEMENTED;
1277     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1278     return 0;
1279 }
1280
1281 /*
1282  * @unimplemented
1283  */
1284 DWORD
1285 STDCALL
1286 GetBitmapAttributes(HBITMAP hbm)
1287 {
1288     UNIMPLEMENTED;
1289     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1290     return 0;
1291 }
1292
1293 /*
1294  * @unimplemented
1295  */
1296 DWORD
1297 STDCALL
1298 GetBrushAttributes(HBRUSH hbr)
1299 {
1300     UNIMPLEMENTED;
1301     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1302     return 0;
1303 }
1304
1305 /*
1306  * @implemented
1307  */
1308 ULONG
1309 STDCALL
1310 GetEUDCTimeStamp(VOID)
1311 {
1312     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1313 }
1314
1315 /*
1316  * @implemented
1317  */
1318 ULONG
1319 STDCALL
1320 GetFontAssocStatus(HDC hdc)
1321 {
1322     ULONG retValue = 0;
1323
1324     if (hdc)
1325     {
1326         retValue = NtGdiQueryFontAssocInfo(hdc);
1327     }
1328
1329     return retValue;
1330 }
1331
1332 /*
1333  * @implemented
1334  */
1335 BOOL
1336 STDCALL
1337 GetTextExtentExPointWPri(HDC hdc,
1338                          LPWSTR lpwsz,
1339                          ULONG cwc,
1340                          ULONG dxMax,
1341                          ULONG *pcCh,
1342                          PULONG pdxOut,
1343                          LPSIZE psize)
1344 {
1345     return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1346 }
1347
1348 /*
1349  * @implemented
1350  */
1351 INT
1352 STDCALL
1353 GetTextFaceAliasW(HDC hdc,
1354                   int cChar,
1355                   LPWSTR pszOut)
1356 {
1357     INT retValue = 0;
1358     if ((!pszOut) || (cChar))
1359     {
1360         retValue = NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE);
1361     }
1362     else
1363     {
1364         SetLastError(ERROR_INVALID_PARAMETER);
1365     }
1366     return retValue;
1367 }
1368
1369 /*
1370  * @unimplemented
1371  */
1372 DWORD
1373 STDCALL
1374 QueryFontAssocStatus(VOID)
1375 {
1376     UNIMPLEMENTED;
1377     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1378     return 0;
1379 }
1380
1381 /*
1382  * @implemented
1383  */
1384 BOOL
1385 STDCALL
1386 RemoveFontMemResourceEx(HANDLE fh)
1387 {
1388     BOOL retValue=0;
1389
1390     if (fh)
1391     {
1392         retValue = NtGdiRemoveFontMemResourceEx(fh);
1393     }
1394     else
1395     {
1396         SetLastError(ERROR_INVALID_PARAMETER);
1397     }
1398     return retValue;
1399 }
1400
1401 /*
1402  * @unimplemented
1403  */
1404 int
1405 STDCALL
1406 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1407 {
1408         UNIMPLEMENTED;
1409         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1410         return 0;
1411 }
1412
1413 /*
1414  * @unimplemented
1415  */
1416 HBITMAP
1417 STDCALL
1418 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1419 {
1420         UNIMPLEMENTED;
1421         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1422         return 0;
1423 }
1424
1425 /*
1426  * @unimplemented
1427  */
1428 HBRUSH
1429 STDCALL
1430 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1431 {
1432         UNIMPLEMENTED;
1433         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1434         return 0;
1435 }
1436
1437 /*
1438  * @implemented
1439  */
1440 int
1441 STDCALL
1442 StartFormPage(HDC hdc)
1443 {
1444     return StartPage(hdc);
1445 }
1446
1447 /*
1448  * @unimplemented
1449  */
1450 VOID
1451 STDCALL
1452 UnloadNetworkFonts(DWORD unknown)
1453 {
1454     UNIMPLEMENTED;
1455     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1456 }
1457
1458 /*
1459  * @unimplemented
1460  */
1461 BOOL
1462 STDCALL
1463 GdiRealizationInfo(HDC hdc,
1464                    PREALIZATION_INFO pri)
1465 {
1466     UNIMPLEMENTED;
1467     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1468     return 0;
1469 }
1470
1471 /*
1472  * @implemented
1473  */
1474 BOOL
1475 STDCALL
1476 GetETM(HDC hdc,
1477        EXTTEXTMETRIC *petm)
1478 {
1479   BOOL Ret = NtGdiGetETM(hdc, petm);
1480
1481   if (Ret && petm)
1482     petm->emKernPairs = GetKerningPairsA(hdc, 0, 0);
1483
1484   return Ret;
1485 }
1486
1487 /*
1488  * @unimplemented
1489  */
1490 BOOL
1491 STDCALL
1492 GdiAddGlsRecord(HDC hdc,
1493                 DWORD unknown1,
1494                 LPCSTR unknown2,
1495                 LPRECT unknown3)
1496 {
1497     UNIMPLEMENTED;
1498     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1499     return 0;
1500 }
1501
1502 /*
1503  * @unimplemented
1504  */
1505 HANDLE
1506 STDCALL
1507 GdiConvertMetaFilePict(HGLOBAL hMem)
1508 {
1509     UNIMPLEMENTED;
1510     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1511     return 0;
1512 }
1513
1514 /*
1515  * @implemented
1516  */
1517 DEVMODEW *
1518 STDCALL
1519 GdiConvertToDevmodeW(DEVMODEA *dm)
1520 {
1521     LPDEVMODEW dmw;
1522
1523     dmw = HEAP_alloc(sizeof(DEVMODEW));
1524     #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
1525     #define COPYN(f) dmw->f = dm->f
1526     COPYS(dmDeviceName, CCHDEVICENAME );
1527     COPYN(dmSpecVersion);
1528     COPYN(dmDriverVersion);
1529     switch ( dm->dmSize )
1530     {
1531         case SIZEOF_DEVMODEA_300:
1532             dmw->dmSize = SIZEOF_DEVMODEW_300;
1533             break;
1534         case SIZEOF_DEVMODEA_400:
1535             dmw->dmSize = SIZEOF_DEVMODEW_400;
1536             break;
1537         case SIZEOF_DEVMODEA_500:
1538             default: /* FIXME what to do??? */
1539                 dmw->dmSize = SIZEOF_DEVMODEW_500;
1540             break;
1541     }
1542     COPYN(dmDriverExtra);
1543     COPYN(dmFields);
1544     COPYN(dmPosition.x);
1545     COPYN(dmPosition.y);
1546     COPYN(dmScale);
1547     COPYN(dmCopies);
1548     COPYN(dmDefaultSource);
1549     COPYN(dmPrintQuality);
1550     COPYN(dmColor);
1551     COPYN(dmDuplex);
1552     COPYN(dmYResolution);
1553     COPYN(dmTTOption);
1554     COPYN(dmCollate);
1555     COPYS(dmFormName,CCHFORMNAME);
1556     COPYN(dmLogPixels);
1557     COPYN(dmBitsPerPel);
1558     COPYN(dmPelsWidth);
1559     COPYN(dmPelsHeight);
1560     COPYN(dmDisplayFlags); // aka dmNup
1561     COPYN(dmDisplayFrequency);
1562
1563     if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
1564     {
1565         return dmw; // we're done with 0x300 fields
1566     }
1567
1568     COPYN(dmICMMethod);
1569     COPYN(dmICMIntent);
1570     COPYN(dmMediaType);
1571     COPYN(dmDitherType);
1572     COPYN(dmReserved1);
1573     COPYN(dmReserved2);
1574
1575     if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
1576     {
1577         return dmw; // we're done with 0x400 fields
1578     }
1579
1580     COPYN(dmPanningWidth);
1581     COPYN(dmPanningHeight);
1582
1583     return dmw;
1584
1585     #undef COPYN
1586     #undef COPYS
1587 }
1588
1589 /*
1590  * @unimplemented
1591  */
1592 HENHMETAFILE
1593 STDCALL
1594 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
1595 {
1596     UNIMPLEMENTED;
1597     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1598     return 0;
1599 }
1600
1601 /*
1602  * @unimplemented
1603  */
1604 METAFILEPICT *
1605 STDCALL
1606 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
1607 {
1608     UNIMPLEMENTED;
1609     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1610     return 0;
1611 }
1612
1613
1614 /*
1615  * @unimplemented
1616  */
1617 HANDLE
1618 STDCALL
1619 GdiGetSpoolFileHandle(LPWSTR pwszPrinterName,
1620                       LPDEVMODEW pDevmode,
1621                       LPWSTR pwszDocName)
1622 {
1623     UNIMPLEMENTED;
1624     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1625     return 0;
1626 }
1627
1628 /*
1629  * @unimplemented
1630  */
1631 BOOL
1632 STDCALL
1633 GdiDeleteSpoolFileHandle(HANDLE SpoolFileHandle)
1634 {
1635     UNIMPLEMENTED;
1636     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1637     return 0;
1638 }
1639
1640 /*
1641  * @unimplemented
1642  */
1643 DWORD
1644 STDCALL
1645 GdiGetPageCount(HANDLE SpoolFileHandle)
1646 {
1647     UNIMPLEMENTED;
1648     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1649     return 0;
1650 }
1651
1652 /*
1653  * @unimplemented
1654  */
1655 HDC
1656 STDCALL
1657 GdiGetDC(HANDLE SpoolFileHandle)
1658 {
1659     UNIMPLEMENTED;
1660     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1661     return 0;
1662 }
1663
1664 /*
1665  * @unimplemented
1666  */
1667 HANDLE
1668 STDCALL
1669 GdiGetPageHandle(HANDLE SpoolFileHandle,
1670                  DWORD Page,
1671                  LPDWORD pdwPageType)
1672 {
1673     UNIMPLEMENTED;
1674     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1675     return 0;
1676 }
1677
1678 /*
1679  * @unimplemented
1680  */
1681 BOOL
1682 STDCALL
1683 GdiStartDocEMF(HANDLE SpoolFileHandle,
1684                DOCINFOW *pDocInfo)
1685 {
1686     UNIMPLEMENTED;
1687     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1688     return 0;
1689 }
1690
1691 /*
1692  * @unimplemented
1693  */
1694 BOOL
1695 STDCALL
1696 GdiStartPageEMF(HANDLE SpoolFileHandle)
1697 {
1698     UNIMPLEMENTED;
1699     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1700     return 0;
1701 }
1702
1703 /*
1704  * @unimplemented
1705  */
1706 BOOL
1707 STDCALL
1708 GdiPlayPageEMF(HANDLE SpoolFileHandle,
1709                HANDLE hemf,
1710                RECT *prectDocument,
1711                RECT *prectBorder,
1712                RECT *prectClip)
1713 {
1714     UNIMPLEMENTED;
1715     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1716     return 0;
1717 }
1718
1719 /*
1720  * @unimplemented
1721  */
1722 BOOL
1723 STDCALL
1724 GdiEndPageEMF(HANDLE SpoolFileHandle,
1725               DWORD dwOptimization)
1726 {
1727     UNIMPLEMENTED;
1728     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1729     return 0;
1730 }
1731
1732 /*
1733  * @unimplemented
1734  */
1735 BOOL
1736 STDCALL
1737 GdiEndDocEMF(HANDLE SpoolFileHandle)
1738 {
1739     UNIMPLEMENTED;
1740     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1741     return 0;
1742 }
1743
1744 /*
1745  * @unimplemented
1746  */
1747 BOOL
1748 STDCALL
1749 GdiGetDevmodeForPage(HANDLE SpoolFileHandle,
1750                      DWORD dwPageNumber,
1751                      PDEVMODEW *pCurrDM,
1752                      PDEVMODEW *pLastDM)
1753 {
1754     UNIMPLEMENTED;
1755     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1756     return 0;
1757 }
1758
1759 /*
1760  * @unimplemented
1761  */
1762 BOOL
1763 STDCALL
1764 GdiResetDCEMF(HANDLE SpoolFileHandle,
1765               PDEVMODEW pCurrDM)
1766 {
1767     UNIMPLEMENTED;
1768     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1769     return 0;
1770 }
1771
1772
1773 HBITMAP
1774 STDCALL
1775 CreateDIBitmap(HDC hDc,
1776                const BITMAPINFOHEADER *Header,
1777                DWORD Init, LPCVOID Bits, const BITMAPINFO *Data,
1778                UINT ColorUse)
1779 {
1780     /* FIMXE we need do more thing in user mode */
1781     return NtGdiCreateDIBitmap(hDc, Header, Init, Bits, Data,  ColorUse);
1782 }
1783
1784 /*
1785  * @unimplemented
1786  */
1787 INT
1788 STDCALL
1789 CombineRgn(HRGN  hDest,
1790            HRGN  hSrc1,
1791            HRGN  hSrc2,
1792            INT  CombineMode)
1793 {
1794     /* FIXME some part should be done in user mode */
1795     return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
1796 }
1797
1798 /*
1799  * @unimplemented
1800  */
1801 HBITMAP STDCALL
1802 CreateBitmap(INT  Width,
1803              INT  Height,
1804              UINT  Planes,
1805              UINT  BitsPixel,
1806              PCVOID pUnsafeBits)
1807 {
1808     /* FIXME some part should be done in user mode */
1809     return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
1810 }
1811
1812 /*
1813  * @unimplemented
1814  */
1815 LPWSTR STDCALL
1816 EngGetDriverName(HDEV hdev)
1817 {
1818     UNIMPLEMENTED;
1819     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1820     return 0;
1821 }
1822
1823 /*
1824  * @unimplemented
1825  */
1826 ULONG STDCALL
1827 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
1828                 ULONG Color)
1829 {
1830     UNIMPLEMENTED;
1831     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1832     return 0;
1833 }
1834
1835 /*
1836  * @unimplemented
1837  */
1838 ULONG *
1839 STDCALL
1840 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
1841 {
1842     return XlateObj->pulXlate;
1843 }
1844
1845 /*
1846  * @unimplemented
1847  */
1848 BOOL
1849 STDCALL
1850 GdiPlayEMF(LPWSTR pwszPrinterName,
1851            LPDEVMODEW pDevmode,
1852            LPWSTR pwszDocName,
1853            EMFPLAYPROC pfnEMFPlayFn,
1854            HANDLE hPageQuery
1855 )
1856 {
1857     UNIMPLEMENTED;
1858     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1859     return 0;
1860 }
1861
1862
1863
1864 /*
1865  * @unimplemented
1866  */
1867 BOOL
1868 STDCALL
1869 GdiPlayPrivatePageEMF(HANDLE SpoolFileHandle,
1870                       DWORD unknown,
1871                       RECT *prectDocument)
1872 {
1873     UNIMPLEMENTED;
1874     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1875     return 0;
1876 }
1877
1878 /*
1879  * @unimplemented
1880  */
1881 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
1882 {
1883     UNIMPLEMENTED;
1884     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1885 }
1886
1887
1888 /*
1889  * @implemented
1890  */
1891 INT
1892 STDCALL
1893 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
1894 {
1895     /* FIXME some part need be done on user mode size */
1896     return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
1897 }
1898
1899 /*
1900  * @implemented
1901  */
1902 INT
1903 STDCALL
1904 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
1905 {
1906     /* FIXME some part need be done on user mode size */
1907     return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
1908 }
1909
1910 /*
1911  * @implemented
1912  */
1913 BOOL
1914 STDCALL
1915 GdiGradientFill(
1916     IN HDC hdc,
1917     IN PTRIVERTEX pVertex,
1918     IN ULONG nVertex,
1919     IN PVOID pMesh,
1920     IN ULONG nMesh,
1921     IN ULONG ulMode)
1922 {
1923     /* FIXME some part need be done in user mode */
1924     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
1925 }
1926
1927
1928 /*
1929  * @implemented
1930  */
1931 BOOL
1932 STDCALL
1933 GdiTransparentBlt(IN HDC hdcDst,
1934                   IN INT xDst,
1935                   IN INT yDst,
1936                   IN INT cxDst,
1937                   IN INT cyDst,
1938                   IN HDC hdcSrc,
1939                   IN INT xSrc,
1940                   IN INT ySrc,
1941                   IN INT cxSrc,
1942                   IN INT cySrc,
1943                   IN COLORREF TransColor
1944 )
1945 {
1946     /* FIXME some part need be done in user mode */
1947     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
1948 }
1949
1950 /*
1951  * @unimplemented
1952  */
1953 BOOL
1954 STDCALL
1955 GdiPrinterThunk(
1956     IN HUMPD humpd,
1957     DWORD *status,
1958     DWORD unuse)
1959 {
1960     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
1961     /* status contain some form of return value that being save, what it is I do not known */
1962     /* unsue seam have zero effect, what it is for I do not known */
1963
1964     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
1965     return FALSE;
1966 }
1967
1968 /*
1969  * @unimplemented
1970  *
1971  */
1972 HBITMAP
1973 STDCALL
1974 GdiConvertBitmapV5(
1975     HBITMAP in_format_BitMap,
1976     HBITMAP src_BitMap,
1977     INT bpp,
1978     INT unuse)
1979 {
1980     /* FIXME guessing the prototypes */
1981
1982     /*
1983      * it have create a new bitmap with desired in format,
1984      * then convert it src_bitmap to new format
1985      * and return it as HBITMAP
1986      */
1987
1988     return FALSE;
1989 }
1990
1991
1992 /*
1993  * @implemented
1994  *
1995  */
1996 int
1997 STDCALL
1998 GetDeviceCaps(HDC hdc,
1999               int i)
2000 {
2001     /* FIXME some part need be done in user mode */
2002     return NtGdiGetDeviceCaps(hdc,i);
2003 }
2004
2005 /*
2006  * @implemented
2007  *
2008  */
2009 int
2010 STDCALL
2011 GetClipBox(HDC hdc,
2012            LPRECT lprc)
2013 {
2014     /* FIXME some part need be done in user mode */
2015     return  NtGdiGetAppClipBox(hdc, lprc);
2016 }
2017
2018 /*
2019  * @implemented
2020  *
2021  */
2022 DWORD
2023 STDCALL
2024 GetFontData(HDC hdc,
2025             DWORD dwTable,
2026             DWORD dwOffset,
2027             LPVOID lpvBuffer,
2028             DWORD cbData)
2029 {
2030     if (!lpvBuffer)
2031     {
2032        cbData = 0;
2033     }
2034     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2035 }
2036
2037
2038 /*
2039  * @implemented
2040  *
2041  */
2042 DWORD
2043 STDCALL
2044 GetRegionData(HRGN hrgn,
2045               DWORD nCount,
2046               LPRGNDATA lpRgnData)
2047 {
2048     if (!lpRgnData)
2049     {
2050         nCount = 0;
2051     }
2052
2053     return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
2054 }
2055
2056
2057 /*
2058  * @implemented
2059  *
2060  */
2061 INT
2062 STDCALL
2063 GetRgnBox(HRGN hrgn,
2064           LPRECT prcOut)
2065 {
2066     /* FIXME some stuff need be done in user mode */
2067     return NtGdiGetRgnBox(hrgn, prcOut);
2068 }
2069
2070
2071 /*
2072  * @implemented
2073  *
2074  */
2075 INT
2076 STDCALL
2077 OffsetRgn( HRGN hrgn,
2078           int nXOffset,
2079           int nYOffset)
2080 {
2081     /* FIXME some part are done in user mode */
2082     return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
2083 }
2084
2085
2086 INT
2087 STDCALL
2088 GetTextCharsetInfo(HDC hdc,
2089                    LPFONTSIGNATURE lpSig,
2090                    DWORD dwFlags)
2091 {
2092     /* FIXME some part are done in user mode */
2093     return NtGdiGetTextCharsetInfo(hdc, lpSig, dwFlags);
2094 }
2095
2096
2097
2098 INT
2099 STDCALL
2100 IntersectClipRect(HDC hdc,
2101                   int nLeftRect,
2102                   int nTopRect,
2103                   int nRightRect,
2104                   int nBottomRect)
2105 {
2106     /* FIXME some part are done in user mode */
2107     return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2108 }
2109
2110 INT
2111 STDCALL
2112 OffsetClipRgn(HDC hdc,
2113               int nXOffset,
2114               int nYOffset)
2115 {
2116     /* FIXME some part are done in user mode */
2117     return NtGdiOffsetClipRgn( hdc,  nXOffset,  nYOffset);
2118 }
2119
2120
2121 INT
2122 STDCALL
2123 NamedEscape(HDC hdc,
2124             PWCHAR pDriver,
2125             INT iEsc,
2126             INT cjIn,
2127             LPSTR pjIn,
2128             INT cjOut,
2129             LPSTR pjOut)
2130 {
2131     /* FIXME metadc, metadc are done most in user mode, and we do not support it
2132      * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
2133      * when it calls to NtGdiExtEscape from NamedEscape
2134      */
2135     return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
2136 }
2137
2138
2139
2140 /*
2141  * @unimplemented
2142  */
2143
2144 /* FIXME wrong protypes, it is a fastcall api */
2145 DWORD
2146 STDCALL
2147 cGetTTFFromFOT(DWORD x1 ,DWORD x2 ,DWORD x3, DWORD x4, DWORD x5, DWORD x6, DWORD x7)
2148 {
2149     UNIMPLEMENTED;
2150     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2151     return 0;
2152 }
2153