#ifndef TTOBJS_H_

#define TTOBJS_H_

#include <ft2build.h>

#include FT_INTERNAL_OBJECTS_H

#include FT_INTERNAL_TRUETYPE_TYPES_H

FT_BEGIN_HEADER

  typedef struct TT_DriverRec_*  TT_Driver;

  typedef FT_GlyphSlot  TT_GlyphSlot;

  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_UShort      delta_base;

    FT_UShort      delta_shift;

    FT_Byte        instruct_control;

    /* According to Greg Hitchcock from Microsoft, the `scan_control'     */

    /* variable as documented in the TrueType specification is a 32-bit   */

    /* integer; the high-word part holds the SCANTYPE value, the low-word */

    /* part the SCANCTRL value.  We separate it into two fields.          */

    FT_Bool        scan_control;

    FT_Int         scan_type;

    FT_UShort      gep0;

    FT_UShort      gep1;

    FT_UShort      gep2;

  } TT_GraphicsState;

#ifdef TT_USE_BYTECODE_INTERPRETER

  FT_LOCAL( void )

  tt_glyphzone_done( TT_GlyphZone  zone );

  FT_LOCAL( FT_Error )

  tt_glyphzone_new( FT_Memory     memory,

                    FT_UShort     maxPoints,

                    FT_Short      maxContours,

                    TT_GlyphZone  zone );

#endif /* TT_USE_BYTECODE_INTERPRETER */

#define TT_MAX_CODE_RANGES  3

  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_Long   size;

  } TT_CodeRange;

  typedef TT_CodeRange  TT_CodeRangeTable[TT_MAX_CODE_RANGES];

  typedef struct  TT_DefRecord_

  {

    FT_Int    range;          /* in which code range is it located?     */

    FT_Long   start;          /* where does it start?                   */

    FT_Long   end;            /* where does it end?                     */

    FT_UInt   opc;            /* function #, or instruction code        */

    FT_Bool   active;         /* is it active?                          */

    FT_Bool   inline_delta;   /* is function that defines inline delta? */

    FT_ULong  sph_fdef_flags; /* flags to identify special functions    */

  } TT_DefRecord, *TT_DefArray;

  typedef struct  TT_Transform_

  {

    FT_Fixed    xx, xy;     /* transformation matrix coefficients */

    FT_Fixed    yx, yy;

    FT_F26Dot6  ox, oy;     /* offsets                            */

  } TT_Transform;

  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;

  typedef struct  TT_SizeRec_

  {

    FT_SizeRec         root;

    /* we have our own copy of metrics so that we can modify */

    /* it without affecting auto-hinting (when used)         */

    FT_Size_Metrics*   metrics;        /* for the current rendering mode */

    FT_Size_Metrics    hinted_metrics; /* for the hinted rendering mode  */

    TT_Size_Metrics    ttmetrics;

    FT_ULong           strike_index;      /* 0xFFFFFFFF to indicate invalid */

#ifdef TT_USE_BYTECODE_INTERPRETER

    FT_Long            point_size;    /* for the `MPS' bytecode instruction */

    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    */

    TT_ExecContext     context;

    /* if negative, `fpgm' (resp. `prep'), wasn't executed yet; */

    /* otherwise it is the returned error code                  */

    FT_Error           bytecode_ready;

    FT_Error           cvt_ready;

#endif /* TT_USE_BYTECODE_INTERPRETER */

  } TT_SizeRec;

  typedef struct  TT_DriverRec_

  {

    FT_DriverRec  root;

    TT_GlyphZoneRec  zone;     /* glyph loader points zone */

    FT_UInt  interpreter_version;

  } TT_DriverRec;

  /* Note: All of the functions below (except tt_size_reset()) are used    */

  /* as function pointers in a FT_Driver_ClassRec.  Therefore their        */

  /* parameters are of types FT_Face, FT_Size, etc., rather than TT_Face,  */

  /* TT_Size, etc., so that the compiler can confirm that the types and    */

  /* number of parameters are correct.  In all cases the FT_xxx types are  */

  /* cast to their TT_xxx counterparts inside the functions since FreeType */

  /* will always use the TT driver to create them.                         */

  FT_LOCAL( FT_Error )

  tt_face_init( FT_Stream      stream,

                FT_Face        ttface,      /* TT_Face */

                FT_Int         face_index,

                FT_Int         num_params,

                FT_Parameter*  params );

  FT_LOCAL( void )

  tt_face_done( FT_Face  ttface );          /* TT_Face */

  FT_LOCAL( FT_Error )

  tt_size_init( FT_Size  ttsize );          /* TT_Size */

  FT_LOCAL( void )

  tt_size_done( FT_Size  ttsize );          /* TT_Size */

#ifdef TT_USE_BYTECODE_INTERPRETER

  FT_LOCAL( FT_Error )

  tt_size_run_fpgm( TT_Size  size,

                    FT_Bool  pedantic );

  FT_LOCAL( FT_Error )

  tt_size_run_prep( TT_Size  size,

                    FT_Bool  pedantic );

  FT_LOCAL( FT_Error )

  tt_size_ready_bytecode( TT_Size  size,

                          FT_Bool  pedantic );

#endif /* TT_USE_BYTECODE_INTERPRETER */

  FT_LOCAL( FT_Error )

  tt_size_reset( TT_Size  size,

                 FT_Bool  only_height );

  FT_LOCAL( FT_Error )

  tt_driver_init( FT_Module  ttdriver );    /* TT_Driver */

  FT_LOCAL( void )

  tt_driver_done( FT_Module  ttdriver );    /* TT_Driver */

  FT_LOCAL( FT_Error )

  tt_slot_init( FT_GlyphSlot  slot );

  /* auxiliary */

#define IS_HINTED( flags )  ( ( flags & FT_LOAD_NO_HINTING ) == 0 )

FT_END_HEADER

#endif /* TTOBJS_H_ */

/* END */