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