Ignore:
Timestamp:
Jan 18, 2007, 5:32:59 PM (15 years ago)
Author:
Eugene Romanenko
Message:

freetype update to version 2.3.0

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/freetype2/src/base/ftmac.c

    r165 r182  
    44/*                                                                         */
    55/*    Mac FOND support.  Written by just@letterror.com.                    */
    6 /*  Heavily Fixed by mpsuzuki, George Williams and Sean McBride            */
     6/*  Heavily modified by mpsuzuki, George Williams, and Sean McBride.       */
     7/*                                                                         */
     8/*  This file is for Mac OS X only; see builds/mac/ftoldmac.c for          */
     9/*  classic platforms built by MPW.                                        */
    710/*                                                                         */
    811/*  Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006 by                   */
     
    6770#include FT_INTERNAL_STREAM_H
    6871
    69 #if defined( __GNUC__ ) || defined( __IBMC__ )
    7072  /* This is for Mac OS X.  Without redefinition, OS_INLINE */
    7173  /* expands to `static inline' which doesn't survive the   */
     
    7476#define OS_INLINE   static __inline__
    7577#include <Carbon/Carbon.h>
    76 #else
    77 #include <Resources.h>
    78 #include <Fonts.h>
    79 #include <Endian.h>
    80 #include <Errors.h>
    81 #include <Files.h>
    82 #include <TextUtils.h>
    83 #endif
    84 
    85 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
    86 #include <FSp_fopen.h>
    87 #endif
    88 
    89 #include FT_MAC_H
    90 
    91 
    92   /* FSSpec functions are deprecated since Mac OS X 10.4 */
    93 #ifndef HAVE_FSSPEC
    94 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
    95 #define HAVE_FSSPEC  1
    96 #else
    97 #define HAVE_FSSPEC  0
    98 #endif
    99 #endif
    100 
    101   /* most FSRef functions were introduced since Mac OS 9 */
    102 #ifndef HAVE_FSREF
    103 #if TARGET_API_MAC_OSX
    104 #define HAVE_FSREF  1
    105 #else
    106 #define HAVE_FSREF  0
    107 #endif
    108 #endif
    10978
    11079#ifndef HFS_MAXPATHLEN
     
    11382
    11483
    115   /* QuickDraw is deprecated since Mac OS X 10.4 */
    116 #ifndef HAVE_QUICKDRAW_CARBON
    117 #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
    118 #define HAVE_QUICKDRAW_CARBON  1
    119 #else
    120 #define HAVE_QUICKDRAW_CARBON  0
    121 #endif
    122 #endif
    123 
    124   /* AppleTypeService is available since Mac OS X */
    125 #ifndef HAVE_ATS
    126 #if TARGET_API_MAC_OSX
    127 #define HAVE_ATS  1
    128 #else
    129 #define HAVE_ATS  0
    130 #endif
    131 #endif
     84#include FT_MAC_H
     85
     86  /* undefine blocking-macros in ftmac.h */
     87#undef FT_GetFile_From_Mac_Name( a, b, c )
     88#undef FT_GetFile_From_Mac_ATS_Name( a, b, c )
     89#undef FT_New_Face_From_FSSpec( a, b, c, d )
     90
    13291
    13392  /* Set PREFER_LWFN to 1 if LWFN (Type 1) is preferred over
     
    13998
    14099
    141 #if !HAVE_QUICKDRAW_CARBON  /* QuickDraw is deprecated since Mac OS X 10.4 */
    142 
    143100  FT_EXPORT_DEF( FT_Error )
    144101  FT_GetFile_From_Mac_Name( const char*  fontName,
     
    149106  }
    150107
    151 #else
    152 
    153   FT_EXPORT_DEF( FT_Error )
    154   FT_GetFile_From_Mac_Name( const char*  fontName,
    155                             FSSpec*      pathSpec,
    156                             FT_Long*     face_index )
    157   {
    158     OptionBits            options = kFMUseGlobalScopeOption;
    159 
    160     FMFontFamilyIterator  famIter;
    161     OSStatus              status = FMCreateFontFamilyIterator( NULL, NULL,
    162                                                                options,
    163                                                                &famIter );
    164     FMFont                the_font = 0;
    165     FMFontFamily          family   = 0;
    166 
    167 
    168     *face_index = 0;
    169     while ( status == 0 && !the_font )
    170     {
    171       status = FMGetNextFontFamily( &famIter, &family );
    172       if ( status == 0 )
    173       {
    174         int                           stat2;
    175         FMFontFamilyInstanceIterator  instIter;
    176         Str255                        famNameStr;
    177         char                          famName[256];
    178 
    179 
    180         /* get the family name */
    181         FMGetFontFamilyName( family, famNameStr );
    182         CopyPascalStringToC( famNameStr, famName );
    183 
    184         /* iterate through the styles */
    185         FMCreateFontFamilyInstanceIterator( family, &instIter );
    186 
    187         *face_index = 0;
    188         stat2       = 0;
    189 
    190         while ( stat2 == 0 && !the_font )
    191         {
    192           FMFontStyle  style;
    193           FMFontSize   size;
    194           FMFont       font;
    195 
    196 
    197           stat2 = FMGetNextFontFamilyInstance( &instIter, &font,
    198                                                &style, &size );
    199           if ( stat2 == 0 && size == 0 )
    200           {
    201             char  fullName[256];
    202 
    203 
    204             /* build up a complete face name */
    205             ft_strcpy( fullName, famName );
    206             if ( style & bold )
    207               ft_strcat( fullName, " Bold" );
    208             if ( style & italic )
    209               ft_strcat( fullName, " Italic" );
    210 
    211             /* compare with the name we are looking for */
    212             if ( ft_strcmp( fullName, fontName ) == 0 )
    213             {
    214               /* found it! */
    215               the_font = font;
    216             }
    217             else
    218               ++(*face_index);
    219           }
    220         }
    221 
    222         FMDisposeFontFamilyInstanceIterator( &instIter );
    223       }
    224     }
    225 
    226     FMDisposeFontFamilyIterator( &famIter );
    227 
    228     if ( the_font )
    229     {
    230       FMGetFontContainer( the_font, pathSpec );
    231       return FT_Err_Ok;
    232     }
    233     else
    234       return FT_Err_Unknown_File_Format;
    235   }
    236 
    237 #endif /* HAVE_QUICKDRAW_CARBON */
    238 
    239 
    240 #if !HAVE_ATS
    241 
    242   FT_EXPORT_DEF( FT_Error )
    243   FT_GetFile_From_Mac_ATS_Name( const char*  fontName,
    244                                 FSSpec*      pathSpec,
    245                                 FT_Long*     face_index )
    246   {
    247     return FT_Err_Unimplemented_Feature;
    248   }
    249 
    250 #else
    251108
    252109  FT_EXPORT_DEF( FT_Error )
     
    296153  }
    297154
    298 #endif /* HAVE_ATS */
    299 
    300 
    301 #if defined( __MWERKS__ ) && !TARGET_RT_MAC_MACHO
    302 
    303 #define STREAM_FILE( stream )  ( (FT_FILE*)stream->descriptor.pointer )
    304 
    305 
    306   FT_CALLBACK_DEF( void )
    307   ft_FSp_stream_close( FT_Stream  stream )
    308   {
    309     ft_fclose( STREAM_FILE( stream ) );
    310 
    311     stream->descriptor.pointer = NULL;
    312     stream->size               = 0;
    313     stream->base               = 0;
    314   }
    315 
    316 
    317   FT_CALLBACK_DEF( unsigned long )
    318   ft_FSp_stream_io( FT_Stream       stream,
    319                     unsigned long   offset,
    320                     unsigned char*  buffer,
    321                     unsigned long   count )
    322   {
    323     FT_FILE*  file;
    324 
    325 
    326     file = STREAM_FILE( stream );
    327 
    328     ft_fseek( file, offset, SEEK_SET );
    329 
    330     return (unsigned long)ft_fread( buffer, 1, count, file );
    331   }
    332 
    333 #endif  /* __MWERKS__ && !TARGET_RT_MAC_MACHO */
    334 
    335 
    336 #if HAVE_FSSPEC && !HAVE_FSREF
    337 
    338   static OSErr
    339   FT_FSPathMakeSpec( const UInt8*  pathname,
    340                      FSSpec*       spec_p,
    341                      Boolean       isDirectory )
    342   {
    343     const char  *p, *q;
    344     short       vRefNum;
    345     long        dirID;
    346     Str255      nodeName;
    347     OSErr       err;
    348 
    349 
    350     p = q = (const char *)pathname;
    351     dirID   = 0;
    352     vRefNum = 0;
    353 
    354     while ( 1 )
    355     {
    356       q = p + FT_MIN( 255, ft_strlen( p ) );
    357 
    358       if ( q == p )
    359         return 0;
    360 
    361       if ( 255 < ft_strlen( (char *)pathname ) )
    362       {
    363         while ( p < q && *q != ':' )
    364           q--;
    365       }
    366 
    367       if ( p < q )
    368         *(char *)nodeName = q - p;
    369       else if ( ft_strlen( p ) < 256 )
    370         *(char *)nodeName = ft_strlen( p );
    371       else
    372         return errFSNameTooLong;
    373 
    374       ft_strncpy( (char *)nodeName + 1, (char *)p, *(char *)nodeName );
    375       err = FSMakeFSSpec( vRefNum, dirID, nodeName, spec_p );
    376       if ( err || '\0' == *q )
    377         return err;
    378 
    379       vRefNum = spec_p->vRefNum;
    380       dirID   = spec_p->parID;
    381 
    382       p = q;
    383     }
    384   }
    385 
    386 
    387   static OSErr
    388   FT_FSpMakePath( const FSSpec*  spec_p,
    389                   UInt8*         path,
    390                   UInt32         maxPathSize )
    391   {
    392     OSErr   err;
    393     FSSpec  spec = *spec_p;
    394     short   vRefNum;
    395     long    dirID;
    396     Str255  parDir_name;
    397 
    398 
    399     FT_MEM_SET( path, 0, maxPathSize );
    400     while ( 1 )
    401     {
    402       int             child_namelen = ft_strlen( (char *)path );
    403       unsigned char   node_namelen  = spec.name[0];
    404       unsigned char*  node_name     = spec.name + 1;
    405 
    406 
    407       if ( node_namelen + child_namelen > maxPathSize )
    408         return errFSNameTooLong;
    409 
    410       FT_MEM_MOVE( path + node_namelen + 1, path, child_namelen );
    411       FT_MEM_COPY( path, node_name, node_namelen );
    412       if ( child_namelen > 0 )
    413         path[node_namelen] = ':';
    414 
    415       vRefNum        = spec.vRefNum;
    416       dirID          = spec.parID;
    417       parDir_name[0] = '\0';
    418       err = FSMakeFSSpec( vRefNum, dirID, parDir_name, &spec );
    419       if ( noErr != err || dirID == spec.parID )
    420         break;
    421     }
    422     return noErr;
    423   }
    424 
    425 #endif /* HAVE_FSSPEC && !HAVE_FSREF */
    426 
    427155
    428156  static OSErr
     
    430158                    short*        res )
    431159  {
    432 
    433 #if HAVE_FSREF
    434 
    435160    OSErr  err;
    436161    FSRef  ref;
     
    449174    err  = ResError();
    450175
    451 #else
    452 
    453     OSErr   err;
    454     FSSpec  spec;
    455 
    456 
    457     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
    458       return FT_Err_Cannot_Open_Resource;
    459 
    460     /* at present, no support for dfont format without FSRef */
    461     /* (see above), try original resource-fork font          */
    462     *res = FSpOpenResFile( &spec, fsRdPerm );
    463     err  = ResError();
    464 
    465 #endif /* HAVE_FSREF */
    466 
    467176    return err;
    468177  }
     
    473182  get_file_type_from_path( const UInt8*  pathname )
    474183  {
    475 
    476 #if HAVE_FSREF
    477 
    478184    FSRef          ref;
    479185    FSCatalogInfo  info;
     
    488194
    489195    return ((FInfo *)(info.finderInfo))->fdType;
    490 
    491 #else
    492 
    493     FSSpec  spec;
    494     FInfo  finfo;
    495 
    496 
    497     if ( noErr != FT_FSPathMakeSpec( pathname, &spec, FALSE ) )
    498       return ( OSType ) 0;
    499 
    500     if ( noErr != FSpGetFInfo( &spec, &finfo ) )
    501       return ( OSType ) 0;
    502 
    503     return finfo.fdType;
    504 
    505 #endif /* HAVE_FSREF */
    506 
    507196  }
    508197
     
    690379                       int              path_size )
    691380  {
    692 
    693 #if HAVE_FSREF
    694 
    695381    FSRef  ref, par_ref;
    696382    int    dirname_len;
     
    731417
    732418    return FT_Err_Ok;
    733 
    734 #else
    735 
    736     int     i;
    737     FSSpec  spec;
    738 
    739 
    740     /* pathname for FSSpec is always HFS format */
    741     if ( ft_strlen( (char *)path_fond ) > path_size )
    742       return FT_Err_Invalid_Argument;
    743 
    744     ft_strcpy( (char *)path_lwfn, (char *)path_fond );
    745 
    746     i = ft_strlen( (char *)path_lwfn ) - 1;
    747     while ( i > 0 && ':' != path_lwfn[i] )
    748       i--;
    749 
    750     if ( i + 1 + base_lwfn[0] > path_size )
    751       return FT_Err_Invalid_Argument;
    752 
    753     if ( ':' == path_lwfn[i] )
    754     {
    755       ft_strcpy( (char *)path_lwfn + i + 1, (char *)base_lwfn + 1 );
    756       path_lwfn[i + 1 + base_lwfn[0]] = '\0';
    757     }
    758     else
    759     {
    760       ft_strcpy( (char *)path_lwfn, (char *)base_lwfn + 1 );
    761       path_lwfn[base_lwfn[0]] = '\0';
    762     }
    763 
    764     if ( noErr != FT_FSPathMakeSpec( path_lwfn, &spec, FALSE ) )
    765       return FT_Err_Cannot_Open_Resource;
    766 
    767     return FT_Err_Ok;
    768 
    769 #endif /* HAVE_FSREF */
    770 
    771419  }
    772420
     
    1186834        goto found_no_lwfn_file;
    1187835
    1188 #if HAVE_FSREF
    1189 
    1190836      {
    1191837        UInt8  path_fond[HFS_MAXPATHLEN];
     
    1207853          have_lwfn = 1;
    1208854      }
    1209 
    1210 #elif HAVE_FSSPEC
    1211 
    1212       {
    1213         UInt8     path_fond[HFS_MAXPATHLEN];
    1214         FCBPBRec  pb;
    1215         Str255    fond_file_name;
    1216         FSSpec    spec;
    1217 
    1218 
    1219         FT_MEM_SET( &spec, 0, sizeof ( FSSpec ) );
    1220         FT_MEM_SET( &pb,   0, sizeof ( FCBPBRec ) );
    1221 
    1222         pb.ioNamePtr = fond_file_name;
    1223         pb.ioVRefNum = 0;
    1224         pb.ioRefNum  = res;
    1225         pb.ioFCBIndx = 0;
    1226 
    1227         err = PBGetFCBInfoSync( &pb );
    1228         if ( noErr != err )
    1229           goto found_no_lwfn_file;
    1230 
    1231         err = FSMakeFSSpec( pb.ioFCBVRefNum, pb.ioFCBParID,
    1232                             fond_file_name, &spec );
    1233         if ( noErr != err )
    1234           goto found_no_lwfn_file;
    1235 
    1236         err = FT_FSpMakePath( &spec, path_fond, sizeof ( path_fond ) );
    1237         if ( noErr != err )
    1238           goto found_no_lwfn_file;
    1239 
    1240         error = lookup_lwfn_by_fond( path_fond, lwfn_file_name,
    1241                                      path_lwfn, sizeof ( path_lwfn ) );
    1242         if ( FT_Err_Ok == error )
    1243           have_lwfn = 1;
    1244       }
    1245 
    1246 #endif /* HAVE_FSREF, HAVE_FSSPEC */
    1247 
    1248855    }
    1249856
     
    1354961                          FT_Face*      aface )
    1355962  {
    1356 
    1357 #if !HAVE_FSREF
    1358 
    1359     return FT_Err_Unimplemented_Feature;
    1360 
    1361 #else
    1362 
    1363963    FT_Error      error;
    1364964    FT_Open_Args  args;
     
    1382982    args.pathname = (char*)pathname;
    1383983    return FT_Open_Face( library, &args, face_index, aface );
    1384 
    1385 #endif /* HAVE_FSREF */
    1386 
    1387984  }
    1388985
     
    14031000                           FT_Face*       aface )
    14041001  {
    1405 
    1406 #if HAVE_FSREF
    1407 
    14081002    FSRef  ref;
    14091003
     
    14131007    else
    14141008      return FT_New_Face_From_FSRef( library, &ref, face_index, aface );
    1415 
    1416 #elif HAVE_FSSPEC
    1417 
    1418     FT_Error      error;
    1419     FT_Open_Args  args;
    1420     OSErr         err;
    1421     UInt8         pathname[HFS_MAXPATHLEN];
    1422 
    1423 
    1424     if ( !spec )
    1425       return FT_Err_Invalid_Argument;
    1426 
    1427     err = FT_FSpMakePath( spec, pathname, sizeof ( pathname ) );
    1428     if ( err )
    1429       error = FT_Err_Cannot_Open_Resource;
    1430 
    1431     error = FT_New_Face_From_Resource( library, pathname, face_index, aface );
    1432     if ( error != 0 || *aface != NULL )
    1433       return error;
    1434 
    1435     /* fallback to datafork font */
    1436     args.flags    = FT_OPEN_PATHNAME;
    1437     args.pathname = (char*)pathname;
    1438     return FT_Open_Face( library, &args, face_index, aface );
    1439 
    1440 #else
    1441 
    1442     return FT_Err_Unimplemented_Feature;
    1443 
    1444 #endif /* HAVE_FSREF, HAVE_FSSPEC */
    1445 
    14461009  }
    14471010
Note: See TracChangeset for help on using the changeset viewer.