/*******************************************************************
 *
 *  truetype.h
 *
 *    Backwards-compatible high-level interface for the TrueType
 *    driver. This file is a replacement for the old "freetype.h"
 *    from 1.0 and 1.1. It can be used to compile applications
 *    and tools using the old API..
 *
 *    Note that this (old) interface is now deprecated and won't
 *    be modified in the future. Developers will have to switch to
 *    the newer interface to get new features ( kerning, embedded
 *    bitmaps, etc.. ).
 *
 *
 *
 *  Copyright 1996-1998 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.
 *
 *  Note:
 *
 *    This is the only file that should be included by client
 *    application sources.  All other types and functions defined
 *    in the "tt*.h" files are library internals and should not be
 *    included.
 *
 ******************************************************************/

#ifndef TRUETYPE_H
#define TRUETYPE_H

/* To make freetype.h independent from configuration files we check */
/* whether EXPORT_DEF has been defined already.                     */

#ifndef EXPORT_DEF
#define EXPORT_DEF extern
#endif

/* The same for TT_Text.  If you define the HAVE_TT_TEXT macro, you */
/* have to provide a typedef declaration for TT_Text before         */
/* including this file.                                             */

#ifndef HAVE_TT_TEXT
#define HAVE_TT_TEXT
  typedef char  TT_Text;              /* the data type to represent */
                                      /* file name string elements  */
#endif

#ifdef __cplusplus
  extern "C" {
#endif


/* The following types are also defined in "drivers/ttlib/ttobjs.h"  */
/* We use the _TRUETYPE_ macro to prevent their redefinition when    */
/* _compiling_ the backwards-compatible layer called "ttapi.c"       */
/*                                                                   */
#ifndef _TRUETYPE_

  /*******************************************************************/
  /*                                                                 */
  /*  FreeType types definitions.                                    */
  /*                                                                 */
  /*  All these begin with a 'TT_' prefix.                           */
  /*                                                                 */
  /*******************************************************************/

  typedef unsigned short  TT_Bool;

  typedef signed long     TT_Fixed;   /* Signed Fixed 16.16 Float */

  typedef signed short    TT_FWord;   /* Distance in FUnits */
  typedef unsigned short  TT_UFWord;  /* Unsigned distance */

  typedef char            TT_String;
  typedef signed char     TT_Char;
  typedef unsigned char   TT_Byte;
  typedef signed short    TT_Short;
  typedef unsigned short  TT_UShort;
  typedef signed long     TT_Long;
  typedef unsigned long   TT_ULong;
  typedef int             TT_Int;

  typedef signed short    TT_F2Dot14; /* Signed fixed float 2.14 used for */
                                      /* unit vectors, with layout:       */
                                      /*                                  */
                                      /*  s : 1  -- sign bit              */
                                      /*  m : 1  -- integer bit           */
                                      /*  f : 14 -- unsigned fractional   */
                                      /*                                  */
                                      /*  's:m' is the 2-bit signed int   */
                                      /*  value to which the positive     */
                                      /*  fractional part should be       */
                                      /*  added.                          */
                                      /*                                  */

  typedef signed long     TT_F26Dot6; /* 26.6 fixed float, used for       */
                                      /* glyph points pixel coordinates.  */

  typedef signed long     TT_Pos;     /* point position, expressed either */
                                      /* in fractional pixels or notional */
                                      /* units, depending on context.     */
                                      /* For example, glyph coordinates   */
                                      /* returned by TT_Load_Glyph are    */
                                      /* expressed in font units when     */
                                      /* scaling wasn't requested, and    */
                                      /* in 26.6 fractional pixels if it  */
                                      /* was.                             */


  struct  TT_UnitVector_      /* guess what...  */
  {
    TT_F2Dot14  x;
    TT_F2Dot14  y;
  };

  typedef struct TT_UnitVector_  TT_UnitVector;


  struct  TT_Vector_          /* Simple vector type */
  {
    TT_F26Dot6  x;
    TT_F26Dot6  y;
  };

  typedef struct TT_Vector_  TT_Vector;


  /* A simple 2x2 matrix used for transformations. */
  /* You should use 16.16 fixed floats.            */
  /*                                               */
  /*  x' = xx*x + xy*y                             */
  /*  y' = yx*x + yy*y                             */
  /*                                               */

  struct  TT_Matrix_
  {
    TT_Fixed  xx, xy;
    TT_Fixed  yx, yy;
  };

  typedef struct TT_Matrix_  TT_Matrix;


  /* A structure used to describe a simple bounding box */

  struct TT_BBox_
  {
    TT_Pos  xMin;
    TT_Pos  yMin;
    TT_Pos  xMax;
    TT_Pos  yMax;
  };

  typedef struct TT_BBox_  TT_BBox;


#endif /* _TRUETYPE_ */


  /* A structure used to describe the source glyph to the renderer. */

  struct  TT_Outline_
  {
    TT_Short         n_contours;   /* number of contours in glyph        */
    TT_UShort        n_points;     /* number of points in the glyph      */

    TT_Vector*       points;       /* the outline's points   */
    TT_Byte*         flags;        /* the points flags       */
    TT_UShort*       contours;     /* the contour end points */

    /* The following flag indicates that the outline owns the arrays it  */
    /* refers to.  Typically, this is true of outlines created from the  */
    /* TT_New_Outline() API, while it isn't for those returned by        */
    /* TT_Get_Glyph_Outline().                                           */

    TT_Bool          owner;      /* the outline owns the coordinates,    */
                                 /* flags and contours array it uses     */

    /* The following flags are set automatically by                      */
    /* TT_Get_Glyph_Outline().  Their meaning is the following:          */
    /*                                                                   */
    /*  high_precision   When true, the scan-line converter will use     */
    /*                   a higher precision to render bitmaps (i.e. a    */
    /*                   1/1024 pixel precision).  This is important for */
    /*                   small ppem sizes.                               */
    /*                                                                   */
    /*  second_pass      When true, the scan-line converter performs     */
    /*                   a second sweep phase dedicated to find          */
    /*                   vertical drop-outs.  If false, only horizontal  */
    /*                   drop-outs will be checked during the first      */
    /*                   vertical sweep (yes, this is a bit confusing    */
    /*                   but it's really the way it should work).        */
    /*                   This is important for small ppems too.          */
    /*                                                                   */
    /*  dropout_mode     Specifies the TrueType drop-out mode to         */
    /*                   use for continuity checking. valid values       */
    /*                   are 0 (no check), 1, 2, 4, and 5.               */
    /*                                                                   */
    /*  Most of the engine's users will safely ignore these fields...    */

    TT_Bool          high_precision;  /* high precision rendering */
    TT_Bool          second_pass;     /* two sweeps rendering     */
    TT_Char          dropout_mode;    /* dropout mode */
  };

  typedef struct TT_Outline_  TT_Outline;


  /* A structure used to return glyph metrics.                          */
  /*                                                                    */
  /* The "bearingX" isn't called "left-side bearing" anymore because    */
  /* it has different meanings depending on the glyph's orientation.    */
  /*                                                                    */
  /* The same is true for "bearingY", which is the top-side bearing     */
  /* defined by the TT_Spec, i.e., the distance from the baseline to    */
  /* the top of the glyph's bbox.  According to our current convention, */
  /* this is always the same as "bbox.yMax" but we make it appear for   */
  /* consistency in its proper field.                                   */
  /*                                                                    */
  /* The "advance" width is the advance width for horizontal layout,    */
  /* and advance height for vertical layouts.                           */
  /*                                                                    */
  /* Finally, the library (ver. 1.1) doesn't support vertical text yet  */
  /* but these changes were introduced to accomodate it, as it will     */
  /* most certainly be introduced in later releases.                    */

  struct  TT_Glyph_Metrics_
  {
    TT_BBox  bbox;      /* glyph bounding box */

    TT_Pos   bearingX;  /* left-side bearing                    */
    TT_Pos   bearingY;  /* top-side bearing, per se the TT spec */

    TT_Pos   advance;   /* advance width (or height) */
  };


  /* A structure used to return horizontal _and_ vertical glyph         */
  /* metrics.                                                           */
  /*                                                                    */
  /* A glyph can be used either in a horizontal or vertical layout.     */
  /* Its glyph metrics vary with orientation.  The Big_Glyph_Metrics    */
  /* structure is used to return _all_ metrics in one call.             */
  /*                                                                    */

  struct TT_Big_Glyph_Metrics_
  {
    TT_BBox  bbox;          /* glyph bounding box */

    TT_Pos   horiBearingX;  /* left side bearing in horizontal layouts */
    TT_Pos   horiBearingY;  /* top side bearing in horizontal layouts  */

    TT_Pos   vertBearingX;  /* left side bearing in vertical layouts */
    TT_Pos   vertBearingY;  /* top side bearing in vertical layouts  */

    TT_Pos   horiAdvance;   /* advance width for horizontal layout */
    TT_Pos   vertAdvance;   /* advance height for vertical layout  */

    /* The following fields represent unhinted scaled metrics values. */
    /* They can be useful for applications needing to do some device  */
    /* independent placement of glyphs.                               */
    /*                                                                */
    /* Applying these metrics to hinted glyphs will most surely ruin  */
    /* the grid fitting performed by the bytecode interpreter.  These */
    /* values are better used to compute accumulated positioning      */
    /* distances.                                                     */

    TT_Pos   linearHoriBearingX;  /* linearly scaled horizontal lsb     */
    TT_Pos   linearHoriAdvance;   /* linearly scaled horizontal advance */

    TT_Pos   linearVertBearingY;  /* linearly scaled vertical tsb     */
    TT_Pos   linearVertAdvance;   /* linearly scaled vertical advance */
  };

  typedef struct TT_Glyph_Metrics_      TT_Glyph_Metrics;
  typedef struct TT_Big_Glyph_Metrics_  TT_Big_Glyph_Metrics;


  /* A structure used to return instance metrics. */

  struct  TT_Instance_Metrics_
  {
    TT_F26Dot6  pointSize;     /* char. size in points (1pt = 1/72 inch) */

    TT_UShort   x_ppem;        /* horizontal pixels per EM square */
    TT_UShort   y_ppem;        /* vertical pixels per EM square   */

    TT_Fixed    x_scale;     /* 16.16 to convert from EM units to 26.6 pix */
    TT_Fixed    y_scale;     /* 16.16 to convert from EM units to 26.6 pix */

    TT_UShort   x_resolution;  /* device horizontal resolution in dpi */
    TT_UShort   y_resolution;  /* device vertical resolution in dpi   */
  };

  typedef struct TT_Instance_Metrics_  TT_Instance_Metrics;


  /* Flow constants:                                             */
  /*                                                             */
  /* The flow of a bitmap refers to the way lines are oriented   */
  /* within the bitmap data, i.e., the orientation of the Y      */
  /* coordinate axis.                                            */

  /* For example, if the first bytes of the bitmap pertain to    */
  /* its top-most line, then the flow is 'down'.  If these bytes */
  /* pertain to its lowest line, the the flow is 'up'.           */

#define TT_Flow_Down  -1  /* bitmap is oriented from top to bottom */
#define TT_Flow_Up     1  /* bitmap is oriented from bottom to top */
#define TT_Flow_Error  0  /* an error occurred during rendering    */


  /* A structure used to describe the target bitmap or pixmap to the   */
  /* renderer.  Note that there is nothing in this structure that      */
  /* gives the nature of the buffer.                                   */

  /* IMPORTANT NOTE:                                                   */
  /*                                                                   */
  /*   In the case of a pixmap, the 'width' and 'cols' fields must     */
  /*   have the _same_ values, and _must_ be padded to 32-bits, i.e.,  */
  /*   be a multiple of 4.  Clipping problems will arise otherwise,    */
  /*   if not even page faults!                                        */
  /*                                                                   */
  /*   The typical settings are:                                       */
  /*                                                                   */
  /*   - for an WxH bitmap:                                            */
  /*                                                                   */
  /*       rows  = H                                                   */
  /*       cols  = (W+7)/8                                             */
  /*       width = W                                                   */
  /*       flow  = your_choice                                         */
  /*                                                                   */
  /*   - for an WxH pixmap:                                            */
  /*                                                                   */
  /*       rows  = H                                                   */
  /*       cols  = (W+3) & ~3                                          */
  /*       width = cols                                                */
  /*       flow  = your_choice                                         */

  struct  TT_Raster_Map_
  {
    int    rows;    /* number of rows                    */
    int    cols;    /* number of columns (bytes) per row */
    int    width;   /* number of pixels per line         */
    int    flow;    /* bitmap orientation                */

    void*  bitmap;  /* bit/pixmap buffer                 */
    long   size;    /* bit/pixmap size in bytes          */
  };

  typedef struct TT_Raster_Map_  TT_Raster_Map;


/* The following tables are also defined in "drivers/ttlib/ttobjs.h" */
/* We use the _TRUETYPE_ macro to prevent their redefinition when    */
/* _compiling_ the backwards-compatible layer called "oldapi.c"      */
/*                                                                   */
#ifndef _TRUETYPE_

  /* ------- The font header TrueType table structure ----- */

  struct  TT_Header_
  {
    TT_Fixed   Table_Version;
    TT_Fixed   Font_Revision;

    TT_Long    CheckSum_Adjust;
    TT_Long    Magic_Number;

    TT_UShort  Flags;
    TT_UShort  Units_Per_EM;

    TT_Long    Created [2];
    TT_Long    Modified[2];

    TT_FWord   xMin;
    TT_FWord   yMin;
    TT_FWord   xMax;
    TT_FWord   yMax;

    TT_UShort  Mac_Style;
    TT_UShort  Lowest_Rec_PPEM;

    TT_Short   Font_Direction;
    TT_Short   Index_To_Loc_Format;
    TT_Short   Glyph_Data_Format;
  };

  typedef struct TT_Header_  TT_Header;


  /* ------- The horizontal header TrueType table structure ----- */

  /*******************************************************/
  /*  This structure is the one defined by the TrueType  */
  /*  specification, plus two fields used to link the    */
  /*  font-units metrics to the header.                  */

  struct  TT_Horizontal_Header_
  {
    TT_Fixed   Version;
    TT_FWord   Ascender;
    TT_FWord   Descender;
    TT_FWord   Line_Gap;

    TT_UFWord  advance_Width_Max;      /* advance width maximum */

    TT_FWord   min_Left_Side_Bearing;  /* minimum left-sb       */
    TT_FWord   min_Right_Side_Bearing; /* minimum right-sb      */
    TT_FWord   xMax_Extent;            /* xmax extents          */
    TT_FWord   caret_Slope_Rise;
    TT_FWord   caret_Slope_Run;

    TT_Short   caret_Offset;           /* only used in vertical header */
    TT_Short   Reserved[4];

    TT_Short   metric_Data_Format;
    TT_UShort  number_Of_HMetrics;

    /* The following fields are not defined by the TrueType specification */
    /* but they're used to connect the metrics header to the relevant     */
    /* "HMTX" or "VMTX" table.                                            */

    void*      long_metrics;
    void*      short_metrics;
  };


  /*******************************************************/
  /*  This structure is the one defined by the TrueType  */
  /*  specification.  Note that it has exactly the same  */
  /*  layout as the horizontal header (both are loaded   */
  /*  by the same function).                             */

  struct  TT_Vertical_Header_
  {
    TT_Fixed   Version;
    TT_FWord   Ascender;
    TT_FWord   Descender;
    TT_FWord   Line_Gap;

    TT_UFWord  advance_Height_Max;      /* advance height maximum */

    TT_FWord   min_Top_Side_Bearing;    /* minimum left-sb or top-sb       */
    TT_FWord   min_Bottom_Side_Bearing; /* minimum right-sb or bottom-sb   */
    TT_FWord   yMax_Extent;             /* xmax or ymax extents            */
    TT_FWord   caret_Slope_Rise;
    TT_FWord   caret_Slope_Run;
    TT_FWord   caret_Offset;

    TT_Short   Reserved[4];

    TT_Short   metric_Data_Format;
    TT_UShort  number_Of_VMetrics;

    /* The following fields are not defined by the TrueType specification */
    /* but they're used to connect the metrics header to the relevant     */
    /* "HMTX" or "VMTX" table.                                            */

    void*      long_metrics;
    void*      short_metrics;
  };


  typedef struct TT_Horizontal_Header_  TT_Horizontal_Header;
  typedef struct TT_Vertical_Header_    TT_Vertical_Header;


  /* ----------- OS/2 Table ----------------------------- */

  struct  TT_OS2_
  {
    TT_UShort  version;                /* 0x0001 */
    TT_FWord   xAvgCharWidth;
    TT_UShort  usWeightClass;
    TT_UShort  usWidthClass;
    TT_Short   fsType;
    TT_FWord   ySubscriptXSize;
    TT_FWord   ySubscriptYSize;
    TT_FWord   ySubscriptXOffset;
    TT_FWord   ySubscriptYOffset;
    TT_FWord   ySuperscriptXSize;
    TT_FWord   ySuperscriptYSize;
    TT_FWord   ySuperscriptXOffset;
    TT_FWord   ySuperscriptYOffset;
    TT_FWord   yStrikeoutSize;
    TT_FWord   yStrikeoutPosition;
    TT_Short   sFamilyClass;

    TT_Byte    panose[10];

    TT_ULong   ulUnicodeRange1;        /* Bits 0-31   */
    TT_ULong   ulUnicodeRange2;        /* Bits 32-63  */
    TT_ULong   ulUnicodeRange3;        /* Bits 64-95  */
    TT_ULong   ulUnicodeRange4;        /* Bits 96-127 */

    TT_Char    achVendID[4];

    TT_UShort  fsSelection;
    TT_UShort  usFirstCharIndex;
    TT_UShort  usLastCharIndex;
    TT_Short   sTypoAscender;
    TT_Short   sTypoDescender;
    TT_Short   sTypoLineGap;
    TT_UShort  usWinAscent;
    TT_UShort  usWinDescent;

    /* only version 1 tables: */

    TT_ULong   ulCodePageRange1;       /* Bits 0-31   */
    TT_ULong   ulCodePageRange2;       /* Bits 32-63  */
  };

  typedef struct TT_OS2_  TT_OS2;


  /* ----------- Postscript table ------------------------ */

  struct  TT_Postscript_
  {
    TT_Fixed  FormatType;
    TT_Fixed  italicAngle;
    TT_FWord  underlinePosition;
    TT_FWord  underlineThickness;
    TT_ULong  isFixedPitch;
    TT_ULong  minMemType42;
    TT_ULong  maxMemType42;
    TT_ULong  minMemType1;
    TT_ULong  maxMemType1;

    /* Glyph names follow in the file, but we don't         */
    /* load them by default.  See the ftxpost.c extension.  */
  };

  typedef struct TT_Postscript_  TT_Postscript;


  /* ------------ horizontal device metrics "hdmx" ---------- */

  struct  TT_Hdmx_Record_
  {
    TT_Byte   ppem;
    TT_Byte   max_width;
    TT_Byte*  widths;
  };

  typedef struct TT_Hdmx_Record_  TT_Hdmx_Record;


  struct  TT_Hdmx_
  {
    TT_UShort        version;
    TT_Short         num_records;
    TT_Hdmx_Record*  records;
  };

  typedef struct TT_Hdmx_  TT_Hdmx;


#else

  typedef  TT_HoriHeader   TT_Horizontal_Header;
  typedef  TT_VertHeader   TT_Vertical_Header;

#endif /* _TRUETYPE_ */


  /* A structure used to describe face properties.                        */
  /* be aware that this is not the same structure as the one define       */
  /* in "freetype/ttlib/ttdriver.h". A suitable conversion is performed   */
  /* in "oldapi/ttapi.c" to build a binary driver that is backwards       */
  /* compatible with FreeType 1.1, in the function TT_Get_Face_Properties */

  struct  TT_Face_Properties_
  {
    TT_UShort  num_Glyphs;      /* number of glyphs in face              */
    TT_UShort  max_Points;      /* maximum number of points in a glyph   */
    TT_UShort  max_Contours;    /* maximum number of contours in a glyph */

    TT_UShort  num_CharMaps;    /* number of charmaps in the face     */
    TT_UShort  num_Names;       /* number of name records in the face */

    TT_ULong   num_Faces;  /* 1 for normal TrueType files, and the  */
                           /* number of embedded faces for TrueType */
                           /* collections                           */

    TT_Header*             header;        /* TrueType header table          */
    TT_Horizontal_Header*  horizontal;    /* TrueType horizontal header     */
    TT_OS2*                os2;           /* TrueType OS/2 table            */
    TT_Postscript*         postscript;    /* TrueType Postscript table      */
    TT_Hdmx*               hdmx;
    TT_Vertical_Header*    vertical;      /* TT Vertical header, if present */
  };

  typedef struct TT_Face_Properties_  TT_Face_Properties;


  /***********************************************************************/
  /*                                                                     */
  /* <Type> TT_Engine                                                    */
  /*                                                                     */
  /* <Description>                                                       */
  /*    A handle to a TrueType driver/engine instance. Engine objects    */
  /*    can be created with the TT_New_Engine and TT_Build_Engine APIs   */
  /*                                                                     */
  /*    TT_Done_Engine will destroy an engine, as well as all the        */
  /*    objects that were created within it.                             */
  /*                                                                     */

  typedef struct TT_EngineRec_   *TT_Engine;

  /* Note : The type TT_Engine is not defined in "drivers/ttlib/ttobjs.h" */


/* The TT_Face type is already defined in "drivers/ttlib/ttobjs.h"   */
/* We use the _TRUETYPE_ macro to prevent their redefinition when    */
/* _compiling_ the backwards-compatible layer called "oldapi.c"      */
/*                                                                   */
#ifndef _TRUETYPE_

  /***********************************************************************/
  /*                                                                     */
  /* <Type> TT_Face                                                      */
  /*                                                                     */
  /* <Description>                                                       */
  /*    A handle to a TrueType face/font object. A TT_Face encapsulates  */
  /*    the resolution and scaling independent parts of a TrueType font  */
  /*    file. Instances (a.k.a. fontsizes) and glyph objects must be     */
  /*    created from them before a glyph can be loaded in memory.        */
  /*                                                                     */
  /*    They are created through TT_New_Face and destroyed with          */
  /*    TT_Done_Face. This will destroy all instance and glyph objects   */
  /*                                                                     */

  typedef struct TT_FaceRec_*   TT_Face;

#endif  /* _TRUETYPE_ */


  /***********************************************************************/
  /*                                                                     */
  /* <Type> TT_Instance                                                  */
  /*                                                                     */
  /* <Description>                                                       */
  /*    A handle to a TrueType instance/fontsize object. A TT_Instance   */
  /*    encapsulates all the resolution and scaling dependent part of    */
  /*    a given font size, but doesn't contain any glyph. They must be   */
  /*    used with glyph objects in order to load glyph objects from      */
  /*    a TT file.                                                       */
  /*                                                                     */
  /*    They are created from face objects with TT_New_Instance, and     */
  /*    destroyed with TT_Done_Instance                                  */
  /*                                                                     */
  /*    A fresh new instance has a default resolution of 96x96 dpi,      */
  /*    and a default point size of 10 pt. Each of these can be changed  */
  /*    dynamically with various APIs defined below..                    */
  /*                                                                     */

  typedef struct TT_InstanceRec_*  TT_Instance;

  /* Note: The TT_Instance type is not defined in "drivers/ttlib/ttobjs.h" */


  /***********************************************************************/
  /*                                                                     */
  /* <Type> TT_Glyph                                                     */
  /*                                                                     */
  /* <Description>                                                       */
  /*    A handle to a TrueType glyph object. A glyph object acts as a    */
  /*    container for any of the glyphs of a given face object. It       */
  /*    encapsulates glyph metrics as well as outline space sized large  */
  /*    enough to allow the loading of any glyph without further         */
  /*    allocation. A glyph object doesn't contain any bitmap or         */
  /*    pixmap data/buffer.                                              */
  /*                                                                     */
  /*    They are created from face objects with TT_New_Glyph, and        */
  /*    destroyed with TT_Done_Glyph                                     */
  /*                                                                     */
  /*    One can create several glyph objects per face, and use           */
  /*    a single instance to load multiple glyphs, even concurrently     */
  /*    in thread-safe and reentrant modes..                             */
  /*                                                                     */

  typedef struct TT_GlyphRec_*    TT_Glyph;

  /* Note: the TT_Glyph type is not defined in "drivers/ttlib/ttobjs.h" */


/* The TT_CharMap type is already defined in "drivers/ttlib/ttobjs.h" */
/* We use the _TRUETYPE_ macro to prevent their redefinition when     */
/* _compiling_ the backwards-compatible layer called "oldapi.c"       */
/*                                                                    */
#ifndef _TRUETYPE_

  /***********************************************************************/
  /*                                                                     */
  /* <Type> TT_CharMap                                                   */
  /*                                                                     */
  /* <Description>                                                       */
  /*    A handle to a TrueType character mapping object. These objects   */
  /*    are used to convert character codes in a specific locale or      */
  /*    encoding into font/face glyph indexes.                           */
  /*                                                                     */
  /*    The list of character maps found within a face can be            */
  /*    enumerated with API functions defined below. An CharMap object   */
  /*    is created with TT_New_CharMap. They are destroyed automatically */
  /*    when their parent face objects are discarded.                    */
  /*                                                                     */

  typedef struct TT_CharMapRec_*   TT_CharMap;

  typedef long  TT_Error;

#endif /* _TRUETYPE_ */


  EXPORT_DEF
  const TT_Instance   TT_Null_Instance;


  /*******************************************************************/
  /*                                                                 */
  /*  Postscript Names extension                                     */
  /*                                                                 */
  /*******************************************************************/

#define TT_Err_Invalid_Post_Table_Format  0x0B00
#define TT_Err_Invalid_Post_Table         0x0B01

  /* Initialise the Postscript Names extension */
  EXPORT_DEF
  TT_Error TT_Init_Post_Extension( TT_Engine  engine );

  /* Load the Postscript Names table - notice that the 'post' parameter */
  /* will be ignored in 2.0.                                            */
  EXPORT_DEF
  TT_Error TT_Load_PS_Names( TT_Face   face,
                             void*     post );

  /* Gets the postscript name of a single glyph */
  EXPORT_DEF
  TT_Error TT_Get_PS_Name( TT_Face      face,
                           TT_UShort    index,
                           TT_String**  PSname );


  /*******************************************************************/
  /*                                                                 */
  /*  Embedded Bitmaps (sbits) extension                             */
  /*                                                                 */
  /*******************************************************************/

#ifndef _TRUETYPE_
  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Metrics                                  */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used to hold the big metrics of a given    */
  /*    glyph bitmap in a TrueType or OpenType font. These     */
  /*    are usually found in the "EBDT" table.                 */
  /*                                                           */
  /* <Fields>                                                  */
  /*    height       :: glyph height in pixels                 */
  /*    width        :: glyph width in pixels                  */
  /*                                                           */
  /*    horiBearingX :: horizontal left bearing                */
  /*    horiBearingY :: horizontal top bearing                 */
  /*    horiAdvance  :: horizontal advance                     */
  /*                                                           */
  /*    vertBearingX :: vertical left bearing                  */
  /*    vertBearingY :: vertical top bearing                   */
  /*    vertAdvance  :: vertical advance                       */
  /*                                                           */
  typedef struct TT_SBit_Metrics_
  {
    TT_Byte  height;
    TT_Byte  width;

    TT_Char  horiBearingX;
    TT_Char  horiBearingY;
    TT_Byte  horiAdvance;

    TT_Char  vertBearingX;
    TT_Char  vertBearingY;
    TT_Byte  vertAdvance;

  } TT_SBit_Metrics;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Small_Metrics                            */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used to hold the small metrics of a given  */
  /*    glyph bitmap in a TrueType or OpenType font. These     */
  /*    are usually found in the "EBDT" table.                 */
  /*                                                           */
  /* <Fields>                                                  */
  /*    height    :: glyph height in pixels                    */
  /*    width     :: glyph width in pixels                     */
  /*                                                           */
  /*    bearingX  :: left-side bearing                         */
  /*    bearingY  :: top-side bearing                          */
  /*    advance   :: advance width or height                   */
  /*                                                           */
  typedef struct TT_SBit_Small_Metrics_
  {
    TT_Byte  height;
    TT_Byte  width;

    TT_Char  bearingX;
    TT_Char  bearingY;
    TT_Byte  advance;

  } TT_SBit_Small_Metrics;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Line_Metrics                             */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used to describe the text line metrics of  */
  /*    a given bitmap strike, for either an horizontal or     */
  /*    vertical layout.                                       */
  /*                                                           */
  /* <Fields>                                                  */
  /*    ascender  :: ascender in pixels                        */
  /*    descender :: descender in pixels                       */
  /*    max_width :: maximum glyph width in pixels             */
  /*                                                           */
  /*    caret_slope_enumerator  :: ?                           */
  /*    caret_slope_denominator :: ?                           */
  /*    caret_offset            :: ?                           */
  /*                                                           */
  /*    min_origin_SB  :: ?                                    */
  /*    min_advance_SB :: ?                                    */
  /*    max_before_BL  :: ?                                    */
  /*    min_after_BL   :: ?                                    */
  /*                                                           */
  typedef struct TT_SBit_Line_Metrics_
  {
    TT_Char  ascender;
    TT_Char  descender;
    TT_Byte  max_width;
    TT_Char  caret_slope_numerator;
    TT_Char  caret_slope_denominator;
    TT_Char  caret_offset;
    TT_Char  min_origin_SB;
    TT_Char  min_advance_SB;
    TT_Char  max_before_BL;
    TT_Char  min_after_BL;
    TT_Char  pads[2];

  } TT_SBit_Line_Metrics;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Range                                    */
  /*                                                           */
  /* <Description>                                             */
  /*    A TrueType/OpenType subIndexTable as defined in the    */
  /*    "EBLC" or "bloc" tables.                               */
  /*                                                           */
  /* <Fields>                                                  */
  /*                                                           */
  /*    first_glyph  :: first glyph index in range             */
  /*    last_glyph   :: last glyph index in range              */
  /*                                                           */
  /*    index_format :: format of index table. valid           */
  /*                    values are 1 to 5.                     */
  /*                                                           */
  /*    image_format :: format of 'EBDT' image data            */
  /*    image_offset :: offset to image data in 'EBDT'         */
  /*                                                           */
  /*    image_size   :: for index formats 2 and 5. This is     */
  /*                    the size in bytes of each glyph bitmap */
  /*                    glyph bitmap                           */
  /*                                                           */
  /*    big_metrics  :: for index formats 2 and 5. This is     */
  /*                    the big metrics for each glyph bitmap  */
  /*                                                           */
  /*    num_glyphs   :: for index formats 4 and 5. This is     */
  /*                    the number of glyphs in the code       */
  /*                    array.                                 */
  /*                                                           */
  /*    glyph_offsets :: for index formats 1 and 3.            */
  /*    glyph_codes   :: for index formats 4 and 5.            */
  /*                                                           */
  /*    table_offset  :: offset of index table in 'EBLC' table */
  /*                     only used during strike loading..     */
  /*                                                           */
  typedef struct TT_SBit_Range
  {
    TT_UShort        first_glyph;
    TT_UShort        last_glyph;

    TT_UShort        index_format;
    TT_UShort        image_format;
    TT_ULong         image_offset;

    TT_ULong         image_size;
    TT_SBit_Metrics  metrics;
    TT_ULong         num_glyphs;

    TT_ULong*        glyph_offsets;
    TT_UShort*       glyph_codes;

    TT_ULong         table_offset;

  } TT_SBit_Range;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Strike                                   */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used describe a given bitmap strike in the */
  /*    "EBLC" or "bloc" tables.                               */
  /*                                                           */
  /* <Fields>                                                  */
  /*                                                           */
  /*   num_index_ranges  :: number of index ranges             */
  /*   index_ranges      :: array of glyph index ranges        */
  /*                                                           */
  /*   color_ref   :: unused. color reference ??               */
  /*   hori        :: line metrics for horizontal layouts.     */
  /*   vert        :: line metrics for vertical layouts.       */
  /*                                                           */
  /*   start_glyph :: lowest glyph index for this strike.      */
  /*   end_glyph   :: higher glyph index for this strike.      */
  /*                                                           */
  /*   x_ppem      :: horizontal pixels per EM                 */
  /*   y_ppem      :: vertical pixels per EM                   */
  /*   bit_depth   :: bit depth. valid values are 1, 2, 4 & 8  */
  /*   flags       :: vertical or horizontal ?                 */
  /*                                                           */
  typedef struct TT_SBit_Strike_
  {
    TT_Int                 num_ranges;
    TT_SBit_Range*         sbit_ranges;
    TT_ULong               ranges_offset;

    TT_ULong               color_ref;

    TT_SBit_Line_Metrics   hori;
    TT_SBit_Line_Metrics   vert;

    TT_UShort              start_glyph;
    TT_UShort              end_glyph;

    TT_Byte                x_ppem;
    TT_Byte                y_ppem;
    TT_Byte                bit_depth;
    TT_Char                flags;

  } TT_SBit_Strike;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Component                                */
  /*                                                           */
  /* <Description>                                             */
  /*    A simple structure to describe a compound sbit element */
  /*                                                           */
  /* <Fields>                                                  */
  /*    glyph_code  :: element's glyph index                   */
  /*    x_offset    :: element's left bearing                  */
  /*    y_offset    :: element's top bearing                   */
  /*                                                           */
  typedef struct TT_SBit_Component_
  {
    TT_UShort  glyph_code;
    TT_Char    x_offset;
    TT_Char    y_offset;

  } TT_SBit_Component;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Scale                                    */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used describe a given bitmap scaling       */
  /*    table, asdefined for the "EBSC" table.                 */
  /*                                                           */
  /* <Fields>                                                  */
  /*                                                           */
  /*    hori   :: horizontal line metrics                      */
  /*    vert   :: vertical line metrics                        */
  /*                                                           */
  /*    x_ppem :: horizontal pixels per EM                     */
  /*    y_ppem :: vertical pixels per EM                       */
  /*                                                           */
  /*    x_ppem_substitute  :: substitution x_ppem              */
  /*    y_ppem_substitute  :: substitution y_ppem              */
  /*                                                           */
  typedef struct TT_SBit_Scale_
  {
    TT_SBit_Line_Metrics  hori;
    TT_SBit_Line_Metrics  vert;
    TT_Byte               x_ppem;
    TT_Byte               y_ppem;
    TT_Byte               x_ppem_substitute;
    TT_Byte               y_ppem_substitute;

  } TT_SBit_Scale;
#endif /* _TRUETYPE_ */


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_SBit_Image                                    */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used to describe a given embedded bitmap   */
  /*    image.                                                 */
  /*                                                           */
  /* <Fields>                                                  */
  /*    map        :: bitmap descriptor                        */
  /*    bit_depth  :: pixel bit depth                          */
  /*    metrics    :: glyph metrics for the bitmap             */
  /*                                                           */
  typedef struct TT_SBit_Image_
  {
    TT_Raster_Map         map;
    int                   bit_depth;
    TT_Big_Glyph_Metrics  metrics;

  } TT_SBit_Image;


  /*************************************************************/
  /*                                                           */
  /* <Struct> TT_EBLC                                          */
  /*                                                           */
  /* <Description>                                             */
  /*    A structure used to describe the "EBLC" table from     */
  /*    a TrueTYpe font.                                       */
  /*                                                           */
  /* <Fields>                                                  */
  /*                                                           */
  /*    version     :: version number of the EBLC table        */
  /*                                                           */
  /*    num_strikes :: the number of strikes, i.e. bitmap      */
  /*                   sizes, present in this font             */
  /*                                                           */
  /*    strikes     :: array of strikes                        */
  /*                                                           */
  typedef struct TT_EBLC_
  {
    TT_ULong         version;
    TT_ULong         num_strikes;
    TT_SBit_Strike*  strikes;

  } TT_EBLC;


  /*************************************************************/
  /*                                                           */
  /* <Function>                                                */
  /*    TT_Init_SBit_Extension                                 */
  /*                                                           */
  /* <Description>                                             */
  /*    Initialise the embedded bitmaps extension for the      */
  /*    FreeType engine.                                       */
  /*                                                           */
  /* <Input>                                                   */
  /*    engine  :: handle to current FreeType library instance */
  /*                                                           */
  /* <Return>                                                  */
  /*    Error code. 0 means success.                           */
  /*                                                           */
  EXPORT_DEF
  TT_Error  TT_Init_SBit_Extension( TT_Engine  engine );


  /*************************************************************/
  /*                                                           */
  /* <Function>                                                */
  /*    TT_Get_Face_Bitmaps                                    */
  /*                                                           */
  /* <Description>                                             */
  /*    Loads the "EBLC" table from a font file, if any.       */
  /*                                                           */
  /* <Input>                                                   */
  /*    face :: handle to the source TrueType font/face        */
  /*                                                           */
  /* <Output>                                                  */
  /*    eblc_table :: a descriptor for the EBLC table          */
  /*                                                           */
  /* <Return>                                                  */
  /*    Error code. 0 means success.                           */
  /*                                                           */
  /* <Note>                                                    */
  /*    This function returns TT_Err_Table_Missing when the    */
  /*    font contains no embedded bitmaps. All fields in       */
  /*    "eblc_table" will then be set to 0.                    */
  /*                                                           */
  EXPORT_DEF
  TT_Error  TT_Get_Face_Bitmaps( TT_Face   face,
                                 TT_EBLC  *eblc_table );

  /*************************************************************/
  /*                                                           */
  /* <Function>                                                */
  /*    TT_New_SBit_Image                                      */
  /*                                                           */
  /* <Description>                                             */
  /*    Allocates a new embedded bitmap container              */
  /*                                                           */
  /* <Output>                                                  */
  /*    image :: sbit image                                    */
  /*                                                           */
  /* <Return>                                                  */
  /*    Error code. 0 means success.                           */
  /*                                                           */
  EXPORT_DEF
  TT_Error  TT_New_SBit_Image( TT_SBit_Image*  *image );


  /*************************************************************/
  /*                                                           */
  /* <Function>                                                */
  /*    TT_Done_SBit_Image                                     */
  /*                                                           */
  /* <Description>                                             */
  /*    Releases an embedded bitmap container                  */
  /*                                                           */
  /* <Input>                                                   */
  /*    image :: sbit image                                    */
  /*                                                           */
  EXPORT_DEF
  void      TT_Done_SBit_Image( TT_SBit_Image*  image );


  /*************************************************************/
  /*                                                           */
  /* <Function>                                                */
  /*    TT_Load_Glyph_Bitmap                                   */
  /*                                                           */
  /* <Description>                                             */
  /*    Loads a given glyph embedded bitmap                    */
  /*                                                           */
  /* <Input>                                                   */
  /*    face        :: handle to the source TrueType font/face */
  /*    instance    :: current size/transform instance         */
  /*    glyph_index :: index of source glyph                   */
  /*    bitmap      :: target embedded bitmap descriptor       */
  /*                                                           */
  /* <Return>                                                  */
  /*    Error code. 0 means success.                           */
  /*                                                           */
  /* <Note>                                                    */
  /*    This function returns an error if there is no          */
  /*    embedded bitmap for the glyph at the given             */
  /*    instance.                                              */
  /*                                                           */
  EXPORT_DEF
  TT_Error  TT_Load_Glyph_Bitmap( TT_Face         face,
                                  TT_Instance     instance,
                                  TT_UShort       glyph_index,
                                  TT_SBit_Image*  bitmap );


  /*******************************************************************/
  /*                                                                 */
  /*  FreeType API                                                   */
  /*                                                                 */
  /*  All these begin with a 'TT_' prefix.                           */
  /*                                                                 */
  /*  Most of them are implemented in the 'ttapi.c' source file.     */
  /*                                                                 */
  /*******************************************************************/

  /* Initialize the engine. */

  EXPORT_DEF
  TT_Error  TT_Init_FreeType( TT_Engine*  engine );


  /* Finalize the engine, and release all allocated objects. */

  EXPORT_DEF
  TT_Error  TT_Done_FreeType( TT_Engine  engine );


  /* Set the gray level palette.  This is an array of 5 bytes used */
  /* to produce the font smoothed pixmaps.  By convention:         */
  /*                                                               */
  /*  palette[0] = background (white)                              */
  /*  palette[1] = light                                           */
  /*  palette[2] = medium                                          */
  /*  palette[3] = dark                                            */
  /*  palette[4] = foreground (black)                              */
  /*                                                               */

  EXPORT_DEF
  TT_Error  TT_Set_Raster_Gray_Palette( TT_Engine       engine,
                                        const TT_Byte*  palette );


  /* ----------------------- face management ----------------------- */

  /* Open a new TrueType font file, and returns a handle for */
  /* it in variable '*face'.                                 */

  /* Note: The file can be either a TrueType file (*.ttf) or  */
  /*       a TrueType collection (*.ttc, in this case, only   */
  /*       the first face is opened).  The number of faces in */
  /*       the same collection can be obtained in the face's  */
  /*       properties, using TT_Get_Face_Properties() and the */
  /*       'max_Faces' field.                                 */

  EXPORT_DEF
  TT_Error  TT_Open_Face( TT_Engine       engine,
                          const TT_Text*  fontPathName,
                          TT_Face*        face );


  /* Open a TrueType font file located inside a collection. */
  /* The font is assigned by its index in 'fontIndex'.      */

  EXPORT_DEF
  TT_Error  TT_Open_Collection( TT_Engine       engine,
                                const TT_Text*  collectionPathName,
                                TT_ULong        fontIndex,
                                TT_Face*        face );


  /* Return face properties in the 'properties' structure. */

  EXPORT_DEF
  TT_Error  TT_Get_Face_Properties( TT_Face              face,
                                    TT_Face_Properties*  properties );


  /* Set a face object's generic pointer */

  EXPORT_DEF
  TT_Error  TT_Set_Face_Pointer( TT_Face  face,
                                 void*    data );


  /* Get a face object's generic pointer */

  EXPORT_DEF
  void*     TT_Get_Face_Pointer( TT_Face  face );


  /* Close a face's file handle to save system resources.  The file */
  /* will be re-opened automatically on the next disk access.       */

  EXPORT_DEF
  TT_Error  TT_Flush_Face( TT_Face  face );

  /* Get a face's glyph metrics expressed in font units.  Returns any   */
  /* number of arrays.  Set the fields to NULL if you're not interested */
  /* by a given array.                                                  */

  EXPORT_DEF
  TT_Error  TT_Get_Face_Metrics( TT_Face     face,
                                 TT_UShort   firstGlyph,
                                 TT_UShort   lastGlyph,
                                 TT_Short*   leftBearings,
                                 TT_UShort*  widths,
                                 TT_Short*   topBearings,
                                 TT_UShort*  heights );

  /* Close a given font object, destroying all associated */
  /* instances.                                           */

  EXPORT_DEF
  TT_Error  TT_Close_Face( TT_Face  face );


  /* Get font or table data. */

  EXPORT_DEF
  TT_Error  TT_Get_Font_Data( TT_Face   face,
                              TT_ULong  tag,
                              TT_Long   offset,
                              void*     buffer,
                              TT_Long*  length );


/* A simple macro to build table tags from ASCII chars */

#define MAKE_TT_TAG( _x1, _x2, _x3, _x4 ) \
          (((TT_ULong)_x1 << 24) |        \
           ((TT_ULong)_x2 << 16) |        \
           ((TT_ULong)_x3 << 8)  |        \
            (TT_ULong)_x4)


  /* ----------------------- instance management -------------------- */

  /* Open a new font instance and returns an instance handle */
  /* for it in '*instance'.                                  */

  EXPORT_DEF
  TT_Error  TT_New_Instance( TT_Face       face,
                             TT_Instance*  instance );


  /* Set device resolution for a given instance.  The values are      */
  /* given in dpi (Dots Per Inch).  Default is 96 in both directions. */

  EXPORT_DEF
  TT_Error  TT_Set_Instance_Resolutions( TT_Instance  instance,
                                         TT_UShort    xResolution,
                                         TT_UShort    yResolution );


  /* Set the pointsize for a given instance.  Default is 10pt. */

  EXPORT_DEF
  TT_Error  TT_Set_Instance_CharSize( TT_Instance  instance,
                                      TT_F26Dot6   charSize );

  EXPORT_DEF
  TT_Error  TT_Set_Instance_CharSizes( TT_Instance  instance,
                                       TT_F26Dot6   charWidth,
                                       TT_F26Dot6   charHeight );

#define TT_Set_Instance_PointSize( ins, ptsize )   \
            TT_Set_Instance_CharSize( ins, ptsize*64 )

  EXPORT_DEF
  TT_Error  TT_Set_Instance_PixelSizes( TT_Instance  instance,
                                        TT_UShort    pixelWidth,
                                        TT_UShort    pixelHeight,
                                        TT_F26Dot6   pointSize );


  /* This function has been deprecated !! Do not use it, as it    */
  /* doesn't work reliably. You can perfectly control hinting     */
  /* yourself when loading glyphs, then apply transforms as usual */

  EXPORT_DEF
  TT_Error  TT_Set_Instance_Transform_Flags( TT_Instance  instance,
                                             TT_Bool      rotated,
                                             TT_Bool      stretched );


  /* Return instance metrics in 'metrics'. */

  EXPORT_DEF
  TT_Error  TT_Get_Instance_Metrics( TT_Instance           instance,
                                     TT_Instance_Metrics*  metrics );


  /* Set an instance's generic pointer. */

  EXPORT_DEF
  TT_Error  TT_Set_Instance_Pointer( TT_Instance  instance,
                                     void*        data );


  /* Get an instance's generic pointer. */

  EXPORT_DEF
  void*     TT_Get_Instance_Pointer( TT_Instance  instance );


  /* Close a given instance object, destroying all associated data. */

  EXPORT_DEF
  TT_Error  TT_Done_Instance( TT_Instance  instance );


  /* ----------------------- glyph management ----------------------- */

  /* Create a new glyph object related to the given 'face'. */

  EXPORT_DEF
  TT_Error  TT_New_Glyph( TT_Face    face,
                          TT_Glyph*  glyph );


  /* Discard (and destroy) a given glyph object. */

  EXPORT_DEF
  TT_Error  TT_Done_Glyph( TT_Glyph  glyph );


#define TTLOAD_SCALE_GLYPH  1
#define TTLOAD_HINT_GLYPH   2

#define TTLOAD_DEFAULT  (TTLOAD_SCALE_GLYPH | TTLOAD_HINT_GLYPH)


  /* Load and process (scale/transform and hint) a glyph from the */
  /* given 'instance'.  The glyph and instance handles must be    */
  /* related to the same face object.  The glyph index can be     */
  /* computed with a call to TT_Char_Index().                     */

  /* The 'load_flags' argument is a combination of the macros     */
  /* TTLOAD_SCALE_GLYPH and TTLOAD_HINT_GLYPH.  Hinting will be   */
  /* applied only if the scaling is selected.                     */

  /* When scaling is off (i.e., load_flags = 0), the returned     */
  /* outlines are in EM square coordinates (also called FUnits),  */
  /* extracted directly from the font with no hinting.            */
  /* Other glyph metrics are also in FUnits.                      */

  /* When scaling is on, the returned outlines are in fractional  */
  /* pixel units (i.e. TT_F26Dot6 = 26.6 fixed floats).           */

  /* NOTE:  The glyph index must be in the range 0..num_glyphs-1  */
  /*        where 'num_glyphs' is the total number of glyphs in   */
  /*        the font file (given in the face properties).         */

  EXPORT_DEF
  TT_Error  TT_Load_Glyph( TT_Instance  instance,
                           TT_Glyph     glyph,
                           TT_UShort    glyphIndex,
                           TT_UShort    loadFlags );


  /* Return glyph outline pointers in 'outline'.  Note that the returned */
  /* pointers are owned by the glyph object, and will be destroyed with  */
  /* it.  The client application should _not_ change the pointers.       */

  EXPORT_DEF
  TT_Error  TT_Get_Glyph_Outline( TT_Glyph     glyph,
                                  TT_Outline*  outline );


  /* Copy the glyph metrics into 'metrics'. */

  EXPORT_DEF
  TT_Error  TT_Get_Glyph_Metrics( TT_Glyph           glyph,
                                  TT_Glyph_Metrics*  metrics );


  /* Copy the glyph's big metrics into 'metrics'. */
  /* Necessary to obtain vertical metrics.        */

  EXPORT_DEF
  TT_Error  TT_Get_Glyph_Big_Metrics( TT_Glyph               glyph,
                                      TT_Big_Glyph_Metrics*  metrics );


  /* Render the glyph into a bitmap, with given position offsets.     */

  /*  Note:  Only use integer pixel offsets to preserve the fine      */
  /*         hinting of the glyph and the 'correct' anti-aliasing     */
  /*         (where vertical and horizontal stems aren't grayed).     */
  /*         This means that xOffset and yOffset must be multiples    */
  /*         of 64!                                                   */

  EXPORT_DEF
  TT_Error  TT_Get_Glyph_Bitmap( TT_Glyph        glyph,
                                 TT_Raster_Map*  map,
                                 TT_F26Dot6      xOffset,
                                 TT_F26Dot6      yOffset );


  /* Render the glyph into a pixmap, with given position offsets.     */

  /*  Note : Only use integer pixel offsets to preserve the fine      */
  /*         hinting of the glyph and the 'correct' anti-aliasing     */
  /*         (where vertical and horizontal stems aren't grayed).     */
  /*         This means that xOffset and yOffset must be multiples    */
  /*         of 64!                                                   */

  EXPORT_DEF
  TT_Error  TT_Get_Glyph_Pixmap( TT_Glyph        glyph,
                                 TT_Raster_Map*  map,
                                 TT_F26Dot6      xOffset,
                                 TT_F26Dot6      yOffset );


  /* ----------------------- outline support ------------------------ */

  /* Allocate a new outline.  Reserve space for 'numPoints' and */
  /* 'numContours'.                                             */

  EXPORT_DEF
  TT_Error  TT_New_Outline( TT_UShort    numPoints,
                            TT_Short     numContours,
                            TT_Outline*  outline );


  /* Release an outline. */

  EXPORT_DEF
  TT_Error  TT_Done_Outline( TT_Outline*  outline );


  /* Copy an outline into another one. */

  EXPORT_DEF
  TT_Error  TT_Copy_Outline( TT_Outline*  source,
                             TT_Outline*  target );


  /* Render an outline into a bitmap. */

  EXPORT_DEF
  TT_Error  TT_Get_Outline_Bitmap( TT_Engine       engine,
                                   TT_Outline*     outline,
                                   TT_Raster_Map*  map );


  /* Render an outline into a pixmap -- note that this function uses */
  /* a different pixel scale, where 1.0 pixels = 128           XXXX  */

  EXPORT_DEF
  TT_Error  TT_Get_Outline_Pixmap( TT_Engine       engine,
                                   TT_Outline*     outline,
                                   TT_Raster_Map*  map );


  /* Return an outline's bounding box -- this function is slow as it */
  /* performs a complete scan-line process, without drawing, to get  */
  /* the most accurate values.                                 XXXX  */

  EXPORT_DEF
  TT_Error  TT_Get_Outline_BBox( TT_Outline*  outline,
                                 TT_BBox*     bbox );


  /* Apply a transformation to a glyph outline. */

  EXPORT_DEF
  void      TT_Transform_Outline( TT_Outline*  outline,
                                  TT_Matrix*   matrix );


  /* Apply a translation to a glyph outline. */

  EXPORT_DEF
  void      TT_Translate_Outline( TT_Outline*  outline,
                                  TT_F26Dot6   xOffset,
                                  TT_F26Dot6   yOffset );


  /* Apply a transformation to a vector. */

  EXPORT_DEF
  void      TT_Transform_Vector( TT_F26Dot6*  x,
                                 TT_F26Dot6*  y,
                                 TT_Matrix*   matrix );


  /* Multiply a matrix with another -- computes "b := a*b". */

  EXPORT_DEF
  void      TT_Matrix_Multiply( TT_Matrix*  a,
                                TT_Matrix*  b );


  /* Invert a transformation matrix. */

  EXPORT_DEF
  TT_Error  TT_Matrix_Invert( TT_Matrix*  matrix );


  /* Compute A*B/C with 64 bits intermediate precision. */

  EXPORT_DEF
  TT_Long   TT_MulDiv( TT_Long A, TT_Long B, TT_Long C );


  /* Compute A*B/0x10000 with 64 bits intermediate precision. */
  /* Useful to multiply by a 16.16 fixed float value.         */

  EXPORT_DEF
  TT_Long   TT_MulFix( TT_Long A, TT_Long B );


  /* ----------------- character mappings support ------------- */

  /* Return the number of character mappings found in this file. */
  /* Returns -1 in case of failure (invalid face handle).        */
  /*                                                             */
  /* DON'T USE THIS FUNCTION! IT HAS BEEN DEPRECATED!            */
  /*                                                             */
  /* It is retained for backwards compatibility only and will    */
  /* fail on 16bit systems.                                      */
  /*                                                             */
  /* You can now get the charmap count in the "num_CharMaps"     */
  /* field of a face's properties.                               */
  /*                                                             */

  EXPORT_DEF
  int  TT_Get_CharMap_Count( TT_Face  face );


  /* Return the ID of charmap number 'charmapIndex' of a given face */
  /* used to enumerate the charmaps present in a TrueType file.     */

  EXPORT_DEF
  TT_Error  TT_Get_CharMap_ID( TT_Face     face,
                               TT_UShort   charmapIndex,
                               TT_UShort*  platformID,
                               TT_UShort*  encodingID );


  /* Look up the character maps found in 'face' and return a handle */
  /* for the one matching 'platformID' and 'platformEncodingID'     */
  /* (see the TrueType specs relating to the 'cmap' table for       */
  /* information on these ID numbers).  Returns an error code.      */
  /* In case of failure, the handle is set to NULL and is invalid.  */

  EXPORT_DEF
  TT_Error  TT_Get_CharMap( TT_Face      face,
                            TT_UShort    charmapIndex,
                            TT_CharMap*  charMap );


  /* Translate a character code through a given character map   */
  /* and return the corresponding glyph index to be used in     */
  /* a TT_Load_Glyph call.  This function returns 0 in case of  */
  /* failure.                                                   */

  EXPORT_DEF
  TT_UShort  TT_Char_Index( TT_CharMap  charMap,
                            TT_UShort   charCode );


  /* --------------------- names table support ------------------- */

  /* Return the number of name strings found in the name table.  */
  /* Returns -1 in case of failure (invalid face handle).        */
  /*                                                             */
  /* DON'T USE THIS FUNCTION! IT HAS BEEN DEPRECATED!            */
  /*                                                             */
  /* It is retained for backwards compatibility only and will    */
  /* fail on 16bit systems.                                      */
  /*                                                             */
  /* You can now get the number of name strings in a face with   */
  /* the "num_Names" field of its properties..                   */
  /*                                                             */

  EXPORT_DEF
  int  TT_Get_Name_Count( TT_Face  face );


  /* Return the ID of the name number 'nameIndex' of a given face */
  /* used to enumerate the charmaps present in a TrueType file.   */

  EXPORT_DEF
  TT_Error  TT_Get_Name_ID( TT_Face     face,
                            TT_UShort   nameIndex,
                            TT_UShort*  platformID,
                            TT_UShort*  encodingID,
                            TT_UShort*  languageID,
                            TT_UShort*  nameID );


  /* Return the address and length of the name number 'nameIndex' */
  /* of a given face.  The string is part of the face object and  */
  /* shouldn't be written to or released.                         */

  /* Note that if for an invalid platformID a null pointer will   */
  /* be returned.                                                 */

  EXPORT_DEF
  TT_Error  TT_Get_Name_String( TT_Face      face,
                                TT_UShort    nameIndex,
                                TT_String**  stringPtr, /* pointer address */
                                TT_UShort*   length );  /* string length
                                                           address */


#ifdef __cplusplus
  }
#endif

#endif /* TRUETYPE_H */


/* END */