1148 lines
43 KiB
C
1148 lines
43 KiB
C
|
/*******************************************************************
|
||
|
*
|
||
|
* freetype.h
|
||
|
*
|
||
|
* High-level interface specification.
|
||
|
*
|
||
|
* Copyright 1996-1999 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 FREETYPE_H
|
||
|
#define FREETYPE_H
|
||
|
|
||
|
|
||
|
#define TT_FREETYPE_MAJOR 1
|
||
|
#define TT_FREETYPE_MINOR 3
|
||
|
|
||
|
|
||
|
#include "fterrid.h"
|
||
|
#include "ftnameid.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
|
||
|
|
||
|
|
||
|
/*******************************************************************/
|
||
|
/* */
|
||
|
/* FreeType types definitions. */
|
||
|
/* */
|
||
|
/* All these begin with a 'TT_' prefix. */
|
||
|
/* */
|
||
|
/*******************************************************************/
|
||
|
|
||
|
typedef int 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 int TT_Int;
|
||
|
typedef unsigned int TT_UInt;
|
||
|
typedef signed long TT_Long;
|
||
|
typedef unsigned long TT_ULong;
|
||
|
|
||
|
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 if */
|
||
|
/* 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 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 If 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 If 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 is */
|
||
|
/* 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 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;
|
||
|
|
||
|
|
||
|
/* 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' field is the advance width for horizontal layout, */
|
||
|
/* and advance height for vertical layouts. */
|
||
|
|
||
|
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) */
|
||
|
};
|
||
|
|
||
|
typedef struct TT_Glyph_Metrics_ TT_Glyph_Metrics;
|
||
|
|
||
|
|
||
|
/* 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 TT_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_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 a WxH bitmap: */
|
||
|
/* */
|
||
|
/* rows = H */
|
||
|
/* cols = (W+7) / 8 */
|
||
|
/* width = W */
|
||
|
/* flow = your_choice */
|
||
|
/* */
|
||
|
/* - for a 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 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 Reserved0,
|
||
|
Reserved1,
|
||
|
Reserved2,
|
||
|
Reserved3,
|
||
|
Reserved4;
|
||
|
|
||
|
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;
|
||
|
};
|
||
|
|
||
|
typedef struct TT_Horizontal_Header_ TT_Horizontal_Header;
|
||
|
|
||
|
|
||
|
/*******************************************************/
|
||
|
/* 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 Reserved1,
|
||
|
Reserved2,
|
||
|
Reserved3,
|
||
|
Reserved4;
|
||
|
|
||
|
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_Vertical_Header_ TT_Vertical_Header;
|
||
|
|
||
|
|
||
|
/* ------ The OS/2 table ------ */
|
||
|
|
||
|
/************************************************************************/
|
||
|
/* Note that since FreeType 1.3, we support Mac fonts which do not have */
|
||
|
/* an OS/2 table. In this case the `version' field will be set to */
|
||
|
/* 0xFFFF by the table loader; all other fields should be 0. */
|
||
|
|
||
|
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;
|
||
|
|
||
|
|
||
|
/* ------ The 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;
|
||
|
|
||
|
|
||
|
/* ------ The horizontal device metrics table (`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;
|
||
|
|
||
|
|
||
|
/* A structure used to describe 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; /* TrueType hor. dev. metr. table */
|
||
|
TT_Vertical_Header* vertical; /* TT Vertical header, if present */
|
||
|
};
|
||
|
|
||
|
typedef struct TT_Face_Properties_ TT_Face_Properties;
|
||
|
|
||
|
|
||
|
/* Here are the definitions of the handle types used for FreeType's */
|
||
|
/* most common objects accessed by the client application. We use */
|
||
|
/* a simple trick: */
|
||
|
/* */
|
||
|
/* Each handle type is a structure that only contains one */
|
||
|
/* pointer. The advantage of structures is that they are */
|
||
|
/* mutually exclusive types. We could have defined the */
|
||
|
/* following types: */
|
||
|
/* */
|
||
|
/* typedef void* TT_Stream; */
|
||
|
/* typedef void* TT_Face; */
|
||
|
/* typedef void* TT_Instance; */
|
||
|
/* typedef void* TT_Glyph; */
|
||
|
/* typedef void* TT_CharMap; */
|
||
|
/* */
|
||
|
/* but these would have allowed lines like: */
|
||
|
/* */
|
||
|
/* stream = instance; */
|
||
|
/* */
|
||
|
/* in the client code this would be a severe bug, unnoticed */
|
||
|
/* by the compiler! */
|
||
|
/* */
|
||
|
/* Thus, we enforce type checking with a simple language */
|
||
|
/* trick... */
|
||
|
/* */
|
||
|
/* NOTE: Some macros are defined in tttypes.h to perform */
|
||
|
/* automatic type conversions for library hackers... */
|
||
|
|
||
|
struct TT_Engine_ { void* z; };
|
||
|
struct TT_Stream_ { void* z; };
|
||
|
struct TT_Face_ { void* z; };
|
||
|
struct TT_Instance_ { void* z; };
|
||
|
struct TT_Glyph_ { void* z; };
|
||
|
struct TT_CharMap_ { void* z; };
|
||
|
|
||
|
typedef struct TT_Engine_ TT_Engine; /* engine instance */
|
||
|
typedef struct TT_Stream_ TT_Stream; /* stream handle type */
|
||
|
typedef struct TT_Face_ TT_Face; /* face handle type */
|
||
|
typedef struct TT_Instance_ TT_Instance; /* instance handle type */
|
||
|
typedef struct TT_Glyph_ TT_Glyph; /* glyph handle type */
|
||
|
typedef struct TT_CharMap_ TT_CharMap; /* character map handle type */
|
||
|
|
||
|
|
||
|
/* Almost all functions return an error code of this type. */
|
||
|
|
||
|
typedef long TT_Error;
|
||
|
|
||
|
|
||
|
/*******************************************************************/
|
||
|
/* */
|
||
|
/* FreeType API */
|
||
|
/* */
|
||
|
/* All these begin with a `TT_' prefix. */
|
||
|
/* */
|
||
|
/* Most of them are implemented in the `ttapi.c' source file. */
|
||
|
/* */
|
||
|
/*******************************************************************/
|
||
|
|
||
|
/* Get version information. */
|
||
|
|
||
|
EXPORT_DEF
|
||
|
TT_Error TT_FreeType_Version( int *major,
|
||
|
int *minor );
|
||
|
|
||
|
|
||
|
/* 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,
|
||
|
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. */
|
||
|
/* */
|
||
|
/* Note that since version 1.3, we support font files with no */
|
||
|
/* OS/2 table (mainly old Mac fonts). In this case, the OS/2 */
|
||
|
/* `version' field will be set to 0xFFFF, and all other fields */
|
||
|
/* will be zeroed. */
|
||
|
|
||
|
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 are 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*64L )
|
||
|
|
||
|
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_PEDANTIC 128
|
||
|
#define TTLOAD_IGNORE_GLOBAL_ADVANCE_WIDTH 256
|
||
|
|
||
|
#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. */
|
||
|
/* */
|
||
|
/* If 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. */
|
||
|
/* */
|
||
|
/* If 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. */
|
||
|
|
||
|
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. */
|
||
|
|
||
|
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 );
|
||
|
|
||
|
|
||
|
/* 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 mapping 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 in the variables `stringPtr' resp. `length'. */
|
||
|
/* The string is part of the face object and shouldn't be */
|
||
|
/* written to or released. */
|
||
|
/* */
|
||
|
/* Note that for an invalid platform ID a null pointer will be */
|
||
|
/* returned. */
|
||
|
|
||
|
EXPORT_DEF
|
||
|
TT_Error TT_Get_Name_String( TT_Face face,
|
||
|
TT_UShort nameIndex,
|
||
|
TT_String** stringPtr,
|
||
|
TT_UShort* length );
|
||
|
|
||
|
|
||
|
#ifdef __cplusplus
|
||
|
}
|
||
|
#endif
|
||
|
|
||
|
#endif /* FREETYPE_H */
|
||
|
|
||
|
|
||
|
/* END */
|