ReactOS  0.4.15-dev-2092-gf04890c
ftobjs.h
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ftobjs.h */
4 /* */
5 /* The FreeType private base classes (specification). */
6 /* */
7 /* Copyright 1996-2018 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  /*************************************************************************/
20  /* */
21  /* This file contains the definition of all internal FreeType classes. */
22  /* */
23  /*************************************************************************/
24 
25 
26 #ifndef FTOBJS_H_
27 #define FTOBJS_H_
28 
29 #include <ft2build.h>
30 #include FT_RENDER_H
31 #include FT_SIZES_H
32 #include FT_LCD_FILTER_H
33 #include FT_INTERNAL_MEMORY_H
34 #include FT_INTERNAL_GLYPH_LOADER_H
35 #include FT_INTERNAL_DRIVER_H
36 #include FT_INTERNAL_AUTOHINT_H
37 #include FT_INTERNAL_SERVICE_H
38 #include FT_INTERNAL_PIC_H
39 #include FT_INTERNAL_CALC_H
40 
41 #ifdef FT_CONFIG_OPTION_INCREMENTAL
42 #include FT_INCREMENTAL_H
43 #endif
44 
45 
46 FT_BEGIN_HEADER
47 
48 
49  /*************************************************************************/
50  /* */
51  /* Some generic definitions. */
52  /* */
53 #ifndef TRUE
54 #define TRUE 1
55 #endif
56 
57 #ifndef FALSE
58 #define FALSE 0
59 #endif
60 
61 #ifndef NULL
62 #define NULL (void*)0
63 #endif
64 
65 
66  /*************************************************************************/
67  /* */
68  /* The min and max functions missing in C. As usual, be careful not to */
69  /* write things like FT_MIN( a++, b++ ) to avoid side effects. */
70  /* */
71 #define FT_MIN( a, b ) ( (a) < (b) ? (a) : (b) )
72 #define FT_MAX( a, b ) ( (a) > (b) ? (a) : (b) )
73 
74 #define FT_ABS( a ) ( (a) < 0 ? -(a) : (a) )
75 
76  /*
77  * Approximate sqrt(x*x+y*y) using the `alpha max plus beta min'
78  * algorithm. We use alpha = 1, beta = 3/8, giving us results with a
79  * largest error less than 7% compared to the exact value.
80  */
81 #define FT_HYPOT( x, y ) \
82  ( x = FT_ABS( x ), \
83  y = FT_ABS( y ), \
84  x > y ? x + ( 3 * y >> 3 ) \
85  : y + ( 3 * x >> 3 ) )
86 
87  /* we use FT_TYPEOF to suppress signedness compilation warnings */
88 #define FT_PAD_FLOOR( x, n ) ( (x) & ~FT_TYPEOF( x )( (n) - 1 ) )
89 #define FT_PAD_ROUND( x, n ) FT_PAD_FLOOR( (x) + (n) / 2, n )
90 #define FT_PAD_CEIL( x, n ) FT_PAD_FLOOR( (x) + (n) - 1, n )
91 
92 #define FT_PIX_FLOOR( x ) ( (x) & ~FT_TYPEOF( x )63 )
93 #define FT_PIX_ROUND( x ) FT_PIX_FLOOR( (x) + 32 )
94 #define FT_PIX_CEIL( x ) FT_PIX_FLOOR( (x) + 63 )
95 
96  /* specialized versions (for signed values) */
97  /* that don't produce run-time errors due to integer overflow */
98 #define FT_PAD_ROUND_LONG( x, n ) FT_PAD_FLOOR( ADD_LONG( (x), (n) / 2 ), \
99  n )
100 #define FT_PAD_CEIL_LONG( x, n ) FT_PAD_FLOOR( ADD_LONG( (x), (n) - 1 ), \
101  n )
102 #define FT_PIX_ROUND_LONG( x ) FT_PIX_FLOOR( ADD_LONG( (x), 32 ) )
103 #define FT_PIX_CEIL_LONG( x ) FT_PIX_FLOOR( ADD_LONG( (x), 63 ) )
104 
105 #define FT_PAD_ROUND_INT32( x, n ) FT_PAD_FLOOR( ADD_INT32( (x), (n) / 2 ), \
106  n )
107 #define FT_PAD_CEIL_INT32( x, n ) FT_PAD_FLOOR( ADD_INT32( (x), (n) - 1 ), \
108  n )
109 #define FT_PIX_ROUND_INT32( x ) FT_PIX_FLOOR( ADD_INT32( (x), 32 ) )
110 #define FT_PIX_CEIL_INT32( x ) FT_PIX_FLOOR( ADD_INT32( (x), 63 ) )
111 
112 
113  /*
114  * character classification functions -- since these are used to parse
115  * font files, we must not use those in <ctypes.h> which are
116  * locale-dependent
117  */
118 #define ft_isdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U )
119 
120 #define ft_isxdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U || \
121  ( (unsigned)(x) - 'a' ) < 6U || \
122  ( (unsigned)(x) - 'A' ) < 6U )
123 
124  /* the next two macros assume ASCII representation */
125 #define ft_isupper( x ) ( ( (unsigned)(x) - 'A' ) < 26U )
126 #define ft_islower( x ) ( ( (unsigned)(x) - 'a' ) < 26U )
127 
128 #define ft_isalpha( x ) ( ft_isupper( x ) || ft_islower( x ) )
129 #define ft_isalnum( x ) ( ft_isdigit( x ) || ft_isalpha( x ) )
130 
131 
132  /*************************************************************************/
133  /*************************************************************************/
134  /*************************************************************************/
135  /**** ****/
136  /**** ****/
137  /**** C H A R M A P S ****/
138  /**** ****/
139  /**** ****/
140  /*************************************************************************/
141  /*************************************************************************/
142  /*************************************************************************/
143 
144  /* handle to internal charmap object */
145  typedef struct FT_CMapRec_* FT_CMap;
146 
147  /* handle to charmap class structure */
148  typedef const struct FT_CMap_ClassRec_* FT_CMap_Class;
149 
150  /* internal charmap object structure */
151  typedef struct FT_CMapRec_
152  {
153  FT_CharMapRec charmap;
154  FT_CMap_Class clazz;
155 
156  } FT_CMapRec;
157 
158  /* typecase any pointer to a charmap handle */
159 #define FT_CMAP( x ) ( (FT_CMap)( x ) )
160 
161  /* obvious macros */
162 #define FT_CMAP_PLATFORM_ID( x ) FT_CMAP( x )->charmap.platform_id
163 #define FT_CMAP_ENCODING_ID( x ) FT_CMAP( x )->charmap.encoding_id
164 #define FT_CMAP_ENCODING( x ) FT_CMAP( x )->charmap.encoding
165 #define FT_CMAP_FACE( x ) FT_CMAP( x )->charmap.face
166 
167 
168  /* class method definitions */
169  typedef FT_Error
170  (*FT_CMap_InitFunc)( FT_CMap cmap,
171  FT_Pointer init_data );
172 
173  typedef void
174  (*FT_CMap_DoneFunc)( FT_CMap cmap );
175 
176  typedef FT_UInt
177  (*FT_CMap_CharIndexFunc)( FT_CMap cmap,
178  FT_UInt32 char_code );
179 
180  typedef FT_UInt
181  (*FT_CMap_CharNextFunc)( FT_CMap cmap,
182  FT_UInt32 *achar_code );
183 
184  typedef FT_UInt
185  (*FT_CMap_CharVarIndexFunc)( FT_CMap cmap,
186  FT_CMap unicode_cmap,
187  FT_UInt32 char_code,
188  FT_UInt32 variant_selector );
189 
190  typedef FT_Bool
191  (*FT_CMap_CharVarIsDefaultFunc)( FT_CMap cmap,
192  FT_UInt32 char_code,
193  FT_UInt32 variant_selector );
194 
195  typedef FT_UInt32 *
196  (*FT_CMap_VariantListFunc)( FT_CMap cmap,
197  FT_Memory mem );
198 
199  typedef FT_UInt32 *
200  (*FT_CMap_CharVariantListFunc)( FT_CMap cmap,
201  FT_Memory mem,
202  FT_UInt32 char_code );
203 
204  typedef FT_UInt32 *
205  (*FT_CMap_VariantCharListFunc)( FT_CMap cmap,
206  FT_Memory mem,
207  FT_UInt32 variant_selector );
208 
209 
210  typedef struct FT_CMap_ClassRec_
211  {
212  FT_ULong size;
213 
214  FT_CMap_InitFunc init;
215  FT_CMap_DoneFunc done;
216  FT_CMap_CharIndexFunc char_index;
217  FT_CMap_CharNextFunc char_next;
218 
219  /* Subsequent entries are special ones for format 14 -- the variant */
220  /* selector subtable which behaves like no other */
221 
222  FT_CMap_CharVarIndexFunc char_var_index;
223  FT_CMap_CharVarIsDefaultFunc char_var_default;
224  FT_CMap_VariantListFunc variant_list;
225  FT_CMap_CharVariantListFunc charvariant_list;
226  FT_CMap_VariantCharListFunc variantchar_list;
227 
228  } FT_CMap_ClassRec;
229 
230 
231 #ifndef FT_CONFIG_OPTION_PIC
232 
233 #define FT_DECLARE_CMAP_CLASS( class_ ) \
234  FT_CALLBACK_TABLE const FT_CMap_ClassRec class_;
235 
236 #define FT_DEFINE_CMAP_CLASS( \
237  class_, \
238  size_, \
239  init_, \
240  done_, \
241  char_index_, \
242  char_next_, \
243  char_var_index_, \
244  char_var_default_, \
245  variant_list_, \
246  charvariant_list_, \
247  variantchar_list_ ) \
248  FT_CALLBACK_TABLE_DEF \
249  const FT_CMap_ClassRec class_ = \
250  { \
251  size_, \
252  init_, \
253  done_, \
254  char_index_, \
255  char_next_, \
256  char_var_index_, \
257  char_var_default_, \
258  variant_list_, \
259  charvariant_list_, \
260  variantchar_list_ \
261  };
262 
263 #else /* FT_CONFIG_OPTION_PIC */
264 
265 #define FT_DECLARE_CMAP_CLASS( class_ ) \
266  void \
267  FT_Init_Class_ ## class_( FT_Library library, \
268  FT_CMap_ClassRec* clazz );
269 
270 #define FT_DEFINE_CMAP_CLASS( \
271  class_, \
272  size_, \
273  init_, \
274  done_, \
275  char_index_, \
276  char_next_, \
277  char_var_index_, \
278  char_var_default_, \
279  variant_list_, \
280  charvariant_list_, \
281  variantchar_list_ ) \
282  void \
283  FT_Init_Class_ ## class_( FT_Library library, \
284  FT_CMap_ClassRec* clazz ) \
285  { \
286  FT_UNUSED( library ); \
287  \
288  clazz->size = size_; \
289  clazz->init = init_; \
290  clazz->done = done_; \
291  clazz->char_index = char_index_; \
292  clazz->char_next = char_next_; \
293  clazz->char_var_index = char_var_index_; \
294  clazz->char_var_default = char_var_default_; \
295  clazz->variant_list = variant_list_; \
296  clazz->charvariant_list = charvariant_list_; \
297  clazz->variantchar_list = variantchar_list_; \
298  }
299 
300 #endif /* FT_CONFIG_OPTION_PIC */
301 
302 
303  /* create a new charmap and add it to charmap->face */
304  FT_BASE( FT_Error )
305  FT_CMap_New( FT_CMap_Class clazz,
306  FT_Pointer init_data,
307  FT_CharMap charmap,
308  FT_CMap *acmap );
309 
310  /* destroy a charmap and remove it from face's list */
311  FT_BASE( void )
312  FT_CMap_Done( FT_CMap cmap );
313 
314 
315  /* adds LCD padding to Min and Max boundaries */
316  FT_BASE( void )
317  ft_lcd_padding( FT_Pos* Min,
318  FT_Pos* Max,
319  FT_GlyphSlot slot );
320 
321 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
322 
323  typedef void (*FT_Bitmap_LcdFilterFunc)( FT_Bitmap* bitmap,
324  FT_Render_Mode render_mode,
325  FT_Byte* weights );
326 
327 
328  /* This is the default LCD filter, an in-place, 5-tap FIR filter. */
329  FT_BASE( void )
330  ft_lcd_filter_fir( FT_Bitmap* bitmap,
331  FT_Render_Mode mode,
332  FT_LcdFiveTapFilter weights );
333 
334 #endif /* FT_CONFIG_OPTION_SUBPIXEL_RENDERING */
335 
336  /*************************************************************************/
337  /* */
338  /* <Struct> */
339  /* FT_Face_InternalRec */
340  /* */
341  /* <Description> */
342  /* This structure contains the internal fields of each FT_Face */
343  /* object. These fields may change between different releases of */
344  /* FreeType. */
345  /* */
346  /* <Fields> */
347  /* max_points :: */
348  /* The maximum number of points used to store the vectorial outline */
349  /* of any glyph in this face. If this value cannot be known in */
350  /* advance, or if the face isn't scalable, this should be set to 0. */
351  /* Only relevant for scalable formats. */
352  /* */
353  /* max_contours :: */
354  /* The maximum number of contours used to store the vectorial */
355  /* outline of any glyph in this face. If this value cannot be */
356  /* known in advance, or if the face isn't scalable, this should be */
357  /* set to 0. Only relevant for scalable formats. */
358  /* */
359  /* transform_matrix :: */
360  /* A 2x2 matrix of 16.16 coefficients used to transform glyph */
361  /* outlines after they are loaded from the font. Only used by the */
362  /* convenience functions. */
363  /* */
364  /* transform_delta :: */
365  /* A translation vector used to transform glyph outlines after they */
366  /* are loaded from the font. Only used by the convenience */
367  /* functions. */
368  /* */
369  /* transform_flags :: */
370  /* Some flags used to classify the transform. Only used by the */
371  /* convenience functions. */
372  /* */
373  /* services :: */
374  /* A cache for frequently used services. It should be only */
375  /* accessed with the macro `FT_FACE_LOOKUP_SERVICE'. */
376  /* */
377  /* incremental_interface :: */
378  /* If non-null, the interface through which glyph data and metrics */
379  /* are loaded incrementally for faces that do not provide all of */
380  /* this data when first opened. This field exists only if */
381  /* @FT_CONFIG_OPTION_INCREMENTAL is defined. */
382  /* */
383  /* no_stem_darkening :: */
384  /* Overrides the module-level default, see @stem-darkening[cff], */
385  /* for example. FALSE and TRUE toggle stem darkening on and off, */
386  /* respectively, value~-1 means to use the module/driver default. */
387  /* */
388  /* random_seed :: */
389  /* If positive, override the seed value for the CFF `random' */
390  /* operator. Value~0 means to use the font's value. Value~-1 */
391  /* means to use the CFF driver's default. */
392  /* */
393  /* lcd_weights :: */
394  /* lcd_filter_func :: */
395  /* If subpixel rendering is activated, the LCD filtering weights */
396  /* and callback function. */
397  /* */
398  /* refcount :: */
399  /* A counter initialized to~1 at the time an @FT_Face structure is */
400  /* created. @FT_Reference_Face increments this counter, and */
401  /* @FT_Done_Face only destroys a face if the counter is~1, */
402  /* otherwise it simply decrements it. */
403  /* */
404  typedef struct FT_Face_InternalRec_
405  {
406  FT_Matrix transform_matrix;
407  FT_Vector transform_delta;
408  FT_Int transform_flags;
409 
410  FT_ServiceCacheRec services;
411 
412 #ifdef FT_CONFIG_OPTION_INCREMENTAL
413  FT_Incremental_InterfaceRec* incremental_interface;
414 #endif
415 
416  FT_Char no_stem_darkening;
417  FT_Int32 random_seed;
418 
419 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
420  FT_LcdFiveTapFilter lcd_weights; /* filter weights, if any */
421  FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */
422 #endif
423 
424  FT_Int refcount;
425 
426  } FT_Face_InternalRec;
427 
428 
429  /*************************************************************************/
430  /* */
431  /* <Struct> */
432  /* FT_Slot_InternalRec */
433  /* */
434  /* <Description> */
435  /* This structure contains the internal fields of each FT_GlyphSlot */
436  /* object. These fields may change between different releases of */
437  /* FreeType. */
438  /* */
439  /* <Fields> */
440  /* loader :: The glyph loader object used to load outlines */
441  /* into the glyph slot. */
442  /* */
443  /* flags :: Possible values are zero or */
444  /* FT_GLYPH_OWN_BITMAP. The latter indicates */
445  /* that the FT_GlyphSlot structure owns the */
446  /* bitmap buffer. */
447  /* */
448  /* glyph_transformed :: Boolean. Set to TRUE when the loaded glyph */
449  /* must be transformed through a specific */
450  /* font transformation. This is _not_ the same */
451  /* as the face transform set through */
452  /* FT_Set_Transform(). */
453  /* */
454  /* glyph_matrix :: The 2x2 matrix corresponding to the glyph */
455  /* transformation, if necessary. */
456  /* */
457  /* glyph_delta :: The 2d translation vector corresponding to */
458  /* the glyph transformation, if necessary. */
459  /* */
460  /* glyph_hints :: Format-specific glyph hints management. */
461  /* */
462 
463 #define FT_GLYPH_OWN_BITMAP 0x1U
464 
465  typedef struct FT_Slot_InternalRec_
466  {
467  FT_GlyphLoader loader;
468  FT_UInt flags;
469  FT_Bool glyph_transformed;
470  FT_Matrix glyph_matrix;
471  FT_Vector glyph_delta;
472  void* glyph_hints;
473 
474  } FT_GlyphSlot_InternalRec;
475 
476 
477  /*************************************************************************/
478  /* */
479  /* <Struct> */
480  /* FT_Size_InternalRec */
481  /* */
482  /* <Description> */
483  /* This structure contains the internal fields of each FT_Size */
484  /* object. */
485  /* */
486  /* <Fields> */
487  /* module_data :: Data specific to a driver module. */
488  /* */
489  /* autohint_mode :: The used auto-hinting mode. */
490  /* */
491  /* autohint_metrics :: Metrics used by the auto-hinter. */
492  /* */
493  /*************************************************************************/
494 
495  typedef struct FT_Size_InternalRec_
496  {
497  void* module_data;
498 
499  FT_Render_Mode autohint_mode;
500  FT_Size_Metrics autohint_metrics;
501 
502  } FT_Size_InternalRec;
503 
504 
505  /*************************************************************************/
506  /*************************************************************************/
507  /*************************************************************************/
508  /**** ****/
509  /**** ****/
510  /**** M O D U L E S ****/
511  /**** ****/
512  /**** ****/
513  /*************************************************************************/
514  /*************************************************************************/
515  /*************************************************************************/
516 
517 
518  /*************************************************************************/
519  /* */
520  /* <Struct> */
521  /* FT_ModuleRec */
522  /* */
523  /* <Description> */
524  /* A module object instance. */
525  /* */
526  /* <Fields> */
527  /* clazz :: A pointer to the module's class. */
528  /* */
529  /* library :: A handle to the parent library object. */
530  /* */
531  /* memory :: A handle to the memory manager. */
532  /* */
533  typedef struct FT_ModuleRec_
534  {
535  FT_Module_Class* clazz;
536  FT_Library library;
537  FT_Memory memory;
538 
539  } FT_ModuleRec;
540 
541 
542  /* typecast an object to an FT_Module */
543 #define FT_MODULE( x ) ( (FT_Module)(x) )
544 
545 #define FT_MODULE_CLASS( x ) FT_MODULE( x )->clazz
546 #define FT_MODULE_LIBRARY( x ) FT_MODULE( x )->library
547 #define FT_MODULE_MEMORY( x ) FT_MODULE( x )->memory
548 
549 
550 #define FT_MODULE_IS_DRIVER( x ) ( FT_MODULE_CLASS( x )->module_flags & \
551  FT_MODULE_FONT_DRIVER )
552 
553 #define FT_MODULE_IS_RENDERER( x ) ( FT_MODULE_CLASS( x )->module_flags & \
554  FT_MODULE_RENDERER )
555 
556 #define FT_MODULE_IS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \
557  FT_MODULE_HINTER )
558 
559 #define FT_MODULE_IS_STYLER( x ) ( FT_MODULE_CLASS( x )->module_flags & \
560  FT_MODULE_STYLER )
561 
562 #define FT_DRIVER_IS_SCALABLE( x ) ( FT_MODULE_CLASS( x )->module_flags & \
563  FT_MODULE_DRIVER_SCALABLE )
564 
565 #define FT_DRIVER_USES_OUTLINES( x ) !( FT_MODULE_CLASS( x )->module_flags & \
566  FT_MODULE_DRIVER_NO_OUTLINES )
567 
568 #define FT_DRIVER_HAS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \
569  FT_MODULE_DRIVER_HAS_HINTER )
570 
571 #define FT_DRIVER_HINTS_LIGHTLY( x ) ( FT_MODULE_CLASS( x )->module_flags & \
572  FT_MODULE_DRIVER_HINTS_LIGHTLY )
573 
574 
575  /*************************************************************************/
576  /* */
577  /* <Function> */
578  /* FT_Get_Module_Interface */
579  /* */
580  /* <Description> */
581  /* Finds a module and returns its specific interface as a typeless */
582  /* pointer. */
583  /* */
584  /* <Input> */
585  /* library :: A handle to the library object. */
586  /* */
587  /* module_name :: The module's name (as an ASCII string). */
588  /* */
589  /* <Return> */
590  /* A module-specific interface if available, 0 otherwise. */
591  /* */
592  /* <Note> */
593  /* You should better be familiar with FreeType internals to know */
594  /* which module to look for, and what its interface is :-) */
595  /* */
596  FT_BASE( const void* )
597  FT_Get_Module_Interface( FT_Library library,
598  const char* mod_name );
599 
600  FT_BASE( FT_Pointer )
601  ft_module_get_service( FT_Module module,
602  const char* service_id,
603  FT_Bool global );
604 
605 #ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
606  FT_BASE( FT_Error )
607  ft_property_string_set( FT_Library library,
608  const FT_String* module_name,
609  const FT_String* property_name,
610  FT_String* value );
611 #endif
612 
613  /* */
614 
615 
616  /*************************************************************************/
617  /*************************************************************************/
618  /*************************************************************************/
619  /**** ****/
620  /**** ****/
621  /**** F A C E, S I Z E & G L Y P H S L O T O B J E C T S ****/
622  /**** ****/
623  /**** ****/
624  /*************************************************************************/
625  /*************************************************************************/
626  /*************************************************************************/
627 
628  /* a few macros used to perform easy typecasts with minimal brain damage */
629 
630 #define FT_FACE( x ) ( (FT_Face)(x) )
631 #define FT_SIZE( x ) ( (FT_Size)(x) )
632 #define FT_SLOT( x ) ( (FT_GlyphSlot)(x) )
633 
634 #define FT_FACE_DRIVER( x ) FT_FACE( x )->driver
635 #define FT_FACE_LIBRARY( x ) FT_FACE_DRIVER( x )->root.library
636 #define FT_FACE_MEMORY( x ) FT_FACE( x )->memory
637 #define FT_FACE_STREAM( x ) FT_FACE( x )->stream
638 
639 #define FT_SIZE_FACE( x ) FT_SIZE( x )->face
640 #define FT_SLOT_FACE( x ) FT_SLOT( x )->face
641 
642 #define FT_FACE_SLOT( x ) FT_FACE( x )->glyph
643 #define FT_FACE_SIZE( x ) FT_FACE( x )->size
644 
645 
646  /*************************************************************************/
647  /* */
648  /* <Function> */
649  /* FT_New_GlyphSlot */
650  /* */
651  /* <Description> */
652  /* It is sometimes useful to have more than one glyph slot for a */
653  /* given face object. This function is used to create additional */
654  /* slots. All of them are automatically discarded when the face is */
655  /* destroyed. */
656  /* */
657  /* <Input> */
658  /* face :: A handle to a parent face object. */
659  /* */
660  /* <Output> */
661  /* aslot :: A handle to a new glyph slot object. */
662  /* */
663  /* <Return> */
664  /* FreeType error code. 0 means success. */
665  /* */
666  FT_BASE( FT_Error )
667  FT_New_GlyphSlot( FT_Face face,
668  FT_GlyphSlot *aslot );
669 
670 
671  /*************************************************************************/
672  /* */
673  /* <Function> */
674  /* FT_Done_GlyphSlot */
675  /* */
676  /* <Description> */
677  /* Destroys a given glyph slot. Remember however that all slots are */
678  /* automatically destroyed with its parent. Using this function is */
679  /* not always mandatory. */
680  /* */
681  /* <Input> */
682  /* slot :: A handle to a target glyph slot. */
683  /* */
684  FT_BASE( void )
685  FT_Done_GlyphSlot( FT_GlyphSlot slot );
686 
687  /* */
688 
689 #define FT_REQUEST_WIDTH( req ) \
690  ( (req)->horiResolution \
691  ? ( (req)->width * (FT_Pos)(req)->horiResolution + 36 ) / 72 \
692  : (req)->width )
693 
694 #define FT_REQUEST_HEIGHT( req ) \
695  ( (req)->vertResolution \
696  ? ( (req)->height * (FT_Pos)(req)->vertResolution + 36 ) / 72 \
697  : (req)->height )
698 
699 
700  /* Set the metrics according to a bitmap strike. */
701  FT_BASE( void )
702  FT_Select_Metrics( FT_Face face,
703  FT_ULong strike_index );
704 
705 
706  /* Set the metrics according to a size request. */
707  FT_BASE( void )
708  FT_Request_Metrics( FT_Face face,
709  FT_Size_Request req );
710 
711 
712  /* Match a size request against `available_sizes'. */
713  FT_BASE( FT_Error )
714  FT_Match_Size( FT_Face face,
715  FT_Size_Request req,
716  FT_Bool ignore_width,
717  FT_ULong* size_index );
718 
719 
720  /* Use the horizontal metrics to synthesize the vertical metrics. */
721  /* If `advance' is zero, it is also synthesized. */
722  FT_BASE( void )
723  ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics,
724  FT_Pos advance );
725 
726 
727  /* Free the bitmap of a given glyphslot when needed (i.e., only when it */
728  /* was allocated with ft_glyphslot_alloc_bitmap). */
729  FT_BASE( void )
730  ft_glyphslot_free_bitmap( FT_GlyphSlot slot );
731 
732 
733  /* Preset bitmap metrics of an outline glyphslot prior to rendering. */
734  FT_BASE( void )
735  ft_glyphslot_preset_bitmap( FT_GlyphSlot slot,
736  FT_Render_Mode mode,
737  const FT_Vector* origin );
738 
739  /* Allocate a new bitmap buffer in a glyph slot. */
740  FT_BASE( FT_Error )
741  ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot,
742  FT_ULong size );
743 
744 
745  /* Set the bitmap buffer in a glyph slot to a given pointer. The buffer */
746  /* will not be freed by a later call to ft_glyphslot_free_bitmap. */
747  FT_BASE( void )
748  ft_glyphslot_set_bitmap( FT_GlyphSlot slot,
749  FT_Byte* buffer );
750 
751 
752  /*************************************************************************/
753  /*************************************************************************/
754  /*************************************************************************/
755  /**** ****/
756  /**** ****/
757  /**** R E N D E R E R S ****/
758  /**** ****/
759  /**** ****/
760  /*************************************************************************/
761  /*************************************************************************/
762  /*************************************************************************/
763 
764 
765 #define FT_RENDERER( x ) ( (FT_Renderer)(x) )
766 #define FT_GLYPH( x ) ( (FT_Glyph)(x) )
767 #define FT_BITMAP_GLYPH( x ) ( (FT_BitmapGlyph)(x) )
768 #define FT_OUTLINE_GLYPH( x ) ( (FT_OutlineGlyph)(x) )
769 
770 
771  typedef struct FT_RendererRec_
772  {
773  FT_ModuleRec root;
774  FT_Renderer_Class* clazz;
775  FT_Glyph_Format glyph_format;
776  FT_Glyph_Class glyph_class;
777 
778  FT_Raster raster;
779  FT_Raster_Render_Func raster_render;
780  FT_Renderer_RenderFunc render;
781 
782  } FT_RendererRec;
783 
784 
785  /*************************************************************************/
786  /*************************************************************************/
787  /*************************************************************************/
788  /**** ****/
789  /**** ****/
790  /**** F O N T D R I V E R S ****/
791  /**** ****/
792  /**** ****/
793  /*************************************************************************/
794  /*************************************************************************/
795  /*************************************************************************/
796 
797 
798  /* typecast a module into a driver easily */
799 #define FT_DRIVER( x ) ( (FT_Driver)(x) )
800 
801  /* typecast a module as a driver, and get its driver class */
802 #define FT_DRIVER_CLASS( x ) FT_DRIVER( x )->clazz
803 
804 
805  /*************************************************************************/
806  /* */
807  /* <Struct> */
808  /* FT_DriverRec */
809  /* */
810  /* <Description> */
811  /* The root font driver class. A font driver is responsible for */
812  /* managing and loading font files of a given format. */
813  /* */
814  /* <Fields> */
815  /* root :: Contains the fields of the root module class. */
816  /* */
817  /* clazz :: A pointer to the font driver's class. Note that */
818  /* this is NOT root.clazz. `class' wasn't used */
819  /* as it is a reserved word in C++. */
820  /* */
821  /* faces_list :: The list of faces currently opened by this */
822  /* driver. */
823  /* */
824  /* glyph_loader :: Unused. Used to be glyph loader for all faces */
825  /* managed by this driver. */
826  /* */
827  typedef struct FT_DriverRec_
828  {
829  FT_ModuleRec root;
830  FT_Driver_Class clazz;
831  FT_ListRec faces_list;
832  FT_GlyphLoader glyph_loader;
833 
834  } FT_DriverRec;
835 
836 
837  /*************************************************************************/
838  /*************************************************************************/
839  /*************************************************************************/
840  /**** ****/
841  /**** ****/
842  /**** L I B R A R I E S ****/
843  /**** ****/
844  /**** ****/
845  /*************************************************************************/
846  /*************************************************************************/
847  /*************************************************************************/
848 
849 
850  /* This hook is used by the TrueType debugger. It must be set to an */
851  /* alternate truetype bytecode interpreter function. */
852 #define FT_DEBUG_HOOK_TRUETYPE 0
853 
854 
855  /*************************************************************************/
856  /* */
857  /* <Struct> */
858  /* FT_LibraryRec */
859  /* */
860  /* <Description> */
861  /* The FreeType library class. This is the root of all FreeType */
862  /* data. Use FT_New_Library() to create a library object, and */
863  /* FT_Done_Library() to discard it and all child objects. */
864  /* */
865  /* <Fields> */
866  /* memory :: The library's memory object. Manages memory */
867  /* allocation. */
868  /* */
869  /* version_major :: The major version number of the library. */
870  /* */
871  /* version_minor :: The minor version number of the library. */
872  /* */
873  /* version_patch :: The current patch level of the library. */
874  /* */
875  /* num_modules :: The number of modules currently registered */
876  /* within this library. This is set to 0 for new */
877  /* libraries. New modules are added through the */
878  /* FT_Add_Module() API function. */
879  /* */
880  /* modules :: A table used to store handles to the currently */
881  /* registered modules. Note that each font driver */
882  /* contains a list of its opened faces. */
883  /* */
884  /* renderers :: The list of renderers currently registered */
885  /* within the library. */
886  /* */
887  /* cur_renderer :: The current outline renderer. This is a */
888  /* shortcut used to avoid parsing the list on */
889  /* each call to FT_Outline_Render(). It is a */
890  /* handle to the current renderer for the */
891  /* FT_GLYPH_FORMAT_OUTLINE format. */
892  /* */
893  /* auto_hinter :: The auto-hinter module interface. */
894  /* */
895  /* debug_hooks :: An array of four function pointers that allow */
896  /* debuggers to hook into a font format's */
897  /* interpreter. Currently, only the TrueType */
898  /* bytecode debugger uses this. */
899  /* */
900  /* lcd_weights :: If subpixel rendering is activated, the LCD */
901  /* filter weights, if any. */
902  /* */
903  /* lcd_filter_func :: If subpixel rendering is activated, the LCD */
904  /* filtering callback function. */
905  /* */
906  /* pic_container :: Contains global structs and tables, instead */
907  /* of defining them globally. */
908  /* */
909  /* refcount :: A counter initialized to~1 at the time an */
910  /* @FT_Library structure is created. */
911  /* @FT_Reference_Library increments this counter, */
912  /* and @FT_Done_Library only destroys a library */
913  /* if the counter is~1, otherwise it simply */
914  /* decrements it. */
915  /* */
916  typedef struct FT_LibraryRec_
917  {
918  FT_Memory memory; /* library's memory manager */
919 
920  FT_Int version_major;
921  FT_Int version_minor;
922  FT_Int version_patch;
923 
924  FT_UInt num_modules;
925  FT_Module modules[FT_MAX_MODULES]; /* module objects */
926 
927  FT_ListRec renderers; /* list of renderers */
928  FT_Renderer cur_renderer; /* current outline renderer */
929  FT_Module auto_hinter;
930 
931  FT_DebugHook_Func debug_hooks[4];
932 
933 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
934  FT_LcdFiveTapFilter lcd_weights; /* filter weights, if any */
935  FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */
936 #endif
937 
938 #ifdef FT_CONFIG_OPTION_PIC
939  FT_PIC_Container pic_container;
940 #endif
941 
942  FT_Int refcount;
943 
944  } FT_LibraryRec;
945 
946 
947  FT_BASE( FT_Renderer )
948  FT_Lookup_Renderer( FT_Library library,
949  FT_Glyph_Format format,
950  FT_ListNode* node );
951 
952  FT_BASE( FT_Error )
953  FT_Render_Glyph_Internal( FT_Library library,
954  FT_GlyphSlot slot,
955  FT_Render_Mode render_mode );
956 
957  typedef const char*
958  (*FT_Face_GetPostscriptNameFunc)( FT_Face face );
959 
960  typedef FT_Error
961  (*FT_Face_GetGlyphNameFunc)( FT_Face face,
962  FT_UInt glyph_index,
963  FT_Pointer buffer,
964  FT_UInt buffer_max );
965 
966  typedef FT_UInt
967  (*FT_Face_GetGlyphNameIndexFunc)( FT_Face face,
968  FT_String* glyph_name );
969 
970 
971 #ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
972 
973  /*************************************************************************/
974  /* */
975  /* <Function> */
976  /* FT_New_Memory */
977  /* */
978  /* <Description> */
979  /* Creates a new memory object. */
980  /* */
981  /* <Return> */
982  /* A pointer to the new memory object. 0 in case of error. */
983  /* */
984  FT_BASE( FT_Memory )
985  FT_New_Memory( void );
986 
987 
988  /*************************************************************************/
989  /* */
990  /* <Function> */
991  /* FT_Done_Memory */
992  /* */
993  /* <Description> */
994  /* Discards memory manager. */
995  /* */
996  /* <Input> */
997  /* memory :: A handle to the memory manager. */
998  /* */
999  FT_BASE( void )
1000  FT_Done_Memory( FT_Memory memory );
1001 
1002 #endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
1003 
1004 
1005  /* Define default raster's interface. The default raster is located in */
1006  /* `src/base/ftraster.c'. */
1007  /* */
1008  /* Client applications can register new rasters through the */
1009  /* FT_Set_Raster() API. */
1010 
1011 #ifndef FT_NO_DEFAULT_RASTER
1012  FT_EXPORT_VAR( FT_Raster_Funcs ) ft_default_raster;
1013 #endif
1014 
1015 
1016  /*************************************************************************/
1017  /*************************************************************************/
1018  /*************************************************************************/
1019  /**** ****/
1020  /**** ****/
1021  /**** P I C S U P P O R T ****/
1022  /**** ****/
1023  /**** ****/
1024  /*************************************************************************/
1025  /*************************************************************************/
1026  /*************************************************************************/
1027 
1028 
1029  /* PIC support macros for ftimage.h */
1030 
1031 
1032  /*************************************************************************/
1033  /* */
1034  /* <Macro> */
1035  /* FT_DEFINE_OUTLINE_FUNCS */
1036  /* */
1037  /* <Description> */
1038  /* Used to initialize an instance of FT_Outline_Funcs struct. */
1039  /* When FT_CONFIG_OPTION_PIC is defined an init function will need */
1040  /* to be called with a pre-allocated structure to be filled. */
1041  /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
1042  /* allocated in the global scope (or the scope where the macro */
1043  /* is used). */
1044  /* */
1045 #ifndef FT_CONFIG_OPTION_PIC
1046 
1047 #define FT_DEFINE_OUTLINE_FUNCS( \
1048  class_, \
1049  move_to_, \
1050  line_to_, \
1051  conic_to_, \
1052  cubic_to_, \
1053  shift_, \
1054  delta_ ) \
1055  static const FT_Outline_Funcs class_ = \
1056  { \
1057  move_to_, \
1058  line_to_, \
1059  conic_to_, \
1060  cubic_to_, \
1061  shift_, \
1062  delta_ \
1063  };
1064 
1065 #else /* FT_CONFIG_OPTION_PIC */
1066 
1067 #define FT_DEFINE_OUTLINE_FUNCS( \
1068  class_, \
1069  move_to_, \
1070  line_to_, \
1071  conic_to_, \
1072  cubic_to_, \
1073  shift_, \
1074  delta_ ) \
1075  static FT_Error \
1076  Init_Class_ ## class_( FT_Outline_Funcs* clazz ) \
1077  { \
1078  clazz->move_to = move_to_; \
1079  clazz->line_to = line_to_; \
1080  clazz->conic_to = conic_to_; \
1081  clazz->cubic_to = cubic_to_; \
1082  clazz->shift = shift_; \
1083  clazz->delta = delta_; \
1084  \
1085  return FT_Err_Ok; \
1086  }
1087 
1088 #endif /* FT_CONFIG_OPTION_PIC */
1089 
1090 
1091  /*************************************************************************/
1092  /* */
1093  /* <Macro> */
1094  /* FT_DEFINE_RASTER_FUNCS */
1095  /* */
1096  /* <Description> */
1097  /* Used to initialize an instance of FT_Raster_Funcs struct. */
1098  /* When FT_CONFIG_OPTION_PIC is defined an init function will need */
1099  /* to be called with a pre-allocated structure to be filled. */
1100  /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
1101  /* allocated in the global scope (or the scope where the macro */
1102  /* is used). */
1103  /* */
1104 #ifndef FT_CONFIG_OPTION_PIC
1105 
1106 #define FT_DEFINE_RASTER_FUNCS( \
1107  class_, \
1108  glyph_format_, \
1109  raster_new_, \
1110  raster_reset_, \
1111  raster_set_mode_, \
1112  raster_render_, \
1113  raster_done_ ) \
1114  const FT_Raster_Funcs class_ = \
1115  { \
1116  glyph_format_, \
1117  raster_new_, \
1118  raster_reset_, \
1119  raster_set_mode_, \
1120  raster_render_, \
1121  raster_done_ \
1122  };
1123 
1124 #else /* FT_CONFIG_OPTION_PIC */
1125 
1126 #define FT_DEFINE_RASTER_FUNCS( \
1127  class_, \
1128  glyph_format_, \
1129  raster_new_, \
1130  raster_reset_, \
1131  raster_set_mode_, \
1132  raster_render_, \
1133  raster_done_ ) \
1134  void \
1135  FT_Init_Class_ ## class_( FT_Raster_Funcs* clazz ) \
1136  { \
1137  clazz->glyph_format = glyph_format_; \
1138  clazz->raster_new = raster_new_; \
1139  clazz->raster_reset = raster_reset_; \
1140  clazz->raster_set_mode = raster_set_mode_; \
1141  clazz->raster_render = raster_render_; \
1142  clazz->raster_done = raster_done_; \
1143  }
1144 
1145 #endif /* FT_CONFIG_OPTION_PIC */
1146 
1147 
1148  /* PIC support macros for ftrender.h */
1149 
1150 
1151  /*************************************************************************/
1152  /* */
1153  /* <Macro> */
1154  /* FT_DEFINE_GLYPH */
1155  /* */
1156  /* <Description> */
1157  /* Used to initialize an instance of FT_Glyph_Class struct. */
1158  /* When FT_CONFIG_OPTION_PIC is defined an init function will need */
1159  /* to be called with a pre-allocated structure to be filled. */
1160  /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
1161  /* allocated in the global scope (or the scope where the macro */
1162  /* is used). */
1163  /* */
1164 #ifndef FT_CONFIG_OPTION_PIC
1165 
1166 #define FT_DEFINE_GLYPH( \
1167  class_, \
1168  size_, \
1169  format_, \
1170  init_, \
1171  done_, \
1172  copy_, \
1173  transform_, \
1174  bbox_, \
1175  prepare_ ) \
1176  FT_CALLBACK_TABLE_DEF \
1177  const FT_Glyph_Class class_ = \
1178  { \
1179  size_, \
1180  format_, \
1181  init_, \
1182  done_, \
1183  copy_, \
1184  transform_, \
1185  bbox_, \
1186  prepare_ \
1187  };
1188 
1189 #else /* FT_CONFIG_OPTION_PIC */
1190 
1191 #define FT_DEFINE_GLYPH( \
1192  class_, \
1193  size_, \
1194  format_, \
1195  init_, \
1196  done_, \
1197  copy_, \
1198  transform_, \
1199  bbox_, \
1200  prepare_ ) \
1201  void \
1202  FT_Init_Class_ ## class_( FT_Glyph_Class* clazz ) \
1203  { \
1204  clazz->glyph_size = size_; \
1205  clazz->glyph_format = format_; \
1206  clazz->glyph_init = init_; \
1207  clazz->glyph_done = done_; \
1208  clazz->glyph_copy = copy_; \
1209  clazz->glyph_transform = transform_; \
1210  clazz->glyph_bbox = bbox_; \
1211  clazz->glyph_prepare = prepare_; \
1212  }
1213 
1214 #endif /* FT_CONFIG_OPTION_PIC */
1215 
1216 
1217  /*************************************************************************/
1218  /* */
1219  /* <Macro> */
1220  /* FT_DECLARE_RENDERER */
1221  /* */
1222  /* <Description> */
1223  /* Used to create a forward declaration of a */
1224  /* FT_Renderer_Class struct instance. */
1225  /* */
1226  /* <Macro> */
1227  /* FT_DEFINE_RENDERER */
1228  /* */
1229  /* <Description> */
1230  /* Used to initialize an instance of FT_Renderer_Class struct. */
1231  /* */
1232  /* When FT_CONFIG_OPTION_PIC is defined a `create' function will */
1233  /* need to be called with a pointer where the allocated structure is */
1234  /* returned. And when it is no longer needed a `destroy' function */
1235  /* needs to be called to release that allocation. */
1236  /* `ftinit.c' (ft_create_default_module_classes) already contains */
1237  /* a mechanism to call these functions for the default modules */
1238  /* described in `ftmodule.h'. */
1239  /* */
1240  /* Notice that the created `create' and `destroy' functions call */
1241  /* `pic_init' and `pic_free' to allow you to manually allocate and */
1242  /* initialize any additional global data, like a module specific */
1243  /* interface, and put them in the global pic container defined in */
1244  /* `ftpic.h'. If you don't need them just implement the functions as */
1245  /* empty to resolve the link error. Also the `pic_init' and */
1246  /* `pic_free' functions should be declared in `pic.h', to be referred */
1247  /* by the renderer definition calling `FT_DEFINE_RENDERER' in the */
1248  /* following. */
1249  /* */
1250  /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
1251  /* allocated in the global scope (or the scope where the macro */
1252  /* is used). */
1253  /* */
1254 #ifndef FT_CONFIG_OPTION_PIC
1255 
1256 #define FT_DECLARE_RENDERER( class_ ) \
1257  FT_EXPORT_VAR( const FT_Renderer_Class ) class_;
1258 
1259 #define FT_DEFINE_RENDERER( \
1260  class_, \
1261  flags_, \
1262  size_, \
1263  name_, \
1264  version_, \
1265  requires_, \
1266  interface_, \
1267  init_, \
1268  done_, \
1269  get_interface_, \
1270  glyph_format_, \
1271  render_glyph_, \
1272  transform_glyph_, \
1273  get_glyph_cbox_, \
1274  set_mode_, \
1275  raster_class_ ) \
1276  FT_CALLBACK_TABLE_DEF \
1277  const FT_Renderer_Class class_ = \
1278  { \
1279  FT_DEFINE_ROOT_MODULE( flags_, \
1280  size_, \
1281  name_, \
1282  version_, \
1283  requires_, \
1284  interface_, \
1285  init_, \
1286  done_, \
1287  get_interface_ ) \
1288  glyph_format_, \
1289  \
1290  render_glyph_, \
1291  transform_glyph_, \
1292  get_glyph_cbox_, \
1293  set_mode_, \
1294  \
1295  raster_class_ \
1296  };
1297 
1298 #else /* FT_CONFIG_OPTION_PIC */
1299 
1300 #define FT_DECLARE_RENDERER( class_ ) FT_DECLARE_MODULE( class_ )
1301 
1302 #define FT_DEFINE_RENDERER( \
1303  class_, \
1304  flags_, \
1305  size_, \
1306  name_, \
1307  version_, \
1308  requires_, \
1309  interface_, \
1310  init_, \
1311  done_, \
1312  get_interface_, \
1313  glyph_format_, \
1314  render_glyph_, \
1315  transform_glyph_, \
1316  get_glyph_cbox_, \
1317  set_mode_, \
1318  raster_class_ ) \
1319  void \
1320  FT_Destroy_Class_ ## class_( FT_Library library, \
1321  FT_Module_Class* clazz ) \
1322  { \
1323  FT_Renderer_Class* rclazz = (FT_Renderer_Class*)clazz; \
1324  FT_Memory memory = library->memory; \
1325  \
1326  \
1327  class_ ## _pic_free( library ); \
1328  if ( rclazz ) \
1329  FT_FREE( rclazz ); \
1330  } \
1331  \
1332  \
1333  FT_Error \
1334  FT_Create_Class_ ## class_( FT_Library library, \
1335  FT_Module_Class** output_class ) \
1336  { \
1337  FT_Renderer_Class* clazz = NULL; \
1338  FT_Error error; \
1339  FT_Memory memory = library->memory; \
1340  \
1341  \
1342  if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \
1343  return error; \
1344  \
1345  error = class_ ## _pic_init( library ); \
1346  if ( error ) \
1347  { \
1348  FT_FREE( clazz ); \
1349  return error; \
1350  } \
1351  \
1352  FT_DEFINE_ROOT_MODULE( flags_, \
1353  size_, \
1354  name_, \
1355  version_, \
1356  requires_, \
1357  interface_, \
1358  init_, \
1359  done_, \
1360  get_interface_ ) \
1361  \
1362  clazz->glyph_format = glyph_format_; \
1363  \
1364  clazz->render_glyph = render_glyph_; \
1365  clazz->transform_glyph = transform_glyph_; \
1366  clazz->get_glyph_cbox = get_glyph_cbox_; \
1367  clazz->set_mode = set_mode_; \
1368  \
1369  clazz->raster_class = raster_class_; \
1370  \
1371  *output_class = (FT_Module_Class*)clazz; \
1372  \
1373  return FT_Err_Ok; \
1374  }
1375 
1376 #endif /* FT_CONFIG_OPTION_PIC */
1377 
1378 
1379  /* PIC support macros for ftmodapi.h **/
1380 
1381 
1382 #ifdef FT_CONFIG_OPTION_PIC
1383 
1384  /*************************************************************************/
1385  /* */
1386  /* <FuncType> */
1387  /* FT_Module_Creator */
1388  /* */
1389  /* <Description> */
1390  /* A function used to create (allocate) a new module class object. */
1391  /* The object's members are initialized, but the module itself is */
1392  /* not. */
1393  /* */
1394  /* <Input> */
1395  /* memory :: A handle to the memory manager. */
1396  /* output_class :: Initialized with the newly allocated class. */
1397  /* */
1398  typedef FT_Error
1399  (*FT_Module_Creator)( FT_Memory memory,
1400  FT_Module_Class** output_class );
1401 
1402  /*************************************************************************/
1403  /* */
1404  /* <FuncType> */
1405  /* FT_Module_Destroyer */
1406  /* */
1407  /* <Description> */
1408  /* A function used to destroy (deallocate) a module class object. */
1409  /* */
1410  /* <Input> */
1411  /* memory :: A handle to the memory manager. */
1412  /* clazz :: Module class to destroy. */
1413  /* */
1414  typedef void
1415  (*FT_Module_Destroyer)( FT_Memory memory,
1416  FT_Module_Class* clazz );
1417 
1418 #endif
1419 
1420 
1421  /*************************************************************************/
1422  /* */
1423  /* <Macro> */
1424  /* FT_DECLARE_MODULE */
1425  /* */
1426  /* <Description> */
1427  /* Used to create a forward declaration of a */
1428  /* FT_Module_Class struct instance. */
1429  /* */
1430  /* <Macro> */
1431  /* FT_DEFINE_MODULE */
1432  /* */
1433  /* <Description> */
1434  /* Used to initialize an instance of an FT_Module_Class struct. */
1435  /* */
1436  /* When FT_CONFIG_OPTION_PIC is defined a `create' function needs */
1437  /* to be called with a pointer where the allocated structure is */
1438  /* returned. And when it is no longer needed a `destroy' function */
1439  /* needs to be called to release that allocation. */
1440  /* `ftinit.c' (ft_create_default_module_classes) already contains */
1441  /* a mechanism to call these functions for the default modules */
1442  /* described in `ftmodule.h'. */
1443  /* */
1444  /* Notice that the created `create' and `destroy' functions call */
1445  /* `pic_init' and `pic_free' to allow you to manually allocate and */
1446  /* initialize any additional global data, like a module specific */
1447  /* interface, and put them in the global pic container defined in */
1448  /* `ftpic.h'. If you don't need them just implement the functions as */
1449  /* empty to resolve the link error. Also the `pic_init' and */
1450  /* `pic_free' functions should be declared in `pic.h', to be referred */
1451  /* by the module definition calling `FT_DEFINE_MODULE' in the */
1452  /* following. */
1453  /* */
1454  /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */
1455  /* allocated in the global scope (or the scope where the macro */
1456  /* is used). */
1457  /* */
1458  /* <Macro> */
1459  /* FT_DEFINE_ROOT_MODULE */
1460  /* */
1461  /* <Description> */
1462  /* Used to initialize an instance of an FT_Module_Class struct inside */
1463  /* another struct that contains it or in a function that initializes */
1464  /* that containing struct. */
1465  /* */
1466 #ifndef FT_CONFIG_OPTION_PIC
1467 
1468 #define FT_DECLARE_MODULE( class_ ) \
1469  FT_CALLBACK_TABLE \
1470  const FT_Module_Class class_;
1471 
1472 #define FT_DEFINE_ROOT_MODULE( \
1473  flags_, \
1474  size_, \
1475  name_, \
1476  version_, \
1477  requires_, \
1478  interface_, \
1479  init_, \
1480  done_, \
1481  get_interface_ ) \
1482  { \
1483  flags_, \
1484  size_, \
1485  \
1486  name_, \
1487  version_, \
1488  requires_, \
1489  \
1490  interface_, \
1491  \
1492  init_, \
1493  done_, \
1494  get_interface_, \
1495  },
1496 
1497 #define FT_DEFINE_MODULE( \
1498  class_, \
1499  flags_, \
1500  size_, \
1501  name_, \
1502  version_, \
1503  requires_, \
1504  interface_, \
1505  init_, \
1506  done_, \
1507  get_interface_ ) \
1508  FT_CALLBACK_TABLE_DEF \
1509  const FT_Module_Class class_ = \
1510  { \
1511  flags_, \
1512  size_, \
1513  \
1514  name_, \
1515  version_, \
1516  requires_, \
1517  \
1518  interface_, \
1519  \
1520  init_, \
1521  done_, \
1522  get_interface_, \
1523  };
1524 
1525 
1526 #else /* FT_CONFIG_OPTION_PIC */
1527 
1528 #define FT_DECLARE_MODULE( class_ ) \
1529  FT_Error \
1530  FT_Create_Class_ ## class_( FT_Library library, \
1531  FT_Module_Class** output_class ); \
1532  void \
1533  FT_Destroy_Class_ ## class_( FT_Library library, \
1534  FT_Module_Class* clazz );
1535 
1536 #define FT_DEFINE_ROOT_MODULE( \
1537  flags_, \
1538  size_, \
1539  name_, \
1540  version_, \
1541  requires_, \
1542  interface_, \
1543  init_, \
1544  done_, \
1545  get_interface_ ) \
1546  clazz->root.module_flags = flags_; \
1547  clazz->root.module_size = size_; \
1548  clazz->root.module_name = name_; \
1549  clazz->root.module_version = version_; \
1550  clazz->root.module_requires = requires_; \
1551  \
1552  clazz->root.module_interface = interface_; \
1553  \
1554  clazz->root.module_init = init_; \
1555  clazz->root.module_done = done_; \
1556  clazz->root.get_interface = get_interface_;
1557 
1558 #define FT_DEFINE_MODULE( \
1559  class_, \
1560  flags_, \
1561  size_, \
1562  name_, \
1563  version_, \
1564  requires_, \
1565  interface_, \
1566  init_, \
1567  done_, \
1568  get_interface_ ) \
1569  void \
1570  FT_Destroy_Class_ ## class_( FT_Library library, \
1571  FT_Module_Class* clazz ) \
1572  { \
1573  FT_Memory memory = library->memory; \
1574  \
1575  \
1576  class_ ## _pic_free( library ); \
1577  if ( clazz ) \
1578  FT_FREE( clazz ); \
1579  } \
1580  \
1581  \
1582  FT_Error \
1583  FT_Create_Class_ ## class_( FT_Library library, \
1584  FT_Module_Class** output_class ) \
1585  { \
1586  FT_Memory memory = library->memory; \
1587  FT_Module_Class* clazz = NULL; \
1588  FT_Error error; \
1589  \
1590  \
1591  if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \
1592  return error; \
1593  error = class_ ## _pic_init( library ); \
1594  if ( error ) \
1595  { \
1596  FT_FREE( clazz ); \
1597  return error; \
1598  } \
1599  \
1600  clazz->module_flags = flags_; \
1601  clazz->module_size = size_; \
1602  clazz->module_name = name_; \
1603  clazz->module_version = version_; \
1604  clazz->module_requires = requires_; \
1605  \
1606  clazz->module_interface = interface_; \
1607  \
1608  clazz->module_init = init_; \
1609  clazz->module_done = done_; \
1610  clazz->get_interface = get_interface_; \
1611  \
1612  *output_class = clazz; \
1613  \
1614  return FT_Err_Ok; \
1615  }
1616 
1617 #endif /* FT_CONFIG_OPTION_PIC */
1618 
1619 
1620 FT_END_HEADER
1621 
1622 #endif /* FTOBJS_H_ */
1623 
1624 
1625 /* END */
FT_Face_InternalRec_::transform_flags
FT_Int transform_flags
Definition: ftobjs.h:408
FT_DebugHook_Func
void(* FT_DebugHook_Func)(void *arg)
Definition: ftmodapi.h:573
FT_LibraryRec_::debug_hooks
FT_DebugHook_Func debug_hooks[4]
Definition: ftobjs.h:931
ft_glyphslot_set_bitmap
ft_glyphslot_set_bitmap(FT_GlyphSlot slot, FT_Byte *buffer)
Definition: ftobjs.c:466
FT_Error
int FT_Error
Definition: fttypes.h:300
FT_Face_InternalRec_::refcount
FT_Int refcount
Definition: ftobjs.h:424
value
Definition: pdh_main.c:93
FT_CMapRec_::charmap
FT_CharMapRec charmap
Definition: ftobjs.h:153
FT_ULong
unsigned long FT_ULong
Definition: fttypes.h:253
FT_ModuleRec_::memory
FT_Memory memory
Definition: ftobjs.h:537
FT_Pos
FT_BEGIN_HEADER typedef signed long FT_Pos
Definition: ftimage.h:58
void
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
FT_Renderer_Class_
Definition: ftrender.h:145
FT_LibraryRec_::memory
FT_Memory memory
Definition: ftobjs.h:918
ft_synthesize_vertical_metrics
ft_synthesize_vertical_metrics(FT_Glyph_Metrics *metrics, FT_Pos advance)
Definition: ftobjs.c:2933
ft_lcd_padding
ft_lcd_padding(FT_Pos *Min, FT_Pos *Max, FT_GlyphSlot slot)
Definition: ftlcdfil.c:348
FT_Glyph_Class
typedefFT_BEGIN_HEADER struct FT_Glyph_Class_ FT_Glyph_Class
Definition: ftglyph.h:69
global
int global
Definition: ehframes.cpp:22
FT_DriverRec_::faces_list
FT_ListRec faces_list
Definition: ftobjs.h:831
FT_END_HEADER
#define FT_END_HEADER
Definition: ftheader.h:54
FT_Select_Metrics
FT_Select_Metrics(FT_Face face, FT_ULong strike_index)
Definition: ftobjs.c:2993
module_name
static LPCWSTR LPCWSTR module_name
Definition: db.cpp:168
FT_Raster
struct FT_RasterRec_ * FT_Raster
Definition: ftimage.h:800
metrics
GLsizei GLenum const GLvoid GLuint GLsizei GLfloat * metrics
Definition: glext.h:11745
FT_CMap_CharIndexFunc
FT_UInt(* FT_CMap_CharIndexFunc)(FT_CMap cmap, FT_UInt32 char_code)
Definition: ftobjs.h:177
FT_Int
signed int FT_Int
Definition: fttypes.h:220
FT_CMap_ClassRec_::done
FT_CMap_DoneFunc done
Definition: ftobjs.h:215
FT_CMap_ClassRec_::size
FT_ULong size
Definition: ftobjs.h:212
FT_LibraryRec
struct FT_LibraryRec_ FT_LibraryRec
FT_Render_Mode
enum FT_Render_Mode_ FT_Render_Mode
FT_CMap_ClassRec_::init
FT_CMap_InitFunc init
Definition: ftobjs.h:214
FT_CMap_VariantCharListFunc
FT_UInt32 *(* FT_CMap_VariantCharListFunc)(FT_CMap cmap, FT_Memory mem, FT_UInt32 variant_selector)
Definition: ftobjs.h:205
FT_Slot_InternalRec_::glyph_matrix
FT_Matrix glyph_matrix
Definition: ftobjs.h:470
FT_Face_GetGlyphNameIndexFunc
FT_UInt(* FT_Face_GetGlyphNameIndexFunc)(FT_Face face, FT_String *glyph_name)
Definition: ftobjs.h:967
FT_CMap_ClassRec_::char_next
FT_CMap_CharNextFunc char_next
Definition: ftobjs.h:217
FT_Size_InternalRec_::module_data
void * module_data
Definition: ftobjs.h:497
FT_ModuleRec
struct FT_ModuleRec_ FT_ModuleRec
FT_CMap_DoneFunc
void(* FT_CMap_DoneFunc)(FT_CMap cmap)
Definition: ftobjs.h:174
FT_Size_RequestRec_
Definition: freetype.h:2617
origin
voidpf uLong int origin
Definition: ioapi.h:142
buffer
GLuint buffer
Definition: glext.h:5915
FT_Char
signed char FT_Char
Definition: fttypes.h:143
FT_New_GlyphSlot
FT_New_GlyphSlot(FT_Face face, FT_GlyphSlot *aslot)
Definition: ftobjs.c:559
FT_RendererRec_::glyph_class
FT_Glyph_Class glyph_class
Definition: ftobjs.h:776
FT_RendererRec_::glyph_format
FT_Glyph_Format glyph_format
Definition: ftobjs.h:775
FT_Bitmap_
Definition: ftimage.h:261
FT_Face_InternalRec_::services
FT_ServiceCacheRec services
Definition: ftobjs.h:410
library
FT_Library library
Definition: cffdrivr.c:654
FT_EXPORT_VAR
FT_EXPORT_VAR(FT_Raster_Funcs) ft_default_raster
FT_Vector_
Definition: ftimage.h:74
FT_Face_InternalRec_::random_seed
FT_Int32 random_seed
Definition: ftobjs.h:417
memory
static char memory[1024 *256]
Definition: process.c:116
FT_Done_GlyphSlot
FT_Done_GlyphSlot(FT_GlyphSlot slot)
Definition: ftobjs.c:612
FT_Raster_Funcs_
Definition: ftimage.h:1180
FT_Render_Glyph_Internal
FT_Render_Glyph_Internal(FT_Library library, FT_GlyphSlot slot, FT_Render_Mode render_mode)
Definition: ftobjs.c:4485
FT_LibraryRec_::version_patch
FT_Int version_patch
Definition: ftobjs.h:922
FT_ListRec_
Definition: fttypes.h:567
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
FT_DriverRec_
Definition: ftobjs.h:827
FT_Face_InternalRec_::transform_delta
FT_Vector transform_delta
Definition: ftobjs.h:407
FT_DriverRec_::root
FT_ModuleRec root
Definition: ftobjs.h:829
FT_DriverRec_::clazz
FT_Driver_Class clazz
Definition: ftobjs.h:830
FT_LibraryRec_::cur_renderer
FT_Renderer cur_renderer
Definition: ftobjs.h:928
FT_Lookup_Renderer
FT_Lookup_Renderer(FT_Library library, FT_Glyph_Format format, FT_ListNode *node)
Definition: ftobjs.c:4264
FT_Bool
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
FT_LibraryRec_::auto_hinter
FT_Module auto_hinter
Definition: ftobjs.h:929
FT_RendererRec_::clazz
FT_Renderer_Class * clazz
Definition: ftobjs.h:774
ft_module_get_service
ft_module_get_service(FT_Module module, const char *service_id, FT_Bool global)
Definition: ftobjs.c:4880
FT_DriverRec_::glyph_loader
FT_GlyphLoader glyph_loader
Definition: ftobjs.h:832
FT_GlyphSlot_InternalRec
struct FT_Slot_InternalRec_ FT_GlyphSlot_InternalRec
FT_LibraryRec_
Definition: ftobjs.h:916
FT_Byte
unsigned char FT_Byte
Definition: fttypes.h:154
FT_Slot_InternalRec_::loader
FT_GlyphLoader loader
Definition: ftobjs.h:467
FT_BEGIN_HEADER
#define FT_BEGIN_HEADER
Definition: ftheader.h:36
FT_LibraryRec_::version_major
FT_Int version_major
Definition: ftobjs.h:920
FT_New_Memory
FT_New_Memory(void)
Definition: ftsystem.c:287
Max
#define Max(a, b)
Definition: cdprocs.h:78
FT_CMap
struct FT_CMapRec_ * FT_CMap
Definition: ftobjs.h:145
FT_RendererRec_::render
FT_Renderer_RenderFunc render
Definition: ftobjs.h:780
FT_Matrix_
Definition: fttypes.h:385
FT_CMap_VariantListFunc
FT_UInt32 *(* FT_CMap_VariantListFunc)(FT_CMap cmap, FT_Memory mem)
Definition: ftobjs.h:196
FT_ModuleRec_::library
FT_Library library
Definition: ftobjs.h:536
FT_Match_Size
FT_Match_Size(FT_Face face, FT_Size_Request req, FT_Bool ignore_width, FT_ULong *size_index)
Definition: ftobjs.c:2875
FT_CMapRec
struct FT_CMapRec_ FT_CMapRec
FT_Face_InternalRec_
Definition: ftobjs.h:404
FT_Size_Metrics_
Definition: freetype.h:1638
FT_Incremental_InterfaceRec_
Definition: ftincrem.h:315
FT_CMap_ClassRec
struct FT_CMap_ClassRec_ FT_CMap_ClassRec
FT_CMap_ClassRec_::charvariant_list
FT_CMap_CharVariantListFunc charvariant_list
Definition: ftobjs.h:225
FT_CMap_ClassRec_::char_var_default
FT_CMap_CharVarIsDefaultFunc char_var_default
Definition: ftobjs.h:223
FT_Raster_Render_Func
#define FT_Raster_Render_Func
Definition: ftimage.h:1158
FT_Slot_InternalRec_::glyph_transformed
FT_Bool glyph_transformed
Definition: ftobjs.h:469
FT_Request_Metrics
FT_Request_Metrics(FT_Face face, FT_Size_Request req)
Definition: ftobjs.c:3028
bitmap
Definition: uimain.c:88
FT_ListNodeRec_
Definition: fttypes.h:544
ft_glyphslot_alloc_bitmap
ft_glyphslot_alloc_bitmap(FT_GlyphSlot slot, FT_ULong size)
Definition: ftobjs.c:478
FT_CMapRec_
Definition: ftobjs.h:151
FT_LibraryRec_::num_modules
FT_UInt num_modules
Definition: ftobjs.h:924
FT_String
char FT_String
Definition: fttypes.h:187
size
GLsizeiptr size
Definition: glext.h:5919
FT_MAX_MODULES
#define FT_MAX_MODULES
Definition: ftoption.h:376
FT_CMap_ClassRec_::char_var_index
FT_CMap_CharVarIndexFunc char_var_index
Definition: ftobjs.h:222
FT_LibraryRec_::version_minor
FT_Int version_minor
Definition: ftobjs.h:921
face
WORD face[3]
Definition: mesh.c:4747
Min
#define Min(a, b)
Definition: cdprocs.h:74
FT_CMap_ClassRec_
Definition: ftobjs.h:210
FT_GlyphSlotRec_
Definition: freetype.h:1908
FT_LcdFiveTapFilter
FT_Byte FT_LcdFiveTapFilter[FT_LCD_FILTER_FIVE_TAPS]
Definition: ftlcdfil.h:298
FT_Slot_InternalRec_::glyph_delta
FT_Vector glyph_delta
Definition: ftobjs.h:471
FT_ServiceCacheRec_
Definition: ftserv.h:884
FT_Memory
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
FT_ModuleRec_
Definition: ftobjs.h:533
FT_Size_InternalRec_
Definition: ftobjs.h:495
advance
_STLP_MOVE_TO_STD_NAMESPACE void _STLP_CALL advance(_InputIterator &__i, _Distance __n)
Definition: _iterator_base.h:515
FT_LibraryRec_::modules
FT_Module modules[FT_MAX_MODULES]
Definition: ftobjs.h:925
mode
GLenum mode
Definition: glext.h:6217
ft_glyphslot_free_bitmap
ft_glyphslot_free_bitmap(FT_GlyphSlot slot)
Definition: ftobjs.c:314
FT_RendererRec
struct FT_RendererRec_ FT_RendererRec
_slot
Definition: vfat.h:184
FT_Size_InternalRec
struct FT_Size_InternalRec_ FT_Size_InternalRec
FT_CMap_New
FT_CMap_New(FT_CMap_Class clazz, FT_Pointer init_data, FT_CharMap charmap, FT_CMap *acmap)
Definition: ftobjs.c:3614
FT_CMap_Done
FT_CMap_Done(FT_CMap cmap)
Definition: ftobjs.c:3568
FT_Slot_InternalRec_
Definition: ftobjs.h:465
FT_RendererRec_
Definition: ftobjs.h:771
ft_glyphslot_preset_bitmap
ft_glyphslot_preset_bitmap(FT_GlyphSlot slot, FT_Render_Mode mode, const FT_Vector *origin)
Definition: ftobjs.c:334
FT_Glyph_Metrics
FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics
FT_Face_InternalRec_::no_stem_darkening
FT_Char no_stem_darkening
Definition: ftobjs.h:416
FT_Face_InternalRec
struct FT_Face_InternalRec_ FT_Face_InternalRec
FT_CharMapRec_
Definition: freetype.h:840
FT_UInt
unsigned int FT_UInt
Definition: fttypes.h:231
FT_CMap_ClassRec_::char_index
FT_CMap_CharIndexFunc char_index
Definition: ftobjs.h:216
FT_Glyph_Format
enum FT_Glyph_Format_ FT_Glyph_Format
FT_Size_InternalRec_::autohint_mode
FT_Render_Mode autohint_mode
Definition: ftobjs.h:499
FT_Face_GetGlyphNameFunc
FT_Error(* FT_Face_GetGlyphNameFunc)(FT_Face face, FT_UInt glyph_index, FT_Pointer buffer, FT_UInt buffer_max)
Definition: ftobjs.h:961
FT_GlyphLoaderRec_
Definition: ftgloadr.h:61
FT_CMap_ClassRec_::variant_list
FT_CMap_VariantListFunc variant_list
Definition: ftobjs.h:224
FT_Module_Class_
Definition: ftmodapi.h:217
FT_RendererRec_::raster_render
FT_Raster_Render_Func raster_render
Definition: ftobjs.h:779
FT_CMap_Class
const struct FT_CMap_ClassRec_ * FT_CMap_Class
Definition: ftobjs.h:148
FT_Slot_InternalRec_::flags
FT_UInt flags
Definition: ftobjs.h:468
FT_CMap_CharNextFunc
FT_UInt(* FT_CMap_CharNextFunc)(FT_CMap cmap, FT_UInt32 *achar_code)
Definition: ftobjs.h:181
mem
Definition: mem.c:156
FT_Get_Module_Interface
FT_Get_Module_Interface(FT_Library library, const char *mod_name)
Definition: ftobjs.c:4865
FT_Face_InternalRec_::transform_matrix
FT_Matrix transform_matrix
Definition: ftobjs.h:406
FT_FaceRec_
Definition: freetype.h:1068
FT_DriverRec
struct FT_DriverRec_ FT_DriverRec
weights
const GLbyte * weights
Definition: glext.h:6523
FT_LibraryRec_::renderers
FT_ListRec renderers
Definition: ftobjs.h:927
FT_BASE
#define FT_BASE(x)
Definition: ftconfig.h:408
bitmap
static HBITMAP bitmap
Definition: clipboard.c:1344
FT_RendererRec_::root
FT_ModuleRec root
Definition: ftobjs.h:773
FT_LibraryRec_::refcount
FT_Int refcount
Definition: ftobjs.h:942
FT_CMap_InitFunc
FT_Error(* FT_CMap_InitFunc)(FT_CMap cmap, FT_Pointer init_data)
Definition: ftobjs.h:170
FT_Slot_InternalRec_::glyph_hints
void * glyph_hints
Definition: ftobjs.h:472
FT_Renderer_RenderFunc
FT_Error(* FT_Renderer_RenderFunc)(FT_Renderer renderer, FT_GlyphSlot slot, FT_Render_Mode mode, const FT_Vector *origin)
Definition: ftrender.h:89
FT_Size_InternalRec_::autohint_metrics
FT_Size_Metrics autohint_metrics
Definition: ftobjs.h:500
FT_CMap_CharVariantListFunc
FT_UInt32 *(* FT_CMap_CharVariantListFunc)(FT_CMap cmap, FT_Memory mem, FT_UInt32 char_code)
Definition: ftobjs.h:200
FT_Done_Memory
FT_Done_Memory(FT_Memory memory)
Definition: ftsystem.c:311
FT_ModuleRec_::clazz
FT_Module_Class * clazz
Definition: ftobjs.h:535
FT_Driver_ClassRec_
Definition: ftdrv.h:157
FT_CMap_CharVarIndexFunc
FT_UInt(* FT_CMap_CharVarIndexFunc)(FT_CMap cmap, FT_CMap unicode_cmap, FT_UInt32 char_code, FT_UInt32 variant_selector)
Definition: ftobjs.h:185
face
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
FT_CMap_CharVarIsDefaultFunc
FT_Bool(* FT_CMap_CharVarIsDefaultFunc)(FT_CMap cmap, FT_UInt32 char_code, FT_UInt32 variant_selector)
Definition: ftobjs.h:191
FT_RendererRec_::raster
FT_Raster raster
Definition: ftobjs.h:778
FT_CMap_ClassRec_::variantchar_list
FT_CMap_VariantCharListFunc variantchar_list
Definition: ftobjs.h:226
FT_CMapRec_::clazz
FT_CMap_Class clazz
Definition: ftobjs.h:154
node
Definition: dlist.c:348