source: trunk/poppler/freetype-2.1.10/include/freetype/internal/ftobjs.h @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 15 years ago

First import

File size: 36.7 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ftobjs.h                                                               */
4/*                                                                         */
5/*    The FreeType private base classes (specification).                   */
6/*                                                                         */
7/*  Copyright 1996-2001, 2002, 2003, 2004, 2005 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_INTERNAL_MEMORY_H
33#include FT_INTERNAL_GLYPH_LOADER_H
34#include FT_INTERNAL_DRIVER_H
35#include FT_INTERNAL_AUTOHINT_H
36#include FT_INTERNAL_SERVICE_H
37
38#ifdef FT_CONFIG_OPTION_INCREMENTAL
39#include FT_INCREMENTAL_H
40#endif
41
42
43FT_BEGIN_HEADER
44
45
46  /*************************************************************************/
47  /*                                                                       */
48  /* Some generic definitions.                                             */
49  /*                                                                       */
50#ifndef TRUE
51#define TRUE  1
52#endif
53
54#ifndef FALSE
55#define FALSE  0
56#endif
57
58#ifndef NULL
59#define NULL  (void*)0
60#endif
61
62
63  /*************************************************************************/
64  /*                                                                       */
65  /* The min and max functions missing in C.  As usual, be careful not to  */
66  /* write things like FT_MIN( a++, b++ ) to avoid side effects.           */
67  /*                                                                       */
68#define FT_MIN( a, b )  ( (a) < (b) ? (a) : (b) )
69#define FT_MAX( a, b )  ( (a) > (b) ? (a) : (b) )
70
71#define FT_ABS( a )     ( (a) < 0 ? -(a) : (a) )
72
73
74#define FT_PAD_FLOOR( x, n )  ( (x) & ~((n)-1) )
75#define FT_PAD_ROUND( x, n )  FT_PAD_FLOOR( (x) + ((n)/2), n )
76#define FT_PAD_CEIL( x, n )   FT_PAD_FLOOR( (x) + ((n)-1), n )
77
78#define FT_PIX_FLOOR( x )     ( (x) & ~63 )
79#define FT_PIX_ROUND( x )     FT_PIX_FLOOR( (x) + 32 )
80#define FT_PIX_CEIL( x )      FT_PIX_FLOOR( (x) + 63 )
81
82
83  /*
84   *  Return the highest power of 2 that is <= value; this correspond to
85   *  the highest bit in a given 32-bit value.
86   */
87  FT_BASE( FT_UInt32 )
88  ft_highpow2( FT_UInt32  value );
89
90
91  /*************************************************************************/
92  /*************************************************************************/
93  /*************************************************************************/
94  /****                                                                 ****/
95  /****                                                                 ****/
96  /****                       C H A R M A P S                           ****/
97  /****                                                                 ****/
98  /****                                                                 ****/
99  /*************************************************************************/
100  /*************************************************************************/
101  /*************************************************************************/
102
103  /* handle to internal charmap object */
104  typedef struct FT_CMapRec_*              FT_CMap;
105
106  /* handle to charmap class structure */
107  typedef const struct FT_CMap_ClassRec_*  FT_CMap_Class;
108
109  /* internal charmap object structure */
110  typedef struct  FT_CMapRec_
111  {
112    FT_CharMapRec  charmap;
113    FT_CMap_Class  clazz;
114
115  } FT_CMapRec;
116
117  /* typecase any pointer to a charmap handle */
118#define FT_CMAP( x )              ((FT_CMap)( x ))
119
120  /* obvious macros */
121#define FT_CMAP_PLATFORM_ID( x )  FT_CMAP( x )->charmap.platform_id
122#define FT_CMAP_ENCODING_ID( x )  FT_CMAP( x )->charmap.encoding_id
123#define FT_CMAP_ENCODING( x )     FT_CMAP( x )->charmap.encoding
124#define FT_CMAP_FACE( x )         FT_CMAP( x )->charmap.face
125
126
127  /* class method definitions */
128  typedef FT_Error
129  (*FT_CMap_InitFunc)( FT_CMap     cmap,
130                       FT_Pointer  init_data );
131
132  typedef void
133  (*FT_CMap_DoneFunc)( FT_CMap  cmap );
134
135  typedef FT_UInt
136  (*FT_CMap_CharIndexFunc)( FT_CMap    cmap,
137                            FT_UInt32  char_code );
138
139  typedef FT_UInt
140  (*FT_CMap_CharNextFunc)( FT_CMap     cmap,
141                           FT_UInt32  *achar_code );
142
143
144  typedef struct  FT_CMap_ClassRec_
145  {
146    FT_ULong               size;
147    FT_CMap_InitFunc       init;
148    FT_CMap_DoneFunc       done;
149    FT_CMap_CharIndexFunc  char_index;
150    FT_CMap_CharNextFunc   char_next;
151
152  } FT_CMap_ClassRec;
153
154
155  /* create a new charmap and add it to charmap->face */
156  FT_BASE( FT_Error )
157  FT_CMap_New( FT_CMap_Class  clazz,
158               FT_Pointer     init_data,
159               FT_CharMap     charmap,
160               FT_CMap       *acmap );
161
162  /* destroy a charmap and remove it from face's list */
163  FT_BASE( void )
164  FT_CMap_Done( FT_CMap  cmap );
165
166
167  /*************************************************************************/
168  /*                                                                       */
169  /* <Struct>                                                              */
170  /*    FT_Face_InternalRec                                                */
171  /*                                                                       */
172  /* <Description>                                                         */
173  /*    This structure contains the internal fields of each FT_Face        */
174  /*    object.  These fields may change between different releases of     */
175  /*    FreeType.                                                          */
176  /*                                                                       */
177  /* <Fields>                                                              */
178  /*    max_points ::                                                      */
179  /*      The maximal number of points used to store the vectorial outline */
180  /*      of any glyph in this face.  If this value cannot be known in     */
181  /*      advance, or if the face isn't scalable, this should be set to 0. */
182  /*      Only relevant for scalable formats.                              */
183  /*                                                                       */
184  /*    max_contours ::                                                    */
185  /*      The maximal number of contours used to store the vectorial       */
186  /*      outline of any glyph in this face.  If this value cannot be      */
187  /*      known in advance, or if the face isn't scalable, this should be  */
188  /*      set to 0.  Only relevant for scalable formats.                   */
189  /*                                                                       */
190  /*    transform_matrix ::                                                */
191  /*      A 2x2 matrix of 16.16 coefficients used to transform glyph       */
192  /*      outlines after they are loaded from the font.  Only used by the  */
193  /*      convenience functions.                                           */
194  /*                                                                       */
195  /*    transform_delta ::                                                 */
196  /*      A translation vector used to transform glyph outlines after they */
197  /*      are loaded from the font.  Only used by the convenience          */
198  /*      functions.                                                       */
199  /*                                                                       */
200  /*    transform_flags ::                                                 */
201  /*      Some flags used to classify the transform.  Only used by the     */
202  /*      convenience functions.                                           */
203  /*                                                                       */
204  /*    services ::                                                        */
205  /*      A cache for frequently used services.  It should be only         */
206  /*      accessed with the macro `FT_FACE_LOOKUP_SERVICE'.                */
207  /*                                                                       */
208  /*    incremental_interface ::                                           */
209  /*      If non-null, the interface through which glyph data and metrics  */
210  /*      are loaded incrementally for faces that do not provide all of    */
211  /*      this data when first opened.  This field exists only if          */
212  /*      @FT_CONFIG_OPTION_INCREMENTAL is defined.                        */
213  /*                                                                       */
214  typedef struct  FT_Face_InternalRec_
215  {
216    FT_UShort           max_points;
217    FT_Short            max_contours;
218
219    FT_Matrix           transform_matrix;
220    FT_Vector           transform_delta;
221    FT_Int              transform_flags;
222
223    FT_ServiceCacheRec  services;
224
225#ifdef FT_CONFIG_OPTION_INCREMENTAL
226    FT_Incremental_InterfaceRec*  incremental_interface;
227#endif
228
229  } FT_Face_InternalRec;
230
231
232  /*************************************************************************/
233  /*                                                                       */
234  /* <Struct>                                                              */
235  /*    FT_Slot_InternalRec                                                */
236  /*                                                                       */
237  /* <Description>                                                         */
238  /*    This structure contains the internal fields of each FT_GlyphSlot   */
239  /*    object.  These fields may change between different releases of     */
240  /*    FreeType.                                                          */
241  /*                                                                       */
242  /* <Fields>                                                              */
243  /*    loader            :: The glyph loader object used to load outlines */
244  /*                         into the glyph slot.                          */
245  /*                                                                       */
246  /*    flags             :: Possible values are zero or                   */
247  /*                         FT_GLYPH_OWN_BITMAP.  The latter indicates    */
248  /*                         that the FT_GlyphSlot structure owns the      */
249  /*                         bitmap buffer.                                */
250  /*                                                                       */
251  /*    glyph_transformed :: Boolean.  Set to TRUE when the loaded glyph   */
252  /*                         must be transformed through a specific        */
253  /*                         font transformation.  This is _not_ the same  */
254  /*                         as the face transform set through             */
255  /*                         FT_Set_Transform().                           */
256  /*                                                                       */
257  /*    glyph_matrix      :: The 2x2 matrix corresponding to the glyph     */
258  /*                         transformation, if necessary.                 */
259  /*                                                                       */
260  /*    glyph_delta       :: The 2d translation vector corresponding to    */
261  /*                         the glyph transformation, if necessary.       */
262  /*                                                                       */
263  /*    glyph_hints       :: Format-specific glyph hints management.       */
264  /*                                                                       */
265
266#define FT_GLYPH_OWN_BITMAP  0x1
267
268  typedef struct  FT_Slot_InternalRec_
269  {
270    FT_GlyphLoader  loader;
271    FT_UInt         flags;
272    FT_Bool         glyph_transformed;
273    FT_Matrix       glyph_matrix;
274    FT_Vector       glyph_delta;
275    void*           glyph_hints;
276
277  } FT_GlyphSlot_InternalRec;
278
279
280  /*************************************************************************/
281  /*************************************************************************/
282  /*************************************************************************/
283  /****                                                                 ****/
284  /****                                                                 ****/
285  /****                         M O D U L E S                           ****/
286  /****                                                                 ****/
287  /****                                                                 ****/
288  /*************************************************************************/
289  /*************************************************************************/
290  /*************************************************************************/
291
292
293  /*************************************************************************/
294  /*                                                                       */
295  /* <Struct>                                                              */
296  /*    FT_ModuleRec                                                       */
297  /*                                                                       */
298  /* <Description>                                                         */
299  /*    A module object instance.                                          */
300  /*                                                                       */
301  /* <Fields>                                                              */
302  /*    clazz   :: A pointer to the module's class.                        */
303  /*                                                                       */
304  /*    library :: A handle to the parent library object.                  */
305  /*                                                                       */
306  /*    memory  :: A handle to the memory manager.                         */
307  /*                                                                       */
308  /*    generic :: A generic structure for user-level extensibility (?).   */
309  /*                                                                       */
310  typedef struct  FT_ModuleRec_
311  {
312    FT_Module_Class*  clazz;
313    FT_Library        library;
314    FT_Memory         memory;
315    FT_Generic        generic;
316
317  } FT_ModuleRec;
318
319
320  /* typecast an object to a FT_Module */
321#define FT_MODULE( x )          ((FT_Module)( x ))
322#define FT_MODULE_CLASS( x )    FT_MODULE( x )->clazz
323#define FT_MODULE_LIBRARY( x )  FT_MODULE( x )->library
324#define FT_MODULE_MEMORY( x )   FT_MODULE( x )->memory
325
326
327#define FT_MODULE_IS_DRIVER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
328                                    FT_MODULE_FONT_DRIVER )
329
330#define FT_MODULE_IS_RENDERER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
331                                      FT_MODULE_RENDERER )
332
333#define FT_MODULE_IS_HINTER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
334                                    FT_MODULE_HINTER )
335
336#define FT_MODULE_IS_STYLER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
337                                    FT_MODULE_STYLER )
338
339#define FT_DRIVER_IS_SCALABLE( x )  ( FT_MODULE_CLASS( x )->module_flags & \
340                                      FT_MODULE_DRIVER_SCALABLE )
341
342#define FT_DRIVER_USES_OUTLINES( x )  !( FT_MODULE_CLASS( x )->module_flags & \
343                                         FT_MODULE_DRIVER_NO_OUTLINES )
344
345#define FT_DRIVER_HAS_HINTER( x )  ( FT_MODULE_CLASS( x )->module_flags & \
346                                     FT_MODULE_DRIVER_HAS_HINTER )
347
348
349  /*************************************************************************/
350  /*                                                                       */
351  /* <Function>                                                            */
352  /*    FT_Get_Module_Interface                                            */
353  /*                                                                       */
354  /* <Description>                                                         */
355  /*    Finds a module and returns its specific interface as a typeless    */
356  /*    pointer.                                                           */
357  /*                                                                       */
358  /* <Input>                                                               */
359  /*    library     :: A handle to the library object.                     */
360  /*                                                                       */
361  /*    module_name :: The module's name (as an ASCII string).             */
362  /*                                                                       */
363  /* <Return>                                                              */
364  /*    A module-specific interface if available, 0 otherwise.             */
365  /*                                                                       */
366  /* <Note>                                                                */
367  /*    You should better be familiar with FreeType internals to know      */
368  /*    which module to look for, and what its interface is :-)            */
369  /*                                                                       */
370  FT_BASE( const void* )
371  FT_Get_Module_Interface( FT_Library   library,
372                           const char*  mod_name );
373
374  FT_BASE( FT_Pointer )
375  ft_module_get_service( FT_Module    module,
376                         const char*  service_id );
377
378 /* */
379
380
381  /*************************************************************************/
382  /*************************************************************************/
383  /*************************************************************************/
384  /****                                                                 ****/
385  /****                                                                 ****/
386  /****               FACE, SIZE & GLYPH SLOT OBJECTS                   ****/
387  /****                                                                 ****/
388  /****                                                                 ****/
389  /*************************************************************************/
390  /*************************************************************************/
391  /*************************************************************************/
392
393  /* a few macros used to perform easy typecasts with minimal brain damage */
394
395#define FT_FACE( x )          ((FT_Face)(x))
396#define FT_SIZE( x )          ((FT_Size)(x))
397#define FT_SLOT( x )          ((FT_GlyphSlot)(x))
398
399#define FT_FACE_DRIVER( x )   FT_FACE( x )->driver
400#define FT_FACE_LIBRARY( x )  FT_FACE_DRIVER( x )->root.library
401#define FT_FACE_MEMORY( x )   FT_FACE( x )->memory
402#define FT_FACE_STREAM( x )   FT_FACE( x )->stream
403
404#define FT_SIZE_FACE( x )     FT_SIZE( x )->face
405#define FT_SLOT_FACE( x )     FT_SLOT( x )->face
406
407#define FT_FACE_SLOT( x )     FT_FACE( x )->glyph
408#define FT_FACE_SIZE( x )     FT_FACE( x )->size
409
410
411  /*************************************************************************/
412  /*                                                                       */
413  /* <Function>                                                            */
414  /*    FT_New_GlyphSlot                                                   */
415  /*                                                                       */
416  /* <Description>                                                         */
417  /*    It is sometimes useful to have more than one glyph slot for a      */
418  /*    given face object.  This function is used to create additional     */
419  /*    slots.  All of them are automatically discarded when the face is   */
420  /*    destroyed.                                                         */
421  /*                                                                       */
422  /* <Input>                                                               */
423  /*    face  :: A handle to a parent face object.                         */
424  /*                                                                       */
425  /* <Output>                                                              */
426  /*    aslot :: A handle to a new glyph slot object.                      */
427  /*                                                                       */
428  /* <Return>                                                              */
429  /*    FreeType error code.  0 means success.                             */
430  /*                                                                       */
431  FT_BASE( FT_Error )
432  FT_New_GlyphSlot( FT_Face        face,
433                    FT_GlyphSlot  *aslot );
434
435
436  /*************************************************************************/
437  /*                                                                       */
438  /* <Function>                                                            */
439  /*    FT_Done_GlyphSlot                                                  */
440  /*                                                                       */
441  /* <Description>                                                         */
442  /*    Destroys a given glyph slot.  Remember however that all slots are  */
443  /*    automatically destroyed with its parent.  Using this function is   */
444  /*    not always mandatory.                                              */
445  /*                                                                       */
446  /* <Input>                                                               */
447  /*    slot :: A handle to a target glyph slot.                           */
448  /*                                                                       */
449  FT_BASE( void )
450  FT_Done_GlyphSlot( FT_GlyphSlot  slot );
451
452 /* */
453
454 /*
455  * Free the bitmap of a given glyphslot when needed
456  * (i.e., only when it was allocated with ft_glyphslot_alloc_bitmap).
457  */
458  FT_BASE( void )
459  ft_glyphslot_free_bitmap( FT_GlyphSlot  slot );
460
461
462 /*
463  * Allocate a new bitmap buffer in a glyph slot.
464  */
465  FT_BASE( FT_Error )
466  ft_glyphslot_alloc_bitmap( FT_GlyphSlot  slot,
467                             FT_ULong      size );
468
469
470 /*
471  * Set the bitmap buffer in a glyph slot to a given pointer.
472  * The buffer will not be freed by a later call to ft_glyphslot_free_bitmap.
473  */
474  FT_BASE( void )
475  ft_glyphslot_set_bitmap( FT_GlyphSlot  slot,
476                           FT_Byte*      buffer );
477
478
479  /*************************************************************************/
480  /*************************************************************************/
481  /*************************************************************************/
482  /****                                                                 ****/
483  /****                                                                 ****/
484  /****                        R E N D E R E R S                        ****/
485  /****                                                                 ****/
486  /****                                                                 ****/
487  /*************************************************************************/
488  /*************************************************************************/
489  /*************************************************************************/
490
491
492#define FT_RENDERER( x )      ((FT_Renderer)( x ))
493#define FT_GLYPH( x )         ((FT_Glyph)( x ))
494#define FT_BITMAP_GLYPH( x )  ((FT_BitmapGlyph)( x ))
495#define FT_OUTLINE_GLYPH( x ) ((FT_OutlineGlyph)( x ))
496
497
498  typedef struct  FT_RendererRec_
499  {
500    FT_ModuleRec            root;
501    FT_Renderer_Class*      clazz;
502    FT_Glyph_Format         glyph_format;
503    FT_Glyph_Class          glyph_class;
504
505    FT_Raster               raster;
506    FT_Raster_Render_Func   raster_render;
507    FT_Renderer_RenderFunc  render;
508
509  } FT_RendererRec;
510
511
512  /*************************************************************************/
513  /*************************************************************************/
514  /*************************************************************************/
515  /****                                                                 ****/
516  /****                                                                 ****/
517  /****                    F O N T   D R I V E R S                      ****/
518  /****                                                                 ****/
519  /****                                                                 ****/
520  /*************************************************************************/
521  /*************************************************************************/
522  /*************************************************************************/
523
524
525  /* typecast a module into a driver easily */
526#define FT_DRIVER( x )        ((FT_Driver)(x))
527
528  /* typecast a module as a driver, and get its driver class */
529#define FT_DRIVER_CLASS( x )  FT_DRIVER( x )->clazz
530
531
532  /*************************************************************************/
533  /*                                                                       */
534  /* <Struct>                                                              */
535  /*    FT_DriverRec                                                       */
536  /*                                                                       */
537  /* <Description>                                                         */
538  /*    The root font driver class.  A font driver is responsible for      */
539  /*    managing and loading font files of a given format.                 */
540  /*                                                                       */
541  /*  <Fields>                                                             */
542  /*     root         :: Contains the fields of the root module class.     */
543  /*                                                                       */
544  /*     clazz        :: A pointer to the font driver's class.  Note that  */
545  /*                     this is NOT root.clazz.  `class' wasn't used      */
546  /*                     as it is a reserved word in C++.                  */
547  /*                                                                       */
548  /*     faces_list   :: The list of faces currently opened by this        */
549  /*                     driver.                                           */
550  /*                                                                       */
551  /*     extensions   :: A typeless pointer to the driver's extensions     */
552  /*                     registry, if they are supported through the       */
553  /*                     configuration macro FT_CONFIG_OPTION_EXTENSIONS.  */
554  /*                                                                       */
555  /*     glyph_loader :: The glyph loader for all faces managed by this    */
556  /*                     driver.  This object isn't defined for unscalable */
557  /*                     formats.                                          */
558  /*                                                                       */
559  typedef struct  FT_DriverRec_
560  {
561    FT_ModuleRec     root;
562    FT_Driver_Class  clazz;
563
564    FT_ListRec       faces_list;
565    void*            extensions;
566
567    FT_GlyphLoader   glyph_loader;
568
569  } FT_DriverRec;
570
571
572  /*************************************************************************/
573  /*************************************************************************/
574  /*************************************************************************/
575  /****                                                                 ****/
576  /****                                                                 ****/
577  /****                       L I B R A R I E S                         ****/
578  /****                                                                 ****/
579  /****                                                                 ****/
580  /*************************************************************************/
581  /*************************************************************************/
582  /*************************************************************************/
583
584
585/* this hook is used by the TrueType debugger. It must be set to an alternate
586 * truetype bytecode interpreter function
587 */
588#define FT_DEBUG_HOOK_TRUETYPE            0
589
590
591/* set this debug hook to a non-null pointer to force unpatented hinting
592 * for all faces when both TT_CONFIG_OPTION_BYTECODE_INTERPRETER and
593 * TT_CONFIG_OPTION_UNPATENTED_HINTING are defined. this is only used
594 * during debugging
595 */
596#define FT_DEBUG_HOOK_UNPATENTED_HINTING  1
597
598
599  /*************************************************************************/
600  /*                                                                       */
601  /* <Struct>                                                              */
602  /*    FT_LibraryRec                                                      */
603  /*                                                                       */
604  /* <Description>                                                         */
605  /*    The FreeType library class.  This is the root of all FreeType      */
606  /*    data.  Use FT_New_Library() to create a library object, and        */
607  /*    FT_Done_Library() to discard it and all child objects.             */
608  /*                                                                       */
609  /* <Fields>                                                              */
610  /*    memory           :: The library's memory object.  Manages memory   */
611  /*                        allocation.                                    */
612  /*                                                                       */
613  /*    generic          :: Client data variable.  Used to extend the      */
614  /*                        Library class by higher levels and clients.    */
615  /*                                                                       */
616  /*    version_major    :: The major version number of the library.       */
617  /*                                                                       */
618  /*    version_minor    :: The minor version number of the library.       */
619  /*                                                                       */
620  /*    version_patch    :: The current patch level of the library.        */
621  /*                                                                       */
622  /*    num_modules      :: The number of modules currently registered     */
623  /*                        within this library.  This is set to 0 for new */
624  /*                        libraries.  New modules are added through the  */
625  /*                        FT_Add_Module() API function.                  */
626  /*                                                                       */
627  /*    modules          :: A table used to store handles to the currently */
628  /*                        registered modules. Note that each font driver */
629  /*                        contains a list of its opened faces.           */
630  /*                                                                       */
631  /*    renderers        :: The list of renderers currently registered     */
632  /*                        within the library.                            */
633  /*                                                                       */
634  /*    cur_renderer     :: The current outline renderer.  This is a       */
635  /*                        shortcut used to avoid parsing the list on     */
636  /*                        each call to FT_Outline_Render().  It is a     */
637  /*                        handle to the current renderer for the         */
638  /*                        FT_GLYPH_FORMAT_OUTLINE format.                */
639  /*                                                                       */
640  /*    auto_hinter      :: XXX                                            */
641  /*                                                                       */
642  /*    raster_pool      :: The raster object's render pool.  This can     */
643  /*                        ideally be changed dynamically at run-time.    */
644  /*                                                                       */
645  /*    raster_pool_size :: The size of the render pool in bytes.          */
646  /*                                                                       */
647  /*    debug_hooks      :: XXX                                            */
648  /*                                                                       */
649  typedef struct  FT_LibraryRec_
650  {
651    FT_Memory          memory;           /* library's memory manager */
652
653    FT_Generic         generic;
654
655    FT_Int             version_major;
656    FT_Int             version_minor;
657    FT_Int             version_patch;
658
659    FT_UInt            num_modules;
660    FT_Module          modules[FT_MAX_MODULES];  /* module objects  */
661
662    FT_ListRec         renderers;        /* list of renderers        */
663    FT_Renderer        cur_renderer;     /* current outline renderer */
664    FT_Module          auto_hinter;
665
666    FT_Byte*           raster_pool;      /* scan-line conversion */
667                                         /* render pool          */
668    FT_ULong           raster_pool_size; /* size of render pool in bytes */
669
670    FT_DebugHook_Func  debug_hooks[4];
671
672  } FT_LibraryRec;
673
674
675  FT_BASE( FT_Renderer )
676  FT_Lookup_Renderer( FT_Library       library,
677                      FT_Glyph_Format  format,
678                      FT_ListNode*     node );
679
680  FT_BASE( FT_Error )
681  FT_Render_Glyph_Internal( FT_Library      library,
682                            FT_GlyphSlot    slot,
683                            FT_Render_Mode  render_mode );
684
685  typedef const char*
686  (*FT_Face_GetPostscriptNameFunc)( FT_Face  face );
687
688  typedef FT_Error
689  (*FT_Face_GetGlyphNameFunc)( FT_Face     face,
690                               FT_UInt     glyph_index,
691                               FT_Pointer  buffer,
692                               FT_UInt     buffer_max );
693
694  typedef FT_UInt
695  (*FT_Face_GetGlyphNameIndexFunc)( FT_Face     face,
696                                    FT_String*  glyph_name );
697
698
699#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM
700
701  /*************************************************************************/
702  /*                                                                       */
703  /* <Function>                                                            */
704  /*    FT_New_Memory                                                      */
705  /*                                                                       */
706  /* <Description>                                                         */
707  /*    Creates a new memory object.                                       */
708  /*                                                                       */
709  /* <Return>                                                              */
710  /*    A pointer to the new memory object.  0 in case of error.           */
711  /*                                                                       */
712  FT_EXPORT( FT_Memory )
713  FT_New_Memory( void );
714
715
716  /*************************************************************************/
717  /*                                                                       */
718  /* <Function>                                                            */
719  /*    FT_Done_Memory                                                     */
720  /*                                                                       */
721  /* <Description>                                                         */
722  /*    Discards memory manager.                                           */
723  /*                                                                       */
724  /* <Input>                                                               */
725  /*    memory :: A handle to the memory manager.                          */
726  /*                                                                       */
727  FT_EXPORT( void )
728  FT_Done_Memory( FT_Memory  memory );
729
730#endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */
731
732
733  /* Define default raster's interface.  The default raster is located in  */
734  /* `src/base/ftraster.c'.                                                */
735  /*                                                                       */
736  /* Client applications can register new rasters through the              */
737  /* FT_Set_Raster() API.                                                  */
738
739#ifndef FT_NO_DEFAULT_RASTER
740  FT_EXPORT_VAR( FT_Raster_Funcs )  ft_default_raster;
741#endif
742
743
744FT_END_HEADER
745
746#endif /* __FTOBJS_H__ */
747
748
749/* END */
Note: See TracBrowser for help on using the repository browser.