]> git.saurik.com Git - wxWidgets.git/blob - src/freetype/type1/t1gload.c
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fixed to recognise the FINAL=hybrid make flag and to then use the
[wxWidgets.git] / src / freetype / type1 / t1gload.c
1 /***************************************************************************/
2 /* */
3 /* t1gload.c */
4 /* */
5 /* Type 1 Glyph Loader (body). */
6 /* */
7 /* Copyright 1996-2000 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 #ifdef FT_FLAT_COMPILE
20
21 #include "t1gload.h"
22
23 #ifndef T1_CONFIG_OPTION_DISABLE_HINTER
24 #include "t1hinter.h"
25 #endif
26
27 #else /* FT_FLAT_COMPILE */
28
29 #include <type1/t1gload.h>
30
31 #ifndef T1_CONFIG_OPTION_DISABLE_HINTER
32 #include <type1/t1hinter.h>
33 #endif
34
35 #endif /* FT_FLAT_COMPILE */
36
37
38 #include <freetype/internal/ftdebug.h>
39 #include <freetype/internal/ftstream.h>
40 #include <freetype/ftoutln.h>
41
42 #include <string.h> /* for strcmp() */
43
44
45 /*************************************************************************/
46 /* */
47 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */
48 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
49 /* messages during execution. */
50 /* */
51 #undef FT_COMPONENT
52 #define FT_COMPONENT trace_t1gload
53
54
55 /*************************************************************************/
56 /*************************************************************************/
57 /*************************************************************************/
58 /********** *********/
59 /********** *********/
60 /********** GENERIC CHARSTRING PARSING *********/
61 /********** *********/
62 /********** *********/
63 /*************************************************************************/
64 /*************************************************************************/
65 /*************************************************************************/
66
67
68 static
69 void T1_Reset_Builder( T1_Builder* builder,
70 FT_Bool reset_base )
71 {
72 builder->pos_x = 0;
73 builder->pos_y = 0;
74
75 builder->left_bearing.x = 0;
76 builder->left_bearing.y = 0;
77 builder->advance.x = 0;
78 builder->advance.y = 0;
79
80 builder->pass = 0;
81 builder->hint_point = 0;
82
83 if ( builder->loader )
84 {
85 if ( reset_base )
86 FT_GlyphLoader_Rewind( builder->loader );
87
88 FT_GlyphLoader_Prepare( builder->loader );
89 }
90 }
91
92
93 /*************************************************************************/
94 /* */
95 /* <Function> */
96 /* T1_Init_Builder */
97 /* */
98 /* <Description> */
99 /* Initializes a given glyph builder. */
100 /* */
101 /* <InOut> */
102 /* builder :: A pointer to the glyph builder to initialize. */
103 /* */
104 /* <Input> */
105 /* face :: The current face object. */
106 /* */
107 /* size :: The current size object. */
108 /* */
109 /* glyph :: The current glyph object. */
110 /* */
111 /* funcs :: Glyph builder functions (or `methods'). */
112 /* */
113 LOCAL_FUNC
114 void T1_Init_Builder( T1_Builder* builder,
115 T1_Face face,
116 T1_Size size,
117 T1_GlyphSlot glyph,
118 const T1_Builder_Funcs* funcs )
119 {
120 builder->funcs = *funcs;
121 builder->path_begun = 0;
122 builder->load_points = 1;
123
124 builder->face = face;
125 builder->size = size;
126 builder->glyph = glyph;
127 builder->memory = face->root.memory;
128
129 if ( glyph )
130 {
131 FT_GlyphLoader* loader = FT_SLOT( glyph )->loader;
132
133
134 builder->loader = loader;
135 builder->base = &loader->base.outline;
136 builder->current = &loader->current.outline;
137 }
138
139 if ( size )
140 {
141 builder->scale_x = size->root.metrics.x_scale;
142 builder->scale_y = size->root.metrics.y_scale;
143 }
144
145 T1_Reset_Builder( builder, 1 );
146 }
147
148
149 /*************************************************************************/
150 /* */
151 /* <Function> */
152 /* T1_Done_Builder */
153 /* */
154 /* <Description> */
155 /* Finalizes a given glyph builder. Its contents can still be used */
156 /* after the call, but the function saves important information */
157 /* within the corresponding glyph slot. */
158 /* */
159 /* <Input> */
160 /* builder :: A pointer to the glyph builder to finalize. */
161 /* */
162 LOCAL_FUNC
163 void T1_Done_Builder( T1_Builder* builder )
164 {
165 T1_GlyphSlot glyph = builder->glyph;
166
167
168 if ( glyph )
169 glyph->root.outline = *builder->base;
170 }
171
172
173 /*************************************************************************/
174 /* */
175 /* <Function> */
176 /* T1_Init_Decoder */
177 /* */
178 /* <Description> */
179 /* Initializes a given glyph decoder. */
180 /* */
181 /* <InOut> */
182 /* decoder :: A pointer to the glyph builder to initialize. */
183 /* */
184 /* <Input> */
185 /* funcs :: The hinting functions interface. */
186 /* */
187 LOCAL_FUNC
188 void T1_Init_Decoder( T1_Decoder* decoder,
189 const T1_Hinter_Funcs* funcs )
190 {
191 decoder->hinter = *funcs; /* copy hinter interface */
192 decoder->top = 0;
193 decoder->zone = 0;
194
195 decoder->flex_state = 0;
196 decoder->num_flex_vectors = 0;
197
198 /* Clear loader */
199 MEM_Set( &decoder->builder, 0, sizeof ( decoder->builder ) );
200 }
201
202
203 /*************************************************************************/
204 /* */
205 /* <Function> */
206 /* lookup_glyph_by_stdcharcode */
207 /* */
208 /* <Description> */
209 /* Looks up a given glyph by its StandardEncoding charcode. Used */
210 /* to implement the SEAC Type 1 operator. */
211 /* */
212 /* <Input> */
213 /* face :: The current face object. */
214 /* */
215 /* charcode :: The character code to look for. */
216 /* */
217 /* <Return> */
218 /* A glyph index in the font face. Returns -1 if the corresponding */
219 /* glyph wasn't found. */
220 /* */
221 static
222 FT_Int lookup_glyph_by_stdcharcode( T1_Face face,
223 FT_Int charcode )
224 {
225 FT_Int n;
226 const FT_String* glyph_name;
227 PSNames_Interface* psnames = (PSNames_Interface*)face->psnames;
228
229
230 /* check range of standard char code */
231 if ( charcode < 0 || charcode > 255 )
232 return -1;
233
234 glyph_name = psnames->adobe_std_strings(
235 psnames->adobe_std_encoding[charcode] );
236
237 for ( n = 0; n < face->type1.num_glyphs; n++ )
238 {
239 FT_String* name = (FT_String*)face->type1.glyph_names[n];
240
241
242 if ( name && strcmp( name, glyph_name ) == 0 )
243 return n;
244 }
245
246 return -1;
247 }
248
249
250 /*************************************************************************/
251 /* */
252 /* <Function> */
253 /* t1operator_seac */
254 /* */
255 /* <Description> */
256 /* Implements the `seac' Type 1 operator for a Type 1 decoder. */
257 /* */
258 /* <Input> */
259 /* decoder :: The current CID decoder. */
260 /* */
261 /* asb :: The accent's side bearing. */
262 /* */
263 /* adx :: The horizontal offset of the accent. */
264 /* */
265 /* ady :: The vertical offset of the accent. */
266 /* */
267 /* bchar :: The base character's StandardEncoding charcode. */
268 /* */
269 /* achar :: The accent character's StandardEncoding charcode. */
270 /* */
271 /* <Return> */
272 /* FreeType error code. 0 means success. */
273 /* */
274 static
275 FT_Error t1operator_seac( T1_Decoder* decoder,
276 FT_Pos asb,
277 FT_Pos adx,
278 FT_Pos ady,
279 FT_Int bchar,
280 FT_Int achar )
281 {
282 FT_Error error;
283 FT_Int bchar_index, achar_index, n_base_points;
284 FT_Outline* base = decoder->builder.base;
285 FT_Vector left_bearing, advance;
286 T1_Face face = decoder->builder.face;
287 T1_Font* type1 = &face->type1;
288
289
290 bchar_index = lookup_glyph_by_stdcharcode( face, bchar );
291 achar_index = lookup_glyph_by_stdcharcode( face, achar );
292
293 if ( bchar_index < 0 || achar_index < 0 )
294 {
295 FT_ERROR(( "t1operator_seac:" ));
296 FT_ERROR(( " invalid seac character code arguments\n" ));
297 return T1_Err_Syntax_Error;
298 }
299
300 /* if we are trying to load a composite glyph, do not load the */
301 /* accent character and return the array of subglyphs. */
302 if ( decoder->builder.no_recurse )
303 {
304 FT_GlyphSlot glyph = (FT_GlyphSlot)decoder->builder.glyph;
305 FT_GlyphLoader* loader = glyph->loader;
306 FT_SubGlyph* subg;
307
308
309 /* reallocate subglyph array if necessary */
310 error = FT_GlyphLoader_Check_Subglyphs( loader, 2 );
311 if ( error )
312 goto Exit;
313
314 subg = loader->current.subglyphs;
315
316 /* subglyph 0 = base character */
317 subg->index = bchar_index;
318 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES |
319 FT_SUBGLYPH_FLAG_USE_MY_METRICS;
320 subg->arg1 = 0;
321 subg->arg2 = 0;
322 subg++;
323
324 /* subglyph 1 = accent character */
325 subg->index = achar_index;
326 subg->flags = FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES;
327 subg->arg1 = adx - asb;
328 subg->arg2 = ady;
329
330 /* set up remaining glyph fields */
331 glyph->num_subglyphs = 2;
332 glyph->subglyphs = loader->current.subglyphs;
333 glyph->format = ft_glyph_format_composite;
334
335 loader->current.num_subglyphs = 2;
336 goto Exit;
337 }
338
339 /* First load `bchar' in builder */
340 /* now load the unscaled outline */
341
342 if ( decoder->builder.loader )
343 FT_GlyphLoader_Prepare( decoder->builder.loader ); /* prepare loader */
344
345 error = T1_Parse_CharStrings( decoder,
346 type1->charstrings [bchar_index],
347 type1->charstrings_len[bchar_index],
348 type1->num_subrs,
349 type1->subrs,
350 type1->subrs_len );
351 if ( error )
352 goto Exit;
353
354 n_base_points = base->n_points;
355
356 /* save the left bearing and width of the base character */
357 /* as they will be erased by the next load. */
358
359 left_bearing = decoder->builder.left_bearing;
360 advance = decoder->builder.advance;
361
362 decoder->builder.left_bearing.x = 0;
363 decoder->builder.left_bearing.y = 0;
364
365 /* Now load `achar' on top of the base outline */
366 error = T1_Parse_CharStrings( decoder,
367 type1->charstrings [achar_index],
368 type1->charstrings_len[achar_index],
369 type1->num_subrs,
370 type1->subrs,
371 type1->subrs_len );
372 if ( error )
373 return error;
374
375 /* restore the left side bearing and */
376 /* advance width of the base character */
377
378 decoder->builder.left_bearing = left_bearing;
379 decoder->builder.advance = advance;
380
381 /* Finally, move the accent */
382 if ( decoder->builder.load_points )
383 {
384 FT_Outline dummy;
385
386
387 dummy.n_points = base->n_points - n_base_points;
388 dummy.points = base->points + n_base_points;
389
390 FT_Outline_Translate( &dummy, adx - asb, ady );
391 }
392
393 Exit:
394 return error;
395 }
396
397
398 /*************************************************************************/
399 /* */
400 /* <Function> */
401 /* t1operator_flex */
402 /* */
403 /* <Description> */
404 /* Implements the `flex' Type 1 operator for a Type 1 decoder. */
405 /* */
406 /* <Input> */
407 /* decoder :: The current Type 1 decoder. */
408 /* threshold :: The threshold. */
409 /* end_x :: The horizontal position of the final flex point. */
410 /* end_y :: The vertical position of the final flex point. */
411 /* */
412 /* <Return> */
413 /* FreeType error code. 0 means success. */
414 /* */
415 static
416 FT_Error t1operator_flex( T1_Decoder* decoder,
417 FT_Pos threshold,
418 FT_Pos end_x,
419 FT_Pos end_y )
420 {
421 FT_Vector vec;
422 FT_Vector* flex = decoder->flex_vectors;
423 FT_Int n;
424
425 FT_UNUSED( threshold );
426 FT_UNUSED( end_x );
427 FT_UNUSED( end_y );
428
429
430 /* we don't even try to test the threshold in the non-hinting */
431 /* builder, even if the flex operator is said to be a path */
432 /* construction statement in the specification. This is better */
433 /* left to the hinter. */
434
435 flex = decoder->flex_vectors;
436 vec = *flex++;
437
438 for ( n = 0; n < 6; n++ )
439 {
440 flex->x += vec.x;
441 flex->y += vec.y;
442
443 vec = *flex++;
444 }
445
446 flex = decoder->flex_vectors;
447
448 return decoder->builder.funcs.rcurve_to( &decoder->builder,
449 flex[0].x, flex[0].y,
450 flex[1].x, flex[1].y,
451 flex[2].x, flex[2].y ) ||
452
453 decoder->builder.funcs.rcurve_to( &decoder->builder,
454 flex[3].x, flex[3].y,
455 flex[4].x, flex[4].y,
456 flex[5].x, flex[5].y );
457 }
458
459
460 /*************************************************************************/
461 /* */
462 /* <Function> */
463 /* T1_Parse_CharStrings */
464 /* */
465 /* <Description> */
466 /* Parses a given Type 1 charstrings program. */
467 /* */
468 /* <Input> */
469 /* decoder :: The current Type 1 decoder. */
470 /* */
471 /* charstring_base :: The base address of the charstring stream. */
472 /* */
473 /* charstring_len :: The length in bytes of the charstring stream. */
474 /* */
475 /* num_subrs :: The number of sub-routines. */
476 /* */
477 /* subrs_base :: An array of sub-routines addresses. */
478 /* */
479 /* subrs_len :: An array of sub-routines lengths. */
480 /* */
481 /* <Return> */
482 /* Free error code. 0 means success. */
483 /* */
484 LOCAL_FUNC
485 FT_Error T1_Parse_CharStrings( T1_Decoder* decoder,
486 FT_Byte* charstring_base,
487 FT_Int charstring_len,
488 FT_Int num_subrs,
489 FT_Byte** subrs_base,
490 FT_Int* subrs_len )
491 {
492 FT_Error error;
493 T1_Decoder_Zone* zone;
494 FT_Byte* ip;
495 FT_Byte* limit;
496 T1_Builder* builder = &decoder->builder;
497 T1_Builder_Funcs* builds = &builder->funcs;
498 T1_Hinter_Funcs* hints = &decoder->hinter;
499
500 static
501 const FT_Int args_count[op_max] =
502 {
503 0, /* none */
504 0, /* endchar */
505 2, /* hsbw */
506 5, /* seac */
507 4, /* sbw */
508 0, /* closepath */
509 1, /* hlineto */
510 1, /* hmoveto */
511 4, /* hvcurveto */
512 2, /* rlineto */
513 2, /* rmoveto */
514 6, /* rrcurveto */
515 4, /* vhcurveto */
516 1, /* vlineto */
517 1, /* vmoveto */
518 0, /* dotsection */
519 2, /* hstem */
520 6, /* hstem3 */
521 2, /* vstem */
522 6, /* vstem3 */
523 2, /* div */
524 -1, /* callothersubr */
525 1, /* callsubr */
526 0, /* pop */
527 0, /* return */
528 2 /* setcurrentpoint */
529 };
530
531
532 /* First of all, initialize the decoder */
533 decoder->top = decoder->stack;
534 decoder->zone = decoder->zones;
535 zone = decoder->zones;
536
537 builder->path_begun = 0;
538
539 zone->base = charstring_base;
540 limit = zone->limit = charstring_base + charstring_len;
541 ip = zone->cursor = zone->base;
542
543 error = T1_Err_Ok;
544
545 /* now, execute loop */
546 while ( ip < limit )
547 {
548 FT_Int* top = decoder->top;
549 T1_Operator op = op_none;
550 FT_Long value = 0;
551
552
553 /* Start with the decompression of operator or value */
554 switch ( *ip++ )
555 {
556 case 1:
557 op = op_hstem;
558 break;
559
560 case 3:
561 op = op_vstem;
562 break;
563 case 4:
564 op = op_vmoveto;
565 break;
566 case 5:
567 op = op_rlineto;
568 break;
569 case 6:
570 op = op_hlineto;
571 break;
572 case 7:
573 op = op_vlineto;
574 break;
575 case 8:
576 op = op_rrcurveto;
577 break;
578 case 9:
579 op = op_closepath;
580 break;
581 case 10:
582 op = op_callsubr;
583 break;
584 case 11:
585 op = op_return;
586 break;
587
588 case 13:
589 op = op_hsbw;
590 break;
591 case 14:
592 op = op_endchar;
593 break;
594
595 case 21:
596 op = op_rmoveto;
597 break;
598 case 22:
599 op = op_hmoveto;
600 break;
601
602 case 30:
603 op = op_vhcurveto;
604 break;
605 case 31:
606 op = op_hvcurveto;
607 break;
608
609 case 12:
610 if ( ip > limit )
611 {
612 FT_ERROR(( "T1_Parse_CharStrings: invalid escape (12+EOF)\n" ));
613 goto Syntax_Error;
614 }
615
616 switch ( *ip++ )
617 {
618 case 0:
619 op = op_dotsection;
620 break;
621 case 1:
622 op = op_vstem3;
623 break;
624 case 2:
625 op = op_hstem3;
626 break;
627 case 6:
628 op = op_seac;
629 break;
630 case 7:
631 op = op_sbw;
632 break;
633 case 12:
634 op = op_div;
635 break;
636 case 16:
637 op = op_callothersubr;
638 break;
639 case 17:
640 op = op_pop;
641 break;
642 case 33:
643 op = op_setcurrentpoint;
644 break;
645
646 default:
647 FT_ERROR(( "T1_Parse_CharStrings: invalid escape (12+%d)\n",
648 ip[-1] ));
649 goto Syntax_Error;
650 }
651 break;
652
653 case 255: /* four bytes integer */
654 if ( ip + 4 > limit )
655 {
656 FT_ERROR(( "T1_Parse_CharStrings: unexpected EOF in integer\n" ));
657 goto Syntax_Error;
658 }
659
660 value = ( (FT_Long)ip[0] << 24 ) |
661 ( (FT_Long)ip[1] << 16 ) |
662 ( (FT_Long)ip[2] << 8 ) |
663 ip[3];
664 ip += 4;
665 break;
666
667 default:
668 if ( ip[-1] >= 32 )
669 {
670 if ( ip[-1] < 247 )
671 value = (FT_Long)ip[-1] - 139;
672 else
673 {
674 if ( ++ip > limit )
675 {
676 FT_ERROR(( "T1_Parse_CharStrings:" ));
677 FT_ERROR(( " unexpected EOF in integer\n" ));
678 goto Syntax_Error;
679 }
680
681 if ( ip[-2] < 251 )
682 value = ((FT_Long)( ip[-2] - 247 ) << 8 ) + ip[-1] + 108;
683 else
684 value = -( ( ( (FT_Long)ip[-2] - 251 ) << 8 ) + ip[-1] + 108 );
685 }
686 }
687 else
688 {
689 FT_ERROR(( "T1_Parse_CharStrings: invalid byte (%d)\n",
690 ip[-1] ));
691 goto Syntax_Error;
692 }
693 }
694
695 /* push value if necessary */
696 if ( op == op_none )
697 {
698 if ( top - decoder->stack >= T1_MAX_CHARSTRINGS_OPERANDS )
699 {
700 FT_ERROR(( "T1_Parse_CharStrings: stack overflow!\n" ));
701 goto Syntax_Error;
702 }
703
704 *top++ = value;
705 decoder->top = top;
706 }
707
708 else if ( op == op_callothersubr ) /* check arguments differently */
709 {
710 if ( top - decoder->stack < 2 )
711 goto Stack_Underflow;
712
713 top -= 2;
714
715 switch ( top[1] )
716 {
717 case 1: /* start flex feature */
718 if ( top[0] != 0 )
719 goto Unexpected_OtherSubr;
720
721 decoder->flex_state = 1;
722 decoder->num_flex_vectors = 0;
723 decoder->flex_vectors[0].x = 0;
724 decoder->flex_vectors[0].y = 0;
725 break;
726
727 case 2: /* add flex vector */
728 {
729 FT_Int index;
730 FT_Vector* flex;
731
732
733 if ( top[0] != 0 )
734 goto Unexpected_OtherSubr;
735
736 top -= 2;
737 if ( top < decoder->stack )
738 goto Stack_Underflow;
739
740 index = decoder->num_flex_vectors++;
741 if ( index >= 7 )
742 {
743 FT_ERROR(( "T1_Parse_CharStrings: too many flex vectors!\n" ));
744 goto Syntax_Error;
745 }
746
747 flex = decoder->flex_vectors + index;
748 flex->x += top[0];
749 flex->y += top[1];
750 }
751 break;
752
753 case 0: /* end flex feature */
754 if ( decoder->flex_state == 0 ||
755 decoder->num_flex_vectors != 7 )
756 {
757 FT_ERROR(( "T1_Parse_CharStrings: unexpected flex end\n" ));
758 goto Syntax_Error;
759 }
760
761 if ( top[0] != 3 )
762 goto Unexpected_OtherSubr;
763
764 top -= 3;
765 if ( top < decoder->stack )
766 goto Stack_Underflow;
767
768 /* now consume the remaining `pop pop setcurrentpoint' */
769 if ( ip + 6 > limit ||
770 ip[0] != 12 || ip[1] != 17 || /* pop */
771 ip[2] != 12 || ip[3] != 17 || /* pop */
772 ip[4] != 12 || ip[5] != 33 ) /* setcurrentpoint */
773 {
774 FT_ERROR(( "T1_Parse_CharStrings: invalid flex charstring\n" ));
775 goto Syntax_Error;
776 }
777
778 decoder->flex_state = 0;
779 decoder->top = top;
780
781 error = t1operator_flex( decoder, top[0], top[1], top[2] );
782 break;
783
784 case 3: /* change hints */
785 if ( top[0] != 1 )
786 goto Unexpected_OtherSubr;
787
788 /* eat the following `pop' */
789 if ( ip + 2 > limit )
790 {
791 FT_ERROR(( "T1_Parse_CharStrings: invalid escape (12+%d)\n",
792 ip[-1] ));
793 goto Syntax_Error;
794 }
795
796 if ( ip[0] != 12 || ip[1] != 17 )
797 {
798 FT_ERROR(( "T1_Parse_CharStrings:" ));
799 FT_ERROR(( " `pop' expected, found (%d %d)\n", ip[0], ip[1] ));
800 goto Syntax_Error;
801 }
802
803 ip += 2;
804
805 error = hints->change_hints( builder );
806 break;
807
808 default:
809 /* invalid OtherSubrs call */
810 Unexpected_OtherSubr:
811 FT_ERROR(( "T1_Parse_CharStrings: unexpected OtherSubrs [%d %d]\n",
812 top[0], top[1] ));
813 goto Syntax_Error;
814 }
815 decoder->top = top;
816 }
817 else
818 {
819 FT_Int num_args = args_count[op];
820
821
822 if ( top - decoder->stack < num_args )
823 goto Stack_Underflow;
824
825 top -= num_args;
826
827 switch ( op )
828 {
829 case op_endchar:
830 error = builds->end_char( builder );
831 break;
832
833 case op_hsbw:
834 error = builds->set_bearing_point( builder, top[0], 0,
835 top[1], 0 );
836 break;
837
838 case op_seac:
839 /* return immediately after the processing */
840 return t1operator_seac( decoder, top[0], top[1],
841 top[2], top[3], top[4] );
842
843 case op_sbw:
844 error = builds->set_bearing_point( builder, top[0], top[1],
845 top[2], top[3] );
846 break;
847
848 case op_closepath:
849 error = builds->close_path( builder );
850 break;
851
852 case op_hlineto:
853 error = builds->rline_to( builder, top[0], 0 );
854 break;
855
856 case op_hmoveto:
857 error = builds->rmove_to( builder, top[0], 0 );
858 break;
859
860 case op_hvcurveto:
861 error = builds->rcurve_to( builder, top[0], 0,
862 top[1], top[2],
863 0, top[3] );
864 break;
865
866 case op_rlineto:
867 error = builds->rline_to( builder, top[0], top[1] );
868 break;
869
870 case op_rmoveto:
871 /* ignore operator when in flex mode */
872 if ( decoder->flex_state == 0 )
873 error = builds->rmove_to( builder, top[0], top[1] );
874 else
875 top += 2;
876 break;
877
878 case op_rrcurveto:
879 error = builds->rcurve_to( builder, top[0], top[1],
880 top[2], top[3],
881 top[4], top[5] );
882 break;
883
884 case op_vhcurveto:
885 error = builds->rcurve_to( builder, 0, top[0],
886 top[1], top[2],
887 top[3], 0 );
888 break;
889
890 case op_vlineto:
891 error = builds->rline_to( builder, 0, top[0] );
892 break;
893
894 case op_vmoveto:
895 error = builds->rmove_to( builder, 0, top[0] );
896 break;
897
898 case op_dotsection:
899 error = hints->dot_section( builder );
900 break;
901
902 case op_hstem:
903 error = hints->stem( builder, top[0], top[1], 0 );
904 break;
905
906 case op_hstem3:
907 error = hints->stem3( builder, top[0], top[1], top[2],
908 top[3], top[4], top[5], 0 );
909 break;
910
911 case op_vstem:
912 error = hints->stem( builder, top[0], top[1], 1 );
913 break;
914
915 case op_vstem3:
916 error = hints->stem3( builder, top[0], top[1], top[2],
917 top[3], top[4], top[5], 1 );
918 break;
919
920 case op_div:
921 if ( top[1] )
922 {
923 *top = top[0] / top[1];
924 ++top;
925 }
926 else
927 {
928 FT_ERROR(( "T1_Parse_CHarStrings: division by 0\n" ));
929 goto Syntax_Error;
930 }
931 break;
932
933 case op_callsubr:
934 {
935 FT_Int index = top[0];
936
937
938 if ( index < 0 || index >= num_subrs )
939 {
940 FT_ERROR(( "T1_Parse_CharStrings: invalid subrs index\n" ));
941 goto Syntax_Error;
942 }
943
944 if ( zone - decoder->zones >= T1_MAX_SUBRS_CALLS )
945 {
946 FT_ERROR(( "T1_Parse_CharStrings: too many nested subrs\n" ));
947 goto Syntax_Error;
948 }
949
950 zone->cursor = ip; /* save current instruction pointer */
951
952 zone++;
953 zone->base = subrs_base[index];
954 zone->limit = zone->base + subrs_len[index];
955 zone->cursor = zone->base;
956
957 if ( !zone->base )
958 {
959 FT_ERROR(( "T1_Parse_CharStrings: invoking empty subrs!\n" ));
960 goto Syntax_Error;
961 }
962
963 decoder->zone = zone;
964 ip = zone->base;
965 limit = zone->limit;
966 }
967 break;
968
969 case op_pop:
970 FT_ERROR(( "T1_Parse_CharStrings: unexpected POP\n" ));
971 goto Syntax_Error;
972
973 case op_return:
974 if ( zone <= decoder->zones )
975 {
976 FT_ERROR(( "T1_Parse_CharStrings: unexpected return\n" ));
977 goto Syntax_Error;
978 }
979
980 zone--;
981 ip = zone->cursor;
982 limit = zone->limit;
983 decoder->zone = zone;
984 break;
985
986 case op_setcurrentpoint:
987 FT_ERROR(( "T1_Parse_CharStrings:" ));
988 FT_ERROR(( " unexpected `setcurrentpoint'\n" ));
989 goto Syntax_Error;
990 break;
991
992 default:
993 FT_ERROR(( "T1_Parse_CharStrings: unhandled opcode %d\n", op ));
994 goto Syntax_Error;
995 }
996
997 decoder->top = top;
998 }
999 }
1000
1001 return error;
1002
1003 Syntax_Error:
1004 return T1_Err_Syntax_Error;
1005
1006 Stack_Underflow:
1007 return T1_Err_Stack_Underflow;
1008 }
1009
1010
1011 /*************************************************************************/
1012 /* */
1013 /* <Function> */
1014 /* T1_Add_Points */
1015 /* */
1016 /* <Description> */
1017 /* Checks that there is enough room in the current load glyph outline */
1018 /* to accept `num_points' additional outline points. If not, this */
1019 /* function grows the load outline's arrays accordingly. */
1020 /* */
1021 /* <Input> */
1022 /* builder :: A pointer to the glyph builder object. */
1023 /* */
1024 /* num_points :: The number of points that will be added later. */
1025 /* */
1026 /* <Return> */
1027 /* FreeType error code. 0 means success. */
1028 /* */
1029 /* <Note> */
1030 /* This function does NOT update the points count in the glyph */
1031 /* builder. This must be done by the caller itself, after this */
1032 /* function has been invoked. */
1033 /* */
1034 LOCAL_FUNC
1035 FT_Error T1_Add_Points( T1_Builder* builder,
1036 FT_Int num_points )
1037 {
1038 return FT_GlyphLoader_Check_Points( builder->loader, num_points, 0 );
1039 }
1040
1041
1042 /*************************************************************************/
1043 /* */
1044 /* <Function> */
1045 /* T1_Add_Contours */
1046 /* */
1047 /* <Description> */
1048 /* Checks that there is enough room in the current load glyph outline */
1049 /* to accept `num_contours' additional contours. If not, this */
1050 /* function grows the load outline's arrays accordingly. */
1051 /* */
1052 /* <Input> */
1053 /* builder :: A pointer to the glyph builder object. */
1054 /* */
1055 /* num_contours :: The number of contours that will be added later. */
1056 /* */
1057 /* <Return> */
1058 /* FreeType error code. 0 means success. */
1059 /* */
1060 /* <Note> */
1061 /* This function does NOT update the contours count in the load glyph */
1062 /* This must be done by the caller itself, after this function is */
1063 /* invoked. */
1064 /* */
1065 LOCAL_FUNC
1066 FT_Error T1_Add_Contours( T1_Builder* builder,
1067 FT_Int num_contours )
1068 {
1069 return FT_GlyphLoader_Check_Points( builder->loader, 0, num_contours );
1070 }
1071
1072
1073 /*************************************************************************/
1074 /*************************************************************************/
1075 /*************************************************************************/
1076 /********** *********/
1077 /********** COMPUTE THE MAXIMUM ADVANCE WIDTH *********/
1078 /********** *********/
1079 /********** The following code is in charge of computing *********/
1080 /********** the maximum advance width of the font. It *********/
1081 /********** quickly processes each glyph charstring to *********/
1082 /********** extract the value from either a `sbw' or `seac' *********/
1083 /********** operator. *********/
1084 /********** *********/
1085 /*************************************************************************/
1086 /*************************************************************************/
1087 /*************************************************************************/
1088
1089
1090 static
1091 FT_Error maxadv_sbw( T1_Decoder* decoder,
1092 FT_Pos sbx,
1093 FT_Pos sby,
1094 FT_Pos wx,
1095 FT_Pos wy )
1096 {
1097 FT_UNUSED( sbx );
1098 FT_UNUSED( sby );
1099 FT_UNUSED( wy );
1100
1101 if ( wx > decoder->builder.advance.x )
1102 decoder->builder.advance.x = wx;
1103
1104 return -1; /* return an error code to exit the Type 1 parser */
1105 /* immediately. */
1106 }
1107
1108
1109 static
1110 FT_Int maxadv_error( void )
1111 {
1112 /* we should never reach this code, unless with a buggy font */
1113 return -2;
1114 }
1115
1116
1117 /* the maxadv_gbuilder_interface is used when computing the maximum */
1118 /* advance width of all glyphs in a given font. We only process the */
1119 /* `sbw' operator here, and return an error for all others. */
1120
1121 /* Note that `seac' is processed by the T1_Decoder. */
1122 static
1123 const T1_Builder_Funcs maxadv_builder_interface =
1124 {
1125 (T1_Builder_EndChar) maxadv_error,
1126 (T1_Builder_Sbw) maxadv_sbw,
1127 (T1_Builder_ClosePath)maxadv_error,
1128 (T1_Builder_RLineTo) maxadv_error,
1129 (T1_Builder_RMoveTo) maxadv_error,
1130 (T1_Builder_RCurveTo) maxadv_error
1131 };
1132
1133
1134 /* the maxadv_hinter_interface always return an error. */
1135 static
1136 const T1_Hinter_Funcs maxadv_hinter_interface =
1137 {
1138 (T1_Hinter_DotSection) maxadv_error,
1139 (T1_Hinter_ChangeHints)maxadv_error,
1140 (T1_Hinter_Stem) maxadv_error,
1141 (T1_Hinter_Stem3) maxadv_error,
1142 };
1143
1144
1145 LOCAL_FUNC
1146 FT_Error T1_Compute_Max_Advance( T1_Face face,
1147 FT_Int* max_advance )
1148 {
1149 FT_Error error;
1150 T1_Decoder decoder;
1151 FT_Int glyph_index;
1152 T1_Font* type1 = &face->type1;
1153
1154
1155 *max_advance = 0;
1156
1157 /* Initialize load decoder */
1158 T1_Init_Decoder( &decoder, &maxadv_hinter_interface );
1159
1160 T1_Init_Builder( &decoder.builder, face, 0, 0,
1161 &maxadv_builder_interface );
1162
1163 /* For each glyph, parse the glyph charstring and extract */
1164 /* the advance width. */
1165 for ( glyph_index = 0; glyph_index < type1->num_glyphs; glyph_index++ )
1166 {
1167 /* now get load the unscaled outline */
1168 error = T1_Parse_CharStrings( &decoder,
1169 type1->charstrings [glyph_index],
1170 type1->charstrings_len[glyph_index],
1171 type1->num_subrs,
1172 type1->subrs,
1173 type1->subrs_len );
1174 /* ignore the error if one occured - skip to next glyph */
1175 }
1176
1177 *max_advance = decoder.builder.advance.x;
1178 return T1_Err_Ok;
1179 }
1180
1181
1182 /*************************************************************************/
1183 /*************************************************************************/
1184 /*************************************************************************/
1185 /********** *********/
1186 /********** UNHINTED GLYPH LOADER *********/
1187 /********** *********/
1188 /********** The following code is in charge of loading a *********/
1189 /********** single outline. It completely ignores hinting *********/
1190 /********** and is used when FT_LOAD_NO_HINTING is set. *********/
1191 /********** *********/
1192 /********** The Type 1 hinter is located in `t1hint.c' *********/
1193 /********** *********/
1194 /*************************************************************************/
1195 /*************************************************************************/
1196 /*************************************************************************/
1197
1198
1199 static
1200 FT_Error close_open_path( T1_Builder* builder )
1201 {
1202 FT_Error error;
1203 FT_Outline* cur = builder->current;
1204 FT_Int num_points;
1205 FT_Int first_point;
1206
1207
1208 /* Some fonts, like Hershey, are made of `open paths' which are */
1209 /* now managed directly by FreeType. In this case, it is necessary */
1210 /* to close the path by duplicating its points in reverse order, */
1211 /* which is precisely the purpose of this function. */
1212
1213 /* first compute the number of points to duplicate */
1214 if ( cur->n_contours > 1 )
1215 first_point = cur->contours[cur->n_contours - 2] + 1;
1216 else
1217 first_point = 0;
1218
1219 num_points = cur->n_points - first_point - 2;
1220 if ( num_points > 0 )
1221 {
1222 FT_Vector* source_point;
1223 char* source_tags;
1224 FT_Vector* point;
1225 char* tags;
1226
1227
1228 error = T1_Add_Points( builder, num_points );
1229 if ( error )
1230 return error;
1231
1232 point = cur->points + cur->n_points;
1233 tags = cur->tags + cur->n_points;
1234
1235 source_point = point - 2;
1236 source_tags = tags - 2;
1237
1238 cur->n_points += num_points;
1239
1240 if ( builder->load_points )
1241 do
1242 {
1243 *point++ = *source_point--;
1244 *tags++ = *source_tags--;
1245 num_points--;
1246
1247 } while ( num_points > 0 );
1248 }
1249
1250 builder->path_begun = 0;
1251 return T1_Err_Ok;
1252 }
1253
1254
1255 static
1256 FT_Error gload_closepath( T1_Builder* builder )
1257 {
1258 FT_Outline* cur = builder->current;
1259
1260
1261 /* XXXX: We must not include the last point in the path if it */
1262 /* is located on the first point. */
1263 if ( cur->n_points > 1 )
1264 {
1265 FT_Int first = 0;
1266 FT_Vector* p1 = cur->points + first;
1267 FT_Vector* p2 = cur->points + cur->n_points - 1;
1268
1269
1270 if ( cur->n_contours > 1 )
1271 {
1272 first = cur->contours[cur->n_contours - 2] + 1;
1273 p1 = cur->points + first;
1274 }
1275
1276 if ( p1->x == p2->x && p1->y == p2->y )
1277 cur->n_points--;
1278 }
1279
1280 /* save current contour, if any */
1281 if ( cur->n_contours > 0 )
1282 cur->contours[cur->n_contours - 1] = cur->n_points - 1;
1283
1284 #ifndef T1_CONFIG_OPTION_DISABLE_HINTER
1285 /* hint last points if necessary -- this is not strictly required */
1286 /* there, but it helps for debugging, and doesn't affect performance */
1287 if ( builder->pass == 1 )
1288 T1_Hint_Points( builder );
1289 #endif
1290
1291 builder->path_begun = 0;
1292 return T1_Err_Ok;
1293 }
1294
1295
1296 static
1297 FT_Error gload_endchar( T1_Builder* builder )
1298 {
1299 FT_Error error;
1300
1301
1302 /* close path if needed */
1303 if ( builder->path_begun )
1304 {
1305 error = close_open_path( builder );
1306 if ( error )
1307 return error;
1308 }
1309
1310 error = gload_closepath( builder );
1311
1312 FT_GlyphLoader_Add( builder->loader );
1313
1314 return error;
1315 }
1316
1317
1318 static
1319 FT_Error gload_sbw( T1_Builder* builder,
1320 FT_Pos sbx,
1321 FT_Pos sby,
1322 FT_Pos wx,
1323 FT_Pos wy )
1324 {
1325 builder->left_bearing.x += sbx;
1326 builder->left_bearing.y += sby;
1327 builder->advance.x = wx;
1328 builder->advance.y = wy;
1329
1330 builder->last.x = sbx;
1331 builder->last.y = sby;
1332
1333 return 0;
1334 }
1335
1336
1337 static
1338 FT_Error gload_rlineto( T1_Builder* builder,
1339 FT_Pos dx,
1340 FT_Pos dy )
1341 {
1342 FT_Error error;
1343 FT_Outline* cur = builder->current;
1344 FT_Vector vec;
1345
1346
1347 /* grow buffer if necessary */
1348 error = T1_Add_Points( builder, 1 );
1349 if ( error )
1350 return error;
1351
1352 if ( builder->load_points )
1353 {
1354 /* save point */
1355 vec.x = builder->last.x + dx;
1356 vec.y = builder->last.y + dy;
1357
1358 cur->points[cur->n_points] = vec;
1359 cur->tags [cur->n_points] = FT_Curve_Tag_On;
1360
1361 builder->last = vec;
1362 }
1363 cur->n_points++;
1364
1365 builder->path_begun = 1;
1366
1367 return T1_Err_Ok;
1368 }
1369
1370
1371 static
1372 FT_Error gload_rmoveto( T1_Builder* builder,
1373 FT_Pos dx,
1374 FT_Pos dy )
1375 {
1376 FT_Error error;
1377 FT_Outline* cur = builder->current;
1378 FT_Vector vec;
1379
1380
1381 /* in the case where `path_begun' is set, we have an `rmoveto' */
1382 /* after some normal path definition. If the face's paint type */
1383 /* is set to 1, this means that we have an `open path', also */
1384 /* called a `stroke'. The FreeType raster doesn't support */
1385 /* opened paths, so we'll close it explicitely there. */
1386
1387 if ( builder->path_begun && builder->face->type1.paint_type == 1 )
1388 {
1389 if ( builder->face->type1.paint_type == 1 )
1390 {
1391 error = close_open_path( builder );
1392 if ( error )
1393 return error;
1394 }
1395 }
1396
1397 /* grow buffer if necessary */
1398 error = T1_Add_Contours( builder, 1 ) ||
1399 T1_Add_Points ( builder, 1 );
1400 if ( error )
1401 return error;
1402
1403 /* save current contour, if any */
1404 if ( cur->n_contours > 0 )
1405 cur->contours[cur->n_contours - 1] = cur->n_points - 1;
1406
1407 if ( builder->load_points )
1408 {
1409 /* save point */
1410 vec.x = builder->last.x + dx;
1411 vec.y = builder->last.y + dy;
1412 cur->points[cur->n_points] = vec;
1413 cur->tags [cur->n_points] = FT_Curve_Tag_On;
1414
1415 builder->last = vec;
1416 }
1417
1418 cur->n_contours++;
1419 cur->n_points++;
1420
1421 return T1_Err_Ok;
1422 }
1423
1424
1425 static
1426 FT_Error gload_rrcurveto( T1_Builder* builder,
1427 FT_Pos dx1,
1428 FT_Pos dy1,
1429 FT_Pos dx2,
1430 FT_Pos dy2,
1431 FT_Pos dx3,
1432 FT_Pos dy3 )
1433 {
1434 FT_Error error;
1435 FT_Outline* cur = builder->current;
1436 FT_Vector vec;
1437 FT_Vector* points;
1438 char* tags;
1439
1440
1441 /* grow buffer if necessary */
1442 error = T1_Add_Points( builder, 3 );
1443 if ( error )
1444 return error;
1445
1446 if ( builder->load_points )
1447 {
1448 /* save point */
1449 points = cur->points + cur->n_points;
1450 tags = cur->tags + cur->n_points;
1451
1452 vec.x = builder->last.x + dx1;
1453 vec.y = builder->last.y + dy1;
1454 points[0] = vec;
1455 tags[0] = FT_Curve_Tag_Cubic;
1456
1457 vec.x += dx2;
1458 vec.y += dy2;
1459 points[1] = vec;
1460 tags[1] = FT_Curve_Tag_Cubic;
1461
1462 vec.x += dx3;
1463 vec.y += dy3;
1464 points[2] = vec;
1465 tags[2] = FT_Curve_Tag_On;
1466
1467 builder->last = vec;
1468 }
1469
1470 cur->n_points += 3;
1471 builder->path_begun = 1;
1472
1473 return T1_Err_Ok;
1474 }
1475
1476
1477 static
1478 FT_Error gload_ignore( void )
1479 {
1480 return 0;
1481 }
1482
1483
1484 static
1485 const T1_Builder_Funcs gload_builder_interface =
1486 {
1487 gload_endchar,
1488 gload_sbw,
1489 gload_closepath,
1490 gload_rlineto,
1491 gload_rmoveto,
1492 gload_rrcurveto
1493 };
1494
1495
1496 static
1497 const T1_Builder_Funcs gload_builder_interface_null =
1498 {
1499 (T1_Builder_EndChar) gload_ignore,
1500 (T1_Builder_Sbw) gload_sbw, /* record left bearing */
1501 (T1_Builder_ClosePath)gload_ignore,
1502 (T1_Builder_RLineTo) gload_ignore,
1503 (T1_Builder_RMoveTo) gload_ignore,
1504 (T1_Builder_RCurveTo) gload_ignore
1505 };
1506
1507
1508 static
1509 const T1_Hinter_Funcs gload_hinter_interface =
1510 {
1511 (T1_Hinter_DotSection) gload_ignore, /* dotsection */
1512 (T1_Hinter_ChangeHints)gload_ignore, /* changehints */
1513 (T1_Hinter_Stem) gload_ignore, /* hstem & vstem */
1514 (T1_Hinter_Stem3) gload_ignore, /* hstem3 & vestem3 */
1515 };
1516
1517
1518 #ifndef T1_CONFIG_OPTION_DISABLE_HINTER
1519
1520
1521 /*************************************************************************/
1522 /* */
1523 /* Hinter overview: */
1524 /* */
1525 /* This is a two-pass hinter. On the first pass, the hints are all */
1526 /* recorded by the hinter, and no point is loaded in the outline. */
1527 /* */
1528 /* When the first pass is finished, all stems hints are grid-fitted */
1529 /* at once. */
1530 /* */
1531 /* Then, a second pass is performed to load the outline points as */
1532 /* well as hint/scale them correctly. */
1533 /* */
1534 /*************************************************************************/
1535
1536
1537 static
1538 FT_Error t1_load_hinted_glyph( T1_Decoder* decoder,
1539 FT_UInt glyph_index,
1540 FT_Bool recurse )
1541 {
1542 T1_Builder* builder = &decoder->builder;
1543 T1_GlyphSlot glyph = builder->glyph;
1544 T1_Font* type1 = &builder->face->type1;
1545 FT_UInt old_points, old_contours;
1546 FT_GlyphLoader* loader = decoder->builder.loader;
1547 FT_Error error;
1548
1549
1550 /* Pass 1 -- try to load first glyph, simply recording points */
1551 old_points = loader->base.outline.n_points;
1552 old_contours = loader->base.outline.n_contours;
1553
1554 FT_GlyphLoader_Prepare( decoder->builder.loader );
1555
1556 T1_Reset_Builder( builder, 0 );
1557
1558 builder->no_recurse = recurse;
1559 builder->pass = 0;
1560 glyph->hints->hori_stems.num_stems = 0;
1561 glyph->hints->vert_stems.num_stems = 0;
1562
1563 error = T1_Parse_CharStrings( decoder,
1564 type1->charstrings [glyph_index],
1565 type1->charstrings_len[glyph_index],
1566 type1->num_subrs,
1567 type1->subrs,
1568 type1->subrs_len );
1569 if ( error )
1570 goto Exit;
1571
1572 /* check for composite (i.e. `seac' operator) */
1573 if ( glyph->root.format == ft_glyph_format_composite )
1574 {
1575 /* this is a composite glyph, we must then load the first one, */
1576 /* then load the second one on top of it and translate it by a */
1577 /* fixed amount. */
1578 FT_UInt n_base_points;
1579 FT_SubGlyph* subglyph = loader->base.subglyphs;
1580 T1_Size size = builder->size;
1581 FT_Pos dx, dy;
1582 FT_Vector left_bearing, advance;
1583
1584
1585 /* clean glyph format */
1586 glyph->root.format = ft_glyph_format_none;
1587
1588 /* First load `bchar' in builder */
1589 builder->no_recurse = 0;
1590 error = t1_load_hinted_glyph( decoder, subglyph->index, 0 );
1591 if ( error )
1592 goto Exit;
1593
1594 /* save the left bearing and width of the base character */
1595 /* as they will be erased by the next load */
1596 left_bearing = builder->left_bearing;
1597 advance = builder->advance;
1598
1599 /* Then load `achar' in builder */
1600 n_base_points = builder->base->n_points;
1601 subglyph++;
1602 error = t1_load_hinted_glyph( decoder, subglyph->index, 0 );
1603 if ( error )
1604 goto Exit;
1605
1606 /* Finally, move the accent */
1607 dx = FT_MulFix( subglyph->arg1, size->root.metrics.x_scale );
1608 dy = FT_MulFix( subglyph->arg2, size->root.metrics.y_scale );
1609 dx = ( dx + 32 ) & -64;
1610 dy = ( dy + 32 ) & -64;
1611 {
1612 FT_Outline dummy;
1613
1614
1615 dummy.n_points = loader->base.outline.n_points - n_base_points;
1616 dummy.points = loader->base.outline.points + n_base_points;
1617
1618 FT_Outline_Translate( &dummy, dx, dy );
1619 }
1620
1621 /* restore the left side bearing and */
1622 /* advance width of the base character */
1623 builder->left_bearing = left_bearing;
1624 builder->advance = advance;
1625 }
1626 else
1627 {
1628 /* All right, pass 1 is finished, now grid-fit all stem hints */
1629 T1_Hint_Stems( &decoder->builder );
1630
1631 /* undo the end-char */
1632 builder->base->n_points = old_points;
1633 builder->base->n_contours = old_contours;
1634
1635 /* Pass 2 -- record and scale/hint the points */
1636 T1_Reset_Builder( builder, 0 );
1637
1638 builder->pass = 1;
1639 builder->no_recurse = 0;
1640
1641 error = T1_Parse_CharStrings( decoder,
1642 type1->charstrings [glyph_index],
1643 type1->charstrings_len[glyph_index],
1644 type1->num_subrs,
1645 type1->subrs,
1646 type1->subrs_len );
1647 }
1648
1649 /* save new glyph tables */
1650 if ( recurse )
1651 T1_Done_Builder( builder );
1652
1653 Exit:
1654 return error;
1655 }
1656
1657
1658 #endif /* !T1_CONFIG_OPTION_DISABLE_HINTER */
1659
1660
1661 LOCAL_FUNC
1662 FT_Error T1_Load_Glyph( T1_GlyphSlot glyph,
1663 T1_Size size,
1664 FT_Int glyph_index,
1665 FT_Int load_flags )
1666 {
1667 FT_Error error;
1668 T1_Decoder decoder;
1669 T1_Face face = (T1_Face)glyph->root.face;
1670 FT_Bool hinting;
1671 T1_Font* type1 = &face->type1;
1672
1673
1674 if ( load_flags & FT_LOAD_NO_RECURSE )
1675 load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING;
1676
1677 glyph->x_scale = size->root.metrics.x_scale;
1678 glyph->y_scale = size->root.metrics.y_scale;
1679
1680 glyph->root.outline.n_points = 0;
1681 glyph->root.outline.n_contours = 0;
1682
1683 glyph->root.format = ft_glyph_format_outline; /* by default */
1684
1685 hinting = 0;
1686
1687 #ifndef T1_CONFIG_OPTION_DISABLE_HINTER
1688
1689 hinting = ( load_flags & ( FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING ) ) == 0;
1690
1691 if ( hinting )
1692 {
1693 T1_Init_Decoder( &decoder, &t1_hinter_funcs );
1694 T1_Init_Builder( &decoder.builder, face, size, glyph,
1695 &gload_builder_interface );
1696
1697 error = t1_load_hinted_glyph( &decoder, glyph_index, 1 );
1698 }
1699 else
1700
1701 #endif /* !T1_CONFIG_OPTION_DISABLE_HINTER */
1702
1703 {
1704 T1_Init_Decoder( &decoder, &gload_hinter_interface );
1705
1706 T1_Init_Builder( &decoder.builder, face, size, glyph,
1707 &gload_builder_interface );
1708
1709 decoder.builder.no_recurse = ( load_flags & FT_LOAD_NO_RECURSE ) != 0;
1710
1711 /* now load the unscaled outline */
1712 error = T1_Parse_CharStrings( &decoder,
1713 type1->charstrings [glyph_index],
1714 type1->charstrings_len[glyph_index],
1715 type1->num_subrs,
1716 type1->subrs,
1717 type1->subrs_len );
1718
1719 /* save new glyph tables */
1720 T1_Done_Builder( &decoder.builder );
1721 }
1722
1723 /* Now, set the metrics -- this is rather simple, as */
1724 /* the left side bearing is the xMin, and the top side */
1725 /* bearing the yMax */
1726 if ( !error )
1727 {
1728 /* for composite glyphs, return only the left side bearing and the */
1729 /* advance width */
1730 if ( glyph->root.format == ft_glyph_format_composite )
1731 {
1732 glyph->root.metrics.horiBearingX = decoder.builder.left_bearing.x;
1733 glyph->root.metrics.horiAdvance = decoder.builder.advance.x;
1734 }
1735 else
1736 {
1737 FT_BBox cbox;
1738 FT_Glyph_Metrics* metrics = &glyph->root.metrics;
1739
1740
1741 /* apply the font matrix */
1742 FT_Outline_Transform( &glyph->root.outline,
1743 &face->type1.font_matrix );
1744
1745 FT_Outline_Get_CBox( &glyph->root.outline, &cbox );
1746
1747 /* grid fit the bounding box if necessary */
1748 if ( hinting )
1749 {
1750 cbox.xMin &= -64;
1751 cbox.yMin &= -64;
1752 cbox.xMax = ( cbox.xMax + 63 ) & -64;
1753 cbox.yMax = ( cbox.yMax + 63 ) & -64;
1754 }
1755
1756 metrics->width = cbox.xMax - cbox.xMin;
1757 metrics->height = cbox.yMax - cbox.yMin;
1758
1759 metrics->horiBearingX = cbox.xMin;
1760 metrics->horiBearingY = cbox.yMax;
1761
1762 /* copy the _unscaled_ advance width */
1763 metrics->horiAdvance = decoder.builder.advance.x;
1764
1765 /* make up vertical metrics */
1766 metrics->vertBearingX = 0;
1767 metrics->vertBearingY = 0;
1768 metrics->vertAdvance = 0;
1769
1770 glyph->root.format = ft_glyph_format_outline;
1771
1772 glyph->root.outline.flags = 0;
1773
1774 if ( size->root.metrics.y_ppem < 24 )
1775 glyph->root.outline.flags |= ft_outline_high_precision;
1776
1777 glyph->root.outline.flags |= ft_outline_reverse_fill;
1778
1779 if ( hinting )
1780 {
1781 /* adjust the advance width */
1782 /* XXX TODO: consider stem hints grid-fit */
1783 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance,
1784 glyph->x_scale );
1785 }
1786 else if ( ( load_flags & FT_LOAD_NO_SCALE ) == 0 )
1787 {
1788 /* scale the outline and the metrics */
1789 FT_Int n;
1790 FT_Outline* cur = decoder.builder.base;
1791 FT_Vector* vec = cur->points;
1792 FT_Fixed x_scale = glyph->x_scale;
1793 FT_Fixed y_scale = glyph->y_scale;
1794
1795
1796 /* First of all, scale the points */
1797 for ( n = cur->n_points; n > 0; n--, vec++ )
1798 {
1799 vec->x = FT_MulFix( vec->x, x_scale );
1800 vec->y = FT_MulFix( vec->y, y_scale );
1801 }
1802
1803 /* Then scale the metrics */
1804 metrics->width = FT_MulFix( metrics->width, x_scale );
1805 metrics->height = FT_MulFix( metrics->height, y_scale );
1806
1807 metrics->horiBearingX = FT_MulFix( metrics->horiBearingX, x_scale );
1808 metrics->horiBearingY = FT_MulFix( metrics->horiBearingY, y_scale );
1809
1810 metrics->vertBearingX = FT_MulFix( metrics->vertBearingX, x_scale );
1811 metrics->vertBearingY = FT_MulFix( metrics->vertBearingY, y_scale );
1812
1813 metrics->horiAdvance = FT_MulFix( metrics->horiAdvance, x_scale );
1814 metrics->vertAdvance = FT_MulFix( metrics->vertAdvance, y_scale );
1815 }
1816 }
1817 }
1818
1819 return error;
1820 }
1821
1822
1823 /* END */
wxWidgets (Impactor)