ref: e0bba32291f5ca7b3fc7be4c1277d7a8f406daea
dir: /src/oldapi/truetype.h/
/******************************************************************* * * 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 */