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