reactos/win32ss/gdi/gdi32/misc/stubs.c

   1 /*
   2  * dll/win32/gdi32/misc/stubs.c
   3  *
   4  * GDI32.DLL Stubs
   5  *
   6  * When you implement one of these functions,
   7  * remove its stub from this file.
   8  *
   9  */
  10
  11 #include "precomp.h"
  12 #include <debug.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 /*
  22  * @unimplemented
  23  */
  24 BOOL
  25 WINAPI
  26 RestoreDC(IN HDC hdc,
  27           IN INT iLevel)
  28 {
  29     /* FIXME Sharememory */
  30     return NtGdiRestoreDC(hdc, iLevel);
  31 }
  32
  33 /*
  34  * @unimplemented
  35  */
  36 INT
  37 WINAPI
  38 SaveDC(IN HDC hdc)
  39 {
  40     /* FIXME Sharememory */
  41     return NtGdiSaveDC(hdc);
  42 }
  43
  44 /*
  45  * @implemented
  46  */
  47 BOOL
  48 WINAPI
  49 CancelDC(HDC hDC)
  50 {
  51     PDC_ATTR pDc_Attr;
  52
  53     if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC &&
  54             GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC )
  55     {
  56         PLDC pLDC = GdiGetLDC(hDC);
  57         if ( !pLDC )
  58         {
  59             SetLastError(ERROR_INVALID_HANDLE);
  60             return FALSE;
  61         }
  62         /* If a document has started set it to die. */
  63         if (pLDC->Flags & LDC_INIT_DOCUMENT) pLDC->Flags |= LDC_KILL_DOCUMENT;
  64
  65         return NtGdiCancelDC(hDC);
  66     }
  67
  68     if (GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &pDc_Attr))
  69     {
  70         pDc_Attr->ulDirty_ &= ~DC_PLAYMETAFILE;
  71         return TRUE;
  72     }
  73
  74     return FALSE;
  75 }
  76
  77
  78 /*
  79  * @implemented
  80  */
  81 int
  82 WINAPI
  83 DrawEscape(HDC  hDC,
  84            INT nEscape,
  85            INT cbInput,
  86            LPCSTR lpszInData)
  87 {
  88     if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_DC)
  89         return NtGdiDrawEscape(hDC, nEscape, cbInput, (LPSTR) lpszInData);
  90
  91     if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_METADC)
  92     {
  93         PLDC pLDC = GdiGetLDC(hDC);
  94         if ( pLDC )
  95         {
  96             if (pLDC->Flags & LDC_META_PRINT)
  97             {
  98 //           if (nEscape != QUERYESCSUPPORT)
  99 //              return EMFDRV_WriteEscape(hDC, nEscape, cbInput, lpszInData, EMR_DRAWESCAPE);
 100
 101                 return NtGdiDrawEscape(hDC, nEscape, cbInput, (LPSTR) lpszInData);
 102             }
 103         }
 104         SetLastError(ERROR_INVALID_HANDLE);
 105     }
 106     return 0;
 107 }
 108
 109
 110 /*
 111  * @implemented
 112  */
 113 int
 114 WINAPI
 115 EnumObjects(HDC hdc,
 116             int nObjectType,
 117             GOBJENUMPROC lpObjectFunc,
 118             LPARAM lParam)
 119 {
 120     ULONG ObjectsCount;
 121     ULONG Size;
 122     PVOID Buffer = NULL;
 123     DWORD_PTR EndOfBuffer;
 124     int Result = 0;
 125
 126     switch (nObjectType)
 127     {
 128     case OBJ_BRUSH:
 129         Size = sizeof(LOGBRUSH);
 130         break;
 131
 132     case OBJ_PEN:
 133         Size = sizeof(LOGPEN);
 134         break;
 135
 136     default:
 137         SetLastError(ERROR_INVALID_PARAMETER);
 138         return 0;
 139     }
 140
 141     ObjectsCount = NtGdiEnumObjects(hdc, nObjectType, 0, NULL);
 142     if (!ObjectsCount) return 0;
 143
 144     Buffer = HeapAlloc(GetProcessHeap(), 0, ObjectsCount * Size);
 145     if (!Buffer)
 146     {
 147         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 148         return 0;
 149     }
 150
 151     if (!NtGdiEnumObjects(hdc, nObjectType, ObjectsCount * Size, Buffer))
 152     {
 153         HeapFree(GetProcessHeap(), 0, Buffer);
 154         return 0;
 155     }
 156
 157     EndOfBuffer = (DWORD_PTR)Buffer + (ObjectsCount * Size);
 158     while ((DWORD_PTR)Buffer < EndOfBuffer)
 159     {
 160         Result = lpObjectFunc(Buffer, lParam);
 161         if (!Result) break;
 162         Buffer = (PVOID)((DWORD_PTR)Buffer + Size);
 163     }
 164
 165     HeapFree(GetProcessHeap(), 0, Buffer);
 166     return Result;
 167 }
 168
 169 /*
 170  * @implemented
 171  */
 172 UINT
 173 WINAPI
 174 GetBoundsRect(
 175     HDC hdc,
 176     LPRECT      lprcBounds,
 177     UINT        flags
 178 )
 179 {
 180     return NtGdiGetBoundsRect(hdc,lprcBounds,flags & DCB_RESET);
 181 }
 182
 183 /*
 184  * @unimplemented
 185  */
 186 UINT
 187 WINAPI
 188 GetMetaFileBitsEx(
 189     HMETAFILE   a0,
 190     UINT                a1,
 191     LPVOID              a2
 192 )
 193 {
 194     UNIMPLEMENTED;
 195     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 196     return 0;
 197 }
 198
 199 /*
 200  * @unimplemented
 201  */
 202 BOOL
 203 WINAPI
 204 PlayMetaFile(
 205     HDC         a0,
 206     HMETAFILE   a1
 207 )
 208 {
 209     UNIMPLEMENTED;
 210     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 211     return FALSE;
 212 }
 213
 214 /*
 215  * @implemented
 216  */
 217 UINT
 218 WINAPI
 219 SetBoundsRect(HDC hdc,
 220               CONST RECT *prc,
 221               UINT flags)
 222 {
 223     /* FIXME add check for validate the flags */
 224     return NtGdiSetBoundsRect(hdc, (LPRECT)prc, flags);
 225 }
 226
 227 /*
 228  * @unimplemented
 229  */
 230 HMETAFILE
 231 WINAPI
 232 SetMetaFileBitsEx(
 233     UINT                size,
 234     CONST BYTE  *lpData
 235 )
 236 {
 237     const METAHEADER *mh_in = (const METAHEADER *)lpData;
 238
 239     if (size & 1) return 0;
 240
 241     if (!size || mh_in->mtType != METAFILE_MEMORY || mh_in->mtVersion != 0x300 ||
 242             mh_in->mtHeaderSize != sizeof(METAHEADER) / 2)
 243     {
 244         SetLastError(ERROR_INVALID_DATA);
 245         return 0;
 246     }
 247
 248     UNIMPLEMENTED;
 249     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 250     return 0;
 251 }
 252
 253 /*
 254  * @unimplemented
 255  */
 256 BOOL
 257 WINAPI
 258 PlayMetaFileRecord(
 259     HDC         a0,
 260     LPHANDLETABLE       a1,
 261     LPMETARECORD        a2,
 262     UINT                a3
 263 )
 264 {
 265     UNIMPLEMENTED;
 266     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 267     return FALSE;
 268 }
 269
 270
 271 /*
 272  * @unimplemented
 273  */
 274 BOOL
 275 WINAPI
 276 EnumMetaFile(
 277     HDC                 a0,
 278     HMETAFILE           a1,
 279     MFENUMPROC          a2,
 280     LPARAM                      a3
 281 )
 282 {
 283     UNIMPLEMENTED;
 284     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 285     return FALSE;
 286 }
 287
 288 /*
 289  * @unimplemented
 290  */
 291 BOOL
 292 WINAPI
 293 DeleteEnhMetaFile(
 294     HENHMETAFILE        a0
 295 )
 296 {
 297     UNIMPLEMENTED;
 298     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 299     return FALSE;
 300 }
 301
 302 /*
 303  * @unimplemented
 304  */
 305 BOOL
 306 WINAPI
 307 EnumEnhMetaFile(
 308     HDC         hdc,
 309     HENHMETAFILE        hmf,
 310     ENHMFENUMPROC       callback,
 311     LPVOID              data,
 312     CONST RECT  *lpRect
 313 )
 314 {
 315     if(!lpRect && hdc)
 316     {
 317         SetLastError(ERROR_INVALID_PARAMETER);
 318         return FALSE;
 319     }
 320
 321     UNIMPLEMENTED;
 322     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 323     return FALSE;
 324 }
 325
 326 /*
 327  * @unimplemented
 328  */
 329 UINT
 330 WINAPI
 331 GetEnhMetaFileBits(
 332     HENHMETAFILE        a0,
 333     UINT                a1,
 334     LPBYTE              a2
 335 )
 336 {
 337     UNIMPLEMENTED;
 338     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 339     return 0;
 340 }
 341
 342
 343 /*
 344  * @unimplemented
 345  */
 346 UINT
 347 WINAPI
 348 GetEnhMetaFileHeader(
 349     HENHMETAFILE        a0,
 350     UINT                a1,
 351     LPENHMETAHEADER     a2
 352 )
 353 {
 354     UNIMPLEMENTED;
 355     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 356     return 0;
 357 }
 358
 359 /*
 360  * @unimplemented
 361  */
 362 UINT
 363 WINAPI
 364 GetEnhMetaFilePaletteEntries(
 365     HENHMETAFILE        a0,
 366     UINT                a1,
 367     LPPALETTEENTRY      a2
 368 )
 369 {
 370     UNIMPLEMENTED;
 371     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 372     return 0;
 373 }
 374
 375 /*
 376  * @unimplemented
 377  */
 378 UINT
 379 WINAPI
 380 GetWinMetaFileBits(
 381     HENHMETAFILE        a0,
 382     UINT                a1,
 383     LPBYTE              a2,
 384     INT         a3,
 385     HDC         a4
 386 )
 387 {
 388     UNIMPLEMENTED;
 389     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 390     return 0;
 391 }
 392
 393
 394 /*
 395  * @unimplemented
 396  */
 397 BOOL
 398 WINAPI
 399 PlayEnhMetaFile(
 400     HDC         a0,
 401     HENHMETAFILE        a1,
 402     CONST RECT  *a2
 403 )
 404 {
 405     UNIMPLEMENTED;
 406     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 407     return FALSE;
 408 }
 409
 410
 411 /*
 412  * @unimplemented
 413  */
 414 BOOL
 415 WINAPI
 416 PlayEnhMetaFileRecord(
 417     HDC                 a0,
 418     LPHANDLETABLE               a1,
 419     CONST ENHMETARECORD *a2,
 420     UINT                        a3
 421 )
 422 {
 423     UNIMPLEMENTED;
 424     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 425     return FALSE;
 426 }
 427
 428
 429 /*
 430  * @unimplemented
 431  */
 432 HENHMETAFILE
 433 WINAPI
 434 SetEnhMetaFileBits(
 435     UINT                a0,
 436     CONST BYTE  *a1
 437 )
 438 {
 439     UNIMPLEMENTED;
 440     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 441     return 0;
 442 }
 443
 444
 445 /*
 446  * @unimplemented
 447  */
 448 HENHMETAFILE
 449 WINAPI
 450 SetWinMetaFileBits(
 451     UINT                        a0,
 452     CONST BYTE          *a1,
 453     HDC                 a2,
 454     CONST METAFILEPICT  *a3)
 455 {
 456     UNIMPLEMENTED;
 457     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 458     return 0;
 459 }
 460
 461
 462 /*
 463  * @unimplemented
 464  */
 465 BOOL
 466 WINAPI
 467 GdiComment(
 468     HDC         hDC,
 469     UINT                bytes,
 470     CONST BYTE  *buffer
 471 )
 472 {
 473 #if 0
 474     if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF)
 475     {
 476         PLDC pLDC = GdiGetLDC(hDC);
 477         if ( !pLDC )
 478         {
 479             SetLastError(ERROR_INVALID_HANDLE);
 480             return FALSE;
 481         }
 482         if (pLDC->iType == LDC_EMFLDC)
 483         {
 484             // Wine port
 485             return EMFDRV_GdiComment( hDC, bytes, buffer );
 486         }
 487     }
 488 #endif
 489     return FALSE;
 490 }
 491
 492
 493 /*
 494  * @unimplemented
 495  */
 496 BOOL
 497 WINAPI
 498 SetColorAdjustment(
 499     HDC                 hdc,
 500     CONST COLORADJUSTMENT       *a1
 501 )
 502 {
 503     UNIMPLEMENTED;
 504     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 505     return FALSE;
 506 }
 507
 508 /*
 509  * @implemented
 510  */
 511 BOOL
 512 WINAPI
 513 UnrealizeObject(HGDIOBJ  hgdiobj)
 514 {
 515     BOOL retValue = TRUE;
 516     /*
 517        Win 2k Graphics API, Black Book. by coriolis.com
 518        Page 62, Note that Steps 3, 5, and 6 are not required for Windows NT(tm)
 519        and Windows 2000(tm).
 520
 521        Step 5. UnrealizeObject(hTrackBrush);
 522      */
 523     /*
 524         msdn.microsoft.com,
 525         "Windows 2000/XP: If hgdiobj is a brush, UnrealizeObject does nothing,
 526         and the function returns TRUE. Use SetBrushOrgEx to set the origin of
 527         a brush."
 528      */
 529     if (GDI_HANDLE_GET_TYPE(hgdiobj) != GDI_OBJECT_TYPE_BRUSH)
 530     {
 531         retValue = NtGdiUnrealizeObject(hgdiobj);
 532     }
 533
 534     return retValue;
 535 }
 536
 537
 538 /*
 539  * @implemented
 540  */
 541 BOOL
 542 WINAPI
 543 GdiFlush()
 544 {
 545     NtGdiFlush();
 546     return TRUE;
 547 }
 548
 549
 550 /*
 551  * @unimplemented
 552  */
 553 int
 554 WINAPI
 555 SetICMMode(
 556     HDC hdc,
 557     int iEnableICM
 558 )
 559 {
 560     /*FIXME:  Assume that ICM is always off, and cannot be turned on */
 561     if (iEnableICM == ICM_OFF) return ICM_OFF;
 562     if (iEnableICM == ICM_ON) return 0;
 563     if (iEnableICM == ICM_QUERY) return ICM_OFF;
 564
 565     UNIMPLEMENTED;
 566     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 567     return 0;
 568 }
 569
 570
 571 /*
 572  * @unimplemented
 573  */
 574 BOOL
 575 WINAPI
 576 CheckColorsInGamut(
 577     HDC a0,
 578     LPVOID      a1,
 579     LPVOID      a2,
 580     DWORD       a3
 581 )
 582 {
 583     UNIMPLEMENTED;
 584     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 585     return FALSE;
 586 }
 587
 588
 589 /*
 590  * @implemented
 591  */
 592 BOOL
 593 WINAPI
 594 GetDeviceGammaRamp( HDC hdc,
 595                     LPVOID lpGammaRamp)
 596 {
 597     BOOL retValue = FALSE;
 598     if (lpGammaRamp == NULL)
 599     {
 600         SetLastError(ERROR_INVALID_PARAMETER);
 601     }
 602     else
 603     {
 604         retValue = NtGdiGetDeviceGammaRamp(hdc,lpGammaRamp);
 605     }
 606
 607     return retValue;
 608 }
 609
 610 /*
 611  * @implemented
 612  */
 613 BOOL
 614 WINAPI
 615 SetDeviceGammaRamp(HDC hdc,
 616                    LPVOID lpGammaRamp)
 617 {
 618     BOOL retValue = FALSE;
 619
 620     if (lpGammaRamp)
 621     {
 622         retValue = NtGdiSetDeviceGammaRamp(hdc, lpGammaRamp);
 623     }
 624     else
 625     {
 626         SetLastError(ERROR_INVALID_PARAMETER);
 627     }
 628
 629     return  retValue;
 630 }
 631
 632
 633 /*
 634  * @unimplemented
 635  */
 636 BOOL
 637 WINAPI
 638 ColorMatchToTarget(
 639     HDC a0,
 640     HDC a1,
 641     DWORD       a2
 642 )
 643 {
 644     UNIMPLEMENTED;
 645     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 646     return FALSE;
 647 }
 648
 649 /* === AFTER THIS POINT I GUESS... =========
 650  * (based on stack size in Norlander's .def)
 651  * === WHERE ARE THEY DEFINED? =============
 652  */
 653
 654 /*
 655  * @unimplemented
 656  */
 657 DWORD
 658 WINAPI
 659 IsValidEnhMetaRecord(
 660     DWORD       a0,
 661     DWORD       a1
 662 )
 663 {
 664     UNIMPLEMENTED;
 665     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 666     return 0;
 667
 668 }
 669
 670 /*
 671  * @unimplemented
 672  */
 673 DWORD
 674 WINAPI
 675 IsValidEnhMetaRecordOffExt(
 676     DWORD       a0,
 677     DWORD       a1,
 678     DWORD       a2,
 679     DWORD       a3
 680 )
 681 {
 682     UNIMPLEMENTED;
 683     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 684     return 0;
 685
 686 }
 687
 688 /*
 689  * @unimplemented
 690  */
 691 DWORD
 692 WINAPI
 693 GetGlyphOutlineWow(
 694     DWORD       a0,
 695     DWORD       a1,
 696     DWORD       a2,
 697     DWORD       a3,
 698     DWORD       a4,
 699     DWORD       a5,
 700     DWORD       a6
 701 )
 702 {
 703     UNIMPLEMENTED;
 704     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 705     return 0;
 706 }
 707
 708 /*
 709  * @unimplemented
 710  */
 711 DWORD
 712 WINAPI
 713 gdiPlaySpoolStream(
 714     DWORD       a0,
 715     DWORD       a1,
 716     DWORD       a2,
 717     DWORD       a3,
 718     DWORD       a4,
 719     DWORD       a5
 720 )
 721 {
 722     UNIMPLEMENTED;
 723     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 724     return 0;
 725 }
 726
 727 /*
 728  * @implemented
 729  */
 730 HANDLE
 731 WINAPI
 732 AddFontMemResourceEx(
 733     PVOID pbFont,
 734     DWORD cbFont,
 735     PVOID pdv,
 736     DWORD *pcFonts
 737 )
 738 {
 739     if ( pbFont && cbFont && pcFonts)
 740     {
 741         return NtGdiAddFontMemResourceEx(pbFont, cbFont, NULL, 0, pcFonts);
 742     }
 743     SetLastError(ERROR_INVALID_PARAMETER);
 744     return NULL;
 745 }
 746
 747 /*
 748  * @unimplemented
 749  */
 750 int
 751 WINAPI
 752 AddFontResourceTracking(
 753     LPCSTR lpString,
 754     int unknown
 755 )
 756 {
 757     UNIMPLEMENTED;
 758     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 759     return 0;
 760 }
 761
 762
 763
 764 /*
 765  * @unimplemented
 766  */
 767 HBITMAP
 768 WINAPI
 769 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
 770 {
 771     UNIMPLEMENTED;
 772     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 773     return 0;
 774 }
 775
 776 /*
 777  * @unimplemented
 778  */
 779 HBRUSH
 780 WINAPI
 781 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
 782 {
 783     UNIMPLEMENTED;
 784     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 785     return 0;
 786 }
 787
 788 /*
 789  * @unimplemented
 790  */
 791 BOOL
 792 WINAPI
 793 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
 794 {
 795     UNIMPLEMENTED;
 796     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 797     return 0;
 798 }
 799
 800 /*
 801  * @unimplemented
 802  */
 803 BOOL
 804 WINAPI
 805 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
 806 {
 807     UNIMPLEMENTED;
 808     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 809     return 0;
 810 }
 811
 812 /*
 813  * @implemented
 814  */
 815 BOOL
 816 WINAPI
 817 GdiCleanCacheDC(HDC hdc)
 818 {
 819     if (GDI_HANDLE_GET_TYPE(hdc) == GDILoObjType_LO_DC_TYPE)
 820         return TRUE;
 821     SetLastError(ERROR_INVALID_HANDLE);
 822     return FALSE;
 823 }
 824
 825 /*
 826  * @implemented
 827  */
 828 HDC
 829 WINAPI
 830 GdiConvertAndCheckDC(HDC hdc)
 831 {
 832     PLDC pldc;
 833     ULONG hType = GDI_HANDLE_GET_TYPE(hdc);
 834     if (hType == GDILoObjType_LO_DC_TYPE || hType == GDILoObjType_LO_METADC16_TYPE)
 835         return hdc;
 836     pldc = GdiGetLDC(hdc);
 837     if (pldc)
 838     {
 839         if (pldc->Flags & LDC_SAPCALLBACK) GdiSAPCallback(pldc);
 840         if (pldc->Flags & LDC_KILL_DOCUMENT) return NULL;
 841         if (pldc->Flags & LDC_STARTPAGE) StartPage(hdc);
 842         return hdc;
 843     }
 844     SetLastError(ERROR_INVALID_HANDLE);
 845     return NULL;
 846 }
 847
 848 /*
 849  * @unimplemented
 850  */
 851 HENHMETAFILE
 852 WINAPI
 853 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
 854 {
 855     UNIMPLEMENTED;
 856     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 857     return 0;
 858 }
 859
 860 /*
 861  * @unimplemented
 862  */
 863 BOOL
 864 WINAPI
 865 GdiDrawStream(HDC dc, ULONG l, VOID *v) // See Bug 4784
 866 {
 867     UNIMPLEMENTED;
 868     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 869     return 0;
 870 }
 871
 872 /*
 873  * @implemented
 874  */
 875 BOOL
 876 WINAPI
 877 GdiIsMetaFileDC(HDC hDC)
 878 {
 879     if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC)
 880     {
 881         if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC)
 882             return TRUE;
 883         else
 884         {
 885             PLDC pLDC = GdiGetLDC(hDC);
 886             if ( !pLDC )
 887             {
 888                 SetLastError(ERROR_INVALID_HANDLE);
 889                 return FALSE;
 890             }
 891             if ( pLDC->iType == LDC_EMFLDC) return TRUE;
 892         }
 893     }
 894     return FALSE;
 895 }
 896
 897 /*
 898  * @implemented
 899  */
 900 BOOL
 901 WINAPI
 902 GdiIsMetaPrintDC(HDC hDC)
 903 {
 904
 905     if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC)
 906     {
 907         if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC)
 908             return FALSE;
 909         else
 910         {
 911             PLDC pLDC = GdiGetLDC(hDC);
 912             if ( !pLDC )
 913             {
 914                 SetLastError(ERROR_INVALID_HANDLE);
 915                 return FALSE;
 916             }
 917             if ( pLDC->Flags & LDC_META_PRINT) return TRUE;
 918         }
 919     }
 920     return FALSE;
 921 }
 922
 923 /*
 924  * @implemented
 925  */
 926 BOOL
 927 WINAPI
 928 GdiIsPlayMetafileDC(HDC hDC)
 929 {
 930     PLDC pLDC = GdiGetLDC(hDC);
 931     if ( pLDC )
 932     {
 933         if ( pLDC->Flags & LDC_PLAY_MFDC ) return TRUE;
 934     }
 935     return FALSE;
 936 }
 937
 938 /*
 939  * @implemented
 940  */
 941 BOOL
 942 WINAPI
 943 GdiValidateHandle(HGDIOBJ hobj)
 944 {
 945     PGDI_TABLE_ENTRY Entry = GdiHandleTable + GDI_HANDLE_GET_INDEX(hobj);
 946     if ( (Entry->Type & GDI_ENTRY_BASETYPE_MASK) != 0 &&
 947             ( (Entry->Type << GDI_ENTRY_UPPER_SHIFT) & GDI_HANDLE_TYPE_MASK ) ==
 948             GDI_HANDLE_GET_TYPE(hobj) )
 949     {
 950         HANDLE pid = (HANDLE)((ULONG_PTR)Entry->ProcessId & ~0x1);
 951         if(pid == NULL || pid == CurrentProcessId)
 952         {
 953             return TRUE;
 954         }
 955     }
 956     return FALSE;
 957
 958 }
 959
 960 /*
 961  * @unimplemented
 962  */
 963 DWORD
 964 WINAPI
 965 GetBitmapAttributes(HBITMAP hbm)
 966 {
 967     UNIMPLEMENTED;
 968     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 969     return 0;
 970 }
 971
 972 /*
 973  * @unimplemented
 974  */
 975 DWORD
 976 WINAPI
 977 GetBrushAttributes(HBRUSH hbr)
 978 {
 979     UNIMPLEMENTED;
 980     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 981     return 0;
 982 }
 983
 984 /*
 985  * @implemented
 986  */
 987 ULONG
 988 WINAPI
 989 GetEUDCTimeStamp(VOID)
 990 {
 991     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
 992 }
 993
 994 /*
 995  * @implemented
 996  */
 997 ULONG
 998 WINAPI
 999 GetFontAssocStatus(HDC hdc)
1000 {
1001     ULONG retValue = 0;
1002
1003     if (hdc)
1004     {
1005         retValue = NtGdiQueryFontAssocInfo(hdc);
1006     }
1007
1008     return retValue;
1009 }
1010
1011 /*
1012  * @implemented
1013  */
1014 BOOL
1015 WINAPI
1016 GetTextExtentExPointWPri(HDC hdc,
1017                          LPWSTR lpwsz,
1018                          ULONG cwc,
1019                          ULONG dxMax,
1020                          ULONG *pcCh,
1021                          PULONG pdxOut,
1022                          LPSIZE psize)
1023 {
1024     return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1025 }
1026
1027 /*
1028  * @unimplemented
1029  */
1030 DWORD
1031 WINAPI
1032 QueryFontAssocStatus(VOID)
1033 {
1034     UNIMPLEMENTED;
1035     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1036     return 0;
1037 }
1038
1039 /*
1040  * @implemented
1041  */
1042 BOOL
1043 WINAPI
1044 RemoveFontMemResourceEx(HANDLE fh)
1045 {
1046     if (fh)
1047     {
1048         return NtGdiRemoveFontMemResourceEx(fh);
1049     }
1050     SetLastError(ERROR_INVALID_PARAMETER);
1051     return FALSE;
1052 }
1053
1054 /*
1055  * @unimplemented
1056  */
1057 int
1058 WINAPI
1059 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1060 {
1061     UNIMPLEMENTED;
1062     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1063     return 0;
1064 }
1065
1066 /*
1067  * @unimplemented
1068  */
1069 HBITMAP
1070 WINAPI
1071 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1072 {
1073     UNIMPLEMENTED;
1074     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1075     return 0;
1076 }
1077
1078 /*
1079  * @unimplemented
1080  */
1081 HBRUSH
1082 WINAPI
1083 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1084 {
1085     UNIMPLEMENTED;
1086     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1087     return 0;
1088 }
1089
1090 /*
1091  * @implemented
1092  */
1093 int
1094 WINAPI
1095 StartFormPage(HDC hdc)
1096 {
1097     return StartPage(hdc);
1098 }
1099
1100 /*
1101  * @unimplemented
1102  */
1103 VOID
1104 WINAPI
1105 UnloadNetworkFonts(DWORD unknown)
1106 {
1107     UNIMPLEMENTED;
1108     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1109 }
1110
1111 /*
1112  * @unimplemented
1113  */
1114 BOOL
1115 WINAPI
1116 GdiRealizationInfo(HDC hdc,
1117                    PREALIZATION_INFO pri)
1118 {
1119     // ATM we do not support local font data and Language Pack.
1120     return NtGdiGetRealizationInfo(hdc, pri, (HFONT) NULL);
1121 }
1122
1123 /*
1124  * @implemented
1125  */
1126 BOOL
1127 WINAPI
1128 GetETM(HDC hdc,
1129        EXTTEXTMETRIC *petm)
1130 {
1131     BOOL Ret = NtGdiGetETM(hdc, petm);
1132
1133     if (Ret && petm)
1134         petm->emKernPairs = GetKerningPairsA(hdc, 0, 0);
1135
1136     return Ret;
1137 }
1138
1139 /*
1140  * @unimplemented
1141  */
1142 int
1143 WINAPI
1144 Escape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpvInData, LPVOID lpvOutData)
1145 {
1146     int retValue = SP_ERROR;
1147     HGDIOBJ hObject = hdc;
1148     UINT Type = 0;
1149     LPVOID pUserData = NULL;
1150
1151     Type = GDI_HANDLE_GET_TYPE(hObject);
1152
1153     if (Type == GDI_OBJECT_TYPE_METADC)
1154     {
1155         /* FIXME we do not support metafile */
1156         UNIMPLEMENTED;
1157         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1158     }
1159     else
1160     {
1161         switch (nEscape)
1162         {
1163         case ABORTDOC:
1164             /* Note Winodws check see if the handle have any user data for ABORTDOC command
1165              * ReactOS copy this behavior to be compatible with windows 2003
1166              */
1167             if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1168                     (pUserData == NULL) )
1169             {
1170                 GdiSetLastError(ERROR_INVALID_HANDLE);
1171                 retValue = FALSE;
1172             }
1173             else
1174             {
1175                 retValue = AbortDoc(hdc);
1176             }
1177             break;
1178
1179         case DRAFTMODE:
1180         case FLUSHOUTPUT:
1181         case SETCOLORTABLE:
1182             /* Note 1: DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE is outdated and been replace with other api */
1183             /* Note 2: Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command
1184              * ReactOS copy this behavior to be compatible with windows 2003
1185              */
1186             if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1187                     (pUserData == NULL) )
1188             {
1189                 GdiSetLastError(ERROR_INVALID_HANDLE);
1190             }
1191             retValue = FALSE;
1192             break;
1193
1194         case SETABORTPROC:
1195             /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command
1196              * ReactOS copy this behavior to be compatible with windows 2003
1197              */
1198             if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1199                     (pUserData == NULL) )
1200             {
1201                 GdiSetLastError(ERROR_INVALID_HANDLE);
1202                 retValue = FALSE;
1203             }
1204             retValue = SetAbortProc(hdc, (ABORTPROC)lpvInData);
1205             break;
1206
1207         case GETCOLORTABLE:
1208             retValue = GetSystemPaletteEntries(hdc, (UINT)*lpvInData, 1, (LPPALETTEENTRY)lpvOutData);
1209             if ( !retValue )
1210             {
1211                 retValue = SP_ERROR;
1212             }
1213             break;
1214
1215         case ENDDOC:
1216             /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command
1217              * ReactOS copy this behavior to be compatible with windows 2003
1218              */
1219             if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1220                     (pUserData == NULL) )
1221             {
1222                 GdiSetLastError(ERROR_INVALID_HANDLE);
1223                 retValue = FALSE;
1224             }
1225             retValue = EndDoc(hdc);
1226             break;
1227
1228
1229         case GETSCALINGFACTOR:
1230             /* Note GETSCALINGFACTOR is outdated have been replace by GetDeviceCaps */
1231             if ( Type == GDI_OBJECT_TYPE_DC )
1232             {
1233                 if ( lpvOutData )
1234                 {
1235                     PPOINT ptr = (PPOINT) lpvOutData;
1236                     ptr->x = 0;
1237                     ptr->y = 0;
1238                 }
1239             }
1240             retValue = FALSE;
1241             break;
1242
1243         case GETEXTENDEDTEXTMETRICS:
1244             retValue = (int) GetETM( hdc, (EXTTEXTMETRIC *) lpvOutData) != 0;
1245             break;
1246
1247         case  STARTDOC:
1248         {
1249             DOCINFOA *pUserDatalpdi;
1250             DOCINFOA lpdi;
1251
1252             /* Note : Winodws check see if the handle have any user data for STARTDOC command
1253              * ReactOS copy this behavior to be compatible with windows 2003
1254              */
1255             if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserDatalpdi)) ||
1256                     (pUserData == NULL) )
1257             {
1258                 GdiSetLastError(ERROR_INVALID_HANDLE);
1259                 retValue = FALSE;
1260             }
1261
1262             lpdi.cbSize = sizeof(DOCINFOA);
1263
1264             /* NOTE lpszOutput will be store in handle userdata */
1265             lpdi.lpszOutput = 0;
1266
1267             lpdi.lpszDatatype = 0;
1268             lpdi.fwType = 0;
1269             lpdi.lpszDocName = lpvInData;
1270
1271             /* NOTE : doc for StartDocA/W at msdn http://msdn2.microsoft.com/en-us/library/ms535793(VS.85).aspx */
1272             retValue = StartDocA(hdc, &lpdi);
1273
1274             /* StartDocA fail */
1275             if (retValue < 0)
1276             {
1277                 /* check see if outbuffer contain any data, if it does abort */
1278                 if  ( (pUserDatalpdi->lpszOutput != 0) &&
1279                         ( (*(WCHAR *)pUserDatalpdi->lpszOutput) != UNICODE_NULL) )
1280                 {
1281                     retValue = SP_APPABORT;
1282                 }
1283                 else
1284                 {
1285                     retValue = GetLastError();
1286
1287                     /* Translate StartDocA error code to STARTDOC error code
1288                      * see msdn http://msdn2.microsoft.com/en-us/library/ms535472.aspx
1289                      */
1290                     switch(retValue)
1291                     {
1292                     case ERROR_NOT_ENOUGH_MEMORY:
1293                         retValue = SP_OUTOFMEMORY;
1294                         break;
1295
1296                     case ERROR_PRINT_CANCELLED:
1297                         retValue = SP_USERABORT;
1298                         break;
1299
1300                     case ERROR_DISK_FULL:
1301                         retValue = SP_OUTOFDISK;
1302                         break;
1303
1304                     default:
1305                         retValue = SP_ERROR;
1306                         break;
1307                     }
1308                 }
1309             }
1310         }
1311         break;
1312
1313
1314
1315
1316         default:
1317             UNIMPLEMENTED;
1318             SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1319         }
1320     }
1321
1322     return retValue;
1323 }
1324
1325 /*
1326  * @unimplemented
1327  */
1328 BOOL
1329 WINAPI
1330 GdiAddGlsRecord(HDC hdc,
1331                 DWORD unknown1,
1332                 LPCSTR unknown2,
1333                 LPRECT unknown3)
1334 {
1335     UNIMPLEMENTED;
1336     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1337     return 0;
1338 }
1339
1340 /*
1341  * @unimplemented
1342  */
1343 HANDLE
1344 WINAPI
1345 GdiConvertMetaFilePict(HGLOBAL hMem)
1346 {
1347     UNIMPLEMENTED;
1348     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1349     return 0;
1350 }
1351
1352 /*
1353  * @implemented
1354  */
1355 DEVMODEW *
1356 WINAPI
1357 GdiConvertToDevmodeW(const DEVMODEA *dmA)
1358 {
1359     DEVMODEW *dmW;
1360     WORD dmW_size, dmA_size;
1361
1362     dmA_size = dmA->dmSize;
1363
1364     /* this is the minimal dmSize that XP accepts */
1365     if (dmA_size < FIELD_OFFSET(DEVMODEA, dmFields))
1366         return NULL;
1367
1368     if (dmA_size > sizeof(DEVMODEA))
1369         dmA_size = sizeof(DEVMODEA);
1370
1371     dmW_size = dmA_size + CCHDEVICENAME;
1372     if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME)
1373         dmW_size += CCHFORMNAME;
1374
1375     dmW = HeapAlloc(GetProcessHeap(), 0, dmW_size + dmA->dmDriverExtra);
1376     if (!dmW) return NULL;
1377
1378     MultiByteToWideChar(CP_ACP, 0, (const char*) dmA->dmDeviceName, CCHDEVICENAME,
1379                         dmW->dmDeviceName, CCHDEVICENAME);
1380     /* copy slightly more, to avoid long computations */
1381     memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion, dmA_size - CCHDEVICENAME);
1382
1383     if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME)
1384     {
1385         MultiByteToWideChar(CP_ACP, 0, (const char*) dmA->dmFormName, CCHFORMNAME,
1386                             dmW->dmFormName, CCHFORMNAME);
1387         if (dmA_size > FIELD_OFFSET(DEVMODEA, dmLogPixels))
1388             memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA_size - FIELD_OFFSET(DEVMODEA, dmLogPixels));
1389     }
1390
1391     if (dmA->dmDriverExtra)
1392         memcpy((char *)dmW + dmW_size, (const char *)dmA + dmA_size, dmA->dmDriverExtra);
1393
1394     dmW->dmSize = dmW_size;
1395
1396     return dmW;
1397 }
1398
1399 /*
1400  * @unimplemented
1401  */
1402 HENHMETAFILE
1403 WINAPI
1404 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
1405 {
1406     UNIMPLEMENTED;
1407     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1408     return 0;
1409 }
1410
1411 /*
1412  * @unimplemented
1413  */
1414 METAFILEPICT *
1415 WINAPI
1416 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
1417 {
1418     UNIMPLEMENTED;
1419     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1420     return 0;
1421 }
1422
1423 /*
1424  * @unimplemented
1425  */
1426 HDC
1427 WINAPI
1428 GdiGetDC(HANDLE SpoolFileHandle)
1429 {
1430     UNIMPLEMENTED;
1431     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1432     return 0;
1433 }
1434
1435 /*
1436  * @unimplemented
1437  */
1438 HANDLE
1439 WINAPI
1440 GdiGetPageHandle(HANDLE SpoolFileHandle,
1441                  DWORD Page,
1442                  LPDWORD pdwPageType)
1443 {
1444     UNIMPLEMENTED;
1445     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1446     return 0;
1447 }
1448
1449 /*
1450  * @unimplemented
1451  */
1452 BOOL
1453 WINAPI
1454 GdiStartDocEMF(HANDLE SpoolFileHandle,
1455                DOCINFOW *pDocInfo)
1456 {
1457     UNIMPLEMENTED;
1458     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1459     return 0;
1460 }
1461
1462 /*
1463  * @unimplemented
1464  */
1465 BOOL
1466 WINAPI
1467 GdiStartPageEMF(HANDLE SpoolFileHandle)
1468 {
1469     UNIMPLEMENTED;
1470     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1471     return 0;
1472 }
1473
1474 /*
1475  * @unimplemented
1476  */
1477 BOOL
1478 WINAPI
1479 GdiPlayPageEMF(HANDLE SpoolFileHandle,
1480                HANDLE hemf,
1481                RECT *prectDocument,
1482                RECT *prectBorder,
1483                RECT *prectClip)
1484 {
1485     UNIMPLEMENTED;
1486     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1487     return 0;
1488 }
1489
1490 /*
1491  * @unimplemented
1492  */
1493 BOOL
1494 WINAPI
1495 GdiEndPageEMF(HANDLE SpoolFileHandle,
1496               DWORD dwOptimization)
1497 {
1498     UNIMPLEMENTED;
1499     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1500     return 0;
1501 }
1502
1503 /*
1504  * @unimplemented
1505  */
1506 BOOL
1507 WINAPI
1508 GdiEndDocEMF(HANDLE SpoolFileHandle)
1509 {
1510     UNIMPLEMENTED;
1511     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1512     return 0;
1513 }
1514
1515 /*
1516  * @unimplemented
1517  */
1518 BOOL
1519 WINAPI
1520 GdiGetDevmodeForPage(HANDLE SpoolFileHandle,
1521                      DWORD dwPageNumber,
1522                      PDEVMODEW *pCurrDM,
1523                      PDEVMODEW *pLastDM)
1524 {
1525     UNIMPLEMENTED;
1526     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1527     return 0;
1528 }
1529
1530 /*
1531  * @unimplemented
1532  */
1533 BOOL
1534 WINAPI
1535 GdiResetDCEMF(HANDLE SpoolFileHandle,
1536               PDEVMODEW pCurrDM)
1537 {
1538     UNIMPLEMENTED;
1539     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1540     return 0;
1541 }
1542
1543 /*
1544  * @unimplemented
1545  */
1546 ULONG *
1547 WINAPI
1548 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
1549 {
1550     return XlateObj->pulXlate;
1551 }
1552
1553 /*
1554  * @unimplemented
1555  */
1556 BOOL
1557 WINAPI
1558 GdiPlayEMF(LPWSTR pwszPrinterName,
1559            LPDEVMODEW pDevmode,
1560            LPWSTR pwszDocName,
1561            EMFPLAYPROC pfnEMFPlayFn,
1562            HANDLE hPageQuery
1563           )
1564 {
1565     UNIMPLEMENTED;
1566     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1567     return 0;
1568 }
1569
1570 /*
1571  * @unimplemented
1572  */
1573 BOOL
1574 WINAPI
1575 GdiPlayPrivatePageEMF(HANDLE SpoolFileHandle,
1576                       DWORD unknown,
1577                       RECT *prectDocument)
1578 {
1579     UNIMPLEMENTED;
1580     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1581     return 0;
1582 }
1583
1584 /*
1585  * @unimplemented
1586  */
1587 VOID WINAPI GdiInitializeLanguagePack(DWORD InitParam)
1588 {
1589     UNIMPLEMENTED;
1590     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1591 }
1592
1593 /*
1594  * @implemented
1595  */
1596 BOOL
1597 WINAPI
1598 GdiGradientFill(
1599     IN HDC hdc,
1600     IN PTRIVERTEX pVertex,
1601     IN ULONG nVertex,
1602     IN PVOID pMesh,
1603     IN ULONG nMesh,
1604     IN ULONG ulMode)
1605 {
1606     /* FIXME some part need be done in user mode */
1607     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
1608 }
1609
1610 /*
1611  * @implemented
1612  */
1613 BOOL
1614 WINAPI
1615 GdiTransparentBlt(IN HDC hdcDst,
1616                   IN INT xDst,
1617                   IN INT yDst,
1618                   IN INT cxDst,
1619                   IN INT cyDst,
1620                   IN HDC hdcSrc,
1621                   IN INT xSrc,
1622                   IN INT ySrc,
1623                   IN INT cxSrc,
1624                   IN INT cySrc,
1625                   IN UINT TransColor
1626                  )
1627 {
1628     /* FIXME some part need be done in user mode */
1629     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, (COLORREF)TransColor);
1630 }
1631
1632 /*
1633  * @unimplemented
1634  */
1635 BOOL
1636 WINAPI
1637 GdiPrinterThunk(
1638     IN HUMPD humpd,
1639     DWORD *status,
1640     DWORD unuse)
1641 {
1642     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
1643     /* status contain some form of return value that being save, what it is I do not known */
1644     /* unsue seam have zero effect, what it is for I do not known */
1645
1646     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
1647     return FALSE;
1648 }
1649
1650 /*
1651  * @unimplemented
1652  *
1653  */
1654 HBITMAP
1655 WINAPI
1656 GdiConvertBitmapV5(
1657     HBITMAP in_format_BitMap,
1658     HBITMAP src_BitMap,
1659     INT bpp,
1660     INT unuse)
1661 {
1662     /* FIXME guessing the prototypes */
1663
1664     /*
1665      * it have create a new bitmap with desired in format,
1666      * then convert it src_bitmap to new format
1667      * and return it as HBITMAP
1668      */
1669
1670     return FALSE;
1671 }
1672
1673 /*
1674  * @implemented
1675  *
1676  */
1677 int
1678 WINAPI
1679 GetClipBox(HDC hdc,
1680            LPRECT lprc)
1681 {
1682     return  NtGdiGetAppClipBox(hdc, lprc);
1683 }
1684
1685 /*
1686  * @implemented
1687  *
1688  */
1689 DWORD
1690 WINAPI
1691 GetFontData(HDC hdc,
1692             DWORD dwTable,
1693             DWORD dwOffset,
1694             LPVOID lpvBuffer,
1695             DWORD cbData)
1696 {
1697     if (!lpvBuffer)
1698     {
1699         cbData = 0;
1700     }
1701     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
1702 }
1703
1704 INT
1705 WINAPI
1706 NamedEscape(HDC hdc,
1707             PWCHAR pDriver,
1708             INT iEsc,
1709             INT cjIn,
1710             LPSTR pjIn,
1711             INT cjOut,
1712             LPSTR pjOut)
1713 {
1714     /* FIXME metadc, metadc are done most in user mode, and we do not support it
1715      * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
1716      * when it calls to NtGdiExtEscape from NamedEscape
1717      */
1718     return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
1719 }
1720
1721 /*
1722  * @unimplemented
1723  */
1724
1725 /* FIXME wrong protypes, it is a fastcall api */
1726 DWORD
1727 WINAPI
1728 cGetTTFFromFOT(DWORD x1 ,DWORD x2 ,DWORD x3, DWORD x4, DWORD x5, DWORD x6, DWORD x7)
1729 {
1730     UNIMPLEMENTED;
1731     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1732     return 0;
1733 }
1734