reactos/dll/win32/gdi32/misc/stubs.c

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