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_EMBEDDED_BITMAPS    FT_UInt            strike_index;    /* 0xFFFF to indicate invalid */    FT_Size_Metrics    strike_metrics;  /* current strike's metrics   */#endif#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_GlyphZoneRec    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_GlyphZoneRec  zone;     /* glyph loader points zone */    void*            extension_component;  } TT_DriverRec;  /*************************************************************************/  /*                                                                       */  /* Face functions                                                        */  /*                                                                       */  FT_LOCAL( FT_Error )  TT_Face_Init( FT_Stream      stream,                TT_Face        face,                FT_Int         face_index,                FT_Int         num_params,                FT_Parameter*  params );  FT_LOCAL( void )  TT_Face_Done( TT_Face  face );  /*************************************************************************/  /*                                                                       */  /* Size functions                                                        */  /*                                                                       */  FT_LOCAL( FT_Error )  TT_Size_Init( TT_Size  size );  FT_LOCAL( void )  TT_Size_Done( TT_Size  size );  FT_LOCAL( FT_Error )  TT_Size_Reset( TT_Size  size );  /*************************************************************************/  /*                                                                       */  /* Driver functions                                                      */  /*                                                                       */  FT_LOCAL( FT_Error )  TT_Driver_Init( TT_Driver  driver );  FT_LOCAL( void )  TT_Driver_Done( TT_Driver  driver );FT_END_HEADER#endif /* __TTOBJS_H__ *//* END */