projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[CMAKE]
[reactos.git] / lib / 3rdparty / freetype / src / cff / cffobjs.c
1 /***************************************************************************/
2 /* */
3 /* cffobjs.c */
4 /* */
5 /* OpenType objects manager (body). */
6 /* */
7 /* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 by */
8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
9 /* */
10 /* This file is part of the FreeType project, and may only be used, */
11 /* modified, and distributed under the terms of the FreeType project */
12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
13 /* this file you indicate that you have read the license and */
14 /* understand and accept it fully. */
15 /* */
16 /***************************************************************************/
17
18
19 #include <ft2build.h>
20 #include FT_INTERNAL_DEBUG_H
21 #include FT_INTERNAL_CALC_H
22 #include FT_INTERNAL_STREAM_H
23 #include FT_ERRORS_H
24 #include FT_TRUETYPE_IDS_H
25 #include FT_TRUETYPE_TAGS_H
26 #include FT_INTERNAL_SFNT_H
27 #include FT_SERVICE_POSTSCRIPT_CMAPS_H
28 #include FT_INTERNAL_POSTSCRIPT_HINTS_H
29 #include "cffobjs.h"
30 #include "cffload.h"
31 #include "cffcmap.h"
32 #include "cfferrs.h"
33 #include "cffpic.h"
34
35
36 /*************************************************************************/
37 /* */
38 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
39 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
40 /* messages during execution. */
41 /* */
42 #undef FT_COMPONENT
43 #define FT_COMPONENT trace_cffobjs
44
45
46 /*************************************************************************/
47 /* */
48 /* SIZE FUNCTIONS */
49 /* */
50 /* Note that we store the global hints in the size's `internal' root */
51 /* field. */
52 /* */
53 /*************************************************************************/
54
55
56 static PSH_Globals_Funcs
57 cff_size_get_globals_funcs( CFF_Size size )
58 {
59 CFF_Face face = (CFF_Face)size->root.face;
60 CFF_Font font = (CFF_Font)face->extra.data;
61 PSHinter_Service pshinter = (PSHinter_Service)font->pshinter;
62 FT_Module module;
63
64
65 module = FT_Get_Module( size->root.face->driver->root.library,
66 "pshinter" );
67 return ( module && pshinter && pshinter->get_globals_funcs )
68 ? pshinter->get_globals_funcs( module )
69 : 0;
70 }
71
72
73 FT_LOCAL_DEF( void )
74 cff_size_done( FT_Size cffsize ) /* CFF_Size */
75 {
76 CFF_Size size = (CFF_Size)cffsize;
77 CFF_Face face = (CFF_Face)size->root.face;
78 CFF_Font font = (CFF_Font)face->extra.data;
79 CFF_Internal internal = (CFF_Internal)cffsize->internal;
80
81
82 if ( internal )
83 {
84 PSH_Globals_Funcs funcs;
85
86
87 funcs = cff_size_get_globals_funcs( size );
88 if ( funcs )
89 {
90 FT_UInt i;
91
92
93 funcs->destroy( internal->topfont );
94
95 for ( i = font->num_subfonts; i > 0; i-- )
96 funcs->destroy( internal->subfonts[i - 1] );
97 }
98
99 /* `internal' is freed by destroy_size (in ftobjs.c) */
100 }
101 }
102
103
104 /* CFF and Type 1 private dictionaries have slightly different */
105 /* structures; we need to synthesize a Type 1 dictionary on the fly */
106
107 static void
108 cff_make_private_dict( CFF_SubFont subfont,
109 PS_Private priv )
110 {
111 CFF_Private cpriv = &subfont->private_dict;
112 FT_UInt n, count;
113
114
115 FT_MEM_ZERO( priv, sizeof ( *priv ) );
116
117 count = priv->num_blue_values = cpriv->num_blue_values;
118 for ( n = 0; n < count; n++ )
119 priv->blue_values[n] = (FT_Short)cpriv->blue_values[n];
120
121 count = priv->num_other_blues = cpriv->num_other_blues;
122 for ( n = 0; n < count; n++ )
123 priv->other_blues[n] = (FT_Short)cpriv->other_blues[n];
124
125 count = priv->num_family_blues = cpriv->num_family_blues;
126 for ( n = 0; n < count; n++ )
127 priv->family_blues[n] = (FT_Short)cpriv->family_blues[n];
128
129 count = priv->num_family_other_blues = cpriv->num_family_other_blues;
130 for ( n = 0; n < count; n++ )
131 priv->family_other_blues[n] = (FT_Short)cpriv->family_other_blues[n];
132
133 priv->blue_scale = cpriv->blue_scale;
134 priv->blue_shift = (FT_Int)cpriv->blue_shift;
135 priv->blue_fuzz = (FT_Int)cpriv->blue_fuzz;
136
137 priv->standard_width[0] = (FT_UShort)cpriv->standard_width;
138 priv->standard_height[0] = (FT_UShort)cpriv->standard_height;
139
140 count = priv->num_snap_widths = cpriv->num_snap_widths;
141 for ( n = 0; n < count; n++ )
142 priv->snap_widths[n] = (FT_Short)cpriv->snap_widths[n];
143
144 count = priv->num_snap_heights = cpriv->num_snap_heights;
145 for ( n = 0; n < count; n++ )
146 priv->snap_heights[n] = (FT_Short)cpriv->snap_heights[n];
147
148 priv->force_bold = cpriv->force_bold;
149 priv->language_group = cpriv->language_group;
150 priv->lenIV = cpriv->lenIV;
151 }
152
153
154 FT_LOCAL_DEF( FT_Error )
155 cff_size_init( FT_Size cffsize ) /* CFF_Size */
156 {
157 CFF_Size size = (CFF_Size)cffsize;
158 FT_Error error = CFF_Err_Ok;
159 PSH_Globals_Funcs funcs = cff_size_get_globals_funcs( size );
160
161
162 if ( funcs )
163 {
164 CFF_Face face = (CFF_Face)cffsize->face;
165 CFF_Font font = (CFF_Font)face->extra.data;
166 CFF_Internal internal;
167
168 PS_PrivateRec priv;
169 FT_Memory memory = cffsize->face->memory;
170
171 FT_UInt i;
172
173
174 if ( FT_NEW( internal ) )
175 goto Exit;
176
177 cff_make_private_dict( &font->top_font, &priv );
178 error = funcs->create( cffsize->face->memory, &priv,
179 &internal->topfont );
180 if ( error )
181 goto Exit;
182
183 for ( i = font->num_subfonts; i > 0; i-- )
184 {
185 CFF_SubFont sub = font->subfonts[i - 1];
186
187
188 cff_make_private_dict( sub, &priv );
189 error = funcs->create( cffsize->face->memory, &priv,
190 &internal->subfonts[i - 1] );
191 if ( error )
192 goto Exit;
193 }
194
195 cffsize->internal = (FT_Size_Internal)(void*)internal;
196 }
197
198 size->strike_index = 0xFFFFFFFFUL;
199
200 Exit:
201 return error;
202 }
203
204
205 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
206
207 FT_LOCAL_DEF( FT_Error )
208 cff_size_select( FT_Size size,
209 FT_ULong strike_index )
210 {
211 CFF_Size cffsize = (CFF_Size)size;
212 PSH_Globals_Funcs funcs;
213
214
215 cffsize->strike_index = strike_index;
216
217 FT_Select_Metrics( size->face, strike_index );
218
219 funcs = cff_size_get_globals_funcs( cffsize );
220
221 if ( funcs )
222 {
223 CFF_Face face = (CFF_Face)size->face;
224 CFF_Font font = (CFF_Font)face->extra.data;
225 CFF_Internal internal = (CFF_Internal)size->internal;
226
227 FT_ULong top_upm = font->top_font.font_dict.units_per_em;
228 FT_UInt i;
229
230
231 funcs->set_scale( internal->topfont,
232 size->metrics.x_scale, size->metrics.y_scale,
233 0, 0 );
234
235 for ( i = font->num_subfonts; i > 0; i-- )
236 {
237 CFF_SubFont sub = font->subfonts[i - 1];
238 FT_ULong sub_upm = sub->font_dict.units_per_em;
239 FT_Pos x_scale, y_scale;
240
241
242 if ( top_upm != sub_upm )
243 {
244 x_scale = FT_MulDiv( size->metrics.x_scale, top_upm, sub_upm );
245 y_scale = FT_MulDiv( size->metrics.y_scale, top_upm, sub_upm );
246 }
247 else
248 {
249 x_scale = size->metrics.x_scale;
250 y_scale = size->metrics.y_scale;
251 }
252
253 funcs->set_scale( internal->subfonts[i - 1],
254 x_scale, y_scale, 0, 0 );
255 }
256 }
257
258 return CFF_Err_Ok;
259 }
260
261 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
262
263
264 FT_LOCAL_DEF( FT_Error )
265 cff_size_request( FT_Size size,
266 FT_Size_Request req )
267 {
268 CFF_Size cffsize = (CFF_Size)size;
269 PSH_Globals_Funcs funcs;
270
271
272 #ifdef TT_CONFIG_OPTION_EMBEDDED_BITMAPS
273
274 if ( FT_HAS_FIXED_SIZES( size->face ) )
275 {
276 CFF_Face cffface = (CFF_Face)size->face;
277 SFNT_Service sfnt = (SFNT_Service)cffface->sfnt;
278 FT_ULong strike_index;
279
280
281 if ( sfnt->set_sbit_strike( cffface, req, &strike_index ) )
282 cffsize->strike_index = 0xFFFFFFFFUL;
283 else
284 return cff_size_select( size, strike_index );
285 }
286
287 #endif /* TT_CONFIG_OPTION_EMBEDDED_BITMAPS */
288
289 FT_Request_Metrics( size->face, req );
290
291 funcs = cff_size_get_globals_funcs( cffsize );
292
293 if ( funcs )
294 {
295 CFF_Face cffface = (CFF_Face)size->face;
296 CFF_Font font = (CFF_Font)cffface->extra.data;
297 CFF_Internal internal = (CFF_Internal)size->internal;
298
299 FT_ULong top_upm = font->top_font.font_dict.units_per_em;
300 FT_UInt i;
301
302
303 funcs->set_scale( internal->topfont,
304 size->metrics.x_scale, size->metrics.y_scale,
305 0, 0 );
306
307 for ( i = font->num_subfonts; i > 0; i-- )
308 {
309 CFF_SubFont sub = font->subfonts[i - 1];
310 FT_ULong sub_upm = sub->font_dict.units_per_em;
311 FT_Pos x_scale, y_scale;
312
313
314 if ( top_upm != sub_upm )
315 {
316 x_scale = FT_MulDiv( size->metrics.x_scale, top_upm, sub_upm );
317 y_scale = FT_MulDiv( size->metrics.y_scale, top_upm, sub_upm );
318 }
319 else
320 {
321 x_scale = size->metrics.x_scale;
322 y_scale = size->metrics.y_scale;
323 }
324
325 funcs->set_scale( internal->subfonts[i - 1],
326 x_scale, y_scale, 0, 0 );
327 }
328 }
329
330 return CFF_Err_Ok;
331 }
332
333
334 /*************************************************************************/
335 /* */
336 /* SLOT FUNCTIONS */
337 /* */
338 /*************************************************************************/
339
340 FT_LOCAL_DEF( void )
341 cff_slot_done( FT_GlyphSlot slot )
342 {
343 slot->internal->glyph_hints = 0;
344 }
345
346
347 FT_LOCAL_DEF( FT_Error )
348 cff_slot_init( FT_GlyphSlot slot )
349 {
350 CFF_Face face = (CFF_Face)slot->face;
351 CFF_Font font = (CFF_Font)face->extra.data;
352 PSHinter_Service pshinter = (PSHinter_Service)font->pshinter;
353
354
355 if ( pshinter )
356 {
357 FT_Module module;
358
359
360 module = FT_Get_Module( slot->face->driver->root.library,
361 "pshinter" );
362 if ( module )
363 {
364 T2_Hints_Funcs funcs;
365
366
367 funcs = pshinter->get_t2_funcs( module );
368 slot->internal->glyph_hints = (void*)funcs;
369 }
370 }
371
372 return CFF_Err_Ok;
373 }
374
375
376 /*************************************************************************/
377 /* */
378 /* FACE FUNCTIONS */
379 /* */
380 /*************************************************************************/
381
382 static FT_String*
383 cff_strcpy( FT_Memory memory,
384 const FT_String* source )
385 {
386 FT_Error error;
387 FT_String* result;
388
389
390 (void)FT_STRDUP( result, source );
391
392 FT_UNUSED( error );
393
394 return result;
395 }
396
397
398 FT_LOCAL_DEF( FT_Error )
399 cff_face_init( FT_Stream stream,
400 FT_Face cffface, /* CFF_Face */
401 FT_Int face_index,
402 FT_Int num_params,
403 FT_Parameter* params )
404 {
405 CFF_Face face = (CFF_Face)cffface;
406 FT_Error error;
407 SFNT_Service sfnt;
408 FT_Service_PsCMaps psnames;
409 PSHinter_Service pshinter;
410 FT_Bool pure_cff = 1;
411 FT_Bool sfnt_format = 0;
412 FT_Library library = cffface->driver->root.library;
413
414
415 #if 0
416 FT_FACE_FIND_GLOBAL_SERVICE( face, sfnt, SFNT );
417 FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_NAMES );
418 FT_FACE_FIND_GLOBAL_SERVICE( face, pshinter, POSTSCRIPT_HINTER );
419
420 if ( !sfnt )
421 goto Bad_Format;
422 #else
423 sfnt = (SFNT_Service)FT_Get_Module_Interface(
424 library, "sfnt" );
425 if ( !sfnt )
426 goto Bad_Format;
427
428 FT_FACE_FIND_GLOBAL_SERVICE( face, psnames, POSTSCRIPT_CMAPS );
429
430 pshinter = (PSHinter_Service)FT_Get_Module_Interface(
431 library, "pshinter" );
432 #endif
433
434 /* create input stream from resource */
435 if ( FT_STREAM_SEEK( 0 ) )
436 goto Exit;
437
438 /* check whether we have a valid OpenType file */
439 error = sfnt->init_face( stream, face, face_index, num_params, params );
440 if ( !error )
441 {
442 if ( face->format_tag != TTAG_OTTO ) /* `OTTO'; OpenType/CFF font */
443 {
444 FT_TRACE2(( "[not a valid OpenType/CFF font]\n" ));
445 goto Bad_Format;
446 }
447
448 /* if we are performing a simple font format check, exit immediately */
449 if ( face_index < 0 )
450 return CFF_Err_Ok;
451
452 /* UNDOCUMENTED! A CFF in an SFNT can have only a single font. */
453 if ( face_index > 0 )
454 {
455 FT_ERROR(( "cff_face_init: invalid face index\n" ));
456 error = CFF_Err_Invalid_Argument;
457 goto Exit;
458 }
459
460 sfnt_format = 1;
461
462 /* now, the font can be either an OpenType/CFF font, or an SVG CEF */
463 /* font; in the latter case it doesn't have a `head' table */
464 error = face->goto_table( face, TTAG_head, stream, 0 );
465 if ( !error )
466 {
467 pure_cff = 0;
468
469 /* load font directory */
470 error = sfnt->load_face( stream, face, 0, num_params, params );
471 if ( error )
472 goto Exit;
473 }
474 else
475 {
476 /* load the `cmap' table explicitly */
477 error = sfnt->load_cmap( face, stream );
478 if ( error )
479 goto Exit;
480
481 /* XXX: we don't load the GPOS table, as OpenType Layout */
482 /* support will be added later to a layout library on top of */
483 /* FreeType 2 */
484 }
485
486 /* now load the CFF part of the file */
487 error = face->goto_table( face, TTAG_CFF, stream, 0 );
488 if ( error )
489 goto Exit;
490 }
491 else
492 {
493 /* rewind to start of file; we are going to load a pure-CFF font */
494 if ( FT_STREAM_SEEK( 0 ) )
495 goto Exit;
496 error = CFF_Err_Ok;
497 }
498
499 /* now load and parse the CFF table in the file */
500 {
501 CFF_Font cff;
502 CFF_FontRecDict dict;
503 FT_Memory memory = cffface->memory;
504 FT_Int32 flags;
505 FT_UInt i;
506
507
508 if ( FT_NEW( cff ) )
509 goto Exit;
510
511 face->extra.data = cff;
512 error = cff_font_load( library, stream, face_index, cff, pure_cff );
513 if ( error )
514 goto Exit;
515
516 cff->pshinter = pshinter;
517 cff->psnames = (void*)psnames;
518
519 cffface->face_index = face_index;
520
521 /* Complement the root flags with some interesting information. */
522 /* Note that this is only necessary for pure CFF and CEF fonts; */
523 /* SFNT based fonts use the `name' table instead. */
524
525 cffface->num_glyphs = cff->num_glyphs;
526
527 dict = &cff->top_font.font_dict;
528
529 /* we need the `PSNames' module for CFF and CEF formats */
530 /* which aren't CID-keyed */
531 if ( dict->cid_registry == 0xFFFFU && !psnames )
532 {
533 FT_ERROR(( "cff_face_init:"
534 " cannot open CFF & CEF fonts\n"
535 " "
536 " without the `PSNames' module\n" ));
537 goto Bad_Format;
538 }
539
540 if ( !dict->units_per_em )
541 dict->units_per_em = pure_cff ? 1000 : face->root.units_per_EM;
542
543 /* Normalize the font matrix so that `matrix->xx' is 1; the */
544 /* scaling is done with `units_per_em' then (at this point, */
545 /* it already contains the scaling factor, but without */
546 /* normalization of the matrix). */
547 /* */
548 /* Note that the offsets must be expressed in integer font */
549 /* units. */
550
551 {
552 FT_Matrix* matrix = &dict->font_matrix;
553 FT_Vector* offset = &dict->font_offset;
554 FT_ULong* upm = &dict->units_per_em;
555 FT_Fixed temp = FT_ABS( matrix->yy );
556
557
558 if ( temp != 0x10000L )
559 {
560 *upm = FT_DivFix( *upm, temp );
561
562 matrix->xx = FT_DivFix( matrix->xx, temp );
563 matrix->yx = FT_DivFix( matrix->yx, temp );
564 matrix->xy = FT_DivFix( matrix->xy, temp );
565 matrix->yy = FT_DivFix( matrix->yy, temp );
566 offset->x = FT_DivFix( offset->x, temp );
567 offset->y = FT_DivFix( offset->y, temp );
568 }
569
570 offset->x >>= 16;
571 offset->y >>= 16;
572 }
573
574 for ( i = cff->num_subfonts; i > 0; i-- )
575 {
576 CFF_FontRecDict sub = &cff->subfonts[i - 1]->font_dict;
577 CFF_FontRecDict top = &cff->top_font.font_dict;
578
579 FT_Matrix* matrix;
580 FT_Vector* offset;
581 FT_ULong* upm;
582 FT_Fixed temp;
583
584
585 if ( sub->units_per_em )
586 {
587 FT_Long scaling;
588
589
590 if ( top->units_per_em > 1 && sub->units_per_em > 1 )
591 scaling = FT_MIN( top->units_per_em, sub->units_per_em );
592 else
593 scaling = 1;
594
595 FT_Matrix_Multiply_Scaled( &top->font_matrix,
596 &sub->font_matrix,
597 scaling );
598 FT_Vector_Transform_Scaled( &sub->font_offset,
599 &top->font_matrix,
600 scaling );
601
602 sub->units_per_em = FT_MulDiv( sub->units_per_em,
603 top->units_per_em,
604 scaling );
605 }
606 else
607 {
608 sub->font_matrix = top->font_matrix;
609 sub->font_offset = top->font_offset;
610
611 sub->units_per_em = top->units_per_em;
612 }
613
614 matrix = &sub->font_matrix;
615 offset = &sub->font_offset;
616 upm = &sub->units_per_em;
617 temp = FT_ABS( matrix->yy );
618
619 if ( temp != 0x10000L )
620 {
621 *upm = FT_DivFix( *upm, temp );
622
623 /* if *upm is larger than 100*1000 we divide by 1000 -- */
624 /* this can happen if e.g. there is no top-font FontMatrix */
625 /* and the subfont FontMatrix already contains the complete */
626 /* scaling for the subfont (see section 5.11 of the PLRM) */
627
628 /* 100 is a heuristic value */
629
630 if ( *upm > 100L * 1000L )
631 *upm = ( *upm + 500 ) / 1000;
632
633 matrix->xx = FT_DivFix( matrix->xx, temp );
634 matrix->yx = FT_DivFix( matrix->yx, temp );
635 matrix->xy = FT_DivFix( matrix->xy, temp );
636 matrix->yy = FT_DivFix( matrix->yy, temp );
637 offset->x = FT_DivFix( offset->x, temp );
638 offset->y = FT_DivFix( offset->y, temp );
639 }
640
641 offset->x >>= 16;
642 offset->y >>= 16;
643 }
644
645 if ( pure_cff )
646 {
647 char* style_name = NULL;
648
649
650 /* set up num_faces */
651 cffface->num_faces = cff->num_faces;
652
653 /* compute number of glyphs */
654 if ( dict->cid_registry != 0xFFFFU )
655 cffface->num_glyphs = cff->charset.max_cid;
656 else
657 cffface->num_glyphs = cff->charstrings_index.count;
658
659 /* set global bbox, as well as EM size */
660 cffface->bbox.xMin = dict->font_bbox.xMin >> 16;
661 cffface->bbox.yMin = dict->font_bbox.yMin >> 16;
662 /* no `U' suffix here to 0xFFFF! */
663 cffface->bbox.xMax = ( dict->font_bbox.xMax + 0xFFFF ) >> 16;
664 cffface->bbox.yMax = ( dict->font_bbox.yMax + 0xFFFF ) >> 16;
665
666 cffface->units_per_EM = (FT_UShort)( dict->units_per_em );
667
668 cffface->ascender = (FT_Short)( cffface->bbox.yMax );
669 cffface->descender = (FT_Short)( cffface->bbox.yMin );
670
671 cffface->height = (FT_Short)( ( cffface->units_per_EM * 12 ) / 10 );
672 if ( cffface->height < cffface->ascender - cffface->descender )
673 cffface->height = (FT_Short)( cffface->ascender - cffface->descender );
674
675 cffface->underline_position =
676 (FT_Short)( dict->underline_position >> 16 );
677 cffface->underline_thickness =
678 (FT_Short)( dict->underline_thickness >> 16 );
679
680 /* retrieve font family & style name */
681 cffface->family_name = cff_index_get_name( &cff->name_index,
682 face_index );
683
684 if ( cffface->family_name )
685 {
686 char* full = cff_index_get_sid_string( &cff->string_index,
687 dict->full_name,
688 psnames );
689 char* fullp = full;
690 char* family = cffface->family_name;
691 char* family_name = 0;
692
693
694 if ( dict->family_name )
695 {
696 family_name = cff_index_get_sid_string( &cff->string_index,
697 dict->family_name,
698 psnames);
699 if ( family_name )
700 family = family_name;
701 }
702
703 /* We try to extract the style name from the full name. */
704 /* We need to ignore spaces and dashes during the search. */
705 if ( full && family )
706 {
707 while ( *fullp )
708 {
709 /* skip common characters at the start of both strings */
710 if ( *fullp == *family )
711 {
712 family++;
713 fullp++;
714 continue;
715 }
716
717 /* ignore spaces and dashes in full name during comparison */
718 if ( *fullp == ' ' || *fullp == '-' )
719 {
720 fullp++;
721 continue;
722 }
723
724 /* ignore spaces and dashes in family name during comparison */
725 if ( *family == ' ' || *family == '-' )
726 {
727 family++;
728 continue;
729 }
730
731 if ( !*family && *fullp )
732 {
733 /* The full name begins with the same characters as the */
734 /* family name, with spaces and dashes removed. In this */
735 /* case, the remaining string in `fullp' will be used as */
736 /* the style name. */
737 style_name = cff_strcpy( memory, fullp );
738 }
739 break;
740 }
741
742 if ( family_name )
743 FT_FREE( family_name );
744 FT_FREE( full );
745 }
746 }
747 else
748 {
749 char *cid_font_name =
750 cff_index_get_sid_string( &cff->string_index,
751 dict->cid_font_name,
752 psnames );
753
754
755 /* do we have a `/FontName' for a CID-keyed font? */
756 if ( cid_font_name )
757 cffface->family_name = cid_font_name;
758 }
759
760 if ( style_name )
761 cffface->style_name = style_name;
762 else
763 /* assume "Regular" style if we don't know better */
764 cffface->style_name = cff_strcpy( memory, (char *)"Regular" );
765
766 /*******************************************************************/
767 /* */
768 /* Compute face flags. */
769 /* */
770 flags = (FT_UInt32)( FT_FACE_FLAG_SCALABLE | /* scalable outlines */
771 FT_FACE_FLAG_HORIZONTAL | /* horizontal data */
772 FT_FACE_FLAG_HINTER ); /* has native hinter */
773
774 if ( sfnt_format )
775 flags |= (FT_UInt32)FT_FACE_FLAG_SFNT;
776
777 /* fixed width font? */
778 if ( dict->is_fixed_pitch )
779 flags |= (FT_UInt32)FT_FACE_FLAG_FIXED_WIDTH;
780
781 /* XXX: WE DO NOT SUPPORT KERNING METRICS IN THE GPOS TABLE FOR NOW */
782 #if 0
783 /* kerning available? */
784 if ( face->kern_pairs )
785 flags |= (FT_UInt32)FT_FACE_FLAG_KERNING;
786 #endif
787
788 cffface->face_flags = flags;
789
790 /*******************************************************************/
791 /* */
792 /* Compute style flags. */
793 /* */
794 flags = 0;
795
796 if ( dict->italic_angle )
797 flags |= FT_STYLE_FLAG_ITALIC;
798
799 {
800 char *weight = cff_index_get_sid_string( &cff->string_index,
801 dict->weight,
802 psnames );
803
804
805 if ( weight )
806 if ( !ft_strcmp( weight, "Bold" ) ||
807 !ft_strcmp( weight, "Black" ) )
808 flags |= FT_STYLE_FLAG_BOLD;
809 FT_FREE( weight );
810 }
811
812 /* double check */
813 if ( !(flags & FT_STYLE_FLAG_BOLD) && cffface->style_name )
814 if ( !ft_strncmp( cffface->style_name, "Bold", 4 ) ||
815 !ft_strncmp( cffface->style_name, "Black", 5 ) )
816 flags |= FT_STYLE_FLAG_BOLD;
817
818 cffface->style_flags = flags;
819 }
820
821
822 #ifndef FT_CONFIG_OPTION_NO_GLYPH_NAMES
823 /* CID-keyed CFF fonts don't have glyph names -- the SFNT loader */
824 /* has unset this flag because of the 3.0 `post' table. */
825 if ( dict->cid_registry == 0xFFFFU )
826 cffface->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
827 #endif
828
829 if ( dict->cid_registry != 0xFFFFU && pure_cff )
830 cffface->face_flags |= FT_FACE_FLAG_CID_KEYED;
831
832
833 /*******************************************************************/
834 /* */
835 /* Compute char maps. */
836 /* */
837
838 /* Try to synthesize a Unicode charmap if there is none available */
839 /* already. If an OpenType font contains a Unicode "cmap", we */
840 /* will use it, whatever be in the CFF part of the file. */
841 {
842 FT_CharMapRec cmaprec;
843 FT_CharMap cmap;
844 FT_UInt nn;
845 CFF_Encoding encoding = &cff->encoding;
846
847
848 for ( nn = 0; nn < (FT_UInt)cffface->num_charmaps; nn++ )
849 {
850 cmap = cffface->charmaps[nn];
851
852 /* Windows Unicode (3,1)? */
853 if ( cmap->platform_id == 3 && cmap->encoding_id == 1 )
854 goto Skip_Unicode;
855
856 /* Deprecated Unicode platform id? */
857 if ( cmap->platform_id == 0 )
858 goto Skip_Unicode; /* Standard Unicode (deprecated) */
859 }
860
861 /* since CID-keyed fonts don't contain glyph names, we can't */
862 /* construct a cmap */
863 if ( pure_cff && cff->top_font.font_dict.cid_registry != 0xFFFFU )
864 goto Exit;
865
866 /* we didn't find a Unicode charmap -- synthesize one */
867 cmaprec.face = cffface;
868 cmaprec.platform_id = 3;
869 cmaprec.encoding_id = 1;
870 cmaprec.encoding = FT_ENCODING_UNICODE;
871
872 nn = (FT_UInt)cffface->num_charmaps;
873
874 FT_CMap_New( &FT_CFF_CMAP_UNICODE_CLASS_REC_GET, NULL, &cmaprec, NULL );
875
876 /* if no Unicode charmap was previously selected, select this one */
877 if ( cffface->charmap == NULL && nn != (FT_UInt)cffface->num_charmaps )
878 cffface->charmap = cffface->charmaps[nn];
879
880 Skip_Unicode:
881 if ( encoding->count > 0 )
882 {
883 FT_CMap_Class clazz;
884
885
886 cmaprec.face = cffface;
887 cmaprec.platform_id = 7; /* Adobe platform id */
888
889 if ( encoding->offset == 0 )
890 {
891 cmaprec.encoding_id = TT_ADOBE_ID_STANDARD;
892 cmaprec.encoding = FT_ENCODING_ADOBE_STANDARD;
893 clazz = &FT_CFF_CMAP_ENCODING_CLASS_REC_GET;
894 }
895 else if ( encoding->offset == 1 )
896 {
897 cmaprec.encoding_id = TT_ADOBE_ID_EXPERT;
898 cmaprec.encoding = FT_ENCODING_ADOBE_EXPERT;
899 clazz = &FT_CFF_CMAP_ENCODING_CLASS_REC_GET;
900 }
901 else
902 {
903 cmaprec.encoding_id = TT_ADOBE_ID_CUSTOM;
904 cmaprec.encoding = FT_ENCODING_ADOBE_CUSTOM;
905 clazz = &FT_CFF_CMAP_ENCODING_CLASS_REC_GET;
906 }
907
908 FT_CMap_New( clazz, NULL, &cmaprec, NULL );
909 }
910 }
911 }
912
913 Exit:
914 return error;
915
916 Bad_Format:
917 error = CFF_Err_Unknown_File_Format;
918 goto Exit;
919 }
920
921
922 FT_LOCAL_DEF( void )
923 cff_face_done( FT_Face cffface ) /* CFF_Face */
924 {
925 CFF_Face face = (CFF_Face)cffface;
926 FT_Memory memory;
927 SFNT_Service sfnt;
928
929
930 if ( !face )
931 return;
932
933 memory = cffface->memory;
934 sfnt = (SFNT_Service)face->sfnt;
935
936 if ( sfnt )
937 sfnt->done_face( face );
938
939 {
940 CFF_Font cff = (CFF_Font)face->extra.data;
941
942
943 if ( cff )
944 {
945 cff_font_done( cff );
946 FT_FREE( face->extra.data );
947 }
948 }
949 }
950
951
952 FT_LOCAL_DEF( FT_Error )
953 cff_driver_init( FT_Module module )
954 {
955 FT_UNUSED( module );
956
957 return CFF_Err_Ok;
958 }
959
960
961 FT_LOCAL_DEF( void )
962 cff_driver_done( FT_Module module )
963 {
964 FT_UNUSED( module );
965 }
966
967
968 /* END */
A free Windows-compatible Operating System