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  * @implemented
1101  */
1102 BOOL
1103 WINAPI
1104 GdiIsMetaFileDC(HDC hDC)
1105 {
1106   if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC)
1107   {
1108      if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC)
1109         return TRUE;
1110      else
1111      {
1112         PLDC pLDC = GdiGetLDC(hDC);
1113         if ( !pLDC )
1114         {
1115            SetLastError(ERROR_INVALID_HANDLE);
1116            return FALSE;
1117         }
1118         if ( pLDC->iType == LDC_EMFLDC) return TRUE;
1119      }
1120   }
1121   return FALSE;
1122 }
1123
1124 /*
1125  * @implemented
1126  */
1127 BOOL
1128 WINAPI
1129 GdiIsMetaPrintDC(HDC hDC)
1130 {
1131
1132   if (GDI_HANDLE_GET_TYPE(hDC) != GDI_OBJECT_TYPE_DC)
1133   {
1134      if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_METADC)
1135         return FALSE;
1136      else
1137      {
1138         PLDC pLDC = GdiGetLDC(hDC);
1139         if ( !pLDC )
1140         {
1141            SetLastError(ERROR_INVALID_HANDLE);
1142            return FALSE;
1143         }
1144         if ( pLDC->Flags & LDC_META_PRINT) return TRUE;
1145      }
1146   }
1147   return FALSE;
1148 }
1149
1150 /*
1151  * @implemented
1152  */
1153 BOOL
1154 WINAPI
1155 GdiIsPlayMetafileDC(HDC hDC)
1156 {
1157   PDC_ATTR Dc_Attr;
1158   PLDC pLDC;
1159
1160   GdiGetHandleUserData((HGDIOBJ) hDC, GDI_OBJECT_TYPE_DC, (PVOID) &Dc_Attr);
1161   if ( Dc_Attr )
1162   {
1163      pLDC = Dc_Attr->pvLDC;
1164      if ( pLDC )
1165      {
1166         if ( pLDC->Flags & LDC_PLAY_MFDC ) return TRUE;
1167      }
1168   }
1169   return FALSE;
1170 }
1171
1172 /*
1173  * @unimplemented
1174  */
1175 BOOL
1176 WINAPI
1177 GdiValidateHandle(HGDIOBJ hobj)
1178 {
1179     UNIMPLEMENTED;
1180     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1181     return 0;
1182 }
1183
1184 /*
1185  * @unimplemented
1186  */
1187 DWORD
1188 WINAPI
1189 GetBitmapAttributes(HBITMAP hbm)
1190 {
1191     UNIMPLEMENTED;
1192     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1193     return 0;
1194 }
1195
1196 /*
1197  * @unimplemented
1198  */
1199 DWORD
1200 WINAPI
1201 GetBrushAttributes(HBRUSH hbr)
1202 {
1203     UNIMPLEMENTED;
1204     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1205     return 0;
1206 }
1207
1208 /*
1209  * @implemented
1210  */
1211 ULONG
1212 WINAPI
1213 GetEUDCTimeStamp(VOID)
1214 {
1215     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1216 }
1217
1218 /*
1219  * @implemented
1220  */
1221 ULONG
1222 WINAPI
1223 GetFontAssocStatus(HDC hdc)
1224 {
1225     ULONG retValue = 0;
1226
1227     if (hdc)
1228     {
1229         retValue = NtGdiQueryFontAssocInfo(hdc);
1230     }
1231
1232     return retValue;
1233 }
1234
1235 /*
1236  * @implemented
1237  */
1238 BOOL
1239 WINAPI
1240 GetTextExtentExPointWPri(HDC hdc,
1241                          LPWSTR lpwsz,
1242                          ULONG cwc,
1243                          ULONG dxMax,
1244                          ULONG *pcCh,
1245                          PULONG pdxOut,
1246                          LPSIZE psize)
1247 {
1248     return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1249 }
1250
1251 /*
1252  * @unimplemented
1253  */
1254 DWORD
1255 WINAPI
1256 QueryFontAssocStatus(VOID)
1257 {
1258     UNIMPLEMENTED;
1259     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1260     return 0;
1261 }
1262
1263 /*
1264  * @implemented
1265  */
1266 BOOL
1267 WINAPI
1268 RemoveFontMemResourceEx(HANDLE fh)
1269 {
1270     BOOL retValue=0;
1271
1272     if (fh)
1273     {
1274         retValue = NtGdiRemoveFontMemResourceEx(fh);
1275     }
1276     else
1277     {
1278         SetLastError(ERROR_INVALID_PARAMETER);
1279     }
1280     return retValue;
1281 }
1282
1283 /*
1284  * @unimplemented
1285  */
1286 int
1287 WINAPI
1288 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1289 {
1290         UNIMPLEMENTED;
1291         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1292         return 0;
1293 }
1294
1295 /*
1296  * @unimplemented
1297  */
1298 HBITMAP
1299 WINAPI
1300 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1301 {
1302         UNIMPLEMENTED;
1303         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1304         return 0;
1305 }
1306
1307 /*
1308  * @unimplemented
1309  */
1310 HBRUSH
1311 WINAPI
1312 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1313 {
1314         UNIMPLEMENTED;
1315         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1316         return 0;
1317 }
1318
1319 /*
1320  * @implemented
1321  */
1322 int
1323 WINAPI
1324 StartFormPage(HDC hdc)
1325 {
1326     return StartPage(hdc);
1327 }
1328
1329 /*
1330  * @unimplemented
1331  */
1332 VOID
1333 WINAPI
1334 UnloadNetworkFonts(DWORD unknown)
1335 {
1336     UNIMPLEMENTED;
1337     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1338 }
1339
1340 /*
1341  * @unimplemented
1342  */
1343 BOOL
1344 WINAPI
1345 GdiRealizationInfo(HDC hdc,
1346                    PREALIZATION_INFO pri)
1347 {
1348     // ATM we do not support local font data and Language Pack.
1349     return NtGdiGetRealizationInfo(hdc, pri, (HFONT) NULL);
1350 }
1351
1352 /*
1353  * @implemented
1354  */
1355 BOOL
1356 WINAPI
1357 GetETM(HDC hdc,
1358        EXTTEXTMETRIC *petm)
1359 {
1360   BOOL Ret = NtGdiGetETM(hdc, petm);
1361
1362   if (Ret && petm)
1363     petm->emKernPairs = GetKerningPairsA(hdc, 0, 0);
1364
1365   return Ret;
1366 }
1367
1368 /*
1369  * @unimplemented
1370  */
1371 int
1372 WINAPI
1373 Escape(HDC hdc, INT nEscape, INT cbInput, LPCSTR lpvInData, LPVOID lpvOutData)
1374 {
1375     int retValue = SP_ERROR;
1376     HGDIOBJ hObject = hdc;
1377     UINT Type = 0;
1378     LPVOID pUserData = NULL;
1379
1380     Type = GDI_HANDLE_GET_TYPE(hObject);
1381
1382     if (Type == GDI_OBJECT_TYPE_METADC)
1383     {
1384         /* FIXME we do not support metafile */
1385         UNIMPLEMENTED;
1386         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1387     }
1388     else
1389     {
1390         switch (nEscape)
1391         {
1392             case ABORTDOC:
1393                 /* Note Winodws check see if the handle have any user data for ABORTDOC command
1394                  * ReactOS copy this behavior to be compatible with windows 2003
1395                  */
1396                 if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1397                       (pUserData == NULL) )
1398                  {
1399                      GdiSetLastError(ERROR_INVALID_HANDLE);
1400                      retValue = FALSE;
1401                  }
1402                  else
1403                  {
1404                     retValue = AbortDoc(hdc);
1405                  }
1406                 break;
1407
1408             case DRAFTMODE:
1409             case FLUSHOUTPUT:
1410             case SETCOLORTABLE:
1411                 /* Note 1: DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE is outdated and been replace with other api */
1412                 /* Note 2: Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command
1413                  * ReactOS copy this behavior to be compatible with windows 2003
1414                  */
1415                 if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1416                      (pUserData == NULL) )
1417                 {
1418                     GdiSetLastError(ERROR_INVALID_HANDLE);
1419                 }
1420                 retValue = FALSE;
1421                 break;
1422
1423             case SETABORTPROC:
1424                 /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command
1425                  * ReactOS copy this behavior to be compatible with windows 2003
1426                  */
1427                 if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1428                      (pUserData == NULL) )
1429                 {
1430                     GdiSetLastError(ERROR_INVALID_HANDLE);
1431                     retValue = FALSE;
1432                 }
1433                 retValue = SetAbortProc(hdc, (ABORTPROC)lpvInData);
1434                 break;
1435
1436             case GETCOLORTABLE:
1437                 retValue = GetSystemPaletteEntries(hdc, (UINT)*lpvInData, 1, (LPPALETTEENTRY)lpvOutData);
1438                 if ( !retValue )
1439                 {
1440                     retValue = SP_ERROR;
1441                 }
1442                 break;
1443
1444             case ENDDOC:
1445                 /* Note : Winodws check see if the handle have any user data for DRAFTMODE, FLUSHOUTPUT, SETCOLORTABLE command
1446                  * ReactOS copy this behavior to be compatible with windows 2003
1447                  */
1448                 if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserData)) ||
1449                      (pUserData == NULL) )
1450                 {
1451                     GdiSetLastError(ERROR_INVALID_HANDLE);
1452                     retValue = FALSE;
1453                 }
1454                 retValue = EndDoc(hdc);
1455                 break;
1456
1457
1458             case GETSCALINGFACTOR:
1459                 /* Note GETSCALINGFACTOR is outdated have been replace by GetDeviceCaps */
1460                 if ( Type == GDI_OBJECT_TYPE_DC )
1461                 {
1462                     if ( lpvOutData )
1463                     {
1464                         PPOINT ptr = (PPOINT) lpvOutData;
1465                         ptr->x = 0;
1466                         ptr->y = 0;
1467                     }
1468                 }
1469                 retValue = FALSE;
1470                 break;
1471
1472             case GETEXTENDEDTEXTMETRICS:
1473                 retValue = (int) GetETM( hdc, (EXTTEXTMETRIC *) lpvOutData) != 0;
1474                 break;
1475
1476             case  STARTDOC:
1477                 {
1478                     DOCINFOA *pUserDatalpdi;
1479                     DOCINFOA lpdi;
1480
1481                     /* Note : Winodws check see if the handle have any user data for STARTDOC command
1482                      * ReactOS copy this behavior to be compatible with windows 2003
1483                      */
1484                     if ( (!GdiGetHandleUserData(hObject, (DWORD)Type, (PVOID) &pUserDatalpdi)) ||
1485                          (pUserData == NULL) )
1486                     {
1487                         GdiSetLastError(ERROR_INVALID_HANDLE);
1488                         retValue = FALSE;
1489                     }
1490
1491                     lpdi.cbSize = sizeof(DOCINFOA);
1492
1493                     /* NOTE lpszOutput will be store in handle userdata */
1494                     lpdi.lpszOutput = 0;
1495
1496                     lpdi.lpszDatatype = 0;
1497                     lpdi.fwType = 0;
1498                     lpdi.lpszDocName = lpvInData;
1499
1500                     /* NOTE : doc for StartDocA/W at msdn http://msdn2.microsoft.com/en-us/library/ms535793(VS.85).aspx */
1501                     retValue = StartDocA(hdc, &lpdi);
1502
1503                     /* StartDocA fail */
1504                     if (retValue < 0)
1505                     {
1506                         /* check see if outbuffer contain any data, if it does abort */
1507                         if  ( (pUserDatalpdi->lpszOutput != 0) &&
1508                               ( (*(WCHAR *)pUserDatalpdi->lpszOutput) != UNICODE_NULL) )
1509                         {
1510                             retValue = SP_APPABORT;
1511                         }
1512                         else
1513                         {
1514                             retValue = GetLastError();
1515
1516                             /* Translate StartDocA error code to STARTDOC error code
1517                              * see msdn http://msdn2.microsoft.com/en-us/library/ms535472.aspx
1518                              */
1519                             switch(retValue)
1520                             {
1521                                 case ERROR_NOT_ENOUGH_MEMORY:
1522                                     retValue = SP_OUTOFMEMORY;
1523                                     break;
1524
1525                                 case ERROR_PRINT_CANCELLED:
1526                                     retValue = SP_USERABORT;
1527                                     break;
1528
1529                                 case ERROR_DISK_FULL:
1530                                     retValue = SP_OUTOFDISK;
1531                                     break;
1532
1533                                 default:
1534                                     retValue = SP_ERROR;
1535                                     break;
1536                             }
1537                         }
1538                     }
1539                 }
1540                 break;
1541
1542
1543
1544
1545             default:
1546                 UNIMPLEMENTED;
1547                 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1548         }
1549     }
1550
1551     return retValue;
1552 }
1553
1554 /*
1555  * @unimplemented
1556  */
1557 BOOL
1558 WINAPI
1559 GdiAddGlsRecord(HDC hdc,
1560                 DWORD unknown1,
1561                 LPCSTR unknown2,
1562                 LPRECT unknown3)
1563 {
1564     UNIMPLEMENTED;
1565     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1566     return 0;
1567 }
1568
1569 /*
1570  * @unimplemented
1571  */
1572 HANDLE
1573 WINAPI
1574 GdiConvertMetaFilePict(HGLOBAL hMem)
1575 {
1576     UNIMPLEMENTED;
1577     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1578     return 0;
1579 }
1580
1581 /*
1582  * @implemented
1583  */
1584 DEVMODEW *
1585 WINAPI
1586 GdiConvertToDevmodeW(DEVMODEA *dmA)
1587 {
1588     DEVMODEW *dmW;
1589     WORD dmW_size, dmA_size;
1590
1591     dmA_size = dmA->dmSize;
1592
1593     /* this is the minimal dmSize that XP accepts */
1594     if (dmA_size < FIELD_OFFSET(DEVMODEA, dmFields))
1595         return NULL;
1596
1597     if (dmA_size > sizeof(DEVMODEA))
1598         dmA_size = sizeof(DEVMODEA);
1599
1600     dmW_size = dmA_size + CCHDEVICENAME;
1601     if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME)
1602         dmW_size += CCHFORMNAME;
1603
1604     dmW = HeapAlloc(GetProcessHeap(), 0, dmW_size + dmA->dmDriverExtra);
1605     if (!dmW) return NULL;
1606
1607     MultiByteToWideChar(CP_ACP, 0, (const char*) dmA->dmDeviceName, CCHDEVICENAME,
1608                                    dmW->dmDeviceName, CCHDEVICENAME);
1609     /* copy slightly more, to avoid long computations */
1610     memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion, dmA_size - CCHDEVICENAME);
1611
1612     if (dmA_size >= FIELD_OFFSET(DEVMODEA, dmFormName) + CCHFORMNAME)
1613     {
1614         MultiByteToWideChar(CP_ACP, 0, (const char*) dmA->dmFormName, CCHFORMNAME,
1615                                        dmW->dmFormName, CCHFORMNAME);
1616         if (dmA_size > FIELD_OFFSET(DEVMODEA, dmLogPixels))
1617             memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA_size - FIELD_OFFSET(DEVMODEA, dmLogPixels));
1618     }
1619
1620     if (dmA->dmDriverExtra)
1621         memcpy((char *)dmW + dmW_size, (const char *)dmA + dmA_size, dmA->dmDriverExtra);
1622
1623     dmW->dmSize = dmW_size;
1624
1625     return dmW;
1626 }
1627
1628 /*
1629  * @unimplemented
1630  */
1631 HENHMETAFILE
1632 WINAPI
1633 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
1634 {
1635     UNIMPLEMENTED;
1636     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1637     return 0;
1638 }
1639
1640 /*
1641  * @unimplemented
1642  */
1643 METAFILEPICT *
1644 WINAPI
1645 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
1646 {
1647     UNIMPLEMENTED;
1648     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1649     return 0;
1650 }
1651
1652
1653 /*
1654  * @unimplemented
1655  */
1656 HANDLE
1657 WINAPI
1658 GdiGetSpoolFileHandle(LPWSTR pwszPrinterName,
1659                       LPDEVMODEW pDevmode,
1660                       LPWSTR pwszDocName)
1661 {
1662     UNIMPLEMENTED;
1663     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1664     return 0;
1665 }
1666
1667 /*
1668  * @unimplemented
1669  */
1670 BOOL
1671 WINAPI
1672 GdiDeleteSpoolFileHandle(HANDLE SpoolFileHandle)
1673 {
1674     UNIMPLEMENTED;
1675     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1676     return 0;
1677 }
1678
1679 /*
1680  * @unimplemented
1681  */
1682 DWORD
1683 WINAPI
1684 GdiGetPageCount(HANDLE SpoolFileHandle)
1685 {
1686     UNIMPLEMENTED;
1687     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1688     return 0;
1689 }
1690
1691 /*
1692  * @unimplemented
1693  */
1694 HDC
1695 WINAPI
1696 GdiGetDC(HANDLE SpoolFileHandle)
1697 {
1698     UNIMPLEMENTED;
1699     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1700     return 0;
1701 }
1702
1703 /*
1704  * @unimplemented
1705  */
1706 HANDLE
1707 WINAPI
1708 GdiGetPageHandle(HANDLE SpoolFileHandle,
1709                  DWORD Page,
1710                  LPDWORD pdwPageType)
1711 {
1712     UNIMPLEMENTED;
1713     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1714     return 0;
1715 }
1716
1717 /*
1718  * @unimplemented
1719  */
1720 BOOL
1721 WINAPI
1722 GdiStartDocEMF(HANDLE SpoolFileHandle,
1723                DOCINFOW *pDocInfo)
1724 {
1725     UNIMPLEMENTED;
1726     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1727     return 0;
1728 }
1729
1730 /*
1731  * @unimplemented
1732  */
1733 BOOL
1734 WINAPI
1735 GdiStartPageEMF(HANDLE SpoolFileHandle)
1736 {
1737     UNIMPLEMENTED;
1738     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1739     return 0;
1740 }
1741
1742 /*
1743  * @unimplemented
1744  */
1745 BOOL
1746 WINAPI
1747 GdiPlayPageEMF(HANDLE SpoolFileHandle,
1748                HANDLE hemf,
1749                RECT *prectDocument,
1750                RECT *prectBorder,
1751                RECT *prectClip)
1752 {
1753     UNIMPLEMENTED;
1754     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1755     return 0;
1756 }
1757
1758 /*
1759  * @unimplemented
1760  */
1761 BOOL
1762 WINAPI
1763 GdiEndPageEMF(HANDLE SpoolFileHandle,
1764               DWORD dwOptimization)
1765 {
1766     UNIMPLEMENTED;
1767     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1768     return 0;
1769 }
1770
1771 /*
1772  * @unimplemented
1773  */
1774 BOOL
1775 WINAPI
1776 GdiEndDocEMF(HANDLE SpoolFileHandle)
1777 {
1778     UNIMPLEMENTED;
1779     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1780     return 0;
1781 }
1782
1783 /*
1784  * @unimplemented
1785  */
1786 BOOL
1787 WINAPI
1788 GdiGetDevmodeForPage(HANDLE SpoolFileHandle,
1789                      DWORD dwPageNumber,
1790                      PDEVMODEW *pCurrDM,
1791                      PDEVMODEW *pLastDM)
1792 {
1793     UNIMPLEMENTED;
1794     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1795     return 0;
1796 }
1797
1798 /*
1799  * @unimplemented
1800  */
1801 BOOL
1802 WINAPI
1803 GdiResetDCEMF(HANDLE SpoolFileHandle,
1804               PDEVMODEW pCurrDM)
1805 {
1806     UNIMPLEMENTED;
1807     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1808     return 0;
1809 }
1810
1811
1812 /*
1813  * @unimplemented
1814  */
1815 INT
1816 WINAPI
1817 CombineRgn(HRGN  hDest,
1818            HRGN  hSrc1,
1819            HRGN  hSrc2,
1820            INT  CombineMode)
1821 {
1822     /* FIXME some part should be done in user mode */
1823     return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
1824 }
1825
1826 /*
1827  * @unimplemented
1828  */
1829 ULONG WINAPI
1830 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
1831                 ULONG Color)
1832 {
1833     UNIMPLEMENTED;
1834     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1835     return 0;
1836 }
1837
1838 /*
1839  * @unimplemented
1840  */
1841 ULONG *
1842 WINAPI
1843 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
1844 {
1845     return XlateObj->pulXlate;
1846 }
1847
1848 /*
1849  * @unimplemented
1850  */
1851 BOOL
1852 WINAPI
1853 GdiPlayEMF(LPWSTR pwszPrinterName,
1854            LPDEVMODEW pDevmode,
1855            LPWSTR pwszDocName,
1856            EMFPLAYPROC pfnEMFPlayFn,
1857            HANDLE hPageQuery
1858 )
1859 {
1860     UNIMPLEMENTED;
1861     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1862     return 0;
1863 }
1864
1865
1866
1867 /*
1868  * @unimplemented
1869  */
1870 BOOL
1871 WINAPI
1872 GdiPlayPrivatePageEMF(HANDLE SpoolFileHandle,
1873                       DWORD unknown,
1874                       RECT *prectDocument)
1875 {
1876     UNIMPLEMENTED;
1877     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1878     return 0;
1879 }
1880
1881 /*
1882  * @unimplemented
1883  */
1884 VOID WINAPI GdiInitializeLanguagePack(DWORD InitParam)
1885 {
1886     UNIMPLEMENTED;
1887     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1888 }
1889
1890
1891 /*
1892  * @implemented
1893  */
1894 INT
1895 WINAPI
1896 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
1897 {
1898     /* FIXME some part need be done on user mode size */
1899     return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
1900 }
1901
1902 /*
1903  * @implemented
1904  */
1905 INT
1906 WINAPI
1907 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
1908 {
1909     /* FIXME some part need be done on user mode size */
1910     return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
1911 }
1912
1913 /*
1914  * @implemented
1915  */
1916 BOOL
1917 WINAPI
1918 GdiGradientFill(
1919     IN HDC hdc,
1920     IN PTRIVERTEX pVertex,
1921     IN ULONG nVertex,
1922     IN PVOID pMesh,
1923     IN ULONG nMesh,
1924     IN ULONG ulMode)
1925 {
1926     /* FIXME some part need be done in user mode */
1927     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
1928 }
1929
1930
1931 /*
1932  * @implemented
1933  */
1934 BOOL
1935 WINAPI
1936 GdiTransparentBlt(IN HDC hdcDst,
1937                   IN INT xDst,
1938                   IN INT yDst,
1939                   IN INT cxDst,
1940                   IN INT cyDst,
1941                   IN HDC hdcSrc,
1942                   IN INT xSrc,
1943                   IN INT ySrc,
1944                   IN INT cxSrc,
1945                   IN INT cySrc,
1946                   IN COLORREF TransColor
1947 )
1948 {
1949     /* FIXME some part need be done in user mode */
1950     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
1951 }
1952
1953 /*
1954  * @unimplemented
1955  */
1956 BOOL
1957 WINAPI
1958 GdiPrinterThunk(
1959     IN HUMPD humpd,
1960     DWORD *status,
1961     DWORD unuse)
1962 {
1963     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
1964     /* status contain some form of return value that being save, what it is I do not known */
1965     /* unsue seam have zero effect, what it is for I do not known */
1966
1967     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
1968     return FALSE;
1969 }
1970
1971 /*
1972  * @unimplemented
1973  *
1974  */
1975 HBITMAP
1976 WINAPI
1977 GdiConvertBitmapV5(
1978     HBITMAP in_format_BitMap,
1979     HBITMAP src_BitMap,
1980     INT bpp,
1981     INT unuse)
1982 {
1983     /* FIXME guessing the prototypes */
1984
1985     /*
1986      * it have create a new bitmap with desired in format,
1987      * then convert it src_bitmap to new format
1988      * and return it as HBITMAP
1989      */
1990
1991     return FALSE;
1992 }
1993
1994 /*
1995  * @implemented
1996  *
1997  */
1998 int
1999 WINAPI
2000 GetClipBox(HDC hdc,
2001            LPRECT lprc)
2002 {
2003     return  NtGdiGetAppClipBox(hdc, lprc);
2004 }
2005
2006 /*
2007  * @implemented
2008  *
2009  */
2010 DWORD
2011 WINAPI
2012 GetFontData(HDC hdc,
2013             DWORD dwTable,
2014             DWORD dwOffset,
2015             LPVOID lpvBuffer,
2016             DWORD cbData)
2017 {
2018     if (!lpvBuffer)
2019     {
2020        cbData = 0;
2021     }
2022     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2023 }
2024
2025
2026 /*
2027  * @implemented
2028  *
2029  */
2030 DWORD
2031 WINAPI
2032 GetRegionData(HRGN hrgn,
2033               DWORD nCount,
2034               LPRGNDATA lpRgnData)
2035 {
2036     if (!lpRgnData)
2037     {
2038         nCount = 0;
2039     }
2040
2041     return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
2042 }
2043
2044
2045 /*
2046  * @implemented
2047  *
2048  */
2049 INT
2050 WINAPI
2051 GetRgnBox(HRGN hrgn,
2052           LPRECT prcOut)
2053 {
2054 #if 0
2055   PRGN_ATTR Rgn_Attr;
2056   if (!GdiGetHandleUserData((HGDIOBJ) hRgn, GDI_OBJECT_TYPE_REGION, (PVOID) &Rgn_Attr))
2057      return NtGdiGetRgnBox(hrgn, prcOut);
2058   if (Rgn_Attr->Flags == NULLREGION)
2059   {
2060      prcOut->left   = 0;
2061      prcOut->top    = 0;
2062      prcOut->right  = 0;
2063      prcOut->bottom = 0;
2064   }
2065   else
2066   {
2067      if (Rgn_Attr->Flags != SIMPLEREGION) return NtGdiGetRgnBox(hrgn, prcOut);
2068      *prcOut = Rgn_Attr->Rect;
2069   }
2070   return Rgn_Attr->Flags;
2071 #endif
2072   return NtGdiGetRgnBox(hrgn, prcOut);
2073 }
2074
2075
2076 /*
2077  * @implemented
2078  *
2079  */
2080 INT
2081 WINAPI
2082 OffsetRgn( HRGN hrgn,
2083           int nXOffset,
2084           int nYOffset)
2085 {
2086     /* FIXME some part are done in user mode */
2087     return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
2088 }
2089
2090 /*
2091  * @implemented
2092  */
2093 INT
2094 WINAPI
2095 IntersectClipRect(HDC hdc,
2096                   int nLeftRect,
2097                   int nTopRect,
2098                   int nRightRect,
2099                   int nBottomRect)
2100 {
2101 #if 0
2102 // Handle something other than a normal dc object.
2103   if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
2104   {
2105     if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
2106       return MFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2107     else
2108     {
2109       PLDC pLDC = GdiGetLDC(hdc);
2110       if ( pLDC )
2111       {
2112          if (pLDC->iType != LDC_EMFLDC || EMFDRV_IntersectClipRect( hdc, nLeftRect, nTopRect, nRightRect, nBottomRect))
2113              return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2114       }
2115       else
2116         SetLastError(ERROR_INVALID_HANDLE);
2117       return 0;
2118     }
2119   }
2120 #endif
2121     return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2122 }
2123
2124 /*
2125  * @implemented
2126  */
2127 INT
2128 WINAPI
2129 OffsetClipRgn(HDC hdc,
2130               int nXOffset,
2131               int nYOffset)
2132 {
2133 #if 0
2134 // Handle something other than a normal dc object.
2135   if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
2136   {
2137     if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
2138       return MFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset );
2139     else
2140     {
2141       PLDC pLDC = GdiGetLDC(hdc);
2142       if ( !pLDC )
2143       {
2144          SetLastError(ERROR_INVALID_HANDLE);
2145          return 0;
2146       }
2147       if (pLDC->iType == LDC_EMFLDC && !EMFDRV_OffsetClipRgn( hdc, nXOffset, nYOffset ))
2148          return 0;
2149       return NtGdiOffsetClipRgn( hdc,  nXOffset,  nYOffset);
2150     }
2151   }
2152 #endif
2153   return NtGdiOffsetClipRgn( hdc,  nXOffset,  nYOffset);
2154 }
2155
2156
2157 INT
2158 WINAPI
2159 NamedEscape(HDC hdc,
2160             PWCHAR pDriver,
2161             INT iEsc,
2162             INT cjIn,
2163             LPSTR pjIn,
2164             INT cjOut,
2165             LPSTR pjOut)
2166 {
2167     /* FIXME metadc, metadc are done most in user mode, and we do not support it
2168      * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
2169      * when it calls to NtGdiExtEscape from NamedEscape
2170      */
2171     return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
2172 }
2173
2174
2175
2176 /*
2177  * @unimplemented
2178  */
2179
2180 /* FIXME wrong protypes, it is a fastcall api */
2181 DWORD
2182 WINAPI
2183 cGetTTFFromFOT(DWORD x1 ,DWORD x2 ,DWORD x3, DWORD x4, DWORD x5, DWORD x6, DWORD x7)
2184 {
2185     UNIMPLEMENTED;
2186     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2187     return 0;
2188 }
2189