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