reactos/lib/gdi32/misc/stubsa.c

   1 /* $Id: stubsa.c,v 1.16 2003/07/21 19:05:52 royce Exp $
   2  *
   3  * reactos/lib/gdi32/misc/stubs.c
   4  *
   5  * GDI32.DLL Stubs for ANSI functions
   6  *
   7  * When you implement one of these functions,
   8  * remove its stub from this file.
   9  *
  10  */
  11 #ifdef UNICODE
  12 #undef UNICODE
  13 #endif
  14
  15 #undef WIN32_LEAN_AND_MEAN
  16 #include <windows.h>
  17 #include <ddk/ntddk.h>
  18 #include <win32k/text.h>
  19 #include <win32k/metafile.h>
  20 #include <win32k/dc.h>
  21 #include <rosrtl/devmode.h>
  22 #include <rosrtl/logfont.h>
  23
  24 /*
  25  * @implemented
  26  */
  27 int
  28 STDCALL
  29 AddFontResourceExA ( LPCSTR lpszFilename, DWORD fl, PVOID pvReserved )
  30 {
  31   NTSTATUS Status;
  32   UNICODE_STRING FilenameU;
  33   int rc;
  34
  35   Status = RtlCreateUnicodeStringFromAsciiz ( &FilenameU,
  36                                               (PCSZ)lpszFilename );
  37   if (!NT_SUCCESS (Status))
  38     {
  39       SetLastError (RtlNtStatusToDosError(Status));
  40       return 0;
  41     }
  42
  43   rc = AddFontResourceExW ( FilenameU.Buffer, fl, pvReserved );
  44
  45   RtlFreeUnicodeString ( &FilenameU );
  46
  47   return rc;
  48 }
  49
  50 /*
  51  * @implemented
  52  */
  53 int
  54 STDCALL
  55 AddFontResourceA ( LPCSTR lpszFilename )
  56 {
  57   return AddFontResourceExA ( lpszFilename, 0, 0 );
  58 }
  59
  60
  61 /*
  62  * @implemented
  63  */
  64 HMETAFILE
  65 STDCALL
  66 CopyMetaFileA(
  67         HMETAFILE       Src,
  68         LPCSTR          lpszFile
  69         )
  70 {
  71   NTSTATUS Status;
  72   UNICODE_STRING FileU;
  73   HMETAFILE rc;
  74
  75   Status = RtlCreateUnicodeStringFromAsciiz ( &FileU,
  76                                               (PCSZ)lpszFile );
  77   if (!NT_SUCCESS (Status))
  78     {
  79       SetLastError (RtlNtStatusToDosError(Status));
  80       return 0;
  81     }
  82
  83   rc = W32kCopyMetaFile ( Src, FileU.Buffer );
  84
  85   RtlFreeUnicodeString ( &FileU );
  86
  87   return rc;
  88 }
  89
  90
  91 /*
  92  * @implemented
  93  */
  94 HDC
  95 STDCALL
  96 CreateICA(
  97         LPCSTR                  lpszDriver,
  98         LPCSTR                  lpszDevice,
  99         LPCSTR                  lpszOutput,
 100         CONST DEVMODEA *        lpdvmInit
 101         )
 102 {
 103   NTSTATUS Status;
 104   UNICODE_STRING Driver, Device, Output;
 105   DEVMODEW dvmInitW;
 106   HDC rc;
 107
 108   Status = RtlCreateUnicodeStringFromAsciiz ( &Driver,
 109                                               (PCSZ)lpszDriver );
 110   if (!NT_SUCCESS (Status))
 111     {
 112       SetLastError (RtlNtStatusToDosError(Status));
 113       return 0;
 114     }
 115
 116   Status = RtlCreateUnicodeStringFromAsciiz ( &Device,
 117                                               (PCSZ)lpszDevice );
 118   if (!NT_SUCCESS (Status))
 119     {
 120       SetLastError (RtlNtStatusToDosError(Status));
 121       return 0;
 122     }
 123
 124   Status = RtlCreateUnicodeStringFromAsciiz ( &Output,
 125                                               (PCSZ)lpszOutput );
 126   if (!NT_SUCCESS (Status))
 127     {
 128       SetLastError (RtlNtStatusToDosError(Status));
 129       return 0;
 130     }
 131
 132   if ( lpdvmInit )
 133     RosRtlDevModeA2W ( &dvmInitW, (const LPDEVMODEA)lpdvmInit );
 134
 135   rc = W32kCreateIC ( Driver.Buffer,
 136                       Device.Buffer,
 137                       Output.Buffer,
 138                       lpdvmInit ? &dvmInitW : NULL );
 139
 140   RtlFreeUnicodeString ( &Output );
 141   RtlFreeUnicodeString ( &Device );
 142   RtlFreeUnicodeString ( &Driver );
 143
 144   return rc;
 145 }
 146
 147
 148 /*
 149  * @implemented
 150  */
 151 HDC
 152 STDCALL
 153 CreateMetaFileA(
 154         LPCSTR          lpszFile
 155         )
 156 {
 157   HDC rc;
 158   NTSTATUS Status;
 159   UNICODE_STRING File;
 160
 161   Status = RtlCreateUnicodeStringFromAsciiz ( &File,
 162                                               (PCSZ)lpszFile );
 163   if (!NT_SUCCESS (Status))
 164     {
 165       SetLastError (RtlNtStatusToDosError(Status));
 166       return 0;
 167     }
 168
 169   rc = W32kCreateMetaFile ( File.Buffer );
 170
 171   RtlFreeUnicodeString ( &File );
 172
 173   return rc;
 174 }
 175
 176
 177 /*
 178  * @implemented
 179  */
 180 BOOL
 181 STDCALL
 182 CreateScalableFontResourceA(
 183         DWORD           fdwHidden,
 184         LPCSTR          lpszFontRes,
 185         LPCSTR          lpszFontFile,
 186         LPCSTR          lpszCurrentPath
 187         )
 188 {
 189   NTSTATUS Status;
 190   UNICODE_STRING FontRes, FontFile, CurrentPath;
 191   BOOL rc;
 192
 193   Status = RtlCreateUnicodeStringFromAsciiz ( &FontRes,
 194                                               (PCSZ)lpszFontRes );
 195   if (!NT_SUCCESS (Status))
 196     {
 197       SetLastError (RtlNtStatusToDosError(Status));
 198       return 0;
 199     }
 200
 201   Status = RtlCreateUnicodeStringFromAsciiz ( &FontFile,
 202                                               (PCSZ)lpszFontFile );
 203   if (!NT_SUCCESS (Status))
 204     {
 205       SetLastError (RtlNtStatusToDosError(Status));
 206       return 0;
 207     }
 208
 209   Status = RtlCreateUnicodeStringFromAsciiz ( &CurrentPath,
 210                                               (PCSZ)lpszCurrentPath );
 211   if (!NT_SUCCESS (Status))
 212     {
 213       SetLastError (RtlNtStatusToDosError(Status));
 214       return 0;
 215     }
 216
 217   return W32kCreateScalableFontResource ( fdwHidden,
 218                                           FontRes.Buffer,
 219                                           FontFile.Buffer,
 220                                           CurrentPath.Buffer );
 221
 222   RtlFreeUnicodeString ( &FontRes );
 223   RtlFreeUnicodeString ( &FontFile );
 224   RtlFreeUnicodeString ( &CurrentPath );
 225
 226   return rc;
 227 }
 228
 229
 230 /*
 231  * @unimplemented
 232  */
 233 int
 234 STDCALL
 235 DeviceCapabilitiesExA(
 236         LPCSTR          pDevice,
 237         LPCSTR          pPort,
 238         WORD            fwCapability,
 239         LPSTR           pOutput,
 240         CONST DEVMODEA  *pDevMode
 241         )
 242 {
 243 #if 0
 244   NTSTATUS Status;
 245   UNICODE_STRING Device, Port, Output;
 246   DEVMODEW DevModeW;
 247   int rc;
 248
 249   Status = RtlCreateUnicodeStringFromAsciiz ( &Device,
 250                                               (PCSZ)pDevice );
 251   if (!NT_SUCCESS (Status))
 252     {
 253       SetLastError (RtlNtStatusToDosError(Status));
 254       return 0;
 255     }
 256
 257   Status = RtlCreateUnicodeStringFromAsciiz ( &Port,
 258                                               (PCSZ)pPort );
 259   if (!NT_SUCCESS (Status))
 260     {
 261       SetLastError (RtlNtStatusToDosError(Status));
 262       return 0;
 263     }
 264
 265   Status = RtlCreateUnicodeStringFromAsciiz ( &Output,
 266                                               (PCSZ)pOutput );
 267   if (!NT_SUCCESS (Status))
 268     {
 269       SetLastError (RtlNtStatusToDosError(Status));
 270       return 0;
 271     }
 272
 273   if ( pDevMode )
 274     RosRtlDevModeA2W ( &DevModeW, (const LPDEVMODEA)pDevMode );
 275
 276   /* FIXME no W32kDeviceCapabilities???? */
 277   rc = W32kDeviceCapabilities ( Device.Buffer,
 278                       Port.Buffer,
 279                       fwCapability
 280                       Output.Buffer,
 281                       pDevMode ? &DevModeW : NULL );
 282
 283   RtlFreeUnicodeString ( &Device );
 284   RtlFreeUnicodeString ( &Port );
 285   RtlFreeUnicodeString ( &Output );
 286
 287   return rc;
 288 #else
 289   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 290   return 0;
 291 #endif
 292 }
 293
 294
 295 /*
 296  * @implemented
 297  */
 298 int
 299 STDCALL
 300 EnumFontFamiliesExA(
 301         HDC             hdc,
 302         LPLOGFONTA      lpLogFont,
 303         FONTENUMEXPROC  lpEnumFontFamProc,
 304         LPARAM          lParam,
 305         DWORD           dwFlags
 306         )
 307 {
 308   LOGFONTW LogFontW;
 309
 310   RosRtlLogFontA2W ( &LogFontW, lpLogFont );
 311
 312   /* no need to convert LogFontW back to lpLogFont b/c it's an [in] parameter only */
 313   return W32kEnumFontFamiliesEx ( hdc, &LogFontW, lpEnumFontFamProc, lParam, dwFlags );
 314 }
 315
 316
 317 /*
 318  * @implemented
 319  */
 320 int
 321 STDCALL
 322 EnumFontFamiliesA(
 323         HDC             hdc,
 324         LPCSTR          lpszFamily,
 325         FONTENUMPROC    lpEnumFontFamProc,
 326         LPARAM          lParam
 327         )
 328 {
 329   NTSTATUS Status;
 330   UNICODE_STRING Family;
 331   int rc;
 332
 333   Status = RtlCreateUnicodeStringFromAsciiz ( &Family,
 334                                               (PCSZ)lpszFamily );
 335   if (!NT_SUCCESS (Status))
 336     {
 337       SetLastError (RtlNtStatusToDosError(Status));
 338       return 0;
 339     }
 340
 341   rc = W32kEnumFontFamilies ( hdc, Family.Buffer, lpEnumFontFamProc, lParam );
 342
 343   RtlFreeUnicodeString ( &Family );
 344
 345   return rc;
 346 }
 347
 348
 349 /*
 350  * @implemented
 351  */
 352 int
 353 STDCALL
 354 EnumFontsA (
 355         HDC  hDC,
 356         LPCSTR lpFaceName,
 357         FONTENUMPROC  FontFunc,
 358         LPARAM  lParam
 359         )
 360 {
 361   NTSTATUS Status;
 362   UNICODE_STRING FaceName;
 363   int rc;
 364
 365   Status = RtlCreateUnicodeStringFromAsciiz ( &FaceName,
 366                                               (PCSZ)lpFaceName );
 367   if (!NT_SUCCESS (Status))
 368     {
 369       SetLastError (RtlNtStatusToDosError(Status));
 370       return 0;
 371     }
 372
 373   rc = W32kEnumFonts ( hDC, FaceName.Buffer, FontFunc, lParam );
 374
 375   RtlFreeUnicodeString ( &FaceName );
 376
 377   return rc;
 378 }
 379
 380
 381 /*
 382  * @implemented
 383  */
 384 BOOL
 385 STDCALL
 386 GetCharWidthA (
 387         HDC     hdc,
 388         UINT    iFirstChar,
 389         UINT    iLastChar,
 390         LPINT   lpBuffer
 391         )
 392 {
 393   return W32kGetCharWidth ( hdc, iFirstChar, iLastChar, lpBuffer );
 394 }
 395
 396
 397 /*
 398  * @implemented
 399  */
 400 BOOL
 401 STDCALL
 402 GetCharWidth32A(
 403         HDC     hdc,
 404         UINT    iFirstChar,
 405         UINT    iLastChar,
 406         LPINT   lpBuffer
 407         )
 408 {
 409   return W32kGetCharWidth32 ( hdc, iFirstChar, iLastChar, lpBuffer );
 410 }
 411
 412
 413 /*
 414  * @implemented
 415  */
 416 BOOL
 417 APIENTRY
 418 GetCharWidthFloatA(
 419         HDC     hdc,
 420         UINT    iFirstChar,
 421         UINT    iLastChar,
 422         PFLOAT  pxBuffer
 423         )
 424 {
 425   return W32kGetCharWidthFloat ( hdc, iFirstChar, iLastChar, pxBuffer );
 426 }
 427
 428
 429 /*
 430  * @implemented
 431  */
 432 BOOL
 433 APIENTRY
 434 GetCharABCWidthsA(
 435         HDC     hdc,
 436         UINT    uFirstChar,
 437         UINT    uLastChar,
 438         LPABC   lpabc
 439         )
 440 {
 441   return W32kGetCharABCWidths ( hdc, uFirstChar, uLastChar, lpabc );
 442 }
 443
 444
 445 /*
 446  * @implemented
 447  */
 448 BOOL
 449 APIENTRY
 450 GetCharABCWidthsFloatA(
 451         HDC             hdc,
 452         UINT            iFirstChar,
 453         UINT            iLastChar,
 454         LPABCFLOAT      lpABCF
 455         )
 456 {
 457   return W32kGetCharABCWidthsFloat ( hdc, iFirstChar, iLastChar, lpABCF );
 458 }
 459
 460
 461 /*
 462  * @implemented
 463  */
 464 DWORD
 465 STDCALL
 466 GetGlyphOutlineA(
 467         HDC             hdc,
 468         UINT            uChar,
 469         UINT            uFormat,
 470         LPGLYPHMETRICS  lpgm,
 471         DWORD           cbBuffer,
 472         LPVOID          lpvBuffer,
 473         CONST MAT2      *lpmat2
 474         )
 475 {
 476   return W32kGetGlyphOutline ( hdc, uChar, uFormat, lpgm, cbBuffer, lpvBuffer, (CONST LPMAT2)lpmat2 );
 477 }
 478
 479
 480 /*
 481  * @implemented
 482  */
 483 HMETAFILE
 484 STDCALL
 485 GetMetaFileA(
 486         LPCSTR  lpszMetaFile
 487         )
 488 {
 489   NTSTATUS Status;
 490   UNICODE_STRING MetaFile;
 491   HMETAFILE rc;
 492
 493   Status = RtlCreateUnicodeStringFromAsciiz ( &MetaFile,
 494                                               (PCSZ)lpszMetaFile );
 495   if (!NT_SUCCESS (Status))
 496     {
 497       SetLastError (RtlNtStatusToDosError(Status));
 498       return 0;
 499     }
 500
 501   rc = W32kGetMetaFile ( MetaFile.Buffer );
 502
 503   RtlFreeUnicodeString ( &MetaFile );
 504
 505   return rc;
 506 }
 507
 508
 509 /*
 510  * @unimplemented
 511  */
 512 UINT
 513 APIENTRY
 514 GetOutlineTextMetricsA(
 515         HDC                     hdc,
 516         UINT                    cbData,
 517         LPOUTLINETEXTMETRICA    lpOTM
 518         )
 519 {
 520   SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 521   return 0;
 522 }
 523
 524
 525 /*
 526  * @unimplemented
 527  */
 528 BOOL
 529 APIENTRY
 530 GetTextExtentExPointA(
 531         HDC             hdc,
 532         LPCSTR          lpszStr,
 533         int             cchString,
 534         int             nMaxExtent,
 535         LPINT           lpnFit,
 536         LPINT           alpDx,
 537         LPSIZE          lpSize
 538         )
 539 {
 540   NTSTATUS Status;
 541   UNICODE_STRING Str;
 542   BOOL rc;
 543
 544   Status = RtlCreateUnicodeStringFromAsciiz ( &Str,
 545                                               (PCSZ)lpszStr );
 546   if (!NT_SUCCESS (Status))
 547     {
 548       SetLastError (RtlNtStatusToDosError(Status));
 549       return 0;
 550     }
 551
 552   rc = W32kGetTextExtentExPoint (
 553     hdc, Str.Buffer, cchString, nMaxExtent, lpnFit, alpDx, lpSize );
 554
 555   RtlFreeUnicodeString ( &Str );
 556
 557   return rc;
 558 }
 559
 560
 561 /*
 562  * @unimplemented
 563  */
 564 DWORD
 565 STDCALL
 566 GetCharacterPlacementA(
 567         HDC             hDc,
 568         LPCSTR          a1,
 569         int             a2,
 570         int             a3,
 571         LPGCP_RESULTS   a4,
 572         DWORD           a5
 573         )
 574 {
 575         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 576         return 0;
 577 }
 578
 579
 580 /*
 581  * @implemented
 582  */
 583 HDC
 584 STDCALL
 585 ResetDCA(
 586         HDC             hdc,
 587         CONST DEVMODEA  *lpInitData
 588         )
 589 {
 590   DEVMODEW InitDataW;
 591
 592   RosRtlDevModeA2W ( &InitDataW, (CONST LPDEVMODEA)lpInitData );
 593
 594   return W32kResetDC ( hdc, &InitDataW );
 595 }
 596
 597
 598 /*
 599  * @implemented
 600  */
 601 BOOL
 602 STDCALL
 603 RemoveFontResourceA(
 604         LPCSTR  lpFileName
 605         )
 606 {
 607   NTSTATUS Status;
 608   UNICODE_STRING FileName;
 609   BOOL rc;
 610
 611   Status = RtlCreateUnicodeStringFromAsciiz ( &FileName,
 612                                               (PCSZ)lpFileName );
 613   if (!NT_SUCCESS (Status))
 614     {
 615       SetLastError (RtlNtStatusToDosError(Status));
 616       return 0;
 617     }
 618
 619   rc = W32kRemoveFontResource ( FileName.Buffer );
 620
 621   RtlFreeUnicodeString ( &FileName );
 622
 623   return rc;
 624 }
 625
 626
 627 /*
 628  * @implemented
 629  */
 630 HENHMETAFILE
 631 STDCALL
 632 CopyEnhMetaFileA(
 633         HENHMETAFILE    hemfSrc,
 634         LPCSTR          lpszFile
 635         )
 636 {
 637   NTSTATUS Status;
 638   UNICODE_STRING File;
 639   HENHMETAFILE rc;
 640
 641   Status = RtlCreateUnicodeStringFromAsciiz ( &File,
 642                                               (PCSZ)lpszFile );
 643   if (!NT_SUCCESS (Status))
 644     {
 645       SetLastError (RtlNtStatusToDosError(Status));
 646       return 0;
 647     }
 648
 649   rc = W32kCopyEnhMetaFile ( hemfSrc, File.Buffer );
 650
 651   RtlFreeUnicodeString ( &File );
 652
 653   return rc;
 654 }
 655
 656
 657 /*
 658  * @implemented
 659  */
 660 HDC
 661 STDCALL
 662 CreateEnhMetaFileA(
 663         HDC             hdc,
 664         LPCSTR          lpFileName,
 665         CONST RECT      *lpRect,
 666         LPCSTR          lpDescription
 667         )
 668 {
 669   NTSTATUS Status;
 670   UNICODE_STRING FileName, Description;
 671   HDC rc;
 672
 673   Status = RtlCreateUnicodeStringFromAsciiz ( &FileName,
 674                                               (PCSZ)lpFileName );
 675   if (!NT_SUCCESS (Status))
 676     {
 677       SetLastError (RtlNtStatusToDosError(Status));
 678       return 0;
 679     }
 680
 681   Status = RtlCreateUnicodeStringFromAsciiz ( &Description,
 682                                               (PCSZ)lpDescription );
 683   if (!NT_SUCCESS (Status))
 684     {
 685       SetLastError (RtlNtStatusToDosError(Status));
 686       return 0;
 687     }
 688
 689   rc = W32kCreateEnhMetaFile ( hdc, FileName.Buffer, (CONST LPRECT)lpRect, Description.Buffer );
 690
 691   RtlFreeUnicodeString ( &FileName );
 692   RtlFreeUnicodeString ( &Description );
 693
 694   return rc;
 695 }
 696
 697
 698 /*
 699  * @implemented
 700  */
 701 HENHMETAFILE
 702 STDCALL
 703 GetEnhMetaFileA(
 704         LPCSTR  lpszMetaFile
 705         )
 706 {
 707   NTSTATUS Status;
 708   UNICODE_STRING MetaFile;
 709   HENHMETAFILE rc;
 710
 711   Status = RtlCreateUnicodeStringFromAsciiz ( &MetaFile,
 712                                               (PCSZ)lpszMetaFile );
 713   if (!NT_SUCCESS (Status))
 714     {
 715       SetLastError (RtlNtStatusToDosError(Status));
 716       return 0;
 717     }
 718
 719   rc = W32kGetEnhMetaFile ( MetaFile.Buffer );
 720
 721   RtlFreeUnicodeString ( &MetaFile );
 722
 723   return rc;
 724 }
 725
 726
 727 /*
 728  * @implemented
 729  */
 730 UINT
 731 STDCALL
 732 GetEnhMetaFileDescriptionA(
 733         HENHMETAFILE    hemf,
 734         UINT            cchBuffer,
 735         LPSTR           lpszDescription
 736         )
 737 {
 738   HANDLE hHeap;
 739   NTSTATUS Status;
 740   LPWSTR lpszDescriptionW;
 741   UINT rc;
 742
 743   if ( lpszDescription && cchBuffer )
 744     {
 745       hHeap = RtlGetProcessHeap();
 746       lpszDescriptionW = RtlAllocateHeap ( hHeap, 0, cchBuffer );
 747     }
 748
 749   rc = W32kGetEnhMetaFileDescription ( hemf, cchBuffer, lpszDescriptionW );
 750
 751   if ( lpszDescription && cchBuffer )
 752     {
 753       Status = RtlUnicodeToMultiByteN ( lpszDescription,
 754                                         cchBuffer,
 755                                         NULL,
 756                                         lpszDescriptionW,
 757                                         cchBuffer );
 758       RtlFreeHeap ( hHeap, 0, lpszDescriptionW );
 759       if ( !NT_SUCCESS(Status) )
 760         {
 761           SetLastError (RtlNtStatusToDosError(Status));
 762           return 0;
 763         }
 764     }
 765
 766   return rc;
 767 }
 768
 769
 770 /*
 771  * @unimplemented
 772  */
 773 int
 774 STDCALL
 775 StartDocA(
 776         HDC             hdc,
 777         CONST DOCINFO   *a1
 778         )
 779 {
 780         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 781         return 0;
 782 }
 783
 784
 785 /*
 786  * @unimplemented
 787  */
 788 int
 789 STDCALL
 790 GetObjectA(
 791         HGDIOBJ         a0,
 792         int             a1,
 793         LPVOID          a2
 794         )
 795 {
 796         return W32kGetObject ( a0, a1, a2 );
 797 }
 798
 799
 800 /*
 801  * @unimplemented
 802  */
 803 BOOL
 804 STDCALL
 805 PolyTextOutA(
 806         HDC                     hdc,
 807         CONST POLYTEXT          *a1,
 808         int                     a2
 809         )
 810 {
 811         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 812         return FALSE;
 813 }
 814
 815
 816 /*
 817  * @unimplemented
 818  */
 819 int
 820 STDCALL
 821 GetTextFaceA(
 822         HDC     a0,
 823         int     a1,
 824         LPSTR   a2
 825         )
 826 {
 827         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 828         return FALSE;
 829 }
 830
 831
 832 /*
 833  * @unimplemented
 834  */
 835 DWORD
 836 STDCALL
 837 GetKerningPairsA(
 838         HDC             a0,
 839         DWORD           a1,
 840         LPKERNINGPAIR   a2
 841         )
 842 {
 843         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 844         return 0;
 845 }
 846
 847
 848 /*
 849  * @unimplemented
 850  */
 851 BOOL
 852 STDCALL
 853 GetLogColorSpaceA(
 854         HCOLORSPACE             a0,
 855         LPLOGCOLORSPACE a1,
 856         DWORD                   a2
 857         )
 858 {
 859         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 860         return FALSE;
 861 }
 862
 863
 864 /*
 865  * @unimplemented
 866  */
 867 HCOLORSPACE
 868 STDCALL
 869 CreateColorSpaceA(
 870         LPLOGCOLORSPACE a0
 871         )
 872 {
 873         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 874         return 0;
 875 }
 876
 877
 878 /*
 879  * @unimplemented
 880  */
 881 WINBOOL
 882 STDCALL
 883 GetICMProfileA(
 884         HDC             a0,
 885         DWORD           a1,     /* MS says LPDWORD! */
 886         LPSTR           a2
 887         )
 888 {
 889         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 890         return FALSE;
 891 }
 892
 893
 894 /*
 895  * @unimplemented
 896  */
 897 BOOL
 898 STDCALL
 899 SetICMProfileA(
 900         HDC     a0,
 901         LPSTR   a1
 902         )
 903 {
 904         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 905         return FALSE;
 906 }
 907
 908
 909 /*
 910  * @unimplemented
 911  */
 912 int
 913 STDCALL
 914 EnumICMProfilesA(
 915         HDC             a0,
 916         ICMENUMPROC     a1,
 917         LPARAM          a2
 918         )
 919 {
 920         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 921         return 0;
 922 }
 923
 924
 925 /*
 926  * @unimplemented
 927  */
 928 BOOL
 929 STDCALL
 930 wglUseFontBitmapsA(
 931         HDC             a0,
 932         DWORD           a1,
 933         DWORD           a2,
 934         DWORD           a3
 935         )
 936 {
 937         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 938         return FALSE;
 939 }
 940
 941
 942 /*
 943  * @unimplemented
 944  */
 945 BOOL
 946 STDCALL
 947 wglUseFontOutlinesA(
 948         HDC                     a0,
 949         DWORD                   a1,
 950         DWORD                   a2,
 951         DWORD                   a3,
 952         FLOAT                   a4,
 953         FLOAT                   a5,
 954         int                     a6,
 955         LPGLYPHMETRICSFLOAT     a7
 956         )
 957 {
 958         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 959         return FALSE;
 960 }
 961
 962
 963 /*
 964  * @unimplemented
 965  */
 966 WINBOOL
 967 STDCALL
 968 UpdateICMRegKeyA(
 969         DWORD   a0,
 970         DWORD   a1,
 971         LPSTR   a2,
 972         UINT    a3
 973         )
 974 {
 975         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 976         return FALSE;
 977 }
 978
 979
 980 /* EOF */