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