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 STDCALL
  29 TranslateCharsetInfo(DWORD * lpSrc,
  30                      LPCHARSETINFO lpCs,
  31                      DWORD dwFlags)
  32 {
  33     /* FIXME share memory */
  34     return NtGdiTranslateCharsetInfo(lpSrc, lpCs, dwFlags );
  35 }
  36
  37 /*
  38  * @unimplemented
  39  */
  40 int
  41 STDCALL
  42 StretchDIBits(HDC hdc,
  43               int XDest,
  44               int YDest,
  45               int nDestWidth,
  46               int nDestHeight,
  47               int XSrc,
  48               int YSrc,
  49               int nSrcWidth,
  50               int nSrcHeight,
  51               CONST VOID *lpBits,
  52               CONST BITMAPINFO *lpBitsInfo,
  53               UINT iUsage,
  54               DWORD dwRop)
  55
  56 {
  57     /* FIXME share memory */
  58     return NtGdiStretchDIBits(hdc, XDest, YDest, nDestWidth, nDestHeight, XSrc, YSrc,
  59                               nSrcWidth, nSrcHeight, lpBits, lpBitsInfo, iUsage, dwRop);
  60 }
  61
  62 /*
  63  * @unimplemented
  64  */
  65 int
  66 STDCALL
  67 SetDIBits(HDC hdc,
  68           HBITMAP hbmp,
  69           UINT uStartScan,
  70           UINT cScanLines,
  71           CONST VOID *lpvBits,
  72           CONST BITMAPINFO *lpbmi,
  73           UINT fuColorUse)
  74 {
  75     /* FIXME share memory */
  76     return NtGdiSetDIBits(hdc, hbmp, uStartScan, cScanLines, lpvBits, lpbmi, fuColorUse);
  77 }
  78
  79 /*
  80  * @unimplemented
  81  */
  82 int
  83 STDCALL
  84 SetGraphicsMode(HDC hdc,
  85                 int iMode)
  86 {
  87     /* FIXME share memory */
  88     return NtGdiSetGraphicsMode(hdc, iMode);
  89 }
  90
  91 /*
  92  * @unimplemented
  93  */
  94 int
  95 STDCALL
  96 SetPolyFillMode(HDC hdc,
  97                 int iPolyFillMode)
  98 {
  99     /* FIXME share memory */
 100     return NtGdiSetPolyFillMode(hdc, iPolyFillMode);
 101 }
 102
 103 /*
 104  * @unimplemented
 105  */
 106 int
 107 STDCALL
 108 SetROP2(HDC hdc,
 109         int fnDrawMode)
 110 {
 111     UNIMPLEMENTED;
 112     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 113     return 0;
 114 }
 115
 116 /*
 117  * @unimplemented
 118  */
 119 int
 120 STDCALL
 121 SetStretchBltMode(HDC hdc, int iStretchMode)
 122 {
 123     /* FIXME share memory */
 124     return NtGdiSetStretchBltMode(hdc, iStretchMode);
 125 }
 126
 127 /*
 128  * @unimplemented
 129  */
 130 BOOL
 131 STDCALL
 132 SetRectRgn(HRGN hrgn,
 133            int nLeftRect,
 134            int nTopRect,
 135            int nRightRect,
 136            int nBottomRect)
 137 {
 138     /* FIXME metadc stuff */
 139     return NtGdiSetRectRgn(hrgn, nLeftRect, nTopRect, nRightRect, nBottomRect);
 140 }
 141
 142 /*
 143  * @unimplemented
 144  */
 145 UINT
 146 STDCALL
 147 SetTextAlign(HDC hdc,
 148              UINT fMode)
 149 {
 150     /* FIXME share memory */
 151     return NtGdiSetTextAlign(hdc, fMode);
 152 }
 153
 154 /*
 155  * @unimplemented
 156  */
 157 BOOL
 158 STDCALL
 159 SetViewportExtEx(HDC hdc,
 160                  int nXExtent,
 161                  int nYExtent,
 162                  LPSIZE lpSize)
 163 {
 164     /* FIXME share memory */
 165     return NtGdiSetViewportExtEx(hdc, nXExtent, nYExtent, lpSize);
 166 }
 167
 168 /*
 169  * @unimplemented
 170  */
 171 BOOL
 172 STDCALL
 173 SetWindowOrgEx(HDC hdc,
 174                int X,
 175                int Y,
 176                LPPOINT lpPoint)
 177 {
 178     /* FIXME share memory */
 179     return NtGdiSetWindowOrgEx(hdc,X,Y,lpPoint);
 180 }
 181
 182 /*
 183  * @unimplemented
 184  */
 185 BOOL
 186 STDCALL
 187 SetWindowExtEx(HDC hdc,
 188                int nXExtent,
 189                int nYExtent,
 190                LPSIZE lpSize)
 191 {
 192     /* FIXME share memory */
 193     return NtGdiSetWindowExtEx(hdc, nXExtent, nYExtent, lpSize);
 194 }
 195
 196 /*
 197  * @unimplemented
 198  */
 199 BOOL
 200 STDCALL
 201 SetViewportOrgEx(HDC hdc,
 202                  int X,
 203                  int Y,
 204                  LPPOINT lpPoint)
 205 {
 206     /* FIXME share memory */
 207     return NtGdiSetViewportOrgEx(hdc,X,Y,lpPoint);
 208 }
 209
 210 /*
 211  * @unimplemented
 212  */
 213 BOOL
 214 STDCALL
 215 SetBrushOrgEx(HDC hdc,
 216               int nXOrg,
 217               int nYOrg,
 218               LPPOINT lppt)
 219 {
 220     /* FIXME share memory */
 221     return NtGdiSetBrushOrg(hdc,nXOrg,nYOrg,lppt);
 222 }
 223
 224 /*
 225  * @unimplemented
 226  */
 227 BOOL
 228 STDCALL
 229 PtInRegion(IN HRGN hrgn,
 230            int x,
 231            int y)
 232 {
 233     /* FIXME some stuff at user mode need be fixed */
 234     return NtGdiPtInRegion(hrgn,x,y);
 235 }
 236
 237 /*
 238  * @unimplemented
 239  */
 240 BOOL
 241 STDCALL
 242 RectInRegion(HRGN hrgn,
 243              LPCRECT prcl)
 244 {
 245     /* FIXME some stuff at user mode need be fixed */
 246     return NtGdiRectInRegion(hrgn, (LPRECT) prcl);
 247 }
 248
 249 /*
 250  * @unimplemented
 251  */
 252 BOOL
 253 STDCALL
 254 RestoreDC(IN HDC hdc,
 255           IN INT iLevel)
 256 {
 257     /* FIXME Sharememory */
 258     return NtGdiRestoreDC(hdc, iLevel);
 259 }
 260
 261 /*
 262  * @unimplemented
 263  */
 264 INT
 265 STDCALL
 266 SaveDC(IN HDC hdc)
 267 {
 268     /* FIXME Sharememory */
 269     return NtGdiSaveDC(hdc);
 270 }
 271
 272
 273
 274 /*
 275  * @unimplemented
 276  */
 277 BOOL
 278 STDCALL
 279 CancelDC(HDC hdc)
 280 {
 281     UNIMPLEMENTED;
 282     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 283     return FALSE;
 284 }
 285
 286
 287 /*
 288  * @unimplemented
 289  */
 290 int
 291 STDCALL
 292 DrawEscape(HDC  hdc,
 293            int a1,
 294            int a2,
 295            LPCSTR a3)
 296 {
 297     UNIMPLEMENTED;
 298     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 299     return 0;
 300 }
 301
 302
 303 /*
 304  * @unimplemented
 305  */
 306 int
 307 STDCALL
 308 EnumObjects(HDC hdc,
 309             int a1,
 310             GOBJENUMPROC a2,
 311             LPARAM a3)
 312 {
 313     UNIMPLEMENTED;
 314     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 315     return 0;
 316 }
 317
 318 /*
 319  * @unimplemented
 320  */
 321 int
 322 STDCALL
 323 Escape(HDC hdc, INT escape, INT in_count, LPCSTR in_data, LPVOID out_data)
 324 {
 325         UNIMPLEMENTED;
 326         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 327         return 0;
 328 }
 329
 330 /*
 331  * @unimplemented
 332  */
 333 HRGN
 334 STDCALL
 335 ExtCreateRegion(
 336         CONST XFORM *   a0,
 337         DWORD           a1,
 338         CONST RGNDATA * a2
 339         )
 340 {
 341         UNIMPLEMENTED;
 342         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 343         return 0;
 344 }
 345
 346
 347 /*
 348  * @implemented
 349  */
 350 UINT
 351 STDCALL
 352 GetBoundsRect(
 353         HDC     hdc,
 354         LPRECT  lprcBounds,
 355         UINT    flags
 356         )
 357 {
 358     return NtGdiGetBoundsRect(hdc,lprcBounds,flags & DCB_RESET);
 359 }
 360
 361
 362 /*
 363  * @implemented
 364  */
 365 int
 366 STDCALL
 367 GetMetaRgn(HDC hdc,
 368            HRGN hrgn)
 369 {
 370     return NtGdiGetRandomRgn(hdc,hrgn,2);
 371 }
 372
 373
 374 /*
 375  * @unimplemented
 376  */
 377 UINT
 378 STDCALL
 379 GetMetaFileBitsEx(
 380         HMETAFILE       a0,
 381         UINT            a1,
 382         LPVOID          a2
 383         )
 384 {
 385         UNIMPLEMENTED;
 386         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 387         return 0;
 388 }
 389
 390
 391
 392 /*
 393  * @unimplemented
 394  */
 395 DWORD
 396 STDCALL
 397 GetFontLanguageInfo(
 398         HDC     hDc
 399         )
 400 {
 401         UNIMPLEMENTED;
 402         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 403         return 0;
 404 }
 405
 406 /*
 407  * @unimplemented
 408  */
 409 BOOL
 410 STDCALL
 411 PlayMetaFile(
 412         HDC             a0,
 413         HMETAFILE       a1
 414         )
 415 {
 416         UNIMPLEMENTED;
 417         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 418         return FALSE;
 419 }
 420
 421 /*
 422  * @unimplemented
 423  */
 424 BOOL
 425 STDCALL
 426 ResizePalette(
 427         HPALETTE        a0,
 428         UINT            a1
 429         )
 430 {
 431         UNIMPLEMENTED;
 432         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 433         return FALSE;
 434 }
 435
 436 /*
 437  * @unimplemented
 438  */
 439 int
 440 STDCALL
 441 SetMetaRgn(
 442         HDC     hdc
 443         )
 444 {
 445         UNIMPLEMENTED;
 446         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 447         return 0;
 448 }
 449
 450 /*
 451  * @implemented
 452  */
 453 UINT
 454 STDCALL
 455 SetBoundsRect(HDC hdc,
 456               CONST RECT *prc,
 457               UINT flags)
 458 {
 459     /* FIXME add check for vaildate the flags */
 460     return NtGdiSetBoundsRect(hdc, (LPRECT)prc, flags);
 461 }
 462
 463
 464 /*
 465  * @unimplemented
 466  */
 467 DWORD
 468 STDCALL
 469 SetMapperFlags(
 470         HDC     a0,
 471         DWORD   a1
 472         )
 473 {
 474         UNIMPLEMENTED;
 475         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 476         return 0;
 477 }
 478
 479 /*
 480  * @unimplemented
 481  */
 482 HMETAFILE
 483 STDCALL
 484 SetMetaFileBitsEx(
 485         UINT            a0,
 486         CONST BYTE      *a1
 487         )
 488 {
 489         UNIMPLEMENTED;
 490         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 491         return 0;
 492 }
 493
 494 /*
 495  * @unimplemented
 496  */
 497 BOOL
 498 STDCALL
 499 SetTextJustification(
 500         HDC     a0,
 501         int     a1,
 502         int     a2
 503         )
 504 {
 505         UNIMPLEMENTED;
 506         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 507         return FALSE;
 508 }
 509
 510 /*
 511  * @unimplemented
 512  */
 513 BOOL
 514 STDCALL
 515 UpdateColors(
 516         HDC     hdc
 517         )
 518 {
 519         UNIMPLEMENTED;
 520         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 521         return FALSE;
 522 }
 523
 524
 525 /*
 526  * @unimplemented
 527  */
 528 BOOL
 529 STDCALL
 530 PlayMetaFileRecord(
 531         HDC             a0,
 532         LPHANDLETABLE   a1,
 533         LPMETARECORD    a2,
 534         UINT            a3
 535         )
 536 {
 537         UNIMPLEMENTED;
 538         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 539         return FALSE;
 540 }
 541
 542
 543 /*
 544  * @unimplemented
 545  */
 546 BOOL
 547 STDCALL
 548 EnumMetaFile(
 549         HDC                     a0,
 550         HMETAFILE               a1,
 551         MFENUMPROC              a2,
 552         LPARAM                  a3
 553         )
 554 {
 555         UNIMPLEMENTED;
 556         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 557         return FALSE;
 558 }
 559
 560 /*
 561  * @unimplemented
 562  */
 563 BOOL
 564 STDCALL
 565 DeleteEnhMetaFile(
 566         HENHMETAFILE    a0
 567         )
 568 {
 569         UNIMPLEMENTED;
 570         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 571         return FALSE;
 572 }
 573
 574 /*
 575  * @unimplemented
 576  */
 577 BOOL
 578 STDCALL
 579 EnumEnhMetaFile(
 580         HDC             a0,
 581         HENHMETAFILE    a1,
 582         ENHMFENUMPROC   a2,
 583         LPVOID          a3,
 584         CONST RECT      *a4
 585         )
 586 {
 587         UNIMPLEMENTED;
 588         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 589         return FALSE;
 590 }
 591
 592 /*
 593  * @unimplemented
 594  */
 595 UINT
 596 STDCALL
 597 GetEnhMetaFileBits(
 598         HENHMETAFILE    a0,
 599         UINT            a1,
 600         LPBYTE          a2
 601         )
 602 {
 603         UNIMPLEMENTED;
 604         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 605         return 0;
 606 }
 607
 608
 609 /*
 610  * @unimplemented
 611  */
 612 UINT
 613 STDCALL
 614 GetEnhMetaFileHeader(
 615         HENHMETAFILE    a0,
 616         UINT            a1,
 617         LPENHMETAHEADER a2
 618         )
 619 {
 620         UNIMPLEMENTED;
 621         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 622         return 0;
 623 }
 624
 625 /*
 626  * @unimplemented
 627  */
 628 UINT
 629 STDCALL
 630 GetEnhMetaFilePaletteEntries(
 631         HENHMETAFILE    a0,
 632         UINT            a1,
 633         LPPALETTEENTRY  a2
 634         )
 635 {
 636         UNIMPLEMENTED;
 637         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 638         return 0;
 639 }
 640
 641 /*
 642  * @unimplemented
 643  */
 644 UINT
 645 STDCALL
 646 GetWinMetaFileBits(
 647         HENHMETAFILE    a0,
 648         UINT            a1,
 649         LPBYTE          a2,
 650         INT             a3,
 651         HDC             a4
 652         )
 653 {
 654         UNIMPLEMENTED;
 655         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 656         return 0;
 657 }
 658
 659
 660 /*
 661  * @unimplemented
 662  */
 663 BOOL
 664 STDCALL
 665 PlayEnhMetaFile(
 666         HDC             a0,
 667         HENHMETAFILE    a1,
 668         CONST RECT      *a2
 669         )
 670 {
 671         UNIMPLEMENTED;
 672         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 673         return FALSE;
 674 }
 675
 676
 677 /*
 678  * @unimplemented
 679  */
 680 BOOL
 681 STDCALL
 682 PlayEnhMetaFileRecord(
 683         HDC                     a0,
 684         LPHANDLETABLE           a1,
 685         CONST ENHMETARECORD     *a2,
 686         UINT                    a3
 687         )
 688 {
 689         UNIMPLEMENTED;
 690         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 691         return FALSE;
 692 }
 693
 694
 695 /*
 696  * @unimplemented
 697  */
 698 HENHMETAFILE
 699 STDCALL
 700 SetEnhMetaFileBits(
 701         UINT            a0,
 702         CONST BYTE      *a1
 703         )
 704 {
 705         UNIMPLEMENTED;
 706         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 707         return 0;
 708 }
 709
 710
 711 /*
 712  * @unimplemented
 713  */
 714 HENHMETAFILE
 715 STDCALL
 716 SetWinMetaFileBits(
 717         UINT                    a0,
 718         CONST BYTE              *a1,
 719         HDC                     a2,
 720         CONST METAFILEPICT      *a3)
 721 {
 722         UNIMPLEMENTED;
 723         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 724         return 0;
 725 }
 726
 727
 728 /*
 729  * @unimplemented
 730  */
 731 BOOL
 732 STDCALL
 733 GdiComment(
 734         HDC             hDC,
 735         UINT            bytes,
 736         CONST BYTE      *buffer
 737         )
 738 {
 739 #if 0
 740   if (GDI_HANDLE_GET_TYPE(hDC) == GDI_OBJECT_TYPE_EMF)
 741   {
 742      PLDC pLDC = GdiGetLDC(hDC);
 743      if ( !pLDC )
 744      {
 745         SetLastError(ERROR_INVALID_HANDLE);
 746         return FALSE;
 747      }
 748      if (pLDC->iType == LDC_EMFLDC)
 749      {          // Wine port
 750          return EMFDRV_GdiComment( hDC, bytes, buffer );
 751      }
 752   }
 753 #endif
 754   return FALSE;
 755 }
 756
 757
 758 /*
 759  * @unimplemented
 760  */
 761 BOOL
 762 STDCALL
 763 AngleArc(
 764         HDC     hdc,
 765         int     a1,
 766         int     a2,
 767         DWORD   a3,
 768         FLOAT   a4,
 769         FLOAT   a5
 770         )
 771 {
 772         UNIMPLEMENTED;
 773         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 774         return FALSE;
 775 }
 776
 777
 778 /*
 779  * @unimplemented
 780  */
 781 BOOL
 782 STDCALL
 783 SetColorAdjustment(
 784         HDC                     hdc,
 785         CONST COLORADJUSTMENT   *a1
 786         )
 787 {
 788         UNIMPLEMENTED;
 789         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 790         return FALSE;
 791 }
 792
 793 /*
 794  * @unimplemented
 795  */
 796 int
 797 STDCALL
 798 EndDoc(
 799         HDC     hdc
 800         )
 801 {
 802         UNIMPLEMENTED;
 803         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 804         return 0;
 805 }
 806
 807
 808 /*
 809  * @unimplemented
 810  */
 811 int
 812 STDCALL
 813 StartPage(
 814         HDC     hdc
 815         )
 816 {
 817         UNIMPLEMENTED;
 818         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 819         return 0;
 820 }
 821
 822
 823 /*
 824  * @unimplemented
 825  */
 826 int
 827 STDCALL
 828 EndPage(
 829         HDC     hdc
 830         )
 831 {
 832         UNIMPLEMENTED;
 833         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 834         return 0;
 835 }
 836
 837
 838 /*
 839  * @unimplemented
 840  */
 841 int
 842 STDCALL
 843 AbortDoc(
 844         HDC     hdc
 845         )
 846 {
 847         UNIMPLEMENTED;
 848         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 849         return 0;
 850 }
 851
 852
 853 /*
 854  * @unimplemented
 855  */
 856 int
 857 STDCALL
 858 SetAbortProc(
 859         HDC             hdc,
 860         ABORTPROC       a1
 861         )
 862 {
 863         UNIMPLEMENTED;
 864         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 865         return 0;
 866 }
 867
 868
 869 /*
 870  * @unimplemented
 871  */
 872 BOOL
 873 STDCALL
 874 ScaleViewportExtEx(
 875         HDC     a0,
 876         int     a1,
 877         int     a2,
 878         int     a3,
 879         int     a4,
 880         LPSIZE  a5
 881         )
 882 {
 883         UNIMPLEMENTED;
 884         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 885         return FALSE;
 886 }
 887
 888
 889 /*
 890  * @unimplemented
 891  */
 892 BOOL
 893 STDCALL
 894 ScaleWindowExtEx(
 895         HDC     a0,
 896         int     a1,
 897         int     a2,
 898         int     a3,
 899         int     a4,
 900         LPSIZE  a5
 901         )
 902 {
 903         UNIMPLEMENTED;
 904         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 905         return FALSE;
 906 }
 907
 908
 909 /*
 910  * @implemented
 911  */
 912 BOOL
 913 STDCALL
 914 UnrealizeObject(HGDIOBJ  hgdiobj)
 915 {
 916     BOOL retValue = TRUE;
 917
 918     if (GDI_HANDLE_GET_TYPE(hgdiobj) != GDI_OBJECT_TYPE_BRUSH)
 919     {
 920         retValue = NtGdiUnrealizeObject(hgdiobj);
 921     }
 922
 923     return retValue;
 924 }
 925
 926
 927 /*
 928  * @implemented
 929  */
 930 BOOL
 931 STDCALL
 932 GdiFlush()
 933 {
 934     NtGdiFlush();
 935     return TRUE;
 936 }
 937
 938
 939 /*
 940  * @unimplemented
 941  */
 942 int
 943 STDCALL
 944 SetICMMode(
 945         HDC     a0,
 946         int     a1
 947         )
 948 {
 949         UNIMPLEMENTED;
 950         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 951         return 0;
 952 }
 953
 954
 955 /*
 956  * @unimplemented
 957  */
 958 BOOL
 959 STDCALL
 960 CheckColorsInGamut(
 961         HDC     a0,
 962         LPVOID  a1,
 963         LPVOID  a2,
 964         DWORD   a3
 965         )
 966 {
 967         UNIMPLEMENTED;
 968         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 969         return FALSE;
 970 }
 971
 972
 973 /*
 974  * @unimplemented
 975  */
 976 HCOLORSPACE
 977 STDCALL
 978 GetColorSpace(HDC hDc)
 979 {
 980     UNIMPLEMENTED;
 981     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 982     return 0;
 983 }
 984
 985
 986 /*
 987  * @unimplemented
 988  */
 989 HCOLORSPACE
 990 STDCALL
 991 SetColorSpace(
 992         HDC             a0,
 993         HCOLORSPACE     a1
 994         )
 995 {
 996         UNIMPLEMENTED;
 997         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 998         return FALSE;
 999 }
1000
1001 /*
1002  * @implemented
1003  */
1004 BOOL
1005 STDCALL
1006 GetDeviceGammaRamp( HDC hdc,
1007                     LPVOID lpGammaRamp)
1008 {
1009     BOOL retValue = FALSE;
1010     if (lpGammaRamp == NULL)
1011     {
1012         SetLastError(ERROR_INVALID_PARAMETER);
1013     }
1014     else
1015     {
1016         retValue = NtGdiGetDeviceGammaRamp(hdc,lpGammaRamp);
1017     }
1018
1019     return retValue;
1020 }
1021
1022 /*
1023  * @implemented
1024  */
1025 BOOL
1026 STDCALL
1027 SetDeviceGammaRamp(HDC hdc,
1028                    LPVOID lpGammaRamp)
1029 {
1030     BOOL retValue = FALSE;
1031
1032     if (lpGammaRamp)
1033     {
1034         retValue = NtGdiSetDeviceGammaRamp(hdc, lpGammaRamp);
1035     }
1036     else
1037     {
1038         SetLastError(ERROR_INVALID_PARAMETER);
1039     }
1040
1041     return  retValue;
1042 }
1043
1044
1045 /*
1046  * @unimplemented
1047  */
1048 BOOL
1049 STDCALL
1050 ColorMatchToTarget(
1051         HDC     a0,
1052         HDC     a1,
1053         DWORD   a2
1054         )
1055 {
1056         UNIMPLEMENTED;
1057         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1058         return FALSE;
1059 }
1060
1061
1062 /*
1063  * @unimplemented
1064  */
1065 BOOL
1066 STDCALL
1067 wglCopyContext(
1068         HGLRC   a0,
1069         HGLRC   a1,
1070         UINT    a2
1071         )
1072 {
1073         UNIMPLEMENTED;
1074         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1075         return FALSE;
1076 }
1077
1078
1079 /*
1080  * @unimplemented
1081  */
1082 HGLRC
1083 STDCALL
1084 wglCreateContext(
1085         HDC     hDc
1086         )
1087 {
1088         UNIMPLEMENTED;
1089         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1090         return 0;
1091 }
1092
1093
1094 /*
1095  * @unimplemented
1096  */
1097 HGLRC
1098 STDCALL
1099 wglCreateLayerContext(
1100         HDC     hDc,
1101         int     a1
1102         )
1103 {
1104         UNIMPLEMENTED;
1105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1106         return 0;
1107 }
1108
1109
1110 /*
1111  * @unimplemented
1112  */
1113 BOOL
1114 STDCALL
1115 wglDeleteContext(
1116         HGLRC   a
1117         )
1118 {
1119         UNIMPLEMENTED;
1120         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1121         return FALSE;
1122 }
1123
1124
1125 /*
1126  * @unimplemented
1127  */
1128 HGLRC
1129 STDCALL
1130 wglGetCurrentContext(VOID)
1131 {
1132         UNIMPLEMENTED;
1133         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1134         return 0;
1135 }
1136
1137
1138 /*
1139  * @unimplemented
1140  */
1141 HDC
1142 STDCALL
1143 wglGetCurrentDC(VOID)
1144 {
1145         UNIMPLEMENTED;
1146         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1147         return 0;
1148 }
1149
1150
1151 /*
1152  * @unimplemented
1153  */
1154 PROC
1155 STDCALL
1156 wglGetProcAddress(
1157         LPCSTR          a0
1158         )
1159 {
1160         UNIMPLEMENTED;
1161         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1162         return 0;
1163 }
1164
1165
1166 /*
1167  * @unimplemented
1168  */
1169 BOOL
1170 STDCALL
1171 wglMakeCurrent(
1172         HDC     a0,
1173         HGLRC   a1
1174         )
1175 {
1176         UNIMPLEMENTED;
1177         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1178         return FALSE;
1179 }
1180
1181
1182 /*
1183  * @unimplemented
1184  */
1185 BOOL
1186 STDCALL
1187 wglShareLists(
1188         HGLRC   a0,
1189         HGLRC   a1
1190         )
1191 {
1192         UNIMPLEMENTED;
1193         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1194         return FALSE;
1195 }
1196
1197
1198 /*
1199  * @unimplemented
1200  */
1201 BOOL
1202 STDCALL
1203 wglDescribeLayerPlane(
1204         HDC                     a0,
1205         int                     a1,
1206         int                     a2,
1207         UINT                    a3,
1208         LPLAYERPLANEDESCRIPTOR  a4
1209         )
1210 {
1211         UNIMPLEMENTED;
1212         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1213         return FALSE;
1214 }
1215
1216
1217 /*
1218  * @unimplemented
1219  */
1220 int
1221 STDCALL
1222 wglSetLayerPaletteEntries(
1223         HDC             a0,
1224         int             a1,
1225         int             a2,
1226         int             a3,
1227         CONST COLORREF  *a4
1228         )
1229 {
1230         UNIMPLEMENTED;
1231         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1232         return 0;
1233 }
1234
1235
1236 /*
1237  * @unimplemented
1238  */
1239 int
1240 STDCALL
1241 wglGetLayerPaletteEntries(
1242         HDC             a0,
1243         int             a1,
1244         int             a2,
1245         int             a3,
1246         COLORREF        *a4
1247         )
1248 {
1249         UNIMPLEMENTED;
1250         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1251         return 0;
1252 }
1253
1254
1255 /*
1256  * @unimplemented
1257  */
1258 BOOL
1259 STDCALL
1260 wglRealizeLayerPalette(
1261         HDC             a0,
1262         int             a1,
1263         BOOL            a2
1264         )
1265 {
1266         UNIMPLEMENTED;
1267         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1268         return FALSE;
1269 }
1270
1271
1272 /*
1273  * @unimplemented
1274  */
1275 BOOL
1276 STDCALL
1277 wglSwapLayerBuffers(
1278         HDC             a0,
1279         UINT            a1
1280         )
1281 {
1282         UNIMPLEMENTED;
1283         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1284         return FALSE;
1285 }
1286
1287
1288 /* === AFTER THIS POINT I GUESS... =========
1289  * (based on stack size in Norlander's .def)
1290  * === WHERE ARE THEY DEFINED? =============
1291  */
1292
1293 /*
1294  * @unimplemented
1295  */
1296 DWORD
1297 STDCALL
1298 IsValidEnhMetaRecord(
1299         DWORD   a0,
1300         DWORD   a1
1301         )
1302 {
1303         UNIMPLEMENTED;
1304         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1305         return 0;
1306
1307 }
1308
1309 /*
1310  * @unimplemented
1311  */
1312 DWORD
1313 STDCALL
1314 IsValidEnhMetaRecordOffExt(
1315         DWORD   a0,
1316         DWORD   a1,
1317         DWORD   a2,
1318         DWORD   a3
1319         )
1320 {
1321         UNIMPLEMENTED;
1322         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1323         return 0;
1324
1325 }
1326
1327 /*
1328  * @unimplemented
1329  */
1330 DWORD
1331 STDCALL
1332 GetGlyphOutlineWow(
1333         DWORD   a0,
1334         DWORD   a1,
1335         DWORD   a2,
1336         DWORD   a3,
1337         DWORD   a4,
1338         DWORD   a5,
1339         DWORD   a6
1340         )
1341 {
1342         UNIMPLEMENTED;
1343         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1344         return 0;
1345 }
1346
1347 /*
1348  * @unimplemented
1349  */
1350 DWORD
1351 STDCALL
1352 gdiPlaySpoolStream(
1353         DWORD   a0,
1354         DWORD   a1,
1355         DWORD   a2,
1356         DWORD   a3,
1357         DWORD   a4,
1358         DWORD   a5
1359         )
1360 {
1361         UNIMPLEMENTED;
1362         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1363         return 0;
1364 }
1365
1366 /*
1367  * @unimplemented
1368  */
1369 HANDLE
1370 STDCALL
1371 AddFontMemResourceEx(
1372         PVOID pbFont,
1373         DWORD cbFont,
1374         PVOID pdv,
1375         DWORD *pcFonts
1376 )
1377 {
1378         UNIMPLEMENTED;
1379         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1380         return 0;
1381 }
1382
1383 /*
1384  * @unimplemented
1385  */
1386 int
1387 STDCALL
1388 AddFontResourceTracking(
1389         LPCSTR lpString,
1390         int unknown
1391 )
1392 {
1393         UNIMPLEMENTED;
1394         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1395         return 0;
1396 }
1397
1398
1399
1400 /*
1401  * @unimplemented
1402  */
1403 HBITMAP
1404 STDCALL
1405 ClearBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1406 {
1407         UNIMPLEMENTED;
1408         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1409         return 0;
1410 }
1411
1412 /*
1413  * @unimplemented
1414  */
1415 HBRUSH
1416 STDCALL
1417 ClearBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1418 {
1419         UNIMPLEMENTED;
1420         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1421         return 0;
1422 }
1423
1424 /*
1425  * @unimplemented
1426  */
1427 BOOL
1428 STDCALL
1429 ColorCorrectPalette(HDC hDC,HPALETTE hPalette,DWORD dwFirstEntry,DWORD dwNumOfEntries)
1430 {
1431         UNIMPLEMENTED;
1432         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1433         return 0;
1434 }
1435
1436 /*
1437  * @unimplemented
1438  */
1439 int
1440 STDCALL
1441 EndFormPage(HDC hdc)
1442 {
1443         UNIMPLEMENTED;
1444         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1445         return 0;
1446 }
1447
1448
1449
1450 /*
1451  * @unimplemented
1452  */
1453 DWORD
1454 STDCALL
1455 GdiAddGlsBounds(HDC hdc,LPRECT prc)
1456 {
1457         UNIMPLEMENTED;
1458         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1459         return 0;
1460 }
1461
1462 /*
1463  * @unimplemented
1464  */
1465 BOOL
1466 STDCALL
1467 GdiArtificialDecrementDriver(LPWSTR pDriverName,BOOL unknown)
1468 {
1469         UNIMPLEMENTED;
1470         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1471         return 0;
1472 }
1473
1474 /*
1475  * @unimplemented
1476  */
1477 BOOL
1478 STDCALL
1479 GdiCleanCacheDC(HDC hdc)
1480 {
1481         UNIMPLEMENTED;
1482         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1483         return 0;
1484 }
1485
1486 /*
1487  * @unimplemented
1488  */
1489 HDC
1490 STDCALL
1491 GdiConvertAndCheckDC(HDC hdc)
1492 {
1493         UNIMPLEMENTED;
1494         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1495         return 0;
1496 }
1497
1498 /*
1499  * @unimplemented
1500  */
1501 HENHMETAFILE
1502 STDCALL
1503 GdiConvertEnhMetaFile(HENHMETAFILE hmf)
1504 {
1505         UNIMPLEMENTED;
1506         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1507         return 0;
1508 }
1509
1510 /*
1511  * @unimplemented
1512  */
1513 BOOL
1514 STDCALL
1515 GdiDrawStream(HDC dc, ULONG l, VOID *v)
1516 {
1517         UNIMPLEMENTED;
1518         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1519         return 0;
1520 }
1521
1522 /*
1523  * @unimplemented
1524  */
1525 DWORD
1526 STDCALL
1527 GdiGetCodePage(HDC hdc)
1528 {
1529         UNIMPLEMENTED;
1530         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1531         return 0;
1532 }
1533
1534 /*
1535  * @unimplemented
1536  */
1537 HBRUSH
1538 STDCALL
1539 GdiGetLocalBrush(HBRUSH hbr)
1540 {
1541         UNIMPLEMENTED;
1542         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1543         return 0;
1544 }
1545
1546 /*
1547  * @unimplemented
1548  */
1549 HDC
1550 STDCALL
1551 GdiGetLocalDC(HDC hdc)
1552 {
1553         UNIMPLEMENTED;
1554         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1555         return 0;
1556 }
1557
1558 /*
1559  * @unimplemented
1560  */
1561 HFONT
1562 STDCALL
1563 GdiGetLocalFont(HFONT hfont)
1564 {
1565         UNIMPLEMENTED;
1566         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1567         return 0;
1568 }
1569
1570 /*
1571  * @unimplemented
1572  */
1573 BOOL
1574 STDCALL
1575 GdiIsMetaFileDC(HDC hdc)
1576 {
1577         UNIMPLEMENTED;
1578         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1579         return 0;
1580 }
1581
1582 /*
1583  * @unimplemented
1584  */
1585 BOOL
1586 STDCALL
1587 GdiIsMetaPrintDC(HDC hdc)
1588 {
1589     UNIMPLEMENTED;
1590     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1591     return 0;
1592 }
1593
1594 /*
1595  * @unimplemented
1596  */
1597 BOOL
1598 STDCALL
1599 GdiIsPlayMetafileDC(HDC hdc)
1600 {
1601     UNIMPLEMENTED;
1602     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1603     return 0;
1604 }
1605
1606 /*
1607  * @unimplemented
1608  */
1609 BOOL
1610 STDCALL
1611 GdiValidateHandle(HGDIOBJ hobj)
1612 {
1613     UNIMPLEMENTED;
1614     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1615     return 0;
1616 }
1617
1618 /*
1619  * @unimplemented
1620  */
1621 DWORD
1622 STDCALL
1623 GetBitmapAttributes(HBITMAP hbm)
1624 {
1625     UNIMPLEMENTED;
1626     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1627     return 0;
1628 }
1629
1630 /*
1631  * @unimplemented
1632  */
1633 DWORD
1634 STDCALL
1635 GetBrushAttributes(HBRUSH hbr)
1636 {
1637     UNIMPLEMENTED;
1638     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1639     return 0;
1640 }
1641
1642 /*
1643  * @unimplemented
1644  */
1645 BOOL
1646 STDCALL
1647 GetCharABCWidthsI(HDC hdc,
1648                   UINT giFirst,
1649                   UINT cgi,
1650                   LPWORD pgi,
1651                   LPABC lpabc
1652 )
1653 {
1654     UNIMPLEMENTED;
1655     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1656     return 0;
1657 }
1658
1659 /*
1660  * @unimplemented
1661  */
1662 BOOL
1663 STDCALL
1664 GetCharWidthI(HDC hdc,
1665               UINT giFirst,
1666               UINT cgi,
1667               LPWORD pgi,
1668               LPINT lpBuffer
1669 )
1670 {
1671     UNIMPLEMENTED;
1672     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1673     return 0;
1674 }
1675
1676
1677
1678 /*
1679  * @implemented
1680  */
1681 ULONG
1682 STDCALL
1683 GetEUDCTimeStamp(VOID)
1684 {
1685     return NtGdiGetEudcTimeStampEx(NULL,0,TRUE);
1686 }
1687
1688 /*
1689  * @implemented
1690  */
1691 ULONG
1692 STDCALL
1693 GetFontAssocStatus(HDC hdc)
1694 {
1695     ULONG retValue = 0;
1696
1697     if (hdc)
1698     {
1699         retValue = NtGdiQueryFontAssocInfo(hdc);
1700     }
1701
1702     return retValue;
1703 }
1704
1705 /*
1706  * @unimplemented
1707  */
1708 HFONT
1709 STDCALL
1710 GetHFONT(HDC dc)
1711 {
1712     UNIMPLEMENTED;
1713     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1714     return 0;
1715 }
1716
1717 /*
1718  * @unimplemented
1719  */
1720 DWORD
1721 STDCALL
1722 GetLayout(HDC hdc
1723 )
1724 {
1725     UNIMPLEMENTED;
1726     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1727     return 0;
1728 }
1729
1730 /*
1731  * @implemented
1732  */
1733 BOOL
1734 STDCALL
1735 GetTextExtentExPointWPri(HDC hdc,
1736                          LPWSTR lpwsz,
1737                          ULONG cwc,
1738                          ULONG dxMax,
1739                          ULONG *pcCh,
1740                          PULONG pdxOut,
1741                          LPSIZE psize)
1742 {
1743     return NtGdiGetTextExtentExW(hdc,lpwsz,cwc,dxMax,pcCh,pdxOut,psize,0);
1744 }
1745
1746 /*
1747  * @implemented
1748  */
1749 INT
1750 STDCALL
1751 GetTextFaceAliasW(HDC hdc,
1752                   int cChar,
1753                   LPWSTR pszOut)
1754 {
1755     INT retValue = 0;
1756     if ((!pszOut) || (cChar))
1757     {
1758         retValue = NtGdiGetTextFaceW(hdc,cChar,pszOut,TRUE);
1759     }
1760     else
1761     {
1762         SetLastError(ERROR_INVALID_PARAMETER);
1763     }
1764     return retValue;
1765 }
1766
1767
1768
1769 /*
1770  * @unimplemented
1771  */
1772 BOOL
1773 STDCALL
1774 MirrorRgn(HWND hwnd,HRGN hrgn)
1775 {
1776     UNIMPLEMENTED;
1777     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1778     return 0;
1779 }
1780
1781
1782
1783 /*
1784  * @unimplemented
1785  */
1786 DWORD
1787 STDCALL
1788 QueryFontAssocStatus(VOID)
1789 {
1790     UNIMPLEMENTED;
1791     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1792     return 0;
1793 }
1794
1795 /*
1796  * @implemented
1797  */
1798 BOOL
1799 STDCALL
1800 RemoveFontMemResourceEx(HANDLE fh)
1801 {
1802     BOOL retValue=0;
1803
1804     if (fh)
1805     {
1806         retValue = NtGdiRemoveFontMemResourceEx(fh);
1807     }
1808     else
1809     {
1810         SetLastError(ERROR_INVALID_PARAMETER);
1811     }
1812     return retValue;
1813 }
1814
1815 /*
1816  * @unimplemented
1817  */
1818 int
1819 STDCALL
1820 RemoveFontResourceTracking(LPCSTR lpString,int unknown)
1821 {
1822         UNIMPLEMENTED;
1823         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1824         return 0;
1825 }
1826
1827 /*
1828  * @unimplemented
1829  */
1830 HBITMAP
1831 STDCALL
1832 SetBitmapAttributes(HBITMAP hbm, DWORD dwFlags)
1833 {
1834         UNIMPLEMENTED;
1835         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1836         return 0;
1837 }
1838
1839 /*
1840  * @unimplemented
1841  */
1842 HBRUSH
1843 STDCALL
1844 SetBrushAttributes(HBRUSH hbm, DWORD dwFlags)
1845 {
1846         UNIMPLEMENTED;
1847         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1848         return 0;
1849 }
1850
1851 /*
1852  * @unimplemented
1853  */
1854 DWORD
1855 STDCALL
1856 SetLayout(HDC hdc,
1857           DWORD dwLayout)
1858 {
1859     UNIMPLEMENTED;
1860     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1861     return 0;
1862 }
1863
1864 /*
1865  * @unimplemented
1866  */
1867 DWORD
1868 STDCALL
1869 SetLayoutWidth(HDC hdc,LONG wox,DWORD dwLayout)
1870 {
1871     UNIMPLEMENTED;
1872     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1873     return 0;
1874 }
1875
1876
1877
1878 /*
1879  * @implemented
1880  */
1881 int
1882 STDCALL
1883 StartFormPage(HDC hdc)
1884 {
1885     return StartPage(hdc);
1886 }
1887
1888 /*
1889  * @unimplemented
1890  */
1891 VOID
1892 STDCALL
1893 UnloadNetworkFonts(DWORD unknown)
1894 {
1895     UNIMPLEMENTED;
1896     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1897 }
1898
1899 /*
1900  * @implemented
1901  */
1902 BOOL
1903 STDCALL
1904 GetTextExtentExPointI(HDC hdc,
1905                       LPWORD pgiIn,
1906                       int cgi,
1907                       int nMaxExtent,
1908                       LPINT lpnFit,
1909                       LPINT alpDx,
1910                       LPSIZE lpSize)
1911 {
1912     return NtGdiGetTextExtentExW(hdc,pgiIn,cgi,nMaxExtent,(ULONG *)lpnFit, (PULONG) alpDx,lpSize,1);
1913 }
1914
1915 /*
1916  * @implemented
1917  */
1918 BOOL
1919 STDCALL
1920 GetTextExtentPointI(HDC hdc,
1921                     LPWORD pgiIn,
1922                     int cgi,
1923                     LPSIZE lpSize)
1924 {
1925     return NtGdiGetTextExtent(hdc,pgiIn,cgi,lpSize,2);
1926 }
1927
1928
1929
1930
1931
1932 /*
1933  * @unimplemented
1934  */
1935 BOOL
1936 STDCALL
1937 GdiRealizationInfo(HDC hdc,
1938                    PREALIZATION_INFO pri)
1939 {
1940     UNIMPLEMENTED;
1941     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1942     return 0;
1943 }
1944
1945
1946
1947 /*
1948  * @unimplemented
1949  */
1950 BOOL
1951 STDCALL
1952 GetETM(HDC hdc,
1953        EXTTEXTMETRIC *petm)
1954 {
1955     UNIMPLEMENTED;
1956     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1957     return 0;
1958 }
1959
1960 /*
1961  * @unimplemented
1962  */
1963 BOOL
1964 STDCALL
1965 GdiAddGlsRecord(HDC hdc,
1966                 DWORD unknown1,
1967                 LPCSTR unknown2,
1968                 LPRECT unknown3)
1969 {
1970     UNIMPLEMENTED;
1971     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1972     return 0;
1973 }
1974
1975 /*
1976  * @unimplemented
1977  */
1978 HANDLE
1979 STDCALL
1980 GdiConvertMetaFilePict(HGLOBAL hMem)
1981 {
1982     UNIMPLEMENTED;
1983     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1984     return 0;
1985 }
1986
1987 /*
1988  * @implemented
1989  */
1990 DEVMODEW *
1991 STDCALL
1992 GdiConvertToDevmodeW(DEVMODEA *dm)
1993 {
1994     LPDEVMODEW dmw;
1995
1996     dmw = HEAP_alloc(sizeof(DEVMODEW));
1997     #define COPYS(f,len) MultiByteToWideChar ( CP_THREAD_ACP, 0, (LPSTR)dm->f, len, dmw->f, len )
1998     #define COPYN(f) dmw->f = dm->f
1999     COPYS(dmDeviceName, CCHDEVICENAME );
2000     COPYN(dmSpecVersion);
2001     COPYN(dmDriverVersion);
2002     switch ( dm->dmSize )
2003     {
2004         case SIZEOF_DEVMODEA_300:
2005             dmw->dmSize = SIZEOF_DEVMODEW_300;
2006             break;
2007         case SIZEOF_DEVMODEA_400:
2008             dmw->dmSize = SIZEOF_DEVMODEW_400;
2009             break;
2010         case SIZEOF_DEVMODEA_500:
2011             default: /* FIXME what to do??? */
2012                 dmw->dmSize = SIZEOF_DEVMODEW_500;
2013             break;
2014     }
2015     COPYN(dmDriverExtra);
2016     COPYN(dmFields);
2017     COPYN(dmPosition.x);
2018     COPYN(dmPosition.y);
2019     COPYN(dmScale);
2020     COPYN(dmCopies);
2021     COPYN(dmDefaultSource);
2022     COPYN(dmPrintQuality);
2023     COPYN(dmColor);
2024     COPYN(dmDuplex);
2025     COPYN(dmYResolution);
2026     COPYN(dmTTOption);
2027     COPYN(dmCollate);
2028     COPYS(dmFormName,CCHFORMNAME);
2029     COPYN(dmLogPixels);
2030     COPYN(dmBitsPerPel);
2031     COPYN(dmPelsWidth);
2032     COPYN(dmPelsHeight);
2033     COPYN(dmDisplayFlags); // aka dmNup
2034     COPYN(dmDisplayFrequency);
2035
2036     if ( dm->dmSize <= SIZEOF_DEVMODEA_300 )
2037     {
2038         return dmw; // we're done with 0x300 fields
2039     }
2040
2041     COPYN(dmICMMethod);
2042     COPYN(dmICMIntent);
2043     COPYN(dmMediaType);
2044     COPYN(dmDitherType);
2045     COPYN(dmReserved1);
2046     COPYN(dmReserved2);
2047
2048     if ( dm->dmSize <= SIZEOF_DEVMODEA_400 )
2049     {
2050         return dmw; // we're done with 0x400 fields
2051     }
2052
2053     COPYN(dmPanningWidth);
2054     COPYN(dmPanningHeight);
2055
2056     return dmw;
2057
2058     #undef COPYN
2059     #undef COPYS
2060 }
2061
2062 /*
2063  * @unimplemented
2064  */
2065 HENHMETAFILE
2066 STDCALL
2067 GdiCreateLocalEnhMetaFile(HENHMETAFILE hmo)
2068 {
2069     UNIMPLEMENTED;
2070     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2071     return 0;
2072 }
2073
2074 /*
2075  * @unimplemented
2076  */
2077 METAFILEPICT *
2078 STDCALL
2079 GdiCreateLocalMetaFilePict(HENHMETAFILE hmo)
2080 {
2081     UNIMPLEMENTED;
2082     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2083     return 0;
2084 }
2085
2086
2087 /*
2088  * @unimplemented
2089  */
2090 HANDLE
2091 STDCALL
2092 GdiGetSpoolFileHandle(LPWSTR pwszPrinterName,
2093                       LPDEVMODEW pDevmode,
2094                       LPWSTR pwszDocName)
2095 {
2096     UNIMPLEMENTED;
2097     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2098     return 0;
2099 }
2100
2101 /*
2102  * @unimplemented
2103  */
2104 BOOL
2105 STDCALL
2106 GdiDeleteSpoolFileHandle(HANDLE SpoolFileHandle)
2107 {
2108     UNIMPLEMENTED;
2109     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2110     return 0;
2111 }
2112
2113 /*
2114  * @unimplemented
2115  */
2116 DWORD
2117 STDCALL
2118 GdiGetPageCount(HANDLE SpoolFileHandle)
2119 {
2120     UNIMPLEMENTED;
2121     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2122     return 0;
2123 }
2124
2125 /*
2126  * @unimplemented
2127  */
2128 HDC
2129 STDCALL
2130 GdiGetDC(HANDLE SpoolFileHandle)
2131 {
2132     UNIMPLEMENTED;
2133     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2134     return 0;
2135 }
2136
2137 /*
2138  * @unimplemented
2139  */
2140 HANDLE
2141 STDCALL
2142 GdiGetPageHandle(HANDLE SpoolFileHandle,
2143                  DWORD Page,
2144                  LPDWORD pdwPageType)
2145 {
2146     UNIMPLEMENTED;
2147     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2148     return 0;
2149 }
2150
2151 /*
2152  * @unimplemented
2153  */
2154 BOOL
2155 STDCALL
2156 GdiStartDocEMF(HANDLE SpoolFileHandle,
2157                DOCINFOW *pDocInfo)
2158 {
2159     UNIMPLEMENTED;
2160     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2161     return 0;
2162 }
2163
2164 /*
2165  * @unimplemented
2166  */
2167 BOOL
2168 STDCALL
2169 GdiStartPageEMF(HANDLE SpoolFileHandle)
2170 {
2171     UNIMPLEMENTED;
2172     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2173     return 0;
2174 }
2175
2176 /*
2177  * @unimplemented
2178  */
2179 BOOL
2180 STDCALL
2181 GdiPlayPageEMF(HANDLE SpoolFileHandle,
2182                HANDLE hemf,
2183                RECT *prectDocument,
2184                RECT *prectBorder,
2185                RECT *prectClip)
2186 {
2187     UNIMPLEMENTED;
2188     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2189     return 0;
2190 }
2191
2192 /*
2193  * @unimplemented
2194  */
2195 BOOL
2196 STDCALL
2197 GdiEndPageEMF(HANDLE SpoolFileHandle,
2198               DWORD dwOptimization)
2199 {
2200     UNIMPLEMENTED;
2201     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2202     return 0;
2203 }
2204
2205 /*
2206  * @unimplemented
2207  */
2208 BOOL
2209 STDCALL
2210 GdiEndDocEMF(HANDLE SpoolFileHandle)
2211 {
2212     UNIMPLEMENTED;
2213     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2214     return 0;
2215 }
2216
2217 /*
2218  * @unimplemented
2219  */
2220 BOOL
2221 STDCALL
2222 GdiGetDevmodeForPage(HANDLE SpoolFileHandle,
2223                      DWORD dwPageNumber,
2224                      PDEVMODEW *pCurrDM,
2225                      PDEVMODEW *pLastDM)
2226 {
2227     UNIMPLEMENTED;
2228     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2229     return 0;
2230 }
2231
2232 /*
2233  * @unimplemented
2234  */
2235 BOOL
2236 STDCALL
2237 GdiResetDCEMF(HANDLE SpoolFileHandle,
2238               PDEVMODEW pCurrDM)
2239 {
2240     UNIMPLEMENTED;
2241     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2242     return 0;
2243 }
2244
2245
2246 HBITMAP
2247 STDCALL
2248 CreateDIBitmap(HDC hDc,
2249                const BITMAPINFOHEADER *Header,
2250                DWORD Init, LPCVOID Bits, const BITMAPINFO *Data,
2251                UINT ColorUse)
2252 {
2253     /* FIMXE we need do more thing in user mode */
2254     return NtGdiCreateDIBitmap(hDc, Header, Init, Bits, Data,  ColorUse);
2255 }
2256
2257 /*
2258  * @unimplemented
2259  */
2260 INT
2261 STDCALL
2262 CombineRgn(HRGN  hDest,
2263            HRGN  hSrc1,
2264            HRGN  hSrc2,
2265            INT  CombineMode)
2266 {
2267     /* FIXME some part should be done in user mode */
2268     return NtGdiCombineRgn(hDest, hSrc1, hSrc2, CombineMode);
2269 }
2270
2271 /*
2272  * @unimplemented
2273  */
2274 HBITMAP STDCALL
2275 CreateBitmap(INT  Width,
2276              INT  Height,
2277              UINT  Planes,
2278              UINT  BitsPixel,
2279              PCVOID pUnsafeBits)
2280 {
2281     /* FIXME some part should be done in user mode */
2282     return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
2283 }
2284
2285
2286
2287
2288 /*
2289  * @unimplemented
2290  */
2291 LPWSTR STDCALL
2292 EngGetDriverName(HDEV hdev)
2293 {
2294     UNIMPLEMENTED;
2295     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2296     return 0;
2297 }
2298
2299
2300
2301 /*
2302  * @unimplemented
2303  */
2304 INT STDCALL
2305 EngWideCharToMultiByte( UINT CodePage,
2306                         LPWSTR WideCharString,
2307                         INT BytesInWideCharString,
2308                         LPSTR MultiByteString,
2309                         INT BytesInMultiByteString)
2310 {
2311   return WideCharToMultiByte(
2312                          CodePage,
2313                          0,
2314                          WideCharString,
2315                         (BytesInWideCharString/sizeof(WCHAR)), /* Bytes to (in WCHARs) */
2316                          MultiByteString,
2317                          BytesInMultiByteString,
2318                          NULL,
2319                          NULL);
2320 }
2321
2322
2323 /*
2324  * @unimplemented
2325  */
2326 ULONG STDCALL
2327 XLATEOBJ_iXlate(XLATEOBJ *XlateObj,
2328                 ULONG Color)
2329 {
2330     UNIMPLEMENTED;
2331     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2332     return 0;
2333 }
2334
2335 /*
2336  * @unimplemented
2337  */
2338 ULONG *
2339 STDCALL
2340 XLATEOBJ_piVector(XLATEOBJ *XlateObj)
2341 {
2342     return XlateObj->pulXlate;
2343 }
2344
2345 /*
2346  * @unimplemented
2347  */
2348 BOOL
2349 STDCALL
2350 GdiPlayEMF(LPWSTR pwszPrinterName,
2351            LPDEVMODEW pDevmode,
2352            LPWSTR pwszDocName,
2353            EMFPLAYPROC pfnEMFPlayFn,
2354            HANDLE hPageQuery
2355 )
2356 {
2357     UNIMPLEMENTED;
2358     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2359     return 0;
2360 }
2361
2362
2363
2364 /*
2365  * @unimplemented
2366  */
2367 BOOL
2368 STDCALL
2369 GdiPlayPrivatePageEMF(HANDLE SpoolFileHandle,
2370                       DWORD unknown,
2371                       RECT *prectDocument)
2372 {
2373     UNIMPLEMENTED;
2374     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2375     return 0;
2376 }
2377
2378 /*
2379  * @unimplemented
2380  */
2381 VOID STDCALL GdiInitializeLanguagePack(DWORD InitParam)
2382 {
2383     UNIMPLEMENTED;
2384     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2385 }
2386
2387
2388 /*
2389  * @implemented
2390  */
2391 INT
2392 STDCALL
2393 ExcludeClipRect(IN HDC hdc, IN INT xLeft, IN INT yTop, IN INT xRight, IN INT yBottom)
2394 {
2395     /* FIXME some part need be done on user mode size */
2396     return NtGdiExcludeClipRect(hdc, xLeft, yTop, xRight, yBottom);
2397 }
2398
2399 /*
2400  * @implemented
2401  */
2402 INT
2403 STDCALL
2404 ExtSelectClipRgn( IN HDC hdc, IN HRGN hrgn, IN INT iMode)
2405 {
2406     /* FIXME some part need be done on user mode size */
2407     return NtGdiExtSelectClipRgn(hdc,hrgn, iMode);
2408 }
2409
2410 /*
2411  * @implemented
2412  */
2413 BOOL
2414 STDCALL
2415 GdiGradientFill(
2416     IN HDC hdc,
2417     IN PTRIVERTEX pVertex,
2418     IN ULONG nVertex,
2419     IN PVOID pMesh,
2420     IN ULONG nMesh,
2421     IN ULONG ulMode)
2422 {
2423     /* FIXME some part need be done in user mode */
2424     return NtGdiGradientFill(hdc, pVertex, nVertex, pMesh, nMesh, ulMode);
2425 }
2426
2427
2428 /*
2429  * @implemented
2430  */
2431 BOOL
2432 STDCALL
2433 GdiTransparentBlt(IN HDC hdcDst,
2434                   IN INT xDst,
2435                   IN INT yDst,
2436                   IN INT cxDst,
2437                   IN INT cyDst,
2438                   IN HDC hdcSrc,
2439                   IN INT xSrc,
2440                   IN INT ySrc,
2441                   IN INT cxSrc,
2442                   IN INT cySrc,
2443                   IN COLORREF TransColor
2444 )
2445 {
2446     /* FIXME some part need be done in user mode */
2447     return NtGdiTransparentBlt(hdcDst, xDst, yDst, cxDst, cyDst, hdcSrc, xSrc, ySrc, cxSrc, cySrc, TransColor);
2448 }
2449
2450 /*
2451  * @unimplemented
2452  */
2453 BOOL
2454 STDCALL
2455 GdiPrinterThunk(
2456     IN HUMPD humpd,
2457     DWORD *status,
2458     DWORD unuse)
2459 {
2460     /* FIXME figout the protypes, the HUMPD are a STRUCT or COM object */
2461     /* status contain some form of return value that being save, what it is I do not known */
2462     /* unsue seam have zero effect, what it is for I do not known */
2463
2464     // ? return NtGdiSetPUMPDOBJ(humpd->0x10,TRUE, humpd, ?) <- blackbox, OpenRCE info, and api hooks for anylaysing;
2465     return FALSE;
2466 }
2467
2468 /*
2469  * @unimplemented
2470  *
2471  */
2472 HBITMAP
2473 STDCALL
2474 GdiConvertBitmapV5(
2475     HBITMAP in_format_BitMap,
2476     HBITMAP src_BitMap,
2477     INT bpp,
2478     INT unuse)
2479 {
2480     /* FIXME guessing the prototypes */
2481
2482     /*
2483      * it have create a new bitmap with desired in format,
2484      * then convert it src_bitmap to new format
2485      * and return it as HBITMAP
2486      */
2487
2488     return FALSE;
2489 }
2490
2491
2492 /*
2493  * @implemented
2494  *
2495  */
2496 COLORREF
2497 STDCALL
2498 GetBkColor(HDC hdc)
2499 {
2500     /* FIXME some part are done in user mode */
2501     return NtGdiGetBkColor(hdc);
2502 }
2503
2504 /*
2505  * @implemented
2506  *
2507  */
2508 int
2509 STDCALL
2510 GetBkMode(HDC hdc)
2511 {
2512     /* FIXME some part are done in user mode */
2513     return NtGdiGetBkMode(hdc);
2514 }
2515
2516 /*
2517  * @implemented
2518  *
2519  */
2520 BOOL
2521 STDCALL
2522 GetBrushOrgEx(HDC hdc,LPPOINT pt)
2523 {
2524     /* FIXME some part are done in user mode */
2525     return NtGdiGetBrushOrgEx(hdc,pt);
2526 }
2527
2528 /*
2529  * @implemented
2530  *
2531  */
2532 BOOL
2533 STDCALL
2534 GetCharABCWidthsFloatW(HDC hdc,UINT FirstChar,UINT LastChar,LPABCFLOAT abcF)
2535 {
2536     /* FIXME some part are done in user mode */
2537     return NtGdiGetCharABCWidthsFloat(hdc, FirstChar, LastChar, abcF);
2538 }
2539
2540 /*
2541  * @implemented
2542  *
2543  */
2544 int
2545 STDCALL
2546 GetDeviceCaps(HDC hdc,
2547               int i)
2548 {
2549     /* FIXME some part need be done in user mode */
2550     return NtGdiGetDeviceCaps(hdc,i);
2551 }
2552
2553
2554 /*
2555  * @implemented
2556  *
2557  */
2558 BOOL
2559 STDCALL
2560 GetCurrentPositionEx(HDC hdc,
2561                      LPPOINT lpPoint)
2562 {
2563     /* FIXME some part need be done in user mode */
2564     return  NtGdiGetCurrentPositionEx(hdc, lpPoint);
2565 }
2566
2567 /*
2568  * @implemented
2569  *
2570  */
2571 int
2572 STDCALL
2573 GetClipBox(HDC hdc,
2574            LPRECT lprc)
2575 {
2576     /* FIXME some part need be done in user mode */
2577     return  NtGdiGetClipBox(hdc, lprc);
2578 }
2579
2580 /*
2581  * @implemented
2582  *
2583  */
2584 BOOL
2585 STDCALL
2586 GetCharWidthFloatW(HDC hdc,
2587                    UINT iFirstChar,
2588                    UINT iLastChar,
2589                    PFLOAT pxBuffer)
2590 {
2591     /* FIXME some part need be done in user mode */
2592     return NtGdiGetCharWidthFloat(hdc, iFirstChar, iLastChar, pxBuffer);
2593 }
2594
2595 /*
2596  * @implemented
2597  *
2598  */
2599 BOOL
2600 STDCALL
2601 GetCharWidth32W(HDC hdc,
2602                UINT iFirstChar,
2603                UINT iLastChar,
2604                LPINT lpBuffer)
2605 {
2606     /* FIXME some part need be done in user mode */
2607     return NtGdiGetCharWidth32(hdc, iFirstChar, iLastChar, lpBuffer);
2608 }
2609
2610 /*
2611  * @implemented
2612  *
2613  */
2614 BOOL
2615 STDCALL
2616 GetCharABCWidths(HDC hdc,
2617                  UINT uFirstChar,
2618                  UINT uLastChar,
2619                  LPABC lpabc)
2620 {
2621     /* FIXME some part need be done in user mode */
2622     return NtGdiGetCharABCWidths(hdc, uFirstChar, uLastChar, lpabc);
2623 }
2624
2625
2626 /*
2627  * @implemented
2628  *
2629  */
2630 DWORD
2631 STDCALL
2632 GetFontData(HDC hdc,
2633             DWORD dwTable,
2634             DWORD dwOffset,
2635             LPVOID lpvBuffer,
2636             DWORD cbData)
2637 {
2638     if (!lpvBuffer)
2639     {
2640        cbData = 0;
2641     }
2642     return NtGdiGetFontData(hdc, dwTable, dwOffset, lpvBuffer, cbData);
2643 }
2644
2645
2646 /*
2647  * @implemented
2648  *
2649  */
2650 DWORD
2651 STDCALL
2652 GetRegionData(HRGN hrgn,
2653               DWORD nCount,
2654               LPRGNDATA lpRgnData)
2655 {
2656     if (!lpRgnData)
2657     {
2658         nCount = 0;
2659     }
2660
2661     return NtGdiGetRegionData(hrgn,nCount,lpRgnData);
2662 }
2663
2664
2665 /*
2666  * @implemented
2667  *
2668  */
2669 INT
2670 STDCALL
2671 GetRgnBox(HRGN hrgn,
2672           LPRECT prcOut)
2673 {
2674     /* FIXME some stuff need be done in user mode */
2675     return NtGdiGetRgnBox(hrgn, prcOut);
2676 }
2677
2678
2679 /*
2680  * @implemented
2681  *
2682  */
2683 INT
2684 STDCALL
2685 OffsetRgn( HRGN hrgn,
2686           int nXOffset,
2687           int nYOffset)
2688 {
2689     /* FIXME some part are done in user mode */
2690     return NtGdiOffsetRgn(hrgn,nXOffset,nYOffset);
2691 }
2692
2693
2694 INT
2695 STDCALL
2696 GetTextCharsetInfo(HDC hdc,
2697                    LPFONTSIGNATURE lpSig,
2698                    DWORD dwFlags)
2699 {
2700     /* FIXME some part are done in user mode */
2701     return NtGdiGetTextCharsetInfo(hdc, lpSig, dwFlags);
2702 }
2703
2704
2705
2706 INT
2707 STDCALL
2708 IntersectClipRect(HDC hdc,
2709                   int nLeftRect,
2710                   int nTopRect,
2711                   int nRightRect,
2712                   int nBottomRect)
2713 {
2714     /* FIXME some part are done in user mode */
2715     return NtGdiIntersectClipRect(hdc, nLeftRect, nTopRect, nRightRect, nBottomRect);
2716 }
2717
2718 INT
2719 STDCALL
2720 OffsetClipRgn(HDC hdc,
2721               int nXOffset,
2722               int nYOffset)
2723 {
2724     /* FIXME some part are done in user mode */
2725     return NtGdiOffsetClipRgn( hdc,  nXOffset,  nYOffset);
2726 }
2727
2728
2729 INT
2730 STDCALL
2731 NamedEscape(HDC hdc,
2732             PWCHAR pDriver,
2733             INT iEsc,
2734             INT cjIn,
2735             LPSTR pjIn,
2736             INT cjOut,
2737             LPSTR pjOut)
2738 {
2739     /* FIXME metadc, metadc are done most in user mode, and we do not support it
2740      * Windows 2000/XP/Vista ignore the current hdc, that are being pass and always set hdc to NULL
2741      * when it calls to NtGdiExtEscape from NamedEscape
2742      */
2743     return NtGdiExtEscape(NULL,pDriver,wcslen(pDriver),iEsc,cjIn,pjIn,cjOut,pjOut);
2744 }
2745
2746
2747 BOOL
2748 STDCALL
2749 PatBlt(HDC hdc,
2750        int nXLeft,
2751        int nYLeft,
2752        int nWidth,
2753        int nHeight,
2754        DWORD dwRop)
2755 {
2756     /* FIXME some part need be done in user mode */
2757     return NtGdiPatBlt( hdc,  nXLeft,  nYLeft,  nWidth,  nHeight,  dwRop);
2758 }
2759
2760 BOOL
2761 STDCALL
2762 PolyPatBlt(IN HDC hdc,
2763            IN DWORD rop4,
2764            IN PPOLYPATBLT pPoly,
2765            IN DWORD Count,
2766            IN DWORD Mode)
2767 {
2768     /* FIXME some part need be done in user mode */
2769     return NtGdiPolyPatBlt(hdc, rop4, pPoly,Count,Mode);
2770 }
2771
2772
2773
2774
2775
2776
2777
2778
2779