builds/mac/ftmac.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftmac.c                                                                */
   4 /*                                                                         */
   5 /*    Mac FOND support.  Written by just@letterror.com.                    */
   6 /*  Heavily Fixed by mpsuzuki, George Williams and Sean McBride            */
   7 /*                                                                         */
   8 /*  Copyright 1996-2008, 2013, 2014 by                                     */
   9 /*  Just van Rossum, David Turner, Robert Wilhelm, and Werner Lemberg.     */
  10 /*                                                                         */
  11 /*  This file is part of the FreeType project, and may only be used,       */
  12 /*  modified, and distributed under the terms of the FreeType project      */
  13 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
  14 /*  this file you indicate that you have read the license and              */
  15 /*  understand and accept it fully.                                        */
  16 /*                                                                         */
  17 /***************************************************************************/
  18
  19
  20   /*
  21     Notes
  22
  23     Mac suitcase files can (and often do!) contain multiple fonts.  To
  24     support this I use the face_index argument of FT_(Open|New)_Face()
  25     functions, and pretend the suitcase file is a collection.
  26
  27     Warning: fbit and NFNT bitmap resources are not supported yet.  In old
  28     sfnt fonts, bitmap glyph data for each size is stored in each `NFNT'
  29     resources instead of the `bdat' table in the sfnt resource.  Therefore,
  30     face->num_fixed_sizes is set to 0, because bitmap data in `NFNT'
  31     resource is unavailable at present.
  32
  33     The Mac FOND support works roughly like this:
  34
  35     - Check whether the offered stream points to a Mac suitcase file.  This
  36       is done by checking the file type: it has to be 'FFIL' or 'tfil'.  The
  37       stream that gets passed to our init_face() routine is a stdio stream,
  38       which isn't usable for us, since the FOND resources live in the
  39       resource fork.  So we just grab the stream->pathname field.
  40
  41     - Read the FOND resource into memory, then check whether there is a
  42       TrueType font and/or(!) a Type 1 font available.
  43
  44     - If there is a Type 1 font available (as a separate `LWFN' file), read
  45       its data into memory, massage it slightly so it becomes PFB data, wrap
  46       it into a memory stream, load the Type 1 driver and delegate the rest
  47       of the work to it by calling FT_Open_Face().  (XXX TODO: after this
  48       has been done, the kerning data from the FOND resource should be
  49       appended to the face: On the Mac there are usually no AFM files
  50       available.  However, this is tricky since we need to map Mac char
  51       codes to ps glyph names to glyph ID's...)
  52
  53     - If there is a TrueType font (an `sfnt' resource), read it into memory,
  54       wrap it into a memory stream, load the TrueType driver and delegate
  55       the rest of the work to it, by calling FT_Open_Face().
  56
  57     - Some suitcase fonts (notably Onyx) might point the `LWFN' file to
  58       itself, even though it doesn't contains `POST' resources.  To handle
  59       this special case without opening the file an extra time, we just
  60       ignore errors from the `LWFN' and fallback to the `sfnt' if both are
  61       available.
  62   */
  63
  64
  65 #include <ft2build.h>
  66 #include FT_FREETYPE_H
  67 #include FT_TRUETYPE_TAGS_H
  68 #include FT_INTERNAL_STREAM_H
  69 #include "ftbase.h"
  70
  71 #if defined( __GNUC__ ) || defined( __IBMC__ )
  72   /* This is for Mac OS X.  Without redefinition, OS_INLINE */
  73   /* expands to `static inline' which doesn't survive the   */
  74   /* -ansi compilation flag of GCC.                         */
  75 #if !HAVE_ANSI_OS_INLINE
  76 #undef  OS_INLINE
  77 #define OS_INLINE   static __inline__
  78 #endif
  79 #include <CoreServices/CoreServices.h>
  80 #include <ApplicationServices/ApplicationServices.h>
  81 #include <sys/syslimits.h> /* PATH_MAX */
  82 #else
  83 #include <Resources.h>
  84 #include <Fonts.h>
  85 #include <Endian.h>
  86 #include <Errors.h>
  87 #include <Files.h>
  88 #include <TextUtils.h>
  89 #endif
  90
  91 #ifndef PATH_MAX
  92 #define PATH_MAX 1024 /* same with Mac OS X's syslimits.h */
  93 #endif
  94
  95 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
  96 #include <FSp_fopen.h>
  97 #endif
  98
  99 #define FT_DEPRECATED_ATTRIBUTE
 100
 101 #include FT_MAC_H
 102
 103   /* undefine blocking-macros in ftmac.h */
 104 #undef FT_GetFile_From_Mac_Name
 105 #undef FT_GetFile_From_Mac_ATS_Name
 106 #undef FT_New_Face_From_FOND
 107 #undef FT_New_Face_From_FSSpec
 108 #undef FT_New_Face_From_FSRef
 109
 110
 111   /* FSSpec functions are deprecated since Mac OS X 10.4 */
 112 #ifndef HAVE_FSSPEC
 113 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
 114 #define HAVE_FSSPEC  1
 115 #else
 116 #define HAVE_FSSPEC  0
 117 #endif
 118 #endif
 119
 120   /* most FSRef functions were introduced since Mac OS 9 */
 121 #ifndef HAVE_FSREF
 122 #if TARGET_API_MAC_OSX
 123 #define HAVE_FSREF  1
 124 #else
 125 #define HAVE_FSREF  0
 126 #endif
 127 #endif
 128
 129   /* QuickDraw is deprecated since Mac OS X 10.4 */
 130 #ifndef HAVE_QUICKDRAW_CARBON
 131 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
 132 #define HAVE_QUICKDRAW_CARBON  1
 133 #else
 134 #define HAVE_QUICKDRAW_CARBON  0
 135 #endif
 136 #endif
 137
 138   /* AppleTypeService is available since Mac OS X */
 139 #ifndef HAVE_ATS
 140 #if TARGET_API_MAC_OSX
 141 #define HAVE_ATS  1
 142 #ifndef kATSOptionFlagsUnRestrictedScope /* since Mac OS X 10.1 */
 143 #define kATSOptionFlagsUnRestrictedScope kATSOptionFlagsDefault
 144 #endif
 145 #else
 146 #define HAVE_ATS  0
 147 #endif
 148 #endif
 149
 150   /* `configure' checks the availability of `ResourceIndex' strictly */
 151   /* and sets HAVE_TYPE_RESOURCE_INDEX to 1 or 0 always.  If it is   */
 152   /* not set (e.g., a build without `configure'), the availability   */
 153   /* is guessed from the SDK version.                                */
 154 #ifndef HAVE_TYPE_RESOURCE_INDEX
 155 #if !defined( MAC_OS_X_VERSION_10_5 ) || \
 156     ( MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5 )
 157 #define HAVE_TYPE_RESOURCE_INDEX 0
 158 #else
 159 #define HAVE_TYPE_RESOURCE_INDEX 1
 160 #endif
 161 #endif /* !HAVE_TYPE_RESOURCE_INDEX */
 162
 163 #if ( HAVE_TYPE_RESOURCE_INDEX == 0 )
 164 typedef short ResourceIndex;
 165 #endif
 166
 167   /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
 168      TrueType in case *both* are available (this is not common,
 169      but it *is* possible). */
 170 #ifndef PREFER_LWFN
 171 #define PREFER_LWFN  1
 172 #endif
 173
 174 #ifdef FT_MACINTOSH
 175
 176 #if !HAVE_QUICKDRAW_CARBON  /* QuickDraw is deprecated since Mac OS X 10.4 */
 177
 178   FT_EXPORT_DEF( FT_Error )
 179   FT_GetFile_From_Mac_Name( const char*  fontName,
 180                             FSSpec*      pathSpec,
 181                             FT_Long*     face_index )
 182   {
 183     FT_UNUSED( fontName );
 184     FT_UNUSED( pathSpec );
 185     FT_UNUSED( face_index );
 186
 187     return FT_THROW( Unimplemented_Feature );
 188   }
 189
 190 #else
 191
 192   FT_EXPORT_DEF( FT_Error )
 193   FT_GetFile_From_Mac_Name( const char*  fontName,
 194                             FSSpec*      pathSpec,
 195                             FT_Long*     face_index )
 196   {
 197     OptionBits            options = kFMUseGlobalScopeOption;
 198
 199     FMFontFamilyIterator  famIter;
 200     OSStatus              status = FMCreateFontFamilyIterator( NULL, NULL,
 201                                                                options,
 202                                                                &famIter );
 203     FMFont                the_font = 0;
 204     FMFontFamily          family   = 0;
 205
 206
 207     if ( !fontName || !face_index )
 208       return FT_THROW( Invalid_Argument );
 209
 210     *face_index = 0;
 211     while ( status == 0 && !the_font )
 212     {
 213       status = FMGetNextFontFamily( &famIter, &family );
 214       if ( status == 0 )
 215       {
 216         int                           stat2;
 217         FMFontFamilyInstanceIterator  instIter;
 218         Str255                        famNameStr;
 219         char                          famName[256];
 220
 221
 222         /* get the family name */
 223         FMGetFontFamilyName( family, famNameStr );
 224         CopyPascalStringToC( famNameStr, famName );
 225
 226         /* iterate through the styles */
 227         FMCreateFontFamilyInstanceIterator( family, &instIter );
 228
 229         *face_index = 0;
 230         stat2       = 0;
 231
 232         while ( stat2 == 0 && !the_font )
 233         {
 234           FMFontStyle  style;
 235           FMFontSize   size;
 236           FMFont       font;
 237
 238
 239           stat2 = FMGetNextFontFamilyInstance( &instIter, &font,
 240                                                &style, &size );
 241           if ( stat2 == 0 && size == 0 )
 242           {
 243             char  fullName[256];
 244
 245
 246             /* build up a complete face name */
 247             ft_strcpy( fullName, famName );
 248             if ( style & bold )
 249               ft_strcat( fullName, " Bold" );
 250             if ( style & italic )
 251               ft_strcat( fullName, " Italic" );
 252
 253             /* compare with the name we are looking for */
 254             if ( ft_strcmp( fullName, fontName ) == 0 )
 255             {
 256               /* found it! */
 257               the_font = font;
 258             }
 259             else
 260               ++(*face_index);
 261           }
 262         }
 263
 264         FMDisposeFontFamilyInstanceIterator( &instIter );
 265       }
 266     }
 267
 268     FMDisposeFontFamilyIterator( &famIter );
 269
 270     if ( the_font )
 271     {
 272       FMGetFontContainer( the_font, pathSpec );
 273       return FT_Err_Ok;
 274     }
 275     else
 276       return FT_THROW( Unknown_File_Format );
 277   }
 278
 279 #endif /* HAVE_QUICKDRAW_CARBON */
 280
 281
 282 #if HAVE_ATS
 283
 284   /* Private function.                                         */
 285   /* The FSSpec type has been discouraged for a long time,     */
 286   /* unfortunately an FSRef replacement API for                */
 287   /* ATSFontGetFileSpecification() is only available in        */
 288   /* Mac OS X 10.5 and later.                                  */
 289   static OSStatus
 290   FT_ATSFontGetFileReference( ATSFontRef  ats_font_id,
 291                               FSRef*      ats_font_ref )
 292   {
 293     OSStatus  err;
 294
 295 #if !defined( MAC_OS_X_VERSION_10_5 ) || \
 296     MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
 297     FSSpec    spec;
 298
 299
 300     err = ATSFontGetFileSpecification( ats_font_id, &spec );
 301     if ( noErr == err )
 302       err = FSpMakeFSRef( &spec, ats_font_ref );
 303 #else
 304     err = ATSFontGetFileReference( ats_font_id, ats_font_ref );
 305 #endif
 306
 307     return err;
 308   }
 309
 310
 311   static FT_Error
 312   FT_GetFileRef_From_Mac_ATS_Name( const char*  fontName,
 313                                    FSRef*       ats_font_ref,
 314                                    FT_Long*     face_index )
 315   {
 316     CFStringRef  cf_fontName;
 317     ATSFontRef   ats_font_id;
 318
 319
 320     *face_index = 0;
 321
 322     cf_fontName = CFStringCreateWithCString( NULL, fontName,
 323                                              kCFStringEncodingMacRoman );
 324     ats_font_id = ATSFontFindFromName( cf_fontName,
 325                                        kATSOptionFlagsUnRestrictedScope );
 326     CFRelease( cf_fontName );
 327
 328     if ( ats_font_id == 0 || ats_font_id == 0xFFFFFFFFUL )
 329       return FT_THROW( Unknown_File_Format );
 330
 331     if ( noErr != FT_ATSFontGetFileReference( ats_font_id, ats_font_ref ) )
 332       return FT_THROW( Unknown_File_Format );
 333
 334     /* face_index calculation by searching preceding fontIDs */
 335     /* with same FSRef                                       */
 336     {
 337       ATSFontRef  id2 = ats_font_id - 1;
 338       FSRef       ref2;
 339
 340
 341       while ( id2 > 0 )
 342       {
 343         if ( noErr != FT_ATSFontGetFileReference( id2, &ref2 ) )
 344           break;
 345         if ( noErr != FSCompareFSRefs( ats_font_ref, &ref2 ) )
 346           break;
 347
 348         id2--;
 349       }
 350       *face_index = ats_font_id - ( id2 + 1 );
 351     }
 352
 353     return FT_Err_Ok;
 354   }
 355
 356 #endif
 357
 358 #if !HAVE_ATS
 359
 360   FT_EXPORT_DEF( FT_Error )
 361   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,
 362                                     UInt8*       path,
 363                                     UInt32       maxPathSize,
 364                                     FT_Long*     face_index )
 365   {
 366     FT_UNUSED( fontName );
 367     FT_UNUSED( path );
 368     FT_UNUSED( maxPathSize );
 369     FT_UNUSED( face_index );
 370
 371     return FT_THROW( Unimplemented_Feature );
 372   }
 373
 374 #else
 375
 376   FT_EXPORT_DEF( FT_Error )
 377   FT_GetFilePath_From_Mac_ATS_Name( const char*  fontName,
 378                                     UInt8*       path,
 379                                     UInt32       maxPathSize,
 380                                     FT_Long*     face_index )
 381   {
 382     FSRef     ref;
 383     FT_Error  err;
 384
 385
 386     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );
 387     if ( err )
 388       return err;
 389
 390     if ( noErr != FSRefMakePath( &ref, path, maxPathSize ) )
 391       return FT_THROW( Unknown_File_Format );
 392
 393     return FT_Err_Ok;
 394   }
 395
 396 #endif /* HAVE_ATS */
 397
 398
 399 #if !HAVE_FSSPEC || !HAVE_ATS
 400
 401   FT_EXPORT_DEF( FT_Error )
 402   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
 403                                 FSSpec*      pathSpec,
 404                                 FT_Long*     face_index )
 405   {
 406     FT_UNUSED( fontName );
 407     FT_UNUSED( pathSpec );
 408     FT_UNUSED( face_index );
 409
 410     return FT_THROW( Unimplemented_Feature );
 411   }
 412
 413 #else
 414
 415   /* This function is deprecated because FSSpec is deprecated in Mac OS X. */
 416   FT_EXPORT_DEF( FT_Error )
 417   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
 418                                 FSSpec*      pathSpec,
 419                                 FT_Long*     face_index )
 420   {
 421     FSRef     ref;
 422     FT_Error  err;
 423
 424
 425     err = FT_GetFileRef_From_Mac_ATS_Name( fontName, &ref, face_index );
 426     if ( err )
 427       return err;
 428
 429     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone, NULL, NULL,
 430                                     pathSpec, NULL ) )
 431       return FT_THROW( Unknown_File_Format );
 432
 433     return FT_Err_Ok;
 434   }
 435
 436 #endif
 437
 438
 439 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
 440
 441 #define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )
 442
 443
 444   FT_CALLBACK_DEF( void )
 445   ft_FSp_stream_close( FT_Stream  stream )
 446   {
 447     ft_fclose( STREAM_FILE( stream ) );
 448
 449     stream->descriptor.pointer = NULL;
 450     stream->size               = 0;
 451     stream->base               = 0;
 452   }
 453
 454
 455   FT_CALLBACK_DEF( unsigned long )
 456   ft_FSp_stream_io( FT_Stream       stream,
 457                     unsigned long   offset,
 458                     unsigned char*  buffer,
 459                     unsigned long   count )
 460   {
 461     FT_FILE*  file;
 462
 463
 464     file = STREAM_FILE( stream );
 465
 466     ft_fseek( file, offset, SEEK_SET );
 467
 468     return (unsigned long)ft_fread( buffer, 1, count, file );
 469   }
 470
 471 #endif  /* __MWERKS__ && !TARGET_RT_MAC_MACHO */
 472
 473
 474 #if HAVE_FSSPEC && !HAVE_FSREF
 475
 476   /* isDirectory is a dummy to synchronize API with FSPathMakeRef() */
 477   static OSErr
 478   FT_FSPathMakeSpec( const UInt8*  pathname,
 479                      FSSpec*       spec_p,
 480                      Boolean       isDirectory )
 481   {
 482     const char  *p, *q;
 483     short       vRefNum;
 484     long        dirID;
 485     Str255      nodeName;
 486     OSErr       err;
 487     FT_UNUSED( isDirectory );
 488
 489
 490     p = q = (const char *)pathname;
 491     dirID   = 0;
 492     vRefNum = 0;
 493
 494     while ( 1 )
 495     {
 496       int  len = ft_strlen( p );
 497
 498
 499       if ( len > 255 )
 500         len = 255;
 501
 502       q = p + len;
 503
 504       if ( q == p )
 505         return 0;
 506
 507       if ( 255 < ft_strlen( (char *)pathname ) )
 508       {
 509         while ( p < q && *q != ':' )
 510           q--;
 511       }
 512
 513       if ( p < q )
 514         *(char *)nodeName = q - p;
 515       else if ( ft_strlen( p ) < 256 )
 516         *(char *)nodeName = ft_strlen( p );
 517       else
 518         return errFSNameTooLong;
 519
 520       ft_strncpy( (char *)nodeName + 1, (char *)p, *(char *)nodeName );
 521       err = FSMakeFSSpec( vRefNum, dirID, nodeName, spec_p );
 522       if ( err || '\0' == *q )
 523         return err;
 524
 525       vRefNum = spec_p->vRefNum;
 526       dirID   = spec_p->parID;
 527
 528       p = q;
 529     }
 530   }
 531
 532
 533   static OSErr
 534   FT_FSpMakePath( const FSSpec*  spec_p,
 535                   UInt8*         path,
 536                   UInt32         maxPathSize )
 537   {
 538     OSErr   err;
 539     FSSpec  spec = *spec_p;
 540     short   vRefNum;
 541     long    dirID;
 542     Str255  parDir_name;
 543
 544
 545     FT_MEM_SET( path, 0, maxPathSize );
 546     while ( 1 )
 547     {
 548       int             child_namelen = ft_strlen( (char *)path );
 549       unsigned char   node_namelen  = spec.name[0];
 550       unsigned char*  node_name     = spec.name + 1;
 551
 552
 553       if ( node_namelen + child_namelen > maxPathSize )
 554         return errFSNameTooLong;
 555
 556       FT_MEM_MOVE( path + node_namelen + 1, path, child_namelen );
 557       FT_MEM_COPY( path, node_name, node_namelen );
 558       if ( child_namelen > 0 )
 559         path[node_namelen] = ':';
 560
 561       vRefNum        = spec.vRefNum;
 562       dirID          = spec.parID;
 563       parDir_name[0] = '\0';
 564       err = FSMakeFSSpec( vRefNum, dirID, parDir_name, &spec );
 565       if ( noErr != err || dirID == spec.parID )
 566         break;
 567     }
 568     return noErr;
 569   }
 570
 571 #endif /* HAVE_FSSPEC && !HAVE_FSREF */
 572
 573
 574   static OSErr
 575   FT_FSPathMakeRes( const UInt8*    pathname,
 576                     ResFileRefNum*  res )
 577   {
 578
 579 #if HAVE_FSREF
 580
 581     OSErr  err;
 582     FSRef  ref;
 583
 584
 585     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )
 586       return FT_THROW( Cannot_Open_Resource );
 587
 588     /* at present, no support for dfont format */
 589     err = FSOpenResourceFile( &ref, 0, NULL, fsRdPerm, res );
 590     if ( noErr == err )
 591       return err;
 592
 593     /* fallback to original resource-fork font */
 594     *res = FSOpenResFile( &ref, fsRdPerm );
 595     err  = ResError();
 596
 597 #else
 598
 599     OSErr   err;
 600     FSSpec  spec;
 601
 602
 603     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
 604       return FT_THROW( Cannot_Open_Resource );
 605
 606     /* at present, no support for dfont format without FSRef */
 607     /* (see above), try original resource-fork font          */
 608     *res = FSpOpenResFile( &spec, fsRdPerm );
 609     err  = ResError();
 610
 611 #endif /* HAVE_FSREF */
 612
 613     return err;
 614   }
 615
 616
 617   /* Return the file type for given pathname */
 618   static OSType
 619   get_file_type_from_path( const UInt8*  pathname )
 620   {
 621
 622 #if HAVE_FSREF
 623
 624     FSRef          ref;
 625     FSCatalogInfo  info;
 626
 627
 628     if ( noErr != FSPathMakeRef( pathname, &ref, FALSE ) )
 629       return ( OSType ) 0;
 630
 631     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoFinderInfo, &info,
 632                                     NULL, NULL, NULL ) )
 633       return ( OSType ) 0;
 634
 635     return ((FInfo *)(info.finderInfo))->fdType;
 636
 637 #else
 638
 639     FSSpec  spec;
 640     FInfo   finfo;
 641
 642
 643     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
 644       return ( OSType ) 0;
 645
 646     if ( noErr != FSpGetFInfo( &spec, &finfo ) )
 647       return ( OSType ) 0;
 648
 649     return finfo.fdType;
 650
 651 #endif /* HAVE_FSREF */
 652
 653   }
 654
 655
 656   /* Given a PostScript font name, create the Macintosh LWFN file name. */
 657   static void
 658   create_lwfn_name( char*   ps_name,
 659                     Str255  lwfn_file_name )
 660   {
 661     int       max = 5, count = 0;
 662     FT_Byte*  p = lwfn_file_name;
 663     FT_Byte*  q = (FT_Byte*)ps_name;
 664
 665
 666     lwfn_file_name[0] = 0;
 667
 668     while ( *q )
 669     {
 670       if ( ft_isupper( *q ) )
 671       {
 672         if ( count )
 673           max = 3;
 674         count = 0;
 675       }
 676       if ( count < max && ( ft_isalnum( *q ) || *q == '_' ) )
 677       {
 678         *++p = *q;
 679         lwfn_file_name[0]++;
 680         count++;
 681       }
 682       q++;
 683     }
 684   }
 685
 686
 687   static short
 688   count_faces_sfnt( char*  fond_data )
 689   {
 690     /* The count is 1 greater than the value in the FOND.  */
 691     /* Isn't that cute? :-)                                */
 692
 693     return EndianS16_BtoN( *( (short*)( fond_data +
 694                                         sizeof ( FamRec ) ) ) ) + 1;
 695   }
 696
 697
 698   static short
 699   count_faces_scalable( char*  fond_data )
 700   {
 701     AsscEntry*  assoc;
 702     short       i, face, face_all;
 703
 704
 705     face_all = EndianS16_BtoN( *( (short *)( fond_data +
 706                                              sizeof ( FamRec ) ) ) ) + 1;
 707     assoc    = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
 708     face     = 0;
 709
 710     for ( i = 0; i < face_all; i++ )
 711     {
 712       if ( 0 == EndianS16_BtoN( assoc[i].fontSize ) )
 713         face++;
 714     }
 715     return face;
 716   }
 717
 718
 719   /* Look inside the FOND data, answer whether there should be an SFNT
 720      resource, and answer the name of a possible LWFN Type 1 file.
 721
 722      Thanks to Paul Miller (paulm@profoundeffects.com) for the fix
 723      to load a face OTHER than the first one in the FOND!
 724   */
 725
 726   static void
 727   parse_fond( char*   fond_data,
 728               short*  have_sfnt,
 729               ResID*  sfnt_id,
 730               Str255  lwfn_file_name,
 731               short   face_index )
 732   {
 733     AsscEntry*  assoc;
 734     AsscEntry*  base_assoc;
 735     FamRec*     fond;
 736
 737
 738     *sfnt_id          = 0;
 739     *have_sfnt        = 0;
 740     lwfn_file_name[0] = 0;
 741
 742     fond       = (FamRec*)fond_data;
 743     assoc      = (AsscEntry*)( fond_data + sizeof ( FamRec ) + 2 );
 744     base_assoc = assoc;
 745
 746     /* the maximum faces in a FOND is 48, size of StyleTable.indexes[] */
 747     if ( 47 < face_index )
 748       return;
 749
 750     /* Let's do a little range checking before we get too excited here */
 751     if ( face_index < count_faces_sfnt( fond_data ) )
 752     {
 753       assoc += face_index;        /* add on the face_index! */
 754
 755       /* if the face at this index is not scalable,
 756          fall back to the first one (old behavior) */
 757       if ( EndianS16_BtoN( assoc->fontSize ) == 0 )
 758       {
 759         *have_sfnt = 1;
 760         *sfnt_id   = EndianS16_BtoN( assoc->fontID );
 761       }
 762       else if ( base_assoc->fontSize == 0 )
 763       {
 764         *have_sfnt = 1;
 765         *sfnt_id   = EndianS16_BtoN( base_assoc->fontID );
 766       }
 767     }
 768
 769     if ( EndianS32_BtoN( fond->ffStylOff ) )
 770     {
 771       unsigned char*  p = (unsigned char*)fond_data;
 772       StyleTable*     style;
 773       unsigned short  string_count;
 774       char            ps_name[256];
 775       unsigned char*  names[64];
 776       int             i;
 777
 778
 779       p += EndianS32_BtoN( fond->ffStylOff );
 780       style = (StyleTable*)p;
 781       p += sizeof ( StyleTable );
 782       string_count = EndianS16_BtoN( *(short*)(p) );
 783       p += sizeof ( short );
 784
 785       for ( i = 0; i < string_count && i < 64; i++ )
 786       {
 787         names[i] = p;
 788         p       += names[i][0];
 789         p++;
 790       }
 791
 792       {
 793         size_t  ps_name_len = (size_t)names[0][0];
 794
 795
 796         if ( ps_name_len != 0 )
 797         {
 798           ft_memcpy(ps_name, names[0] + 1, ps_name_len);
 799           ps_name[ps_name_len] = 0;
 800         }
 801         if ( style->indexes[face_index] > 1 &&
 802              style->indexes[face_index] <= FT_MIN( string_count, 64 ) )
 803         {
 804           unsigned char*  suffixes = names[style->indexes[face_index] - 1];
 805
 806
 807           for ( i = 1; i <= suffixes[0]; i++ )
 808           {
 809             unsigned char*  s;
 810             size_t          j = suffixes[i] - 1;
 811
 812
 813             if ( j < string_count && ( s = names[j] ) != NULL )
 814             {
 815               size_t  s_len = (size_t)s[0];
 816
 817
 818               if ( s_len != 0 && ps_name_len + s_len < sizeof ( ps_name ) )
 819               {
 820                 ft_memcpy( ps_name + ps_name_len, s + 1, s_len );
 821                 ps_name_len += s_len;
 822                 ps_name[ps_name_len] = 0;
 823               }
 824             }
 825           }
 826         }
 827       }
 828
 829       create_lwfn_name( ps_name, lwfn_file_name );
 830     }
 831   }
 832
 833
 834   static  FT_Error
 835   lookup_lwfn_by_fond( const UInt8*      path_fond,
 836                        ConstStr255Param  base_lwfn,
 837                        UInt8*            path_lwfn,
 838                        int               path_size )
 839   {
 840
 841 #if HAVE_FSREF
 842
 843     FSRef  ref, par_ref;
 844     int    dirname_len;
 845
 846
 847     /* Pathname for FSRef can be in various formats: HFS, HFS+, and POSIX. */
 848     /* We should not extract parent directory by string manipulation.      */
 849
 850     if ( noErr != FSPathMakeRef( path_fond, &ref, FALSE ) )
 851       return FT_THROW( Invalid_Argument );
 852
 853     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,
 854                                     NULL, NULL, NULL, &par_ref ) )
 855       return FT_THROW( Invalid_Argument );
 856
 857     if ( noErr != FSRefMakePath( &par_ref, path_lwfn, path_size ) )
 858       return FT_THROW( Invalid_Argument );
 859
 860     if ( ft_strlen( (char *)path_lwfn ) + 1 + base_lwfn[0] > path_size )
 861       return FT_THROW( Invalid_Argument );
 862
 863     /* now we have absolute dirname in path_lwfn */
 864     if ( path_lwfn[0] == '/' )
 865       ft_strcat( (char *)path_lwfn, "/" );
 866     else
 867       ft_strcat( (char *)path_lwfn, ":" );
 868
 869     dirname_len = ft_strlen( (char *)path_lwfn );
 870     ft_strcat( (char *)path_lwfn, (char *)base_lwfn + 1 );
 871     path_lwfn[dirname_len + base_lwfn[0]] = '\0';
 872
 873     if ( noErr != FSPathMakeRef( path_lwfn, &ref, FALSE ) )
 874       return FT_THROW( Cannot_Open_Resource );
 875
 876     if ( noErr != FSGetCatalogInfo( &ref, kFSCatInfoNone,
 877                                     NULL, NULL, NULL, NULL ) )
 878       return FT_THROW( Cannot_Open_Resource );
 879
 880     return FT_Err_Ok;
 881
 882 #else
 883
 884     int     i;
 885     FSSpec  spec;
 886
 887
 888     /* pathname for FSSpec is always HFS format */
 889     if ( ft_strlen( (char *)path_fond ) > path_size )
 890       return FT_THROW( Invalid_Argument );
 891
 892     ft_strcpy( (char *)path_lwfn, (char *)path_fond );
 893
 894     i = ft_strlen( (char *)path_lwfn ) - 1;
 895     while ( i > 0 && ':' != path_lwfn[i] )
 896       i--;
 897
 898     if ( i + 1 + base_lwfn[0] > path_size )
 899       return FT_THROW( Invalid_Argument );
 900
 901     if ( ':' == path_lwfn[i] )
 902     {
 903       ft_strcpy( (char *)path_lwfn + i + 1, (char *)base_lwfn + 1 );
 904       path_lwfn[i + 1 + base_lwfn[0]] = '\0';
 905     }
 906     else
 907     {
 908       ft_strcpy( (char *)path_lwfn, (char *)base_lwfn + 1 );
 909       path_lwfn[base_lwfn[0]] = '\0';
 910     }
 911
 912     if ( noErr != FT_FSPathMakeSpec( path_lwfn, &spec, FALSE ) )
 913       return FT_THROW( Cannot_Open_Resource );
 914
 915     return FT_Err_Ok;
 916
 917 #endif /* HAVE_FSREF */
 918
 919   }
 920
 921
 922   static short
 923   count_faces( Handle        fond,
 924                const UInt8*  pathname )
 925   {
 926     ResID     sfnt_id;
 927     short     have_sfnt, have_lwfn;
 928     Str255    lwfn_file_name;
 929     UInt8     buff[PATH_MAX];
 930     FT_Error  err;
 931     short     num_faces;
 932
 933
 934     have_sfnt = have_lwfn = 0;
 935
 936     HLock( fond );
 937     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, 0 );
 938
 939     if ( lwfn_file_name[0] )
 940     {
 941       err = lookup_lwfn_by_fond( pathname, lwfn_file_name,
 942                                  buff, sizeof ( buff )  );
 943       if ( FT_Err_Ok == err )
 944         have_lwfn = 1;
 945     }
 946
 947     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
 948       num_faces = 1;
 949     else
 950       num_faces = count_faces_scalable( *fond );
 951
 952     HUnlock( fond );
 953     return num_faces;
 954   }
 955
 956
 957   /* Read Type 1 data from the POST resources inside the LWFN file,
 958      return a PFB buffer.  This is somewhat convoluted because the FT2
 959      PFB parser wants the ASCII header as one chunk, and the LWFN
 960      chunks are often not organized that way, so we glue chunks
 961      of the same type together. */
 962   static FT_Error
 963   read_lwfn( FT_Memory      memory,
 964              ResFileRefNum  res,
 965              FT_Byte**      pfb_data,
 966              FT_ULong*      size )
 967   {
 968     FT_Error       error = FT_Err_Ok;
 969     ResID          res_id;
 970     unsigned char  *buffer, *p, *size_p = NULL;
 971     FT_ULong       total_size = 0;
 972     FT_ULong       old_total_size = 0;
 973     FT_ULong       post_size, pfb_chunk_size;
 974     Handle         post_data;
 975     char           code, last_code;
 976
 977
 978     UseResFile( res );
 979
 980     /* First pass: load all POST resources, and determine the size of */
 981     /* the output buffer.                                             */
 982     res_id    = 501;
 983     last_code = -1;
 984
 985     for (;;)
 986     {
 987       post_data = Get1Resource( TTAG_POST, res_id++ );
 988       if ( post_data == NULL )
 989         break;  /* we are done */
 990
 991       code = (*post_data)[0];
 992
 993       if ( code != last_code )
 994       {
 995         if ( code == 5 )
 996           total_size += 2; /* just the end code */
 997         else
 998           total_size += 6; /* code + 4 bytes chunk length */
 999       }
1000
1001       total_size += GetHandleSize( post_data ) - 2;
1002       last_code = code;
1003
1004       /* detect integer overflows */
1005       if ( total_size < old_total_size )
1006       {
1007         error = FT_ERR( Array_Too_Large );
1008         goto Error;
1009       }
1010
1011       old_total_size = total_size;
1012     }
1013
1014     if ( FT_ALLOC( buffer, (FT_Long)total_size ) )
1015       goto Error;
1016
1017     /* Second pass: append all POST data to the buffer, add PFB fields. */
1018     /* Glue all consecutive chunks of the same type together.           */
1019     p              = buffer;
1020     res_id         = 501;
1021     last_code      = -1;
1022     pfb_chunk_size = 0;
1023
1024     for (;;)
1025     {
1026       post_data = Get1Resource( TTAG_POST, res_id++ );
1027       if ( post_data == NULL )
1028         break;  /* we are done */
1029
1030       post_size = (FT_ULong)GetHandleSize( post_data ) - 2;
1031       code = (*post_data)[0];
1032
1033       if ( code != last_code )
1034       {
1035         if ( last_code != -1 )
1036         {
1037           /* we are done adding a chunk, fill in the size field */
1038           if ( size_p != NULL )
1039           {
1040             *size_p++ = (FT_Byte)(   pfb_chunk_size         & 0xFF );
1041             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 8  ) & 0xFF );
1042             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 16 ) & 0xFF );
1043             *size_p++ = (FT_Byte)( ( pfb_chunk_size >> 24 ) & 0xFF );
1044           }
1045           pfb_chunk_size = 0;
1046         }
1047
1048         *p++ = 0x80;
1049         if ( code == 5 )
1050           *p++ = 0x03;  /* the end */
1051         else if ( code == 2 )
1052           *p++ = 0x02;  /* binary segment */
1053         else
1054           *p++ = 0x01;  /* ASCII segment */
1055
1056         if ( code != 5 )
1057         {
1058           size_p = p;   /* save for later */
1059           p += 4;       /* make space for size field */
1060         }
1061       }
1062
1063       ft_memcpy( p, *post_data + 2, post_size );
1064       pfb_chunk_size += post_size;
1065       p += post_size;
1066       last_code = code;
1067     }
1068
1069     *pfb_data = buffer;
1070     *size = total_size;
1071
1072   Error:
1073     CloseResFile( res );
1074     return error;
1075   }
1076
1077
1078   /* Create a new FT_Face from a file spec to an LWFN file. */
1079   static FT_Error
1080   FT_New_Face_From_LWFN( FT_Library    library,
1081                          const UInt8*  pathname,
1082                          FT_Long       face_index,
1083                          FT_Face*      aface )
1084   {
1085     FT_Byte*       pfb_data;
1086     FT_ULong       pfb_size;
1087     FT_Error       error;
1088     ResFileRefNum  res;
1089
1090
1091     if ( noErr != FT_FSPathMakeRes( pathname, &res ) )
1092       return FT_THROW( Cannot_Open_Resource );
1093
1094     pfb_data = NULL;
1095     pfb_size = 0;
1096     error = read_lwfn( library->memory, res, &pfb_data, &pfb_size );
1097     CloseResFile( res ); /* PFB is already loaded, useless anymore */
1098     if ( error )
1099       return error;
1100
1101     return open_face_from_buffer( library,
1102                                   pfb_data,
1103                                   pfb_size,
1104                                   face_index,
1105                                   "type1",
1106                                   aface );
1107   }
1108
1109
1110   /* Create a new FT_Face from an SFNT resource, specified by res ID. */
1111   static FT_Error
1112   FT_New_Face_From_SFNT( FT_Library  library,
1113                          ResID       sfnt_id,
1114                          FT_Long     face_index,
1115                          FT_Face*    aface )
1116   {
1117     Handle     sfnt = NULL;
1118     FT_Byte*   sfnt_data;
1119     size_t     sfnt_size;
1120     FT_Error   error  = FT_Err_Ok;
1121     FT_Memory  memory = library->memory;
1122     int        is_cff, is_sfnt_ps;
1123
1124
1125     sfnt = GetResource( TTAG_sfnt, sfnt_id );
1126     if ( sfnt == NULL )
1127       return FT_THROW( Invalid_Handle );
1128
1129     sfnt_size = (FT_ULong)GetHandleSize( sfnt );
1130     if ( FT_ALLOC( sfnt_data, (FT_Long)sfnt_size ) )
1131     {
1132       ReleaseResource( sfnt );
1133       return error;
1134     }
1135
1136     HLock( sfnt );
1137     ft_memcpy( sfnt_data, *sfnt, sfnt_size );
1138     HUnlock( sfnt );
1139     ReleaseResource( sfnt );
1140
1141     is_cff     = sfnt_size > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 );
1142     is_sfnt_ps = sfnt_size > 4 && !ft_memcmp( sfnt_data, "typ1", 4 );
1143
1144     if ( is_sfnt_ps )
1145     {
1146       FT_Stream  stream;
1147
1148
1149       if ( FT_NEW( stream ) )
1150         goto Try_OpenType;
1151
1152       FT_Stream_OpenMemory( stream, sfnt_data, sfnt_size );
1153       if ( !open_face_PS_from_sfnt_stream( library,
1154                                            stream,
1155                                            face_index,
1156                                            0, NULL,
1157                                            aface ) )
1158       {
1159         FT_Stream_Close( stream );
1160         FT_FREE( stream );
1161         FT_FREE( sfnt_data );
1162         goto Exit;
1163       }
1164
1165       FT_FREE( stream );
1166     }
1167   Try_OpenType:
1168     error = open_face_from_buffer( library,
1169                                    sfnt_data,
1170                                    sfnt_size,
1171                                    face_index,
1172                                    is_cff ? "cff" : "truetype",
1173                                    aface );
1174   Exit:
1175     return error;
1176   }
1177
1178
1179   /* Create a new FT_Face from a file spec to a suitcase file. */
1180   static FT_Error
1181   FT_New_Face_From_Suitcase( FT_Library    library,
1182                              const UInt8*  pathname,
1183                              FT_Long       face_index,
1184                              FT_Face*      aface )
1185   {
1186     FT_Error       error = FT_ERR( Cannot_Open_Resource );
1187     ResFileRefNum  res_ref;
1188     ResourceIndex  res_index;
1189     Handle         fond;
1190     short          num_faces_in_res;
1191
1192
1193     if ( noErr != FT_FSPathMakeRes( pathname, &res_ref ) )
1194       return FT_THROW( Cannot_Open_Resource );
1195
1196     UseResFile( res_ref );
1197     if ( ResError() )
1198       return FT_THROW( Cannot_Open_Resource );
1199
1200     num_faces_in_res = 0;
1201     for ( res_index = 1; ; ++res_index )
1202     {
1203       short  num_faces_in_fond;
1204
1205
1206       fond = Get1IndResource( TTAG_FOND, res_index );
1207       if ( ResError() )
1208         break;
1209
1210       num_faces_in_fond  = count_faces( fond, pathname );
1211       num_faces_in_res  += num_faces_in_fond;
1212
1213       if ( 0 <= face_index && face_index < num_faces_in_fond && error )
1214         error = FT_New_Face_From_FOND( library, fond, face_index, aface );
1215
1216       face_index -= num_faces_in_fond;
1217     }
1218
1219     CloseResFile( res_ref );
1220     if ( FT_Err_Ok == error && NULL != aface )
1221       (*aface)->num_faces = num_faces_in_res;
1222     return error;
1223   }
1224
1225
1226   /* documentation is in ftmac.h */
1227
1228   FT_EXPORT_DEF( FT_Error )
1229   FT_New_Face_From_FOND( FT_Library  library,
1230                          Handle      fond,
1231                          FT_Long     face_index,
1232                          FT_Face*    aface )
1233   {
1234     short     have_sfnt, have_lwfn = 0;
1235     ResID     sfnt_id, fond_id;
1236     OSType    fond_type;
1237     Str255    fond_name;
1238     Str255    lwfn_file_name;
1239     UInt8     path_lwfn[PATH_MAX];
1240     OSErr     err;
1241     FT_Error  error = FT_Err_Ok;
1242
1243
1244     /* test for valid `aface' and `library' delayed to */
1245     /* `FT_New_Face_From_XXX'                          */
1246
1247     GetResInfo( fond, &fond_id, &fond_type, fond_name );
1248     if ( ResError() != noErr || fond_type != TTAG_FOND )
1249       return FT_THROW( Invalid_File_Format );
1250
1251     HLock( fond );
1252     parse_fond( *fond, &have_sfnt, &sfnt_id, lwfn_file_name, face_index );
1253     HUnlock( fond );
1254
1255     if ( lwfn_file_name[0] )
1256     {
1257       ResFileRefNum  res;
1258
1259
1260       res = HomeResFile( fond );
1261       if ( noErr != ResError() )
1262         goto found_no_lwfn_file;
1263
1264 #if HAVE_FSREF
1265
1266       {
1267         UInt8  path_fond[PATH_MAX];
1268         FSRef  ref;
1269
1270
1271         err = FSGetForkCBInfo( res, kFSInvalidVolumeRefNum,
1272                                NULL, NULL, NULL, &ref, NULL );
1273         if ( noErr != err )
1274           goto found_no_lwfn_file;
1275
1276         err = FSRefMakePath( &ref, path_fond, sizeof ( path_fond ) );
1277         if ( noErr != err )
1278           goto found_no_lwfn_file;
1279
1280         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
1281                                      path_lwfn, sizeof ( path_lwfn ) );
1282         if ( FT_Err_Ok == error )
1283           have_lwfn = 1;
1284       }
1285
1286 #elif HAVE_FSSPEC
1287
1288       {
1289         UInt8     path_fond[PATH_MAX];
1290         FCBPBRec  pb;
1291         Str255    fond_file_name;
1292         FSSpec    spec;
1293
1294
1295         FT_MEM_SET( &spec, 0, sizeof ( FSSpec ) );
1296         FT_MEM_SET( &pb,   0, sizeof ( FCBPBRec ) );
1297
1298         pb.ioNamePtr = fond_file_name;
1299         pb.ioVRefNum = 0;
1300         pb.ioRefNum  = res;
1301         pb.ioFCBIndx = 0;
1302
1303         err = PBGetFCBInfoSync( &pb );
1304         if ( noErr != err )
1305           goto found_no_lwfn_file;
1306
1307         err = FSMakeFSSpec( pb.ioFCBVRefNum, pb.ioFCBParID,
1308                             fond_file_name, &spec );
1309         if ( noErr != err )
1310           goto found_no_lwfn_file;
1311
1312         err = FT_FSpMakePath( &spec, path_fond, sizeof ( path_fond ) );
1313         if ( noErr != err )
1314           goto found_no_lwfn_file;
1315
1316         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
1317                                      path_lwfn, sizeof ( path_lwfn ) );
1318         if ( FT_Err_Ok == error )
1319           have_lwfn = 1;
1320       }
1321
1322 #endif /* HAVE_FSREF, HAVE_FSSPEC */
1323
1324     }
1325
1326     if ( have_lwfn && ( !have_sfnt || PREFER_LWFN ) )
1327       error = FT_New_Face_From_LWFN( library,
1328                                      path_lwfn,
1329                                      face_index,
1330                                      aface );
1331     else
1332       error = FT_ERR( Unknown_File_Format );
1333
1334   found_no_lwfn_file:
1335     if ( have_sfnt && FT_Err_Ok != error )
1336       error = FT_New_Face_From_SFNT( library,
1337                                      sfnt_id,
1338                                      face_index,
1339                                      aface );
1340
1341     return error;
1342   }
1343
1344
1345   /* Common function to load a new FT_Face from a resource file. */
1346   static FT_Error
1347   FT_New_Face_From_Resource( FT_Library    library,
1348                              const UInt8*  pathname,
1349                              FT_Long       face_index,
1350                              FT_Face*      aface )
1351   {
1352     OSType    file_type;
1353     FT_Error  error;
1354
1355
1356     /* LWFN is a (very) specific file format, check for it explicitly */
1357     file_type = get_file_type_from_path( pathname );
1358     if ( file_type == TTAG_LWFN )
1359       return FT_New_Face_From_LWFN( library, pathname, face_index, aface );
1360
1361     /* Otherwise the file type doesn't matter (there are more than  */
1362     /* `FFIL' and `tfil').  Just try opening it as a font suitcase; */
1363     /* if it works, fine.                                           */
1364
1365     error = FT_New_Face_From_Suitcase( library, pathname, face_index, aface );
1366     if ( error == 0 )
1367       return error;
1368
1369     /* let it fall through to normal loader (.ttf, .otf, etc.); */
1370     /* we signal this by returning no error and no FT_Face      */
1371     *aface = NULL;
1372     return 0;
1373   }
1374
1375
1376   /*************************************************************************/
1377   /*                                                                       */
1378   /* <Function>                                                            */
1379   /*    FT_New_Face                                                        */
1380   /*                                                                       */
1381   /* <Description>                                                         */
1382   /*    This is the Mac-specific implementation of FT_New_Face.  In        */
1383   /*    addition to the standard FT_New_Face() functionality, it also      */
1384   /*    accepts pathnames to Mac suitcase files.  For further              */
1385   /*    documentation see the original FT_New_Face() in freetype.h.        */
1386   /*                                                                       */
1387   FT_EXPORT_DEF( FT_Error )
1388   FT_New_Face( FT_Library   library,
1389                const char*  pathname,
1390                FT_Long      face_index,
1391                FT_Face*     aface )
1392   {
1393     FT_Open_Args  args;
1394     FT_Error      error;
1395
1396
1397     /* test for valid `library' and `aface' delayed to FT_Open_Face() */
1398     if ( !pathname )
1399       return FT_THROW( Invalid_Argument );
1400
1401     *aface = NULL;
1402
1403     /* try resourcefork based font: LWFN, FFIL */
1404     error = FT_New_Face_From_Resource( library, (UInt8 *)pathname,
1405                                        face_index, aface );
1406     if ( error != 0 || *aface != NULL )
1407       return error;
1408
1409     /* let it fall through to normal loader (.ttf, .otf, etc.) */
1410     args.flags    = FT_OPEN_PATHNAME;
1411     args.pathname = (char*)pathname;
1412     return FT_Open_Face( library, &args, face_index, aface );
1413   }
1414
1415
1416   /*************************************************************************/
1417   /*                                                                       */
1418   /* <Function>                                                            */
1419   /*    FT_New_Face_From_FSRef                                             */
1420   /*                                                                       */
1421   /* <Description>                                                         */
1422   /*    FT_New_Face_From_FSRef is identical to FT_New_Face except it       */
1423   /*    accepts an FSRef instead of a path.                                */
1424   /*                                                                       */
1425   /* This function is deprecated because Carbon data types (FSRef)         */
1426   /* are not cross-platform, and thus not suitable for the freetype API.   */
1427   FT_EXPORT_DEF( FT_Error )
1428   FT_New_Face_From_FSRef( FT_Library    library,
1429                           const FSRef*  ref,
1430                           FT_Long       face_index,
1431                           FT_Face*      aface )
1432   {
1433
1434 #if !HAVE_FSREF
1435
1436     FT_UNUSED( library );
1437     FT_UNUSED( ref );
1438     FT_UNUSED( face_index );
1439     FT_UNUSED( aface );
1440
1441     return FT_THROW( Unimplemented_Feature );
1442
1443 #else
1444
1445     FT_Error      error;
1446     FT_Open_Args  args;
1447     OSErr   err;
1448     UInt8   pathname[PATH_MAX];
1449
1450
1451     /* test for valid `library' and `aface' delayed to `FT_Open_Face' */
1452
1453     if ( !ref )
1454       return FT_THROW( Invalid_Argument );
1455
1456     err = FSRefMakePath( ref, pathname, sizeof ( pathname ) );
1457     if ( err )
1458       error = FT_ERR( Cannot_Open_Resource );
1459
1460     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
1461     if ( error != 0 || *aface != NULL )
1462       return error;
1463
1464     /* fallback to datafork font */
1465     args.flags    = FT_OPEN_PATHNAME;
1466     args.pathname = (char*)pathname;
1467     return FT_Open_Face( library, &args, face_index, aface );
1468
1469 #endif /* HAVE_FSREF */
1470
1471   }
1472
1473
1474   /*************************************************************************/
1475   /*                                                                       */
1476   /* <Function>                                                            */
1477   /*    FT_New_Face_From_FSSpec                                            */
1478   /*                                                                       */
1479   /* <Description>                                                         */
1480   /*    FT_New_Face_From_FSSpec is identical to FT_New_Face except it      */
1481   /*    accepts an FSSpec instead of a path.                               */
1482   /*                                                                       */
1483   /* This function is deprecated because Carbon data types (FSSpec)        */
1484   /* are not cross-platform, and thus not suitable for the freetype API.   */
1485   FT_EXPORT_DEF( FT_Error )
1486   FT_New_Face_From_FSSpec( FT_Library     library,
1487                            const FSSpec*  spec,
1488                            FT_Long        face_index,
1489                            FT_Face*       aface )
1490   {
1491
1492 #if HAVE_FSREF
1493
1494     FSRef  ref;
1495
1496
1497     if ( !spec || FSpMakeFSRef( spec, &ref ) != noErr )
1498       return FT_THROW( Invalid_Argument );
1499     else
1500       return FT_New_Face_From_FSRef( library, &ref, face_index, aface );
1501
1502 #elif HAVE_FSSPEC
1503
1504     FT_Error      error;
1505     FT_Open_Args  args;
1506     OSErr         err;
1507     UInt8         pathname[PATH_MAX];
1508
1509
1510     if ( !spec )
1511       return FT_THROW( Invalid_Argument );
1512
1513     err = FT_FSpMakePath( spec, pathname, sizeof ( pathname ) );
1514     if ( err )
1515       error = FT_ERR( Cannot_Open_Resource );
1516
1517     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
1518     if ( error != 0 || *aface != NULL )
1519       return error;
1520
1521     /* fallback to datafork font */
1522     args.flags    = FT_OPEN_PATHNAME;
1523     args.pathname = (char*)pathname;
1524     return FT_Open_Face( library, &args, face_index, aface );
1525
1526 #else
1527
1528     FT_UNUSED( library );
1529     FT_UNUSED( spec );
1530     FT_UNUSED( face_index );
1531     FT_UNUSED( aface );
1532
1533     return FT_THROW( Unimplemented_Feature );
1534
1535 #endif /* HAVE_FSREF, HAVE_FSSPEC */
1536
1537   }
1538
1539 #endif /* FT_MACINTOSH */
1540
1541
1542 /* END */