reactos/lib/gdi32/misc/stubsa.c

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