http://www.ousob.com --- Legacy Redefined OuSob - File: /wwwroot/clipx/usr/include/freetype/freetype.h

/******************************************************************* * * freetype.h * * High-level interface specification. * * Copyright 1996-1999 by * David Turner, Robert Wilhelm, and Werner Lemberg. * * This file is part of the FreeType project and may only be used, * modified, and distributed under the terms of the FreeType project * license, LICENSE.TXT. By continuing to use, modify, or distribute * this file you indicate that you have read the license and * understand and accept it fully. * * Note: * * This is the only file that should be included by client * application sources. All other types and functions defined * in the `tt*.h' files are library internals and should not be * included. * ******************************************************************/ #ifndef FREETYPE_H #define FREETYPE_H #define TT_FREETYPE_MAJOR 1 #define TT_FREETYPE_MINOR 3 #include "fterrid.h" #include "ftnameid.h" /* To make freetype.h independent from configuration files we check */ /* whether EXPORT_DEF has been defined already. */ #ifndef EXPORT_DEF #define EXPORT_DEF extern #endif /* The same for TT_Text. If you define the HAVE_TT_TEXT macro, you */ /* have to provide a typedef declaration for TT_Text before */ /* including this file. */ #ifndef HAVE_TT_TEXT #define HAVE_TT_TEXT typedef char TT_Text; /* The data type to represent */ /* file name string elements. */ #endif #ifdef __cplusplus extern "C" { #endif /*******************************************************************/ /* */ /* FreeType types definitions. */ /* */ /* All these begin with a 'TT_' prefix. */ /* */ /*******************************************************************/ typedef int TT_Bool; typedef signed long TT_Fixed; /* signed fixed 16.16 float */ typedef signed short TT_FWord; /* distance in FUnits */ typedef unsigned short TT_UFWord; /* unsigned distance */ typedef char TT_String; typedef signed char TT_Char; typedef unsigned char TT_Byte; typedef signed short TT_Short; typedef unsigned short TT_UShort; typedef int TT_Int; typedef unsigned int TT_UInt; typedef signed long TT_Long; typedef unsigned long TT_ULong; typedef signed short TT_F2Dot14; /* Signed fixed float 2.14 used for */ /* unit vectors, with layout */ /* */ /* s : 1 -- sign bit */ /* m : 1 -- integer bit */ /* f : 14 -- unsigned fractional */ /* */ /* `s:m' is the 2-bit signed int */ /* value to which the positive */ /* fractional part should be added. */ typedef signed long TT_F26Dot6; /* 26.6 fixed float, used for */ /* glyph points pixel coordinates. */ typedef signed long TT_Pos; /* Point position, expressed either */ /* in fractional pixels or notional */ /* units, depending on context. */ /* For example, glyph coordinates */ /* returned by TT_Load_Glyph() are */ /* expressed in font units if */ /* scaling wasn't requested, and */ /* in 26.6 fractional pixels if it */ /* was. */ struct TT_UnitVector_ /* guess what... */ { TT_F2Dot14 x; TT_F2Dot14 y; }; typedef struct TT_UnitVector_ TT_UnitVector; struct TT_Vector_ /* simple vector type */ { TT_F26Dot6 x; TT_F26Dot6 y; }; typedef struct TT_Vector_ TT_Vector; /* A simple 2x2 matrix used for transformations. */ /* You should use 16.16 fixed floats. */ /* */ /* x' = xx*x + xy*y */ /* y' = yx*x + yy*y */ /* */ struct TT_Matrix_ { TT_Fixed xx, xy; TT_Fixed yx, yy; }; typedef struct TT_Matrix_ TT_Matrix; /* A structure used to describe the source glyph to the renderer. */ struct TT_Outline_ { TT_Short n_contours; /* number of contours in glyph */ TT_UShort n_points; /* number of points in the glyph */ TT_Vector* points; /* the outline's points */ TT_Byte* flags; /* the points flags */ TT_UShort* contours; /* the contour end points */ /* The following flag indicates that the outline owns the arrays it */ /* refers to. Typically, this is true of outlines created from the */ /* TT_New_Outline() API, while it isn't for those returned by */ /* TT_Get_Glyph_Outline(). */ TT_Bool owner; /* The outline owns the coordinates, */ /* flags and contours array it uses. */ /* The following flags are set automatically by */ /* TT_Get_Glyph_Outline(). Their meaning is the following: */ /* */ /* high_precision If true, the scan-line converter will use a */ /* higher precision to render bitmaps (i.e., a */ /* 1/1024 pixel precision). This is important for */ /* small ppem sizes. */ /* */ /* second_pass If true, the scan-line converter performs a */ /* second sweep phase dedicated to find vertical */ /* drop-outs. If false, only horizontal drop-outs */ /* will be checked during the first vertical */ /* sweep (yes, this is a bit confusing but it is */ /* really the way it should work). This is */ /* important for small ppems too. */ /* */ /* dropout_mode Specifies the TrueType drop-out mode to use for */ /* continuity checking. Valid values are 0 (no */ /* check), 1, 2, 4, and 5. */ /* */ /* Most of the engine's users will safely ignore these fields... */ TT_Bool high_precision; /* high precision rendering */ TT_Bool second_pass; /* two sweeps rendering */ TT_Char dropout_mode; /* dropout mode */ }; typedef struct TT_Outline_ TT_Outline; /* A structure used to describe a simple bounding box. */ struct TT_BBox_ { TT_Pos xMin; TT_Pos yMin; TT_Pos xMax; TT_Pos yMax; }; typedef struct TT_BBox_ TT_BBox; /* A structure used to return glyph metrics. */ /* */ /* The `bearingX' isn't called `left-side bearing' anymore because */ /* it has different meanings depending on the glyph's orientation. */ /* */ /* The same is true for `bearingY', which is the top-side bearing */ /* defined by the TT_Spec, i.e., the distance from the baseline to */ /* the top of the glyph's bbox. According to our current convention, */ /* this is always the same as `bbox.yMax' but we make it appear for */ /* consistency in its proper field. */ /* */ /* The `advance' field is the advance width for horizontal layout, */ /* and advance height for vertical layouts. */ struct TT_Glyph_Metrics_ { TT_BBox bbox; /* glyph bounding box */ TT_Pos bearingX; /* left-side bearing */ TT_Pos bearingY; /* top-side bearing, per se the TT spec */ TT_Pos advance; /* advance width (or height) */ }; typedef struct TT_Glyph_Metrics_ TT_Glyph_Metrics; /* A structure used to return horizontal _and_ vertical glyph */ /* metrics. */ /* */ /* A glyph can be used either in a horizontal or vertical layout. */ /* Its glyph metrics vary with orientation. The TT_Big_Glyph_Metrics */ /* structure is used to return _all_ metrics in one call. */ struct TT_Big_Glyph_Metrics_ { TT_BBox bbox; /* glyph bounding box */ TT_Pos horiBearingX; /* left side bearing in horizontal layouts */ TT_Pos horiBearingY; /* top side bearing in horizontal layouts */ TT_Pos vertBearingX; /* left side bearing in vertical layouts */ TT_Pos vertBearingY; /* top side bearing in vertical layouts */ TT_Pos horiAdvance; /* advance width for horizontal layout */ TT_Pos vertAdvance; /* advance height for vertical layout */ /* The following fields represent unhinted scaled metrics values. */ /* They can be useful for applications needing to do some device */ /* independent placement of glyphs. */ /* */ /* Applying these metrics to hinted glyphs will most surely ruin */ /* the grid fitting performed by the bytecode interpreter. These */ /* values are better used to compute accumulated positioning */ /* distances. */ TT_Pos linearHoriBearingX; /* linearly scaled horizontal lsb */ TT_Pos linearHoriAdvance; /* linearly scaled horizontal advance */ TT_Pos linearVertBearingY; /* linearly scaled vertical tsb */ TT_Pos linearVertAdvance; /* linearly scaled vertical advance */ }; typedef struct TT_Big_Glyph_Metrics_ TT_Big_Glyph_Metrics; /* A structure used to return instance metrics. */ struct TT_Instance_Metrics_ { TT_F26Dot6 pointSize; /* char. size in points (1pt = 1/72 inch) */ TT_UShort x_ppem; /* horizontal pixels per EM square */ TT_UShort y_ppem; /* vertical pixels per EM square */ TT_Fixed x_scale; /* 16.16 to convert from EM units to 26.6 pix */ TT_Fixed y_scale; /* 16.16 to convert from EM units to 26.6 pix */ TT_UShort x_resolution; /* device horizontal resolution in dpi */ TT_UShort y_resolution; /* device vertical resolution in dpi */ }; typedef struct TT_Instance_Metrics_ TT_Instance_Metrics; /* Flow constants: */ /* */ /* The flow of a bitmap refers to the way lines are oriented */ /* within the bitmap data, i.e., the orientation of the Y */ /* coordinate axis. */ /* */ /* For example, if the first bytes of the bitmap pertain to */ /* its top-most line, then the flow is `down'. If these bytes */ /* pertain to its lowest line, the the flow is `up'. */ #define TT_Flow_Down -1 /* bitmap is oriented from top to bottom */ #define TT_Flow_Up 1 /* bitmap is oriented from bottom to top */ #define TT_Flow_Error 0 /* an error occurred during rendering */ /* A structure used to describe the target bitmap or pixmap to the */ /* renderer. Note that there is nothing in this structure that */ /* gives the nature of the buffer. */ /* */ /* IMPORTANT NOTE: */ /* */ /* In the case of a pixmap, the `width' and `cols' fields must */ /* have the _same_ values, and _must_ be padded to 32-bits, i.e., */ /* be a multiple of 4. Clipping problems will arise otherwise, */ /* if not even page faults! */ /* */ /* The typical settings are: */ /* */ /* - for a WxH bitmap: */ /* */ /* rows = H */ /* cols = (W+7) / 8 */ /* width = W */ /* flow = your_choice */ /* */ /* - for a WxH pixmap: */ /* */ /* rows = H */ /* cols = (W+3) & ~3 */ /* width = cols */ /* flow = your_choice */ struct TT_Raster_Map_ { int rows; /* number of rows */ int cols; /* number of columns (bytes) per row */ int width; /* number of pixels per line */ int flow; /* bitmap orientation */ void* bitmap; /* bit/pixmap buffer */ long size; /* bit/pixmap size in bytes */ }; typedef struct TT_Raster_Map_ TT_Raster_Map; /* ------ The font header TrueType table structure ------ */ struct TT_Header_ { TT_Fixed Table_Version; TT_Fixed Font_Revision; TT_Long CheckSum_Adjust; TT_Long Magic_Number; TT_UShort Flags; TT_UShort Units_Per_EM; TT_Long Created [2]; TT_Long Modified[2]; TT_FWord xMin; TT_FWord yMin; TT_FWord xMax; TT_FWord yMax; TT_UShort Mac_Style; TT_UShort Lowest_Rec_PPEM; TT_Short Font_Direction; TT_Short Index_To_Loc_Format; TT_Short Glyph_Data_Format; }; typedef struct TT_Header_ TT_Header; /* ------ The horizontal header TrueType table structure ------ */ /*******************************************************/ /* This structure is the one defined by the TrueType */ /* specification, plus two fields used to link the */ /* font-units metrics to the header. */ struct TT_Horizontal_Header_ { TT_Fixed Version; TT_FWord Ascender; TT_FWord Descender; TT_FWord Line_Gap; TT_UFWord advance_Width_Max; /* advance width maximum */ TT_FWord min_Left_Side_Bearing; /* minimum left-sb */ TT_FWord min_Right_Side_Bearing; /* minimum right-sb */ TT_FWord xMax_Extent; /* xmax extents */ TT_FWord caret_Slope_Rise; TT_FWord caret_Slope_Run; TT_Short Reserved0, Reserved1, Reserved2, Reserved3, Reserved4; TT_Short metric_Data_Format; TT_UShort number_Of_HMetrics; /* The following fields are not defined by the TrueType specification */ /* but they're used to connect the metrics header to the relevant */ /* `HMTX' or `VMTX' table. */ void* long_metrics; void* short_metrics; }; typedef struct TT_Horizontal_Header_ TT_Horizontal_Header; /*******************************************************/ /* This structure is the one defined by the TrueType */ /* specification. Note that it has exactly the same */ /* layout as the horizontal header (both are loaded */ /* by the same function). */ struct TT_Vertical_Header_ { TT_Fixed Version; TT_FWord Ascender; TT_FWord Descender; TT_FWord Line_Gap; TT_UFWord advance_Height_Max; /* advance height maximum */ TT_FWord min_Top_Side_Bearing; /* minimum left-sb or top-sb */ TT_FWord min_Bottom_Side_Bearing; /* minimum right-sb or bottom-sb */ TT_FWord yMax_Extent; /* xmax or ymax extents */ TT_FWord caret_Slope_Rise; TT_FWord caret_Slope_Run; TT_FWord caret_Offset; TT_Short Reserved1, Reserved2, Reserved3, Reserved4; TT_Short metric_Data_Format; TT_UShort number_Of_VMetrics; /* The following fields are not defined by the TrueType specification */ /* but they're used to connect the metrics header to the relevant */ /* `HMTX' or `VMTX' table. */ void* long_metrics; void* short_metrics; }; typedef struct TT_Vertical_Header_ TT_Vertical_Header; /* ------ The OS/2 table ------ */ /************************************************************************/ /* Note that since FreeType 1.3, we support Mac fonts which do not have */ /* an OS/2 table. In this case the `version' field will be set to */ /* 0xFFFF by the table loader; all other fields should be 0. */ struct TT_OS2_ { TT_UShort version; /* 0x0001 */ TT_FWord xAvgCharWidth; TT_UShort usWeightClass; TT_UShort usWidthClass; TT_Short fsType; TT_FWord ySubscriptXSize; TT_FWord ySubscriptYSize; TT_FWord ySubscriptXOffset; TT_FWord ySubscriptYOffset; TT_FWord ySuperscriptXSize; TT_FWord ySuperscriptYSize; TT_FWord ySuperscriptXOffset; TT_FWord ySuperscriptYOffset; TT_FWord yStrikeoutSize; TT_FWord yStrikeoutPosition; TT_Short sFamilyClass; TT_Byte panose[10]; TT_ULong ulUnicodeRange1; /* Bits 0-31 */ TT_ULong ulUnicodeRange2; /* Bits 32-63 */ TT_ULong ulUnicodeRange3; /* Bits 64-95 */ TT_ULong ulUnicodeRange4; /* Bits 96-127 */ TT_Char achVendID[4]; TT_UShort fsSelection; TT_UShort usFirstCharIndex; TT_UShort usLastCharIndex; TT_Short sTypoAscender; TT_Short sTypoDescender; TT_Short sTypoLineGap; TT_UShort usWinAscent; TT_UShort usWinDescent; /* only version 1 tables: */ TT_ULong ulCodePageRange1; /* Bits 0-31 */ TT_ULong ulCodePageRange2; /* Bits 32-63 */ }; typedef struct TT_OS2_ TT_OS2; /* ------ The PostScript table ------ */ struct TT_Postscript_ { TT_Fixed FormatType; TT_Fixed italicAngle; TT_FWord underlinePosition; TT_FWord underlineThickness; TT_ULong isFixedPitch; TT_ULong minMemType42; TT_ULong maxMemType42; TT_ULong minMemType1; TT_ULong maxMemType1; /* Glyph names follow in the file, but we don't */ /* load them by default. See the ftxpost.c extension. */ }; typedef struct TT_Postscript_ TT_Postscript; /* ------ The horizontal device metrics table (`hdmx') ------ */ struct TT_Hdmx_Record_ { TT_Byte ppem; TT_Byte max_width; TT_Byte* widths; }; typedef struct TT_Hdmx_Record_ TT_Hdmx_Record; struct TT_Hdmx_ { TT_UShort version; TT_Short num_records; TT_Hdmx_Record* records; }; typedef struct TT_Hdmx_ TT_Hdmx; /* A structure used to describe face properties. */ struct TT_Face_Properties_ { TT_UShort num_Glyphs; /* number of glyphs in face */ TT_UShort max_Points; /* maximum number of points in a glyph */ TT_UShort max_Contours; /* maximum number of contours in a glyph */ TT_UShort num_CharMaps; /* number of charmaps in the face */ TT_UShort num_Names; /* number of name records in the face */ TT_ULong num_Faces; /* 1 for normal TrueType files, and the */ /* number of embedded faces for TrueType */ /* collections */ TT_Header* header; /* TrueType header table */ TT_Horizontal_Header* horizontal; /* TrueType horizontal header */ TT_OS2* os2; /* TrueType OS/2 table */ TT_Postscript* postscript; /* TrueType Postscript table */ TT_Hdmx* hdmx; /* TrueType hor. dev. metr. table */ TT_Vertical_Header* vertical; /* TT Vertical header, if present */ }; typedef struct TT_Face_Properties_ TT_Face_Properties; /* Here are the definitions of the handle types used for FreeType's */ /* most common objects accessed by the client application. We use */ /* a simple trick: */ /* */ /* Each handle type is a structure that only contains one */ /* pointer. The advantage of structures is that they are */ /* mutually exclusive types. We could have defined the */ /* following types: */ /* */ /* typedef void* TT_Stream; */ /* typedef void* TT_Face; */ /* typedef void* TT_Instance; */ /* typedef void* TT_Glyph; */ /* typedef void* TT_CharMap; */ /* */ /* but these would have allowed lines like: */ /* */ /* stream = instance; */ /* */ /* in the client code this would be a severe bug, unnoticed */ /* by the compiler! */ /* */ /* Thus, we enforce type checking with a simple language */ /* trick... */ /* */ /* NOTE: Some macros are defined in tttypes.h to perform */ /* automatic type conversions for library hackers... */ struct TT_Engine_ { void* z; }; struct TT_Stream_ { void* z; }; struct TT_Face_ { void* z; }; struct TT_Instance_ { void* z; }; struct TT_Glyph_ { void* z; }; struct TT_CharMap_ { void* z; }; typedef struct TT_Engine_ TT_Engine; /* engine instance */ typedef struct TT_Stream_ TT_Stream; /* stream handle type */ typedef struct TT_Face_ TT_Face; /* face handle type */ typedef struct TT_Instance_ TT_Instance; /* instance handle type */ typedef struct TT_Glyph_ TT_Glyph; /* glyph handle type */ typedef struct TT_CharMap_ TT_CharMap; /* character map handle type */ /* Almost all functions return an error code of this type. */ typedef long TT_Error; /*******************************************************************/ /* */ /* FreeType API */ /* */ /* All these begin with a `TT_' prefix. */ /* */ /* Most of them are implemented in the `ttapi.c' source file. */ /* */ /*******************************************************************/ /* Get version information. */ EXPORT_DEF TT_Error TT_FreeType_Version( int *major, int *minor ); /* Initialize the engine. */ EXPORT_DEF TT_Error TT_Init_FreeType( TT_Engine* engine ); /* Finalize the engine, and release all allocated objects. */ EXPORT_DEF TT_Error TT_Done_FreeType( TT_Engine engine ); /* Set the gray level palette. This is an array of 5 bytes used */ /* to produce the font smoothed pixmaps. By convention: */ /* */ /* palette[0] = background (white) */ /* palette[1] = light */ /* palette[2] = medium */ /* palette[3] = dark */ /* palette[4] = foreground (black) */ /* */ EXPORT_DEF TT_Error TT_Set_Raster_Gray_Palette( TT_Engine engine, TT_Byte* palette ); /* ----------------------- face management ----------------------- */ /* Open a new TrueType font file, and returns a handle for */ /* it in variable '*face'. */ /* */ /* Note: The file can be either a TrueType file (*.ttf) or */ /* a TrueType collection (*.ttc, in this case, only */ /* the first face is opened). The number of faces in */ /* the same collection can be obtained in the face's */ /* properties, using TT_Get_Face_Properties() and the */ /* `max_Faces' field. */ EXPORT_DEF TT_Error TT_Open_Face( TT_Engine engine, const TT_Text* fontPathName, TT_Face* face ); /* Open a TrueType font file located inside a collection. */ /* The font is assigned by its index in `fontIndex'. */ EXPORT_DEF TT_Error TT_Open_Collection( TT_Engine engine, const TT_Text* collectionPathName, TT_ULong fontIndex, TT_Face* face ); /* Return face properties in the `properties' structure. */ /* */ /* Note that since version 1.3, we support font files with no */ /* OS/2 table (mainly old Mac fonts). In this case, the OS/2 */ /* `version' field will be set to 0xFFFF, and all other fields */ /* will be zeroed. */ EXPORT_DEF TT_Error TT_Get_Face_Properties( TT_Face face, TT_Face_Properties* properties ); /* Set a face object's generic pointer */ EXPORT_DEF TT_Error TT_Set_Face_Pointer( TT_Face face, void* data ); /* Get a face object's generic pointer */ EXPORT_DEF void* TT_Get_Face_Pointer( TT_Face face ); /* Close a face's file handle to save system resources. The file */ /* will be re-opened automatically on the next disk access. */ EXPORT_DEF TT_Error TT_Flush_Face( TT_Face face ); /* Get a face's glyph metrics expressed in font units. Returns any */ /* number of arrays. Set the fields to NULL if you are not interested */ /* by a given array. */ EXPORT_DEF TT_Error TT_Get_Face_Metrics( TT_Face face, TT_UShort firstGlyph, TT_UShort lastGlyph, TT_Short* leftBearings, TT_UShort* widths, TT_Short* topBearings, TT_UShort* heights ); /* Close a given font object, destroying all associated */ /* instances. */ EXPORT_DEF TT_Error TT_Close_Face( TT_Face face ); /* Get font or table data. */ EXPORT_DEF TT_Error TT_Get_Font_Data( TT_Face face, TT_ULong tag, TT_Long offset, void* buffer, TT_Long* length ); /* A simple macro to build table tags from ASCII chars */ #define MAKE_TT_TAG( _x1, _x2, _x3, _x4 ) \ (((TT_ULong)_x1 << 24) | \ ((TT_ULong)_x2 << 16) | \ ((TT_ULong)_x3 << 8) | \ (TT_ULong)_x4) /* ----------------------- instance management -------------------- */ /* Open a new font instance and returns an instance handle */ /* for it in `*instance'. */ EXPORT_DEF TT_Error TT_New_Instance( TT_Face face, TT_Instance* instance ); /* Set device resolution for a given instance. The values are */ /* given in dpi (Dots Per Inch). Default is 96 in both directions. */ EXPORT_DEF TT_Error TT_Set_Instance_Resolutions( TT_Instance instance, TT_UShort xResolution, TT_UShort yResolution ); /* Set the pointsize for a given instance. Default is 10pt. */ EXPORT_DEF TT_Error TT_Set_Instance_CharSize( TT_Instance instance, TT_F26Dot6 charSize ); EXPORT_DEF TT_Error TT_Set_Instance_CharSizes( TT_Instance instance, TT_F26Dot6 charWidth, TT_F26Dot6 charHeight ); #define TT_Set_Instance_PointSize( ins, ptsize ) \ TT_Set_Instance_CharSize( ins, ptsize*64L ) EXPORT_DEF TT_Error TT_Set_Instance_PixelSizes( TT_Instance instance, TT_UShort pixelWidth, TT_UShort pixelHeight, TT_F26Dot6 pointSize ); /* This function has been deprecated! Do not use it, as it */ /* doesn't work reliably. You can perfectly control hinting */ /* yourself when loading glyphs, then apply transforms as usual. */ EXPORT_DEF TT_Error TT_Set_Instance_Transform_Flags( TT_Instance instance, TT_Bool rotated, TT_Bool stretched ); /* Return instance metrics in `metrics'. */ EXPORT_DEF TT_Error TT_Get_Instance_Metrics( TT_Instance instance, TT_Instance_Metrics* metrics ); /* Set an instance's generic pointer. */ EXPORT_DEF TT_Error TT_Set_Instance_Pointer( TT_Instance instance, void* data ); /* Get an instance's generic pointer. */ EXPORT_DEF void* TT_Get_Instance_Pointer( TT_Instance instance ); /* Close a given instance object, destroying all associated data. */ EXPORT_DEF TT_Error TT_Done_Instance( TT_Instance instance ); /* ----------------------- glyph management ----------------------- */ /* Create a new glyph object related to the given `face'. */ EXPORT_DEF TT_Error TT_New_Glyph( TT_Face face, TT_Glyph* glyph ); /* Discard (and destroy) a given glyph object. */ EXPORT_DEF TT_Error TT_Done_Glyph( TT_Glyph glyph ); #define TTLOAD_SCALE_GLYPH 1 #define TTLOAD_HINT_GLYPH 2 #define TTLOAD_PEDANTIC 128 #define TTLOAD_IGNORE_GLOBAL_ADVANCE_WIDTH 256 #define TTLOAD_DEFAULT (TTLOAD_SCALE_GLYPH | TTLOAD_HINT_GLYPH) /* Load and process (scale/transform and hint) a glyph from the */ /* given `instance'. The glyph and instance handles must be */ /* related to the same face object. The glyph index can be */ /* computed with a call to TT_Char_Index(). */ /* */ /* The 'load_flags' argument is a combination of the macros */ /* TTLOAD_SCALE_GLYPH and TTLOAD_HINT_GLYPH. Hinting will be */ /* applied only if the scaling is selected. */ /* */ /* If scaling is off (i.e., load_flags = 0), the returned */ /* outlines are in EM square coordinates (also called FUnits), */ /* extracted directly from the font with no hinting. Other */ /* glyph metrics are also in FUnits. */ /* */ /* If scaling is on, the returned outlines are in fractional */ /* pixel units (i.e. TT_F26Dot6 = 26.6 fixed floats). */ /* */ /* NOTE: The glyph index must be in the range 0..num_glyphs-1, */ /* where `num_glyphs' is the total number of glyphs in */ /* the font file (given in the face properties). */ EXPORT_DEF TT_Error TT_Load_Glyph( TT_Instance instance, TT_Glyph glyph, TT_UShort glyphIndex, TT_UShort loadFlags ); /* Return glyph outline pointers in `outline'. Note that the returned */ /* pointers are owned by the glyph object, and will be destroyed with */ /* it. The client application should _not_ change the pointers. */ EXPORT_DEF TT_Error TT_Get_Glyph_Outline( TT_Glyph glyph, TT_Outline* outline ); /* Copy the glyph metrics into `metrics'. */ EXPORT_DEF TT_Error TT_Get_Glyph_Metrics( TT_Glyph glyph, TT_Glyph_Metrics* metrics ); /* Copy the glyph's big metrics into `metrics'. */ /* Necessary to obtain vertical metrics. */ EXPORT_DEF TT_Error TT_Get_Glyph_Big_Metrics( TT_Glyph glyph, TT_Big_Glyph_Metrics* metrics ); /* Render the glyph into a bitmap, with given position offsets. */ /* */ /* Note: Only use integer pixel offsets to preserve the fine */ /* hinting of the glyph and the `correct' anti-aliasing */ /* (where vertical and horizontal stems aren't grayed). This */ /* means that `xOffset' and `yOffset' must be multiples */ /* of 64! */ EXPORT_DEF TT_Error TT_Get_Glyph_Bitmap( TT_Glyph glyph, TT_Raster_Map* map, TT_F26Dot6 xOffset, TT_F26Dot6 yOffset ); /* Render the glyph into a pixmap, with given position offsets. */ /* */ /* Note: Only use integer pixel offsets to preserve the fine */ /* hinting of the glyph and the `correct' anti-aliasing */ /* (where vertical and horizontal stems aren't grayed). This */ /* means that `xOffset' and `yOffset' must be multiples */ /* of 64! */ EXPORT_DEF TT_Error TT_Get_Glyph_Pixmap( TT_Glyph glyph, TT_Raster_Map* map, TT_F26Dot6 xOffset, TT_F26Dot6 yOffset ); /* ----------------------- outline support ------------------------ */ /* Allocate a new outline. Reserve space for `numPoints' and */ /* `numContours'. */ EXPORT_DEF TT_Error TT_New_Outline( TT_UShort numPoints, TT_Short numContours, TT_Outline* outline ); /* Release an outline. */ EXPORT_DEF TT_Error TT_Done_Outline( TT_Outline* outline ); /* Copy an outline into another one. */ EXPORT_DEF TT_Error TT_Copy_Outline( TT_Outline* source, TT_Outline* target ); /* Render an outline into a bitmap. */ EXPORT_DEF TT_Error TT_Get_Outline_Bitmap( TT_Engine engine, TT_Outline* outline, TT_Raster_Map* map ); /* Render an outline into a pixmap. */ EXPORT_DEF TT_Error TT_Get_Outline_Pixmap( TT_Engine engine, TT_Outline* outline, TT_Raster_Map* map ); /* Return an outline's bounding box -- this function is slow as it */ /* performs a complete scan-line process, without drawing, to get */ /* the most accurate values. */ EXPORT_DEF TT_Error TT_Get_Outline_BBox( TT_Outline* outline, TT_BBox* bbox ); /* Apply a transformation to a glyph outline. */ EXPORT_DEF void TT_Transform_Outline( TT_Outline* outline, TT_Matrix* matrix ); /* Apply a translation to a glyph outline. */ EXPORT_DEF void TT_Translate_Outline( TT_Outline* outline, TT_F26Dot6 xOffset, TT_F26Dot6 yOffset ); /* Apply a transformation to a vector. */ EXPORT_DEF void TT_Transform_Vector( TT_F26Dot6* x, TT_F26Dot6* y, TT_Matrix* matrix ); /* Compute A*B/C with 64 bits intermediate precision. */ EXPORT_DEF TT_Long TT_MulDiv( TT_Long A, TT_Long B, TT_Long C ); /* Compute A*B/0x10000 with 64 bits intermediate precision. */ /* Useful to multiply by a 16.16 fixed float value. */ EXPORT_DEF TT_Long TT_MulFix( TT_Long A, TT_Long B ); /* ----------------- character mapping support --------------- */ /* Return the number of character mappings found in this file. */ /* Returns -1 in case of failure (invalid face handle). */ /* */ /* DON'T USE THIS FUNCTION! IT HAS BEEN DEPRECATED! */ /* */ /* It is retained for backwards compatibility only and will */ /* fail on 16bit systems. */ /* */ /* You can now get the charmap count in the `num_CharMaps' */ /* field of a face's properties. */ /* */ EXPORT_DEF int TT_Get_CharMap_Count( TT_Face face ); /* Return the ID of charmap number `charmapIndex' of a given face */ /* used to enumerate the charmaps present in a TrueType file. */ EXPORT_DEF TT_Error TT_Get_CharMap_ID( TT_Face face, TT_UShort charmapIndex, TT_UShort* platformID, TT_UShort* encodingID ); /* Look up the character maps found in `face' and return a handle */ /* for the one matching `platformID' and `platformEncodingID' */ /* (see the TrueType specs relating to the `cmap' table for */ /* information on these ID numbers). Returns an error code. */ /* In case of failure, the handle is set to NULL and is invalid. */ EXPORT_DEF TT_Error TT_Get_CharMap( TT_Face face, TT_UShort charmapIndex, TT_CharMap* charMap ); /* Translate a character code through a given character map */ /* and return the corresponding glyph index to be used in */ /* a TT_Load_Glyph() call. This function returns 0 in case */ /* of failure. */ EXPORT_DEF TT_UShort TT_Char_Index( TT_CharMap charMap, TT_UShort charCode ); /* --------------------- names table support ------------------- */ /* Return the number of name strings found in the name table. */ /* Returns -1 in case of failure (invalid face handle). */ /* */ /* DON'T USE THIS FUNCTION! IT HAS BEEN DEPRECATED! */ /* */ /* It is retained for backwards compatibility only and will */ /* fail on 16bit systems. */ /* */ /* You can now get the number of name strings in a face with */ /* the `num_Names' field of its properties. */ EXPORT_DEF int TT_Get_Name_Count( TT_Face face ); /* Return the ID of the name number `nameIndex' of a given face */ /* used to enumerate the charmaps present in a TrueType file. */ EXPORT_DEF TT_Error TT_Get_Name_ID( TT_Face face, TT_UShort nameIndex, TT_UShort* platformID, TT_UShort* encodingID, TT_UShort* languageID, TT_UShort* nameID ); /* Return the address and length of the name number `nameIndex' */ /* of a given face in the variables `stringPtr' resp. `length'. */ /* The string is part of the face object and shouldn't be */ /* written to or released. */ /* */ /* Note that for an invalid platform ID a null pointer will be */ /* returned. */ EXPORT_DEF TT_Error TT_Get_Name_String( TT_Face face, TT_UShort nameIndex, TT_String** stringPtr, TT_UShort* length ); #ifdef __cplusplus } #endif #endif /* FREETYPE_H */ /* END */