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_Int16;

A typedef for a 16bit signed integer type.

  typedef unsigned short  FT_UInt16;

A typedef for a 16bit unsigned integer type.

  typedef signed XXX  FT_Int32;

A typedef for a 32bit signed integer type. The size depends on the configuration.

  typedef unsigned XXX  FT_UInt32;

  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. As usual, values 1 and 0 represent true and false, respectively.

  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 32-bit 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 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.

The bounding box is specified with the coordinates of the lower left and the upper right corner. In PostScript, those values are often called (llx,lly) and (urx,ury), respectively.

If ‘yMin’ is negative, this value gives the glyph's descender. Otherwise, the glyph doesn't descend below the baseline. Similarly, if ‘ymax’ is positive, this value gives the glyph's ascender.

‘xMin’ gives the horizontal distance from the glyph's origin to the left edge of the glyph's bounding box. If ‘xMin’ is negative, the glyph extends to the left of the origin.

  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_palette_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 16-bit compilers don't like 32-bit 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 deprecated 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);

Describe 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.

Some 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_Tag)                        \
          ( ( (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 32-bit integers. Don't redefine this macro.