XFA: merge patch from CL 817753002
[pdfium.git] / core / src / fxge / fx_freetype / fxft2.5.01 / src / type1 / t1driver.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  t1driver.c                                                             */
4 /*                                                                         */
5 /*    Type 1 driver interface (body).                                      */
6 /*                                                                         */
7 /*  Copyright 1996-2004, 2006, 2007, 2009, 2011, 2013 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 "../../include/ft2build.h"
20 #include "t1driver.h"
21 #include "t1gload.h"
22 #include "t1load.h"
23
24 #include "t1errors.h"
25
26 #ifndef T1_CONFIG_OPTION_NO_AFM
27 #include "t1afm.h"
28 #endif
29
30 #include "../../include/freetype/internal/ftdebug.h"
31 #include "../../include/freetype/internal/ftstream.h"
32
33 #include "../../include/freetype/internal/services/svmm.h"
34 #include "../../include/freetype/internal/services/svgldict.h"
35 #include "../../include/freetype/internal/services/svxf86nm.h"
36 #include "../../include/freetype/internal/services/svpostnm.h"
37 #include "../../include/freetype/internal/services/svpscmap.h"
38 #include "../../include/freetype/internal/services/svpsinfo.h"
39 #include "../../include/freetype/internal/services/svkern.h"
40
41
42   /*************************************************************************/
43   /*                                                                       */
44   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
45   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
46   /* messages during execution.                                            */
47   /*                                                                       */
48 #undef  FT_COMPONENT
49 #define FT_COMPONENT  trace_t1driver
50
51  /*
52   *  GLYPH DICT SERVICE
53   *
54   */
55
56   static FT_Error
57   t1_get_glyph_name( T1_Face     face,
58                      FT_UInt     glyph_index,
59                      FT_Pointer  buffer,
60                      FT_UInt     buffer_max )
61   {
62     FT_STRCPYN( buffer, face->type1.glyph_names[glyph_index], buffer_max );
63
64     return FT_Err_Ok;
65   }
66
67
68   static FT_UInt
69   t1_get_name_index( T1_Face     face,
70                      FT_String*  glyph_name )
71   {
72     FT_Int  i;
73
74
75     for ( i = 0; i < face->type1.num_glyphs; i++ )
76     {
77       FT_String*  gname = face->type1.glyph_names[i];
78
79
80       if ( !ft_strcmp( glyph_name, gname ) )
81         return (FT_UInt)i;
82     }
83
84     return 0;
85   }
86
87
88   static const FT_Service_GlyphDictRec  t1_service_glyph_dict =
89   {
90     (FT_GlyphDict_GetNameFunc)  t1_get_glyph_name,
91     (FT_GlyphDict_NameIndexFunc)t1_get_name_index
92   };
93
94
95   /*
96    *  POSTSCRIPT NAME SERVICE
97    *
98    */
99
100   static const char*
101   t1_get_ps_name( T1_Face  face )
102   {
103     return (const char*) face->type1.font_name;
104   }
105
106
107   static const FT_Service_PsFontNameRec  t1_service_ps_name =
108   {
109     (FT_PsName_GetFunc)t1_get_ps_name
110   };
111
112
113   /*
114    *  MULTIPLE MASTERS SERVICE
115    *
116    */
117
118 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
119   static const FT_Service_MultiMastersRec  t1_service_multi_masters =
120   {
121     (FT_Get_MM_Func)        T1_Get_Multi_Master,
122     (FT_Set_MM_Design_Func) T1_Set_MM_Design,
123     (FT_Set_MM_Blend_Func)  T1_Set_MM_Blend,
124     (FT_Get_MM_Var_Func)    T1_Get_MM_Var,
125     (FT_Set_Var_Design_Func)T1_Set_Var_Design
126   };
127 #endif
128
129
130   /*
131    *  POSTSCRIPT INFO SERVICE
132    *
133    */
134
135   static FT_Error
136   t1_ps_get_font_info( FT_Face          face,
137                        PS_FontInfoRec*  afont_info )
138   {
139     *afont_info = ((T1_Face)face)->type1.font_info;
140
141     return FT_Err_Ok;
142   }
143
144
145   static FT_Error
146   t1_ps_get_font_extra( FT_Face           face,
147                         PS_FontExtraRec*  afont_extra )
148   {
149     *afont_extra = ((T1_Face)face)->type1.font_extra;
150
151     return FT_Err_Ok;
152   }
153
154
155   static FT_Int
156   t1_ps_has_glyph_names( FT_Face  face )
157   {
158     FT_UNUSED( face );
159
160     return 1;
161   }
162
163
164   static FT_Error
165   t1_ps_get_font_private( FT_Face         face,
166                           PS_PrivateRec*  afont_private )
167   {
168     *afont_private = ((T1_Face)face)->type1.private_dict;
169
170     return FT_Err_Ok;
171   }
172
173
174   static FT_Long
175   t1_ps_get_font_value( FT_Face       face,
176                         PS_Dict_Keys  key,
177                         FT_UInt       idx,
178                         void         *value,
179                         FT_Long       value_len )
180   {
181     FT_Long  retval = -1;
182     T1_Face  t1face = (T1_Face)face;
183     T1_Font  type1  = &t1face->type1;
184
185
186     switch ( key )
187     {
188     case PS_DICT_FONT_TYPE:
189       retval = sizeof ( type1->font_type );
190       if ( value && value_len >= retval )
191         *((FT_Byte *)value) = type1->font_type;
192       break;
193
194     case PS_DICT_FONT_MATRIX:
195       if ( idx < sizeof ( type1->font_matrix ) /
196                    sizeof ( type1->font_matrix.xx ) )
197       {
198         FT_Fixed  val = 0;
199
200
201         retval = sizeof ( val );
202         if ( value && value_len >= retval )
203         {
204           switch ( idx )
205           {
206           case 0:
207             val = type1->font_matrix.xx;
208             break;
209           case 1:
210             val = type1->font_matrix.xy;
211             break;
212           case 2:
213             val = type1->font_matrix.yx;
214             break;
215           case 3:
216             val = type1->font_matrix.yy;
217             break;
218           }
219           *((FT_Fixed *)value) = val;
220         }
221       }
222       break;
223
224     case PS_DICT_FONT_BBOX:
225       if ( idx < sizeof ( type1->font_bbox ) /
226                    sizeof ( type1->font_bbox.xMin ) )
227       {
228         FT_Fixed val = 0;
229
230
231         retval = sizeof ( val );
232         if ( value && value_len >= retval )
233         {
234           switch ( idx )
235           {
236           case 0:
237             val = type1->font_bbox.xMin;
238             break;
239           case 1:
240             val = type1->font_bbox.yMin;
241             break;
242           case 2:
243             val = type1->font_bbox.xMax;
244             break;
245           case 3:
246             val = type1->font_bbox.yMax;
247             break;
248           }
249           *((FT_Fixed *)value) = val;
250         }
251       }
252       break;
253
254     case PS_DICT_PAINT_TYPE:
255       retval = sizeof ( type1->paint_type );
256       if ( value && value_len >= retval )
257         *((FT_Byte *)value) = type1->paint_type;
258       break;
259
260     case PS_DICT_FONT_NAME:
261       retval = (FT_Long)( ft_strlen( type1->font_name ) + 1 );
262       if ( value && value_len >= retval )
263         ft_memcpy( value, (void *)( type1->font_name ), retval );
264       break;
265
266     case PS_DICT_UNIQUE_ID:
267       retval = sizeof ( type1->private_dict.unique_id );
268       if ( value && value_len >= retval )
269         *((FT_Int *)value) = type1->private_dict.unique_id;
270       break;
271
272     case PS_DICT_NUM_CHAR_STRINGS:
273       retval = sizeof ( type1->num_glyphs );
274       if ( value && value_len >= retval )
275         *((FT_Int *)value) = type1->num_glyphs;
276       break;
277
278     case PS_DICT_CHAR_STRING_KEY:
279       if ( idx < (FT_UInt)type1->num_glyphs )
280       {
281         retval = (FT_Long)( ft_strlen( type1->glyph_names[idx] ) + 1 );
282         if ( value && value_len >= retval )
283         {
284           ft_memcpy( value, (void *)( type1->glyph_names[idx] ), retval );
285           ((FT_Char *)value)[retval - 1] = (FT_Char)'\0';
286         }
287       }
288       break;
289
290     case PS_DICT_CHAR_STRING:
291       if ( idx < (FT_UInt)type1->num_glyphs )
292       {
293         retval = (FT_Long)( type1->charstrings_len[idx] + 1 );
294         if ( value && value_len >= retval )
295         {
296           ft_memcpy( value, (void *)( type1->charstrings[idx] ),
297                      retval - 1 );
298           ((FT_Char *)value)[retval - 1] = (FT_Char)'\0';
299         }
300       }
301       break;
302
303     case PS_DICT_ENCODING_TYPE:
304       retval = sizeof ( type1->encoding_type );
305       if ( value && value_len >= retval )
306         *((T1_EncodingType *)value) = type1->encoding_type;
307       break;
308
309     case PS_DICT_ENCODING_ENTRY:
310       if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY &&
311            idx < (FT_UInt)type1->encoding.num_chars       )
312       {
313         retval = (FT_Long)( ft_strlen( type1->encoding.char_name[idx] ) + 1 );
314         if ( value && value_len >= retval )
315         {
316           ft_memcpy( value, (void *)( type1->encoding.char_name[idx] ),
317                      retval - 1 );
318           ((FT_Char *)value)[retval - 1] = (FT_Char)'\0';
319         }
320       }
321       break;
322
323     case PS_DICT_NUM_SUBRS:
324       retval = sizeof ( type1->num_subrs );
325       if ( value && value_len >= retval )
326         *((FT_Int *)value) = type1->num_subrs;
327       break;
328
329     case PS_DICT_SUBR:
330       if ( idx < (FT_UInt)type1->num_subrs )
331       {
332         retval = (FT_Long)( type1->subrs_len[idx] + 1 );
333         if ( value && value_len >= retval )
334         {
335           ft_memcpy( value, (void *)( type1->subrs[idx] ), retval - 1 );
336           ((FT_Char *)value)[retval - 1] = (FT_Char)'\0';
337         }
338       }
339       break;
340
341     case PS_DICT_STD_HW:
342       retval = sizeof ( type1->private_dict.standard_width[0] );
343       if ( value && value_len >= retval )
344         *((FT_UShort *)value) = type1->private_dict.standard_width[0];
345       break;
346
347     case PS_DICT_STD_VW:
348       retval = sizeof ( type1->private_dict.standard_height[0] );
349       if ( value && value_len >= retval )
350         *((FT_UShort *)value) = type1->private_dict.standard_height[0];
351       break;
352
353     case PS_DICT_NUM_BLUE_VALUES:
354       retval = sizeof ( type1->private_dict.num_blue_values );
355       if ( value && value_len >= retval )
356         *((FT_Byte *)value) = type1->private_dict.num_blue_values;
357       break;
358
359     case PS_DICT_BLUE_VALUE:
360       if ( idx < type1->private_dict.num_blue_values )
361       {
362         retval = sizeof ( type1->private_dict.blue_values[idx] );
363         if ( value && value_len >= retval )
364           *((FT_Short *)value) = type1->private_dict.blue_values[idx];
365       }
366       break;
367
368     case PS_DICT_BLUE_SCALE:
369       retval = sizeof ( type1->private_dict.blue_scale );
370       if ( value && value_len >= retval )
371         *((FT_Fixed *)value) = type1->private_dict.blue_scale;
372       break;
373
374     case PS_DICT_BLUE_FUZZ:
375       retval = sizeof ( type1->private_dict.blue_fuzz );
376       if ( value && value_len >= retval )
377         *((FT_Int *)value) = type1->private_dict.blue_fuzz;
378       break;
379
380     case PS_DICT_BLUE_SHIFT:
381       retval = sizeof ( type1->private_dict.blue_shift );
382       if ( value && value_len >= retval )
383         *((FT_Int *)value) = type1->private_dict.blue_shift;
384       break;
385
386     case PS_DICT_NUM_OTHER_BLUES:
387       retval = sizeof ( type1->private_dict.num_other_blues );
388       if ( value && value_len >= retval )
389         *((FT_Byte *)value) = type1->private_dict.num_other_blues;
390       break;
391
392     case PS_DICT_OTHER_BLUE:
393       if ( idx < type1->private_dict.num_other_blues )
394       {
395         retval = sizeof ( type1->private_dict.other_blues[idx] );
396         if ( value && value_len >= retval )
397           *((FT_Short *)value) = type1->private_dict.other_blues[idx];
398       }
399       break;
400
401     case PS_DICT_NUM_FAMILY_BLUES:
402       retval = sizeof ( type1->private_dict.num_family_blues );
403       if ( value && value_len >= retval )
404         *((FT_Byte *)value) = type1->private_dict.num_family_blues;
405       break;
406
407     case PS_DICT_FAMILY_BLUE:
408       if ( idx < type1->private_dict.num_family_blues )
409       {
410         retval = sizeof ( type1->private_dict.family_blues[idx] );
411         if ( value && value_len >= retval )
412           *((FT_Short *)value) = type1->private_dict.family_blues[idx];
413       }
414       break;
415
416     case PS_DICT_NUM_FAMILY_OTHER_BLUES:
417       retval = sizeof ( type1->private_dict.num_family_other_blues );
418       if ( value && value_len >= retval )
419         *((FT_Byte *)value) = type1->private_dict.num_family_other_blues;
420       break;
421
422     case PS_DICT_FAMILY_OTHER_BLUE:
423       if ( idx < type1->private_dict.num_family_other_blues )
424       {
425         retval = sizeof ( type1->private_dict.family_other_blues[idx] );
426         if ( value && value_len >= retval )
427           *((FT_Short *)value) = type1->private_dict.family_other_blues[idx];
428       }
429       break;
430
431     case PS_DICT_NUM_STEM_SNAP_H:
432       retval = sizeof ( type1->private_dict.num_snap_widths );
433       if ( value && value_len >= retval )
434         *((FT_Byte *)value) = type1->private_dict.num_snap_widths;
435       break;
436
437     case PS_DICT_STEM_SNAP_H:
438       if ( idx < type1->private_dict.num_snap_widths )
439       {
440         retval = sizeof ( type1->private_dict.snap_widths[idx] );
441         if ( value && value_len >= retval )
442           *((FT_Short *)value) = type1->private_dict.snap_widths[idx];
443       }
444       break;
445
446     case PS_DICT_NUM_STEM_SNAP_V:
447       retval = sizeof ( type1->private_dict.num_snap_heights );
448       if ( value && value_len >= retval )
449         *((FT_Byte *)value) = type1->private_dict.num_snap_heights;
450       break;
451
452     case PS_DICT_STEM_SNAP_V:
453       if ( idx < type1->private_dict.num_snap_heights )
454       {
455         retval = sizeof ( type1->private_dict.snap_heights[idx] );
456         if ( value && value_len >= retval )
457           *((FT_Short *)value) = type1->private_dict.snap_heights[idx];
458       }
459       break;
460
461     case PS_DICT_RND_STEM_UP:
462       retval = sizeof ( type1->private_dict.round_stem_up );
463       if ( value && value_len >= retval )
464         *((FT_Bool *)value) = type1->private_dict.round_stem_up;
465       break;
466
467     case PS_DICT_FORCE_BOLD:
468       retval = sizeof ( type1->private_dict.force_bold );
469       if ( value && value_len >= retval )
470         *((FT_Bool *)value) = type1->private_dict.force_bold;
471       break;
472
473     case PS_DICT_MIN_FEATURE:
474       if ( idx < sizeof ( type1->private_dict.min_feature ) /
475                    sizeof ( type1->private_dict.min_feature[0] ) )
476       {
477         retval = sizeof ( type1->private_dict.min_feature[idx] );
478         if ( value && value_len >= retval )
479           *((FT_Short *)value) = type1->private_dict.min_feature[idx];
480       }
481       break;
482
483     case PS_DICT_LEN_IV:
484       retval = sizeof ( type1->private_dict.lenIV );
485       if ( value && value_len >= retval )
486         *((FT_Int *)value) = type1->private_dict.lenIV;
487       break;
488
489     case PS_DICT_PASSWORD:
490       retval = sizeof ( type1->private_dict.password );
491       if ( value && value_len >= retval )
492         *((FT_Long *)value) = type1->private_dict.password;
493       break;
494
495     case PS_DICT_LANGUAGE_GROUP:
496       retval = sizeof ( type1->private_dict.language_group );
497       if ( value && value_len >= retval )
498         *((FT_Long *)value) = type1->private_dict.language_group;
499       break;
500
501     case PS_DICT_IS_FIXED_PITCH:
502       retval = sizeof ( type1->font_info.is_fixed_pitch );
503       if ( value && value_len >= retval )
504         *((FT_Bool *)value) = type1->font_info.is_fixed_pitch;
505       break;
506
507     case PS_DICT_UNDERLINE_POSITION:
508       retval = sizeof ( type1->font_info.underline_position );
509       if ( value && value_len >= retval )
510         *((FT_Short *)value) = type1->font_info.underline_position;
511       break;
512
513     case PS_DICT_UNDERLINE_THICKNESS:
514       retval = sizeof ( type1->font_info.underline_thickness );
515       if ( value && value_len >= retval )
516         *((FT_UShort *)value) = type1->font_info.underline_thickness;
517       break;
518
519     case PS_DICT_FS_TYPE:
520       retval = sizeof ( type1->font_extra.fs_type );
521       if ( value && value_len >= retval )
522         *((FT_UShort *)value) = type1->font_extra.fs_type;
523       break;
524
525     case PS_DICT_VERSION:
526       retval = (FT_Long)( ft_strlen( type1->font_info.version ) + 1 );
527       if ( value && value_len >= retval )
528         ft_memcpy( value, (void *)( type1->font_info.version ), retval );
529       break;
530
531     case PS_DICT_NOTICE:
532       retval = (FT_Long)( ft_strlen( type1->font_info.notice ) + 1 );
533       if ( value && value_len >= retval )
534         ft_memcpy( value, (void *)( type1->font_info.notice ), retval );
535       break;
536
537     case PS_DICT_FULL_NAME:
538       retval = (FT_Long)( ft_strlen( type1->font_info.full_name ) + 1 );
539       if ( value && value_len >= retval )
540         ft_memcpy( value, (void *)( type1->font_info.full_name ), retval );
541       break;
542
543     case PS_DICT_FAMILY_NAME:
544       retval = (FT_Long)( ft_strlen( type1->font_info.family_name ) + 1 );
545       if ( value && value_len >= retval )
546         ft_memcpy( value, (void *)( type1->font_info.family_name ), retval );
547       break;
548
549     case PS_DICT_WEIGHT:
550       retval = (FT_Long)( ft_strlen( type1->font_info.weight ) + 1 );
551       if ( value && value_len >= retval )
552         ft_memcpy( value, (void *)( type1->font_info.weight ), retval );
553       break;
554
555     case PS_DICT_ITALIC_ANGLE:
556       retval = sizeof ( type1->font_info.italic_angle );
557       if ( value && value_len >= retval )
558         *((FT_Long *)value) = type1->font_info.italic_angle;
559       break;
560
561     default:
562       break;
563     }
564
565     return retval;
566   }
567
568
569   static const FT_Service_PsInfoRec  t1_service_ps_info =
570   {
571     (PS_GetFontInfoFunc)   t1_ps_get_font_info,
572     (PS_GetFontExtraFunc)  t1_ps_get_font_extra,
573     (PS_HasGlyphNamesFunc) t1_ps_has_glyph_names,
574     (PS_GetFontPrivateFunc)t1_ps_get_font_private,
575     (PS_GetFontValueFunc)  t1_ps_get_font_value,
576   };
577
578
579 #ifndef T1_CONFIG_OPTION_NO_AFM
580   static const FT_Service_KerningRec  t1_service_kerning =
581   {
582     T1_Get_Track_Kerning,
583   };
584 #endif
585
586
587   /*
588    *  SERVICE LIST
589    *
590    */
591
592   static const FT_ServiceDescRec  t1_services[] =
593   {
594     { FT_SERVICE_ID_POSTSCRIPT_FONT_NAME, &t1_service_ps_name },
595     { FT_SERVICE_ID_GLYPH_DICT,           &t1_service_glyph_dict },
596     { FT_SERVICE_ID_XF86_NAME,            FT_XF86_FORMAT_TYPE_1 },
597     { FT_SERVICE_ID_POSTSCRIPT_INFO,      &t1_service_ps_info },
598
599 #ifndef T1_CONFIG_OPTION_NO_AFM
600     { FT_SERVICE_ID_KERNING,              &t1_service_kerning },
601 #endif
602
603 #ifndef T1_CONFIG_OPTION_NO_MM_SUPPORT
604     { FT_SERVICE_ID_MULTI_MASTERS,        &t1_service_multi_masters },
605 #endif
606     { NULL, NULL }
607   };
608
609
610   FT_CALLBACK_DEF( FT_Module_Interface )
611   Get_Interface( FT_Module         module,
612                  const FT_String*  t1_interface )
613   {
614     FT_UNUSED( module );
615
616     return ft_service_list_lookup( t1_services, t1_interface );
617   }
618
619
620 #ifndef T1_CONFIG_OPTION_NO_AFM
621
622   /*************************************************************************/
623   /*                                                                       */
624   /* <Function>                                                            */
625   /*    Get_Kerning                                                        */
626   /*                                                                       */
627   /* <Description>                                                         */
628   /*    A driver method used to return the kerning vector between two      */
629   /*    glyphs of the same face.                                           */
630   /*                                                                       */
631   /* <Input>                                                               */
632   /*    face        :: A handle to the source face object.                 */
633   /*                                                                       */
634   /*    left_glyph  :: The index of the left glyph in the kern pair.       */
635   /*                                                                       */
636   /*    right_glyph :: The index of the right glyph in the kern pair.      */
637   /*                                                                       */
638   /* <Output>                                                              */
639   /*    kerning     :: The kerning vector.  This is in font units for      */
640   /*                   scalable formats, and in pixels for fixed-sizes     */
641   /*                   formats.                                            */
642   /*                                                                       */
643   /* <Return>                                                              */
644   /*    FreeType error code.  0 means success.                             */
645   /*                                                                       */
646   /* <Note>                                                                */
647   /*    Only horizontal layouts (left-to-right & right-to-left) are        */
648   /*    supported by this function.  Other layouts, or more sophisticated  */
649   /*    kernings are out of scope of this method (the basic driver         */
650   /*    interface is meant to be simple).                                  */
651   /*                                                                       */
652   /*    They can be implemented by format-specific interfaces.             */
653   /*                                                                       */
654   static FT_Error
655   Get_Kerning( FT_Face     t1face,        /* T1_Face */
656                FT_UInt     left_glyph,
657                FT_UInt     right_glyph,
658                FT_Vector*  kerning )
659   {
660     T1_Face  face = (T1_Face)t1face;
661
662
663     kerning->x = 0;
664     kerning->y = 0;
665
666     if ( face->afm_data )
667       T1_Get_Kerning( (AFM_FontInfo)face->afm_data,
668                       left_glyph,
669                       right_glyph,
670                       kerning );
671
672     return FT_Err_Ok;
673   }
674
675
676 #endif /* T1_CONFIG_OPTION_NO_AFM */
677
678
679   FT_CALLBACK_TABLE_DEF
680   const FT_Driver_ClassRec  t1_driver_class =
681   {
682     {
683       FT_MODULE_FONT_DRIVER       |
684       FT_MODULE_DRIVER_SCALABLE   |
685       FT_MODULE_DRIVER_HAS_HINTER,
686
687       sizeof ( FT_DriverRec ),
688
689       "type1",
690       0x10000L,
691       0x20000L,
692
693       0,   /* format interface */
694
695       T1_Driver_Init,
696       T1_Driver_Done,
697       Get_Interface,
698     },
699
700     sizeof ( T1_FaceRec ),
701     sizeof ( T1_SizeRec ),
702     sizeof ( T1_GlyphSlotRec ),
703
704     T1_Face_Init,
705     T1_Face_Done,
706     T1_Size_Init,
707     T1_Size_Done,
708     T1_GlyphSlot_Init,
709     T1_GlyphSlot_Done,
710
711     T1_Load_Glyph,
712
713 #ifdef T1_CONFIG_OPTION_NO_AFM
714     0,                     /* FT_Face_GetKerningFunc */
715     0,                     /* FT_Face_AttachFunc     */
716 #else
717     Get_Kerning,
718     T1_Read_Metrics,
719 #endif
720     T1_Get_Advances,
721     T1_Size_Request,
722     0                      /* FT_Size_SelectFunc     */
723   };
724
725
726 /* END */