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