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