typedef unsigned char  FT_Byte;

A simple typedef for the unsigned char type.

  typedef const FT_Byte*  FT_Bytes;

A typedef for constant memory areas.

  typedef signed char  FT_Char;

A simple typedef for the signed char type.

  typedef signed int  FT_Int;

A typedef for the int type.

  typedef unsigned int  FT_UInt;

A typedef for the unsigned int type.

  typedef signed short  FT_Short;

A typedef for signed short.

  typedef unsigned short  FT_UShort;

A typedef for unsigned short.

  typedef signed long  FT_Long;

A typedef for signed long.

  typedef unsigned long  FT_ULong;

A typedef for unsigned long.

  typedef unsigned char  FT_Bool;

A typedef of unsigned char, used for simple booleans.

  typedef size_t  FT_Offset;

This is equivalent to the ANSI C ‘size_t’ type, i.e., the largest unsigned integer type used to express a file size or position, or a memory block size.

  typedef ft_ptrdiff_t  FT_PtrDist;

This is equivalent to the ANSI C ‘ptrdiff_t’ type, i.e., the largest signed integer type used to express the distance between two pointers.

  typedef char  FT_String;

A simple typedef for the char type, usually used for strings.

  typedef FT_UInt32  FT_Tag;

A typedef for 32bit tags (as used in the SFNT format).

  typedef int  FT_Error;

The FreeType error code type. A value of 0 is always interpreted as a successful operation.

  typedef signed long  FT_Fixed;

This type is used to store 16.16 fixed float values, like scaling values or matrix coefficients.

  typedef void*  FT_Pointer;

A simple typedef for a typeless pointer.

  typedef signed long  FT_Pos;

The type FT_Pos is a 32-bit integer used to store vectorial coordinates. Depending on the context, these can represent distances in integer font units, or 16,16, or 26.6 fixed float pixel coordinates.

  typedef struct  FT_Vector_
  {
    FT_Pos  x;
    FT_Pos  y;

  } FT_Vector;

A simple structure used to store a 2D vector; coordinates are of the FT_Pos type.

  typedef struct  FT_BBox_
  {
    FT_Pos  xMin, yMin;
    FT_Pos  xMax, yMax;

  } FT_BBox;

A structure used to hold an outline's bounding box, i.e., the coordinates of its extrema in the horizontal and vertical directions.

  typedef struct  FT_Matrix_
  {
    FT_Fixed  xx, xy;
    FT_Fixed  yx, yy;

  } FT_Matrix;

A simple structure used to store a 2x2 matrix. Coefficients are in 16.16 fixed float format. The computation performed is:

   x' = x*xx + y*xy                                             
   y' = x*yx + y*yy                                             

  typedef signed short  FT_FWord;   /* distance in FUnits */

A signed 16-bit integer used to store a distance in original font units.

  typedef unsigned short  FT_UFWord;  /* unsigned distance */

An unsigned 16-bit integer used to store a distance in original font units.

  typedef signed short  FT_F2Dot14;

A signed 2.14 fixed float type used for unit vectors.

  typedef struct  FT_UnitVector_
  {
    FT_F2Dot14  x;
    FT_F2Dot14  y;

  } FT_UnitVector;

A simple structure used to store a 2D vector unit vector. Uses FT_F2Dot14 types.

  typedef signed long  FT_F26Dot6;

A signed 26.6 fixed float type used for vectorial pixel coordinates.

  typedef enum  FT_Pixel_Mode_
  {
    FT_PIXEL_MODE_NONE = 0,
    FT_PIXEL_MODE_MONO,
    FT_PIXEL_MODE_GRAY,
    FT_PIXEL_MODE_GRAY2,
    FT_PIXEL_MODE_GRAY4,
    FT_PIXEL_MODE_LCD,
    FT_PIXEL_MODE_LCD_V,

    FT_PIXEL_MODE_MAX      /* do not remove */

  } FT_Pixel_Mode;

An enumeration type used to describe the format of pixels in a given bitmap. Note that additional formats may be added in the future.

#define ft_pixel_mode_none   FT_PIXEL_MODE_NONE
#define ft_pixel_mode_mono   FT_PIXEL_MODE_MONO
#define ft_pixel_mode_grays  FT_PIXEL_MODE_GRAY
#define ft_pixel_mode_pal2   FT_PIXEL_MODE_GRAY2
#define ft_pixel_mode_pal4   FT_PIXEL_MODE_GRAY4

A list of deprecated constants. Use the corresponding FT_Pixel_Mode values instead.

  typedef enum  FT_Palette_Mode_
  {
    ft_palette_mode_rgb = 0,
    ft_palette_mode_rgba,

    ft_palettte_mode_max   /* do not remove */

  } FT_Palette_Mode;

THIS TYPE IS DEPRECATED. DO NOT USE IT!

An enumeration type to describe the format of a bitmap palette, used with ft_pixel_mode_pal4 and ft_pixel_mode_pal8.

As ft_pixel_mode_pal2, pal4 and pal8 are currently unused by FreeType, these types are not handled by the library itself.

  typedef struct  FT_Bitmap_
  {
    int             rows;
    int             width;
    int             pitch;
    unsigned char*  buffer;
    short           num_grays;
    char            pixel_mode;
    char            palette_mode;
    void*           palette;

  } FT_Bitmap;

A structure used to describe a bitmap or pixmap to the raster. Note that we now manage pixmaps of various depths through the ‘pixel_mode’ field.

For now, the only pixel modes supported by FreeType are mono and grays. However, drivers might be added in the future to support more ‘colorful’ options.

#ifndef FT_IMAGE_TAG
#define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  \
          value = ( ( (unsigned long)_x1 << 24 ) | \
                    ( (unsigned long)_x2 << 16 ) | \
                    ( (unsigned long)_x3 << 8  ) | \
                      (unsigned long)_x4         )
#endif /* FT_IMAGE_TAG */

This macro converts four-letter tags to an unsigned long type.

Since many 16bit compilers don't like 32bit enumerations, you should redefine this macro in case of problems to something like this:

  #define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 )  value         

to get a simple enumeration without assigning special numbers.

  typedef enum  FT_Glyph_Format_
  {
    FT_IMAGE_TAG( FT_GLYPH_FORMAT_NONE, 0, 0, 0, 0 ),

    FT_IMAGE_TAG( FT_GLYPH_FORMAT_COMPOSITE, 'c', 'o', 'm', 'p' ),
    FT_IMAGE_TAG( FT_GLYPH_FORMAT_BITMAP,    'b', 'i', 't', 's' ),
    FT_IMAGE_TAG( FT_GLYPH_FORMAT_OUTLINE,   'o', 'u', 't', 'l' ),
    FT_IMAGE_TAG( FT_GLYPH_FORMAT_PLOTTER,   'p', 'l', 'o', 't' )

  } FT_Glyph_Format;

An enumeration type used to describe the format of a given glyph image. Note that this version of FreeType only supports two image formats, even though future font drivers will be able to register their own format.

#define ft_glyph_format_none       FT_GLYPH_FORMAT_NONE
#define ft_glyph_format_composite  FT_GLYPH_FORMAT_COMPOSITE
#define ft_glyph_format_bitmap     FT_GLYPH_FORMAT_BITMAP
#define ft_glyph_format_outline    FT_GLYPH_FORMAT_OUTLINE
#define ft_glyph_format_plotter    FT_GLYPH_FORMAT_PLOTTER

A list of decprecated constants. Use the corresponding FT_Glyph_Format values instead.

  typedef struct  FT_Data_
  {
    const FT_Byte*  pointer;
    FT_Int          length;

  } FT_Data;

Read-only binary data represented as a pointer and a length.

  typedef void  (*FT_Generic_Finalizer)(void*  object);

Describes a function used to destroy the ‘client’ data of any FreeType object. See the description of the FT_Generic type for details of usage.

The address of the FreeType object which is under finalization. Its client data is accessed through its ‘generic’ field.

  typedef struct  FT_Generic_
  {
    void*                 data;
    FT_Generic_Finalizer  finalizer;

  } FT_Generic;

Client applications often need to associate their own data to a variety of FreeType core objects. For example, a text layout API might want to associate a glyph cache to a given size object.

Most FreeType object contains a ‘generic’ field, of type FT_Generic, which usage is left to client applications and font servers.

It can be used to store a pointer to client-specific data, as well as the address of a ‘finalizer’ function, which will be called by FreeType when the object is destroyed (for example, the previous client example would put the address of the glyph cache destructor in the ‘finalizer’ field).

#define FT_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
          ( ( (FT_ULong)_x1 << 24 ) |     \
            ( (FT_ULong)_x2 << 16 ) |     \
            ( (FT_ULong)_x3 <<  8 ) |     \
              (FT_ULong)_x4         )

This macro converts four-letter tags which are used to label TrueType tables into an unsigned long to be used within FreeType.

The produced values must be 32bit integers. Don't redefine this macro.