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