src/freetype/truetype/ttobjs.h

/***************************************************************************/
/*                                                                         */
/*  ttobjs.h                                                               */
/*                                                                         */
/*    Objects manager (specification).                                     */
/*                                                                         */
/*  Copyright 1996-2000 by                                                 */
/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
/*                                                                         */
/*  This file is part of the FreeType project, and may only be used,       */
/*  modified, and distributed under the terms of the FreeType project      */
/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
/*  this file you indicate that you have read the license and              */
/*  understand and accept it fully.                                        */
/*                                                                         */
/***************************************************************************/


#ifndef TTOBJS_H
#define TTOBJS_H


#include <freetype/internal/ftobjs.h>
#include <freetype/internal/tttypes.h>
#include <freetype/internal/tterrors.h>


#ifdef __cplusplus
  extern "C" {
#endif


  /*************************************************************************/
  /*                                                                       */
  /* <Type>                                                                */
  /*    TT_Driver                                                          */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A handle to a TrueType driver object.                              */
  /*                                                                       */
  typedef struct TT_DriverRec_*  TT_Driver;


  /*************************************************************************/
  /*                                                                       */
  /* <Type>                                                                */
  /*    TT_Instance                                                        */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A handle to a TrueType size object.                                */
  /*                                                                       */
  typedef struct TT_SizeRec_*  TT_Size;


  /*************************************************************************/
  /*                                                                       */
  /* <Type>                                                                */
  /*    TT_GlyphSlot                                                       */
  /*                                                                       */
  /* <Description>                                                         */
  /*    A handle to a TrueType glyph slot object.                          */
  /*                                                                       */
  /* <Note>                                                                */
  /*    This is a direct typedef of FT_GlyphSlot, as there is nothing      */
  /*    specific about the TrueType glyph slot.                            */
  /*                                                                       */
  typedef FT_GlyphSlot  TT_GlyphSlot;


  /*************************************************************************/
  /*                                                                       */
  /* <Struct>                                                              */
  /*    TT_GraphicsState                                                   */
  /*                                                                       */
  /* <Description>                                                         */
  /*    The TrueType graphics state used during bytecode interpretation.   */
  /*                                                                       */
  typedef struct  TT_GraphicsState_
  {
    FT_UShort      rp0;
    FT_UShort      rp1;
    FT_UShort      rp2;

    FT_UnitVector  dualVector;
    FT_UnitVector  projVector;
    FT_UnitVector  freeVector;

    FT_Long        loop;
    FT_F26Dot6     minimum_distance;
    FT_Int         round_state;

    FT_Bool        auto_flip;
    FT_F26Dot6     control_value_cutin;
    FT_F26Dot6     single_width_cutin;
    FT_F26Dot6     single_width_value;
    FT_Short       delta_base;
    FT_Short       delta_shift;

    FT_Byte        instruct_control;
    FT_Bool        scan_control;
    FT_Int         scan_type;

    FT_UShort      gep0;
    FT_UShort      gep1;
    FT_UShort      gep2;

  } TT_GraphicsState;


  LOCAL_DEF void  TT_Done_GlyphZone( TT_GlyphZone*  zone );

  LOCAL_DEF FT_Error TT_New_GlyphZone( FT_Memory      memory,
                                       FT_UShort      maxPoints,
                                       FT_Short       maxContours,
                                       TT_GlyphZone*  zone );


  /*************************************************************************/
  /*                                                                       */
  /*  EXECUTION SUBTABLES                                                  */
  /*                                                                       */
  /*  These sub-tables relate to instruction execution.                    */
  /*                                                                       */
  /*************************************************************************/


#define TT_MAX_CODE_RANGES  3


  /*************************************************************************/
  /*                                                                       */
  /* There can only be 3 active code ranges at once:                       */
  /*   - the Font Program                                                  */
  /*   - the CVT Program                                                   */
  /*   - a glyph's instructions set                                        */
  /*                                                                       */
  typedef enum  TT_CodeRange_Tag_
  {
    tt_coderange_none = 0,
    tt_coderange_font,
    tt_coderange_cvt,
    tt_coderange_glyph

  } TT_CodeRange_Tag;


  typedef struct  TT_CodeRange_
  {
    FT_Byte*  base;
    FT_ULong  size;

  } TT_CodeRange;

  typedef TT_CodeRange  TT_CodeRangeTable[TT_MAX_CODE_RANGES];


  /*************************************************************************/
  /*                                                                       */
  /* Defines a function/instruction definition record.                     */
  /*                                                                       */
  typedef struct  TT_DefRecord_
  {
    FT_Int   range;      /* in which code range is it located? */
    FT_Long  start;      /* where does it start?               */
    FT_UInt  opc;        /* function #, or instruction code    */
    FT_Bool  active;     /* is it active?                      */

  } TT_DefRecord, *TT_DefArray;


  /*************************************************************************/
  /*                                                                       */
  /* Subglyph transformation record.                                       */
  /*                                                                       */
  typedef struct  TT_Transform_
  {
    FT_Fixed    xx, xy;     /* transformation matrix coefficients */
    FT_Fixed    yx, yy;
    FT_F26Dot6  ox, oy;     /* offsets        */

  } TT_Transform;


  /*************************************************************************/
  /*                                                                       */
  /* Subglyph loading record.  Used to load composite components.          */
  /*                                                                       */
  typedef struct  TT_SubglyphRec_
  {
    FT_Long       index;        /* subglyph index; initialized with -1 */
    FT_Bool       is_scaled;    /* is the subglyph scaled?             */
    FT_Bool       is_hinted;    /* should it be hinted?                */
    FT_Bool       preserve_pps; /* preserve phantom points?            */

    FT_Long       file_offset;

    FT_BBox       bbox;
    FT_Pos        left_bearing;
    FT_Pos        advance;

    TT_GlyphZone  zone;

    FT_Long       arg1;         /* first argument                      */
    FT_Long       arg2;         /* second argument                     */

    FT_UShort     element_flag; /* current load element flag           */

    TT_Transform  transform;    /* transformation matrix               */

    FT_Vector     pp1, pp2;     /* phantom points                      */

  } TT_SubGlyphRec, *TT_SubGlyph_Stack;


  /*************************************************************************/
  /*                                                                       */
  /* A note regarding non-squared pixels:                                  */
  /*                                                                       */
  /* (This text will probably go into some docs at some time; for now, it  */
  /*  is kept here to explain some definitions in the TIns_Metrics         */
  /*  record).                                                             */
  /*                                                                       */
  /* The CVT is a one-dimensional array containing values that control     */
  /* certain important characteristics in a font, like the height of all   */
  /* capitals, all lowercase letter, default spacing or stem width/height. */
  /*                                                                       */
  /* These values are found in FUnits in the font file, and must be scaled */
  /* to pixel coordinates before being used by the CVT and glyph programs. */
  /* Unfortunately, when using distinct x and y resolutions (or distinct x */
  /* and y pointsizes), there are two possible scalings.                   */
  /*                                                                       */
  /* A first try was to implement a `lazy' scheme where all values were    */
  /* scaled when first used.  However, while some values are always used   */
  /* in the same direction, some others are used under many different      */
  /* circumstances and orientations.                                       */
  /*                                                                       */
  /* I have found a simpler way to do the same, and it even seems to work  */
  /* in most of the cases:                                                 */
  /*                                                                       */
  /* - All CVT values are scaled to the maximum ppem size.                 */
  /*                                                                       */
  /* - When performing a read or write in the CVT, a ratio factor is used  */
  /*   to perform adequate scaling.  Example:                              */
  /*                                                                       */
  /*     x_ppem = 14                                                       */
  /*     y_ppem = 10                                                       */
  /*                                                                       */
  /*   We choose ppem = x_ppem = 14 as the CVT scaling size.  All cvt      */
  /*   entries are scaled to it.                                           */
  /*                                                                       */
  /*     x_ratio = 1.0                                                     */
  /*     y_ratio = y_ppem/ppem (< 1.0)                                     */
  /*                                                                       */
  /*   We compute the current ratio like:                                  */
  /*                                                                       */
  /*   - If projVector is horizontal,                                      */
  /*       ratio = x_ratio = 1.0                                           */
  /*                                                                       */
  /*   - if projVector is vertical,                                        */
  /*       ratio = y_ratio                                                 */
  /*                                                                       */
  /*   - else,                                                             */
  /*       ratio = sqrt( (proj.x * x_ratio) ^ 2 + (proj.y * y_ratio) ^ 2 ) */
  /*                                                                       */
  /*   Reading a cvt value returns                                         */
  /*     ratio * cvt[index]                                                */
  /*                                                                       */
  /*   Writing a cvt value in pixels:                                      */
  /*     cvt[index] / ratio                                                */
  /*                                                                       */
  /*   The current ppem is simply                                          */
  /*     ratio * ppem                                                      */
  /*                                                                       */
  /*************************************************************************/


  /*************************************************************************/
  /*                                                                       */
  /* Metrics used by the TrueType size and context objects.                */
  /*                                                                       */
  typedef struct  TT_Size_Metrics_
  {
    /* for non-square pixels */
    FT_Long     x_ratio;
    FT_Long     y_ratio;

    FT_UShort   ppem;               /* maximum ppem size              */
    FT_Long     ratio;              /* current ratio                  */
    FT_Fixed    scale;

    FT_F26Dot6  compensations[4];   /* device-specific compensations  */

    FT_Bool     valid;

    FT_Bool     rotated;            /* `is the glyph rotated?'-flag   */
    FT_Bool     stretched;          /* `is the glyph stretched?'-flag */

  } TT_Size_Metrics;


  /*************************************************************************/
  /*                                                                       */
  /* TrueType size class.                                                  */
  /*                                                                       */
  typedef struct  TT_SizeRec_
  {
    FT_SizeRec         root;

    TT_Size_Metrics    ttmetrics;

#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER

    FT_UInt            num_function_defs; /* number of function definitions */
    FT_UInt            max_function_defs;
    TT_DefArray        function_defs;     /* table of function definitions  */

    FT_UInt            num_instruction_defs;  /* number of ins. definitions */
    FT_UInt            max_instruction_defs;
    TT_DefArray        instruction_defs;      /* table of ins. definitions  */

    FT_UInt            max_func;
    FT_UInt            max_ins;

    TT_CodeRangeTable  codeRangeTable;

    TT_GraphicsState   GS;

    FT_ULong           cvt_size;      /* the scaled control value table */
    FT_Long*           cvt;

    FT_UShort          storage_size; /* The storage area is now part of */
    FT_Long*           storage;      /* the instance                    */

    TT_GlyphZone       twilight;     /* The instance's twilight zone    */

    /* debugging variables */

    /* When using the debugger, we must keep the */
    /* execution context tied to the instance    */
    /* object rather than asking it on demand.   */

    FT_Bool            debug;
    TT_ExecContext     context;

#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */

  } TT_SizeRec;


  /*************************************************************************/
  /*                                                                       */
  /* TrueType driver class.                                                */
  /*                                                                       */
  typedef struct  TT_DriverRec_
  {
    FT_DriverRec    root;
    TT_ExecContext  context;  /* execution context        */
    TT_GlyphZone    zone;     /* glyph loader points zone */

    void*           extension_component;

  } TT_DriverRec;


  /*************************************************************************/
  /*                                                                       */
  /* Face functions                                                        */
  /*                                                                       */
  LOCAL_DEF
  FT_Error  TT_Init_Face( FT_Stream      stream,
                          TT_Face        face,
                          FT_Int         face_index,
                          FT_Int         num_params,
                          FT_Parameter*  params );

  LOCAL_DEF
  void  TT_Done_Face( TT_Face  face );


  /*************************************************************************/
  /*                                                                       */
  /* Size functions                                                        */
  /*                                                                       */
  LOCAL_DEF
  FT_Error  TT_Init_Size( TT_Size  size );

  LOCAL_DEF
  void  TT_Done_Size( TT_Size  size );

  LOCAL_DEF
  FT_Error  TT_Reset_Size( TT_Size  size );


  /*************************************************************************/
  /*                                                                       */
  /* Driver functions                                                      */
  /*                                                                       */
  LOCAL_DEF
  FT_Error  TT_Init_Driver( TT_Driver  driver );

  LOCAL_DEF
  void  TT_Done_Driver( TT_Driver  driver );


#ifdef __cplusplus
  }
#endif

#endif /* TTOBJS_H */


/* END */
Commit	Line	Data
	1	/***************************************************************************/
	2	/* */
	3	/* ttobjs.h */
	4	/* */
	5	/* Objects manager (specification). */
	6	/* */
	7	/* Copyright 1996-2000 by */
	8	/* David Turner, Robert Wilhelm, and Werner Lemberg. */
	9	/* */
	10	/* This file is part of the FreeType project, and may only be used, */
	11	/* modified, and distributed under the terms of the FreeType project */
	12	/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
	13	/* this file you indicate that you have read the license and */
	14	/* understand and accept it fully. */
	15	/* */
	16	/***************************************************************************/
	17
	18
	19	#ifndef TTOBJS_H
	20	#define TTOBJS_H
	21
	22
	23	#include <freetype/internal/ftobjs.h>
	24	#include <freetype/internal/tttypes.h>
	25	#include <freetype/internal/tterrors.h>
	26
	27
	28	#ifdef __cplusplus
	29	extern "C" {
	30	#endif
	31
	32
	33	/*************************************************************************/
	34	/* */
	35	/* <Type> */
	36	/* TT_Driver */
	37	/* */
	38	/* <Description> */
	39	/* A handle to a TrueType driver object. */
	40	/* */
	41	typedef struct TT_DriverRec_* TT_Driver;
	42
	43
	44	/*************************************************************************/
	45	/* */
	46	/* <Type> */
	47	/* TT_Instance */
	48	/* */
	49	/* <Description> */
	50	/* A handle to a TrueType size object. */
	51	/* */
	52	typedef struct TT_SizeRec_* TT_Size;
	53
	54
	55	/*************************************************************************/
	56	/* */
	57	/* <Type> */
	58	/* TT_GlyphSlot */
	59	/* */
	60	/* <Description> */
	61	/* A handle to a TrueType glyph slot object. */
	62	/* */
	63	/* <Note> */
	64	/* This is a direct typedef of FT_GlyphSlot, as there is nothing */
	65	/* specific about the TrueType glyph slot. */
	66	/* */
	67	typedef FT_GlyphSlot TT_GlyphSlot;
	68
	69
	70	/*************************************************************************/
	71	/* */
	72	/* <Struct> */
	73	/* TT_GraphicsState */
	74	/* */
	75	/* <Description> */
	76	/* The TrueType graphics state used during bytecode interpretation. */
	77	/* */
	78	typedef struct TT_GraphicsState_
	79	{
	80	FT_UShort rp0;
	81	FT_UShort rp1;
	82	FT_UShort rp2;
	83
	84	FT_UnitVector dualVector;
	85	FT_UnitVector projVector;
	86	FT_UnitVector freeVector;
	87
	88	FT_Long loop;
	89	FT_F26Dot6 minimum_distance;
	90	FT_Int round_state;
	91
	92	FT_Bool auto_flip;
	93	FT_F26Dot6 control_value_cutin;
	94	FT_F26Dot6 single_width_cutin;
	95	FT_F26Dot6 single_width_value;
	96	FT_Short delta_base;
	97	FT_Short delta_shift;
	98
	99	FT_Byte instruct_control;
	100	FT_Bool scan_control;
	101	FT_Int scan_type;
	102
	103	FT_UShort gep0;
	104	FT_UShort gep1;
	105	FT_UShort gep2;
	106
	107	} TT_GraphicsState;
	108
	109
	110	LOCAL_DEF void TT_Done_GlyphZone( TT_GlyphZone* zone );
	111
	112	LOCAL_DEF FT_Error TT_New_GlyphZone( FT_Memory memory,
	113	FT_UShort maxPoints,
	114	FT_Short maxContours,
	115	TT_GlyphZone* zone );
	116
	117
	118	/*************************************************************************/
	119	/* */
	120	/* EXECUTION SUBTABLES */
	121	/* */
	122	/* These sub-tables relate to instruction execution. */
	123	/* */
	124	/*************************************************************************/
	125
	126
	127	#define TT_MAX_CODE_RANGES 3
	128
	129
	130	/*************************************************************************/
	131	/* */
	132	/* There can only be 3 active code ranges at once: */
	133	/* - the Font Program */
	134	/* - the CVT Program */
	135	/* - a glyph's instructions set */
	136	/* */
	137	typedef enum TT_CodeRange_Tag_
	138	{
	139	tt_coderange_none = 0,
	140	tt_coderange_font,
	141	tt_coderange_cvt,
	142	tt_coderange_glyph
	143
	144	} TT_CodeRange_Tag;
	145
	146
	147	typedef struct TT_CodeRange_
	148	{
	149	FT_Byte* base;
	150	FT_ULong size;
	151
	152	} TT_CodeRange;
	153
	154	typedef TT_CodeRange TT_CodeRangeTable[TT_MAX_CODE_RANGES];
	155
	156
	157	/*************************************************************************/
	158	/* */
	159	/* Defines a function/instruction definition record. */
	160	/* */
	161	typedef struct TT_DefRecord_
	162	{
	163	FT_Int range; /* in which code range is it located? */
	164	FT_Long start; /* where does it start? */
	165	FT_UInt opc; /* function #, or instruction code */
	166	FT_Bool active; /* is it active? */
	167
	168	} TT_DefRecord, *TT_DefArray;
	169
	170
	171	/*************************************************************************/
	172	/* */
	173	/* Subglyph transformation record. */
	174	/* */
	175	typedef struct TT_Transform_
	176	{
	177	FT_Fixed xx, xy; /* transformation matrix coefficients */
	178	FT_Fixed yx, yy;
	179	FT_F26Dot6 ox, oy; /* offsets */
	180
	181	} TT_Transform;
	182
	183
	184	/*************************************************************************/
	185	/* */
	186	/* Subglyph loading record. Used to load composite components. */
	187	/* */
	188	typedef struct TT_SubglyphRec_
	189	{
	190	FT_Long index; /* subglyph index; initialized with -1 */
	191	FT_Bool is_scaled; /* is the subglyph scaled? */
	192	FT_Bool is_hinted; /* should it be hinted? */
	193	FT_Bool preserve_pps; /* preserve phantom points? */
	194
	195	FT_Long file_offset;
	196
	197	FT_BBox bbox;
	198	FT_Pos left_bearing;
	199	FT_Pos advance;
	200
	201	TT_GlyphZone zone;
	202
	203	FT_Long arg1; /* first argument */
	204	FT_Long arg2; /* second argument */
	205
	206	FT_UShort element_flag; /* current load element flag */
	207
	208	TT_Transform transform; /* transformation matrix */
	209
	210	FT_Vector pp1, pp2; /* phantom points */
	211
	212	} TT_SubGlyphRec, *TT_SubGlyph_Stack;
	213
	214
	215	/*************************************************************************/
	216	/* */
	217	/* A note regarding non-squared pixels: */
	218	/* */
	219	/* (This text will probably go into some docs at some time; for now, it */
	220	/* is kept here to explain some definitions in the TIns_Metrics */
	221	/* record). */
	222	/* */
	223	/* The CVT is a one-dimensional array containing values that control */
	224	/* certain important characteristics in a font, like the height of all */
	225	/* capitals, all lowercase letter, default spacing or stem width/height. */
	226	/* */
	227	/* These values are found in FUnits in the font file, and must be scaled */
	228	/* to pixel coordinates before being used by the CVT and glyph programs. */
	229	/* Unfortunately, when using distinct x and y resolutions (or distinct x */
	230	/* and y pointsizes), there are two possible scalings. */
	231	/* */
	232	/* A first try was to implement a `lazy' scheme where all values were */
	233	/* scaled when first used. However, while some values are always used */
	234	/* in the same direction, some others are used under many different */
	235	/* circumstances and orientations. */
	236	/* */
	237	/* I have found a simpler way to do the same, and it even seems to work */
	238	/* in most of the cases: */
	239	/* */
	240	/* - All CVT values are scaled to the maximum ppem size. */
	241	/* */
	242	/* - When performing a read or write in the CVT, a ratio factor is used */
	243	/* to perform adequate scaling. Example: */
	244	/* */
	245	/* x_ppem = 14 */
	246	/* y_ppem = 10 */
	247	/* */
	248	/* We choose ppem = x_ppem = 14 as the CVT scaling size. All cvt */
	249	/* entries are scaled to it. */
	250	/* */
	251	/* x_ratio = 1.0 */
	252	/* y_ratio = y_ppem/ppem (< 1.0) */
	253	/* */
	254	/* We compute the current ratio like: */
	255	/* */
	256	/* - If projVector is horizontal, */
	257	/* ratio = x_ratio = 1.0 */
	258	/* */
	259	/* - if projVector is vertical, */
	260	/* ratio = y_ratio */
	261	/* */
	262	/* - else, */
	263	/* ratio = sqrt( (proj.x * x_ratio) ^ 2 + (proj.y * y_ratio) ^ 2 ) */
	264	/* */
	265	/* Reading a cvt value returns */
	266	/* ratio * cvt[index] */
	267	/* */
	268	/* Writing a cvt value in pixels: */
	269	/* cvt[index] / ratio */
	270	/* */
	271	/* The current ppem is simply */
	272	/* ratio * ppem */
	273	/* */
	274	/*************************************************************************/
	275
	276
	277	/*************************************************************************/
	278	/* */
	279	/* Metrics used by the TrueType size and context objects. */
	280	/* */
	281	typedef struct TT_Size_Metrics_
	282	{
	283	/* for non-square pixels */
	284	FT_Long x_ratio;
	285	FT_Long y_ratio;
	286
	287	FT_UShort ppem; /* maximum ppem size */
	288	FT_Long ratio; /* current ratio */
	289	FT_Fixed scale;
	290
	291	FT_F26Dot6 compensations[4]; /* device-specific compensations */
	292
	293	FT_Bool valid;
	294
	295	FT_Bool rotated; /* `is the glyph rotated?'-flag */
	296	FT_Bool stretched; /* `is the glyph stretched?'-flag */
	297
	298	} TT_Size_Metrics;
	299
	300
	301	/*************************************************************************/
	302	/* */
	303	/* TrueType size class. */
	304	/* */
	305	typedef struct TT_SizeRec_
	306	{
	307	FT_SizeRec root;
	308
	309	TT_Size_Metrics ttmetrics;
	310
	311	#ifdef TT_CONFIG_OPTION_BYTECODE_INTERPRETER
	312
	313	FT_UInt num_function_defs; /* number of function definitions */
	314	FT_UInt max_function_defs;
	315	TT_DefArray function_defs; /* table of function definitions */
	316
	317	FT_UInt num_instruction_defs; /* number of ins. definitions */
	318	FT_UInt max_instruction_defs;
	319	TT_DefArray instruction_defs; /* table of ins. definitions */
	320
	321	FT_UInt max_func;
	322	FT_UInt max_ins;
	323
	324	TT_CodeRangeTable codeRangeTable;
	325
	326	TT_GraphicsState GS;
	327
	328	FT_ULong cvt_size; /* the scaled control value table */
	329	FT_Long* cvt;
	330
	331	FT_UShort storage_size; /* The storage area is now part of */
	332	FT_Long* storage; /* the instance */
	333
	334	TT_GlyphZone twilight; /* The instance's twilight zone */
	335
	336	/* debugging variables */
	337
	338	/* When using the debugger, we must keep the */
	339	/* execution context tied to the instance */
	340	/* object rather than asking it on demand. */
	341
	342	FT_Bool debug;
	343	TT_ExecContext context;
	344
	345	#endif /* TT_CONFIG_OPTION_BYTECODE_INTERPRETER */
	346
	347	} TT_SizeRec;
	348
	349
	350	/*************************************************************************/
	351	/* */
	352	/* TrueType driver class. */
	353	/* */
	354	typedef struct TT_DriverRec_
	355	{
	356	FT_DriverRec root;
	357	TT_ExecContext context; /* execution context */
	358	TT_GlyphZone zone; /* glyph loader points zone */
	359
	360	void* extension_component;
	361
	362	} TT_DriverRec;
	363
	364
	365	/*************************************************************************/
	366	/* */
	367	/* Face functions */
	368	/* */
	369	LOCAL_DEF
	370	FT_Error TT_Init_Face( FT_Stream stream,
	371	TT_Face face,
	372	FT_Int face_index,
	373	FT_Int num_params,
	374	FT_Parameter* params );
	375
	376	LOCAL_DEF
	377	void TT_Done_Face( TT_Face face );
	378
	379
	380	/*************************************************************************/
	381	/* */
	382	/* Size functions */
	383	/* */
	384	LOCAL_DEF
	385	FT_Error TT_Init_Size( TT_Size size );
	386
	387	LOCAL_DEF
	388	void TT_Done_Size( TT_Size size );
	389
	390	LOCAL_DEF
	391	FT_Error TT_Reset_Size( TT_Size size );
	392
	393
	394	/*************************************************************************/
	395	/* */
	396	/* Driver functions */
	397	/* */
	398	LOCAL_DEF
	399	FT_Error TT_Init_Driver( TT_Driver driver );
	400
	401	LOCAL_DEF
	402	void TT_Done_Driver( TT_Driver driver );
	403
	404
	405	#ifdef __cplusplus
	406	}
	407	#endif
	408
	409	#endif /* TTOBJS_H */
	410
	411
	412	/* END */