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