(***************************************************************************) (* *) (* freetype.h *) (* *) (* FreeType high-level API and common types (specification only). *) (* *) (* Copyright 1996-2001, 2002, 2003, 2004, 2005, 2006, 2007 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. *) (* *) (***************************************************************************) (***************************************************************************) (* Initial Pascal port by *) (***************************************************************************) (* Anti-Grain Geometry - Version 2.4 (Public License) *) (* Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com) *) (* *) (* Anti-Grain Geometry - Version 2.4 Release Milano 3 (AggPas 2.4 RM3) *) (* Pascal Port By: Milan Marusinec alias Milano *) (* milan@marusinec.sk *) (* http://www.aggpas.org *) (* Copyright (c) 2005-2007 *) (* *) (* Permission to copy, use, modify, sell and distribute this software *) (* is granted provided this copyright notice appears in all copies. *) (* This software is provided "as is" without express or implied *) (* warranty, and with no claim as to its suitability for any purpose. *) (* *) (***************************************************************************) (***************************************************************************) (* Extended by the UltraStar Deluxe Team *) (***************************************************************************) unit freetype; interface {$IFDEF FPC} {$MODE DELPHI } {$PACKENUM 4} (* use 4-byte enums *) {$PACKRECORDS C} (* C/C++-compatible record packing *) {$ELSE} {$MINENUMSIZE 4} (* use 4-byte enums *) {$ENDIF} uses ctypes; const {$IF Defined(MSWINDOWS)} ft_lib = 'freetype6.dll'; {$ELSEIF Defined(DARWIN)} ft_lib = 'libfreetype.dylib'; {$LINKLIB libfreetype} {$ELSEIF Defined(UNIX)} ft_lib = 'freetype.so'; {$IFEND} type (*************************************************************************) (* *) (* *) (* FT_Library *) (* *) (* *) (* A handle to a FreeType library instance. Each `library' is *) (* completely independent from the others; it is the `root' of a set *) (* of objects like fonts, faces, sizes, etc. *) (* *) (* It also embeds a memory manager (see @FT_Memory), as well as a *) (* scan-line converter object (see @FT_Raster). *) (* *) (* *) (* Library objects are normally created by @FT_Init_FreeType, and *) (* destroyed with @FT_Done_FreeType. *) (* *) FT_Library = Pointer; (*************************************************************************) (* *) (* *) (* FT_FACE_FLAG_XXX *) (* *) (* *) (* A list of bit flags used in the `face_flags' field of the *) (* @FT_FaceRec structure. They inform client applications of *) (* properties of the corresponding face. *) (* *) (* *) (* FT_FACE_FLAG_SCALABLE :: *) (* Indicates that the face provides vectorial outlines. This *) (* doesn't prevent embedded bitmaps, i.e., a face can have both *) (* this bit and @FT_FACE_FLAG_FIXED_SIZES set. *) (* *) (* FT_FACE_FLAG_FIXED_SIZES :: *) (* Indicates that the face contains `fixed sizes', i.e., bitmap *) (* strikes for some given pixel sizes. See the `num_fixed_sizes' *) (* and `available_sizes' fields of @FT_FaceRec. *) (* *) (* FT_FACE_FLAG_FIXED_WIDTH :: *) (* Indicates that the face contains fixed-width characters (like *) (* Courier, Lucido, MonoType, etc.). *) (* *) (* FT_FACE_FLAG_SFNT :: *) (* Indicates that the face uses the `sfnt' storage scheme. For *) (* now, this means TrueType and OpenType. *) (* *) (* FT_FACE_FLAG_HORIZONTAL :: *) (* Indicates that the face contains horizontal glyph metrics. This *) (* should be set for all common formats. *) (* *) (* FT_FACE_FLAG_VERTICAL :: *) (* Indicates that the face contains vertical glyph metrics. This *) (* is only available in some formats, not all of them. *) (* *) (* FT_FACE_FLAG_KERNING :: *) (* Indicates that the face contains kerning information. If set, *) (* the kerning distance can be retrieved through the function *) (* @FT_Get_Kerning. Note that if unset, this function will always *) (* return the vector (0,0). *) (* *) (* FT_FACE_FLAG_FAST_GLYPHS :: *) (* THIS FLAG IS DEPRECATED. DO NOT USE OR TEST IT. *) (* *) (* FT_FACE_FLAG_MULTIPLE_MASTERS :: *) (* Indicates that the font contains multiple masters and is capable *) (* of interpolating between them. See the multiple-masters *) (* specific API for details. *) (* *) (* FT_FACE_FLAG_GLYPH_NAMES :: *) (* Indicates that the font contains glyph names that can be *) (* retrieved through @FT_Get_Glyph_Name. Note that some TrueType *) (* fonts contain broken glyph name tables. Use the function *) (* @FT_Has_PS_Glyph_Names when needed. *) (* *) (* FT_FACE_FLAG_EXTERNAL_STREAM :: *) (* Used internally by FreeType to indicate that a face's stream was *) (* provided by the client application and should not be destroyed *) (* when @FT_Done_Face is called. Don't read or test this flag. *) (* *) const FT_FACE_FLAG_SCALABLE = 1 shl 0; FT_FACE_FLAG_KERNING = 1 shl 6; (*************************************************************************) (* *) (* *) (* FT_ENC_TAG *) (* *) (* *) (* This macro converts four-letter tags into an unsigned long. It is *) (* used to define `encoding' identifiers (see @FT_Encoding). *) (* *) (* *) (* Since many 16-bit compilers don't like 32-bit enumerations, you *) (* should redefine this macro in case of problems to something like *) (* this: *) (* *) (* { *) (* #define FT_ENC_TAG( value, a, b, c, d ) value *) (* } *) (* *) (* to get a simple enumeration without assigning special numbers. *) (* *) { #define FT_ENC_TAG( value, a, b, c, d ) \ value = ( ( (FT_UInt32)(a) << 24 ) | \ ( (FT_UInt32)(b) << 16 ) | \ ( (FT_UInt32)(c) << 8 ) | \ (FT_UInt32)(d) ) } (*************************************************************************) (* *) (* *) (* FT_Encoding *) (* *) (* *) (* An enumeration used to specify encodings supported by charmaps. *) (* Used in the @FT_Select_Charmap API function. *) (* *) (* *) (* Because of 32-bit charcodes defined in Unicode (i.e., surrogates), *) (* all character codes must be expressed as FT_Longs. *) (* *) (* The values of this type correspond to specific character *) (* repertories (i.e. charsets), and not to text encoding methods *) (* (like UTF-8, UTF-16, GB2312_EUC, etc.). *) (* *) (* Other encodings might be defined in the future. *) (* *) (* *) (* FT_ENCODING_NONE :: *) (* The encoding value 0 is reserved. *) (* *) (* FT_ENCODING_UNICODE :: *) (* Corresponds to the Unicode character set. This value covers *) (* all versions of the Unicode repertoire, including ASCII and *) (* Latin-1. Most fonts include a Unicode charmap, but not all *) (* of them. *) (* *) (* FT_ENCODING_MS_SYMBOL :: *) (* Corresponds to the Microsoft Symbol encoding, used to encode *) (* mathematical symbols in the 32..255 character code range. For *) (* more information, see `http://www.ceviz.net/symbol.htm'. *) (* *) (* FT_ENCODING_SJIS :: *) (* Corresponds to Japanese SJIS encoding. More info at *) (* at `http://langsupport.japanreference.com/encoding.shtml'. *) (* See note on multi-byte encodings below. *) (* *) (* FT_ENCODING_GB2312 :: *) (* Corresponds to an encoding system for Simplified Chinese as used *) (* used in mainland China. *) (* *) (* FT_ENCODING_BIG5 :: *) (* Corresponds to an encoding system for Traditional Chinese as used *) (* in Taiwan and Hong Kong. *) (* *) (* FT_ENCODING_WANSUNG :: *) (* Corresponds to the Korean encoding system known as Wansung. *) (* For more information see *) (* `http://www.microsoft.com/typography/unicode/949.txt'. *) (* *) (* FT_ENCODING_JOHAB :: *) (* The Korean standard character set (KS C-5601-1992), which *) (* corresponds to MS Windows code page 1361. This character set *) (* includes all possible Hangeul character combinations. *) (* *) (* FT_ENCODING_ADOBE_LATIN_1 :: *) (* Corresponds to a Latin-1 encoding as defined in a Type 1 *) (* Postscript font. It is limited to 256 character codes. *) (* *) (* FT_ENCODING_ADOBE_STANDARD :: *) (* Corresponds to the Adobe Standard encoding, as found in Type 1, *) (* CFF, and OpenType/CFF fonts. It is limited to 256 character *) (* codes. *) (* *) (* FT_ENCODING_ADOBE_EXPERT :: *) (* Corresponds to the Adobe Expert encoding, as found in Type 1, *) (* CFF, and OpenType/CFF fonts. It is limited to 256 character *) (* codes. *) (* *) (* FT_ENCODING_ADOBE_CUSTOM :: *) (* Corresponds to a custom encoding, as found in Type 1, CFF, and *) (* OpenType/CFF fonts. It is limited to 256 character codes. *) (* *) (* FT_ENCODING_APPLE_ROMAN :: *) (* Corresponds to the 8-bit Apple roman encoding. Many TrueType and *) (* OpenType fonts contain a charmap for this encoding, since older *) (* versions of Mac OS are able to use it. *) (* *) (* FT_ENCODING_OLD_LATIN_2 :: *) (* This value is deprecated and was never used nor reported by *) (* FreeType. Don't use or test for it. *) (* *) (* FT_ENCODING_MS_SJIS :: *) (* Same as FT_ENCODING_SJIS. Deprecated. *) (* *) (* FT_ENCODING_MS_GB2312 :: *) (* Same as FT_ENCODING_GB2312. Deprecated. *) (* *) (* FT_ENCODING_MS_BIG5 :: *) (* Same as FT_ENCODING_BIG5. Deprecated. *) (* *) (* FT_ENCODING_MS_WANSUNG :: *) (* Same as FT_ENCODING_WANSUNG. Deprecated. *) (* *) (* FT_ENCODING_MS_JOHAB :: *) (* Same as FT_ENCODING_JOHAB. Deprecated. *) (* *) (* *) (* By default, FreeType automatically synthetizes a Unicode charmap *) (* for Postscript fonts, using their glyph names dictionaries. *) (* However, it will also report the encodings defined explicitly in *) (* the font file, for the cases when they are needed, with the Adobe *) (* values as well. *) (* *) (* FT_ENCODING_NONE is set by the BDF and PCF drivers if the charmap *) (* is neither Unicode nor ISO-8859-1 (otherwise it is set to *) (* FT_ENCODING_UNICODE). Use `FT_Get_BDF_Charset_ID' to find out *) (* which encoding is really present. If, for example, the *) (* `cs_registry' field is `KOI8' and the `cs_encoding' field is `R', *) (* the font is encoded in KOI8-R. *) (* *) (* FT_ENCODING_NONE is always set (with a single exception) by the *) (* winfonts driver. Use `FT_Get_WinFNT_Header' and examine the *) (* `charset' field of the `FT_WinFNT_HeaderRec' structure to find out *) (* which encoding is really present. For example, FT_WinFNT_ID_CP1251 *) (* (204) means Windows code page 1251 (for Russian). *) (* *) (* FT_ENCODING_NONE is set if `platform_id' is `TT_PLATFORM_MACINTOSH' *) (* and `encoding_id' is not `TT_MAC_ID_ROMAN' (otherwise it is set to *) (* FT_ENCODING_APPLE_ROMAN). *) (* *) (* If `platform_id' is `TT_PLATFORM_MACINTOSH', use the function *) (* `FT_Get_CMap_Language_ID' to query the Mac language ID which may be *) (* needed to be able to distinguish Apple encoding variants. See *) (* *) (* http://www.unicode.org/Public/MAPPINGS/VENDORS/APPLE/README.TXT *) (* *) (* to get an idea how to do that. Basically, if the language ID is 0, *) (* dont use it, otherwise subtract 1 from the language ID. Then *) (* examine `encoding_id'. If, for example, `encoding_id' is *) (* `TT_MAC_ID_ROMAN' and the language ID (minus 1) is *) (* `TT_MAC_LANGID_GREEK', it is the Greek encoding, not Roman. *) (* `TT_MAC_ID_ARABIC' with `TT_MAC_LANGID_FARSI' means the Farsi *) (* variant the Arabic encoding. *) (* *) type PFT_Encoding = ^FT_Encoding; FT_Encoding = cint32; // 32 bit enum of FT_ENC_TAG const FT_ENCODING_NONE = (Ord(#0) shl 24) or (Ord(#0) shl 16) or (Ord(#0) shl 8) or (Ord(#0) shl 0); FT_ENCODING_MS_SYMBOL = (Ord('s') shl 24) or (Ord('y') shl 16) or (Ord('m') shl 8) or (Ord('b') shl 0); FT_ENCODING_UNICODE = (Ord('u') shl 24) or (Ord('n') shl 16) or (Ord('i') shl 8) or (Ord('c') shl 0); FT_ENCODING_SJIS = (Ord('s') shl 24) or (Ord('j') shl 16) or (Ord('i') shl 8) or (Ord('s') shl 0); FT_ENCODING_GB2312 = (Ord('g') shl 24) or (Ord('b') shl 16) or (Ord(' ') shl 8) or (Ord(' ') shl 0); FT_ENCODING_BIG5 = (Ord('b') shl 24) or (Ord('i') shl 16) or (Ord('g') shl 8) or (Ord('5') shl 0); FT_ENCODING_WANSUNG = (Ord('w') shl 24) or (Ord('a') shl 16) or (Ord('n') shl 8) or (Ord('s') shl 0); FT_ENCODING_JOHAB = (Ord('j') shl 24) or (Ord('o') shl 16) or (Ord('h') shl 8) or (Ord('a') shl 0); (*************************************************************************) (* *) (* *) (* FT_STYLE_FLAG_XXX *) (* *) (* *) (* A list of bit-flags used to indicate the style of a given face. *) (* These are used in the `style_flags' field of @FT_FaceRec. *) (* *) (* *) (* FT_STYLE_FLAG_ITALIC :: *) (* Indicates that a given face is italicized. *) (* *) (* FT_STYLE_FLAG_BOLD :: *) (* Indicates that a given face is bold. *) (* *) const FT_STYLE_FLAG_ITALIC = 1 shl 0; FT_STYLE_FLAG_BOLD = 1 shl 1; (*************************************************************************** * * @enum: * FT_LOAD_XXX * * @description: * A list of bit-field constants, used with @FT_Load_Glyph to indicate * what kind of operations to perform during glyph loading. * * @values: * FT_LOAD_DEFAULT :: * Corresponding to 0, this value is used a default glyph load. In this * case, the following will happen: * * 1. FreeType looks for a bitmap for the glyph corresponding to the * face's current size. If one is found, the function returns. The * bitmap data can be accessed from the glyph slot (see note below). * * 2. If no embedded bitmap is searched or found, FreeType looks for a * scalable outline. If one is found, it is loaded from the font * file, scaled to device pixels, then "hinted" to the pixel grid in * order to optimize it. The outline data can be accessed from the * glyph slot (see note below). * * Note that by default, the glyph loader doesn't render outlines into * bitmaps. The following flags are used to modify this default * behaviour to more specific and useful cases. * * FT_LOAD_NO_SCALE :: * Don't scale the vector outline being loaded to 26.6 fractional * pixels, but kept in font units. Note that this also disables * hinting and the loading of embedded bitmaps. You should only use it * when you want to retrieve the original glyph outlines in font units. * * FT_LOAD_NO_HINTING :: * Don't hint glyph outlines after their scaling to device pixels. * This generally generates "blurrier" glyphs in anti-aliased modes. * * This flag is ignored if @FT_LOAD_NO_SCALE is set. * * FT_LOAD_RENDER :: * Render the glyph outline immediately into a bitmap before the glyph * loader returns. By default, the glyph is rendered for the * @FT_RENDER_MODE_NORMAL mode, which corresponds to 8-bit anti-aliased * bitmaps using 256 opacity levels. You can use either * @FT_LOAD_TARGET_MONO or @FT_LOAD_MONOCHROME to render 1-bit * monochrome bitmaps. * * This flag is ignored if @FT_LOAD_NO_SCALE is set. * * FT_LOAD_NO_BITMAP :: * Don't look for bitmaps when loading the glyph. Only scalable * outlines will be loaded when available, and scaled, hinted, or * rendered depending on other bit flags. * * This does not prevent you from rendering outlines to bitmaps * with @FT_LOAD_RENDER, however. * * FT_LOAD_VERTICAL_LAYOUT :: * Prepare the glyph image for vertical text layout. This basically * means that `face.glyph.advance' will correspond to the vertical * advance height (instead of the default horizontal advance width), * and that the glyph image will be translated to match the vertical * bearings positions. * * FT_LOAD_FORCE_AUTOHINT :: * Force the use of the FreeType auto-hinter when a glyph outline is * loaded. You shouldn't need this in a typical application, since it * is mostly used to experiment with its algorithm. * * FT_LOAD_CROP_BITMAP :: * Indicates that the glyph loader should try to crop the bitmap (i.e., * remove all space around its black bits) when loading it. This is * only useful when loading embedded bitmaps in certain fonts, since * bitmaps rendered with @FT_LOAD_RENDER are always cropped by default. * * FT_LOAD_PEDANTIC :: * Indicates that the glyph loader should perform pedantic * verifications during glyph loading, rejecting invalid fonts. This * is mostly used to detect broken glyphs in fonts. By default, * FreeType tries to handle broken fonts also. * * FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH :: * Indicates that the glyph loader should ignore the global advance * width defined in the font. As far as we know, this is only used by * the X-TrueType font server, in order to deal correctly with the * incorrect metrics contained in DynaLab's TrueType CJK fonts. * * FT_LOAD_NO_RECURSE :: * This flag is only used internally. It merely indicates that the * glyph loader should not load composite glyphs recursively. Instead, * it should set the `num_subglyph' and `subglyphs' values of the glyph * slot accordingly, and set "glyph->format" to * @FT_GLYPH_FORMAT_COMPOSITE. * * The description of sub-glyphs is not available to client * applications for now. * * FT_LOAD_IGNORE_TRANSFORM :: * Indicates that the glyph loader should not try to transform the * loaded glyph image. This doesn't prevent scaling, hinting, or * rendering. * * FT_LOAD_MONOCHROME :: * This flag is used with @FT_LOAD_RENDER to indicate that you want * to render a 1-bit monochrome glyph bitmap from a vectorial outline. * * Note that this has no effect on the hinting algorithm used by the * glyph loader. You should better use @FT_LOAD_TARGET_MONO if you * want to render monochrome-optimized glyph images instead. * * FT_LOAD_LINEAR_DESIGN :: * Return the linearly scaled metrics expressed in original font units * instead of the default 16.16 pixel values. * * FT_LOAD_NO_AUTOHINT :: * Indicates that the auto-hinter should never be used to hint glyph * outlines. This doesn't prevent native format-specific hinters from * being used. This can be important for certain fonts where unhinted * output is better than auto-hinted one. * * FT_LOAD_TARGET_NORMAL :: * Use hinting for @FT_RENDER_MODE_NORMAL. * * FT_LOAD_TARGET_LIGHT :: * Use hinting for @FT_RENDER_MODE_LIGHT. * * FT_LOAD_TARGET_MONO :: * Use hinting for @FT_RENDER_MODE_MONO. * * FT_LOAD_TARGET_LCD :: * Use hinting for @FT_RENDER_MODE_LCD. * * FT_LOAD_TARGET_LCD_V :: * Use hinting for @FT_RENDER_MODE_LCD_V. *) const FT_LOAD_DEFAULT = $0000; FT_LOAD_NO_SCALE = $0001; FT_LOAD_NO_HINTING = $0002; FT_LOAD_RENDER = $0004; FT_LOAD_NO_BITMAP = $0008; FT_LOAD_VERTICAL_LAYOUT = $0010; FT_LOAD_FORCE_AUTOHINT = $0020; FT_LOAD_CROP_BITMAP = $0040; FT_LOAD_PEDANTIC = $0080; FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH = $0200; FT_LOAD_NO_RECURSE = $0400; FT_LOAD_IGNORE_TRANSFORM = $0800; FT_LOAD_MONOCHROME = $1000; FT_LOAD_LINEAR_DESIGN = $2000; (* temporary hack! *) FT_LOAD_SBITS_ONLY = $4000; FT_LOAD_NO_AUTOHINT = $8000; (*************************************************************************) (* *) (* *) (* FT_Render_Mode *) (* *) (* *) (* An enumeration type that lists the render modes supported by *) (* FreeType 2. Each mode corresponds to a specific type of scanline *) (* conversion performed on the outline, as well as specific *) (* hinting optimizations. *) (* *) (* For bitmap fonts the `bitmap->pixel_mode' field in the *) (* @FT_GlyphSlotRec structure gives the format of the returned *) (* bitmap. *) (* *) (* *) (* FT_RENDER_MODE_NORMAL :: *) (* This is the default render mode; it corresponds to 8-bit *) (* anti-aliased bitmaps, using 256 levels of opacity. *) (* *) (* FT_RENDER_MODE_LIGHT :: *) (* This is similar to @FT_RENDER_MODE_NORMAL -- you have to use *) (* @FT_LOAD_TARGET_LIGHT in calls to @FT_Load_Glyph to get any *) (* effect since the rendering process no longer influences the *) (* positioning of glyph outlines. *) (* *) (* The resulting glyph shapes are more similar to the original, *) (* while being a bit more fuzzy (`better shapes' instead of `better *) (* contrast', so to say. *) (* *) (* FT_RENDER_MODE_MONO :: *) (* This mode corresponds to 1-bit bitmaps. *) (* *) (* FT_RENDER_MODE_LCD :: *) (* This mode corresponds to horizontal RGB/BGR sub-pixel displays, *) (* like LCD-screens. It produces 8-bit bitmaps that are 3 times *) (* the width of the original glyph outline in pixels, and which use *) (* the @FT_PIXEL_MODE_LCD mode. *) (* *) (* FT_RENDER_MODE_LCD_V :: *) (* This mode corresponds to vertical RGB/BGR sub-pixel displays *) (* (like PDA screens, rotated LCD displays, etc.). It produces *) (* 8-bit bitmaps that are 3 times the height of the original *) (* glyph outline in pixels and use the @FT_PIXEL_MODE_LCD_V mode. *) (* *) (* *) (* The LCD-optimized glyph bitmaps produced by FT_Render_Glyph are *) (* _not filtered_ to reduce color-fringes. It is up to the caller to *) (* perform this pass. *) (* *) type FT_Render_Mode = cint; const FT_RENDER_MODE_NORMAL = 0; FT_RENDER_MODE_LIGHT = FT_RENDER_MODE_NORMAL + 1; FT_RENDER_MODE_MONO = FT_RENDER_MODE_LIGHT + 1; FT_RENDER_MODE_LCD = FT_RENDER_MODE_MONO + 1; FT_RENDER_MODE_LCD_V = FT_RENDER_MODE_LCD + 1; FT_RENDER_MODE_MAX = FT_RENDER_MODE_LCD_V + 1; (*************************************************************************) (* *) (* *) (* FT_GlyphSlot *) (* *) (* *) (* A handle to a given `glyph slot'. A slot is a container where it *) (* is possible to load any one of the glyphs contained in its parent *) (* face. *) (* *) (* In other words, each time you call @FT_Load_Glyph or *) (* @FT_Load_Char, the slot's content is erased by the new glyph data, *) (* i.e. the glyph's metrics, its image (bitmap or outline), and *) (* other control information. *) (* *) (* *) (* @FT_GlyphSlotRec details the publicly accessible glyph fields. *) (* *) type FT_GlyphSlot = ^FT_GlyphSlotRec; {$DEFINE TYPE_DECL} {$I ftconfig.inc} {$I fttypes.inc} {$I ftimage.inc} {$I ftglyph.inc} {$I ftstroke.inc} {$I ftoutln.inc} {$UNDEF TYPE_DECL} (*************************************************************************) (* *) (* *) (* FT_Glyph_Metrics *) (* *) (* *) (* A structure used to model the metrics of a single glyph. The *) (* values are expressed in 26.6 fractional pixel format; if the flag *) (* FT_LOAD_NO_SCALE is used, values are returned in font units *) (* instead. *) (* *) (* *) (* width :: *) (* The glyph's width. *) (* *) (* height :: *) (* The glyph's height. *) (* *) (* horiBearingX :: *) (* Left side bearing for horizontal layout. *) (* *) (* horiBearingY :: *) (* Top side bearing for horizontal layout. *) (* *) (* horiAdvance :: *) (* Advance width for horizontal layout. *) (* *) (* vertBearingX :: *) (* Left side bearing for vertical layout. *) (* *) (* vertBearingY :: *) (* Top side bearing for vertical layout. *) (* *) (* vertAdvance :: *) (* Advance height for vertical layout. *) (* *) FT_Glyph_Metrics = record width , height : FT_Pos; horiBearingX , horiBearingY , horiAdvance : FT_Pos; vertBearingX , vertBearingY , vertAdvance : FT_Pos; end; (*************************************************************************) (* *) (* *) (* FT_Bitmap_Size *) (* *) (* *) (* This structure models the size of a bitmap strike (i.e., a bitmap *) (* instance of the font for a given resolution) in a fixed-size font *) (* face. It is used for the `available_sizes' field of the *) (* @FT_FaceRec structure. *) (* *) (* *) (* height :: The (vertical) baseline-to-baseline distance in pixels. *) (* It makes most sense to define the height of a bitmap *) (* font in this way. *) (* *) (* width :: The average width of the font (in pixels). Since the *) (* algorithms to compute this value are different for the *) (* various bitmap formats, it can only give an additional *) (* hint if the `height' value isn't sufficient to select *) (* the proper font. For monospaced fonts the average width *) (* is the same as the maximum width. *) (* *) (* size :: The point size in 26.6 fractional format this font shall *) (* represent (for a given vertical resolution). *) (* *) (* x_ppem :: The horizontal ppem value (in 26.6 fractional format). *) (* *) (* y_ppem :: The vertical ppem value (in 26.6 fractional format). *) (* Usually, this is the `nominal' pixel height of the font. *) (* *) (* *) (* The values in this structure are taken from the bitmap font. If *) (* the font doesn't provide a parameter it is set to zero to indicate *) (* that the information is not available. *) (* *) (* The following formula converts from dpi to ppem: *) (* *) (* ppem = size * dpi / 72 *) (* *) (* where `size' is in points. *) (* *) (* Windows FNT: *) (* The `size' parameter is not reliable: There exist fonts (e.g., *) (* app850.fon) which have a wrong size for some subfonts; x_ppem *) (* and y_ppem are thus set equal to pixel width and height given in *) (* in the Windows FNT header. *) (* *) (* TrueType embedded bitmaps: *) (* `size', `width', and `height' values are not contained in the *) (* bitmap strike itself. They are computed from the global font *) (* parameters. *) (* *) PFT_Bitmap_Size = ^FT_Bitmap_Size; FT_Bitmap_Size = record height, width : FT_Short; size: FT_Pos; x_ppem: FT_Pos; y_ppem: FT_Pos; end; PAFT_Bitmap_Size = ^AFT_Bitmap_Size; AFT_Bitmap_Size = array[0..High(Word)] of FT_Bitmap_Size; (*************************************************************************) (* *) (* *) (* FT_Face *) (* *) (* *) (* A handle to a given typographic face object. A face object models *) (* a given typeface, in a given style. *) (* *) (* *) (* Each face object also owns a single @FT_GlyphSlot object, as well *) (* as one or more @FT_Size objects. *) (* *) (* Use @FT_New_Face or @FT_Open_Face to create a new face object from *) (* a given filepathname or a custom input stream. *) (* *) (* Use @FT_Done_Face to destroy it (along with its slot and sizes). *) (* *) (* *) (* The @FT_FaceRec details the publicly accessible fields of a given *) (* face object. *) (* *) FT_Face = ^FT_FaceRec; (*************************************************************************) (* *) (* *) (* FT_CharMap *) (* *) (* *) (* A handle to a given character map. A charmap is used to translate *) (* character codes in a given encoding into glyph indexes for its *) (* parent's face. Some font formats may provide several charmaps per *) (* font. *) (* *) (* Each face object owns zero or more charmaps, but only one of them *) (* can be "active" and used by @FT_Get_Char_Index or @FT_Load_Char. *) (* *) (* The list of available charmaps in a face is available through the *) (* "face->num_charmaps" and "face->charmaps" fields of @FT_FaceRec. *) (* *) (* The currently active charmap is available as "face->charmap". *) (* You should call @FT_Set_Charmap to change it. *) (* *) (* *) (* When a new face is created (either through @FT_New_Face or *) (* @FT_Open_Face), the library looks for a Unicode charmap within *) (* the list and automatically activates it. *) (* *) (* *) (* The @FT_CharMapRec details the publicly accessible fields of a *) (* given character map. *) (* *) PFT_CharMap = ^FT_CharMap; FT_CharMap = ^FT_CharMapRec; PAFT_CharMap = ^FT_CharMap; AFT_CharMap = array[0..High(Word)] of FT_CharMap; (*************************************************************************) (* *) (* *) (* FT_SubGlyph *) (* *) (* *) (* The subglyph structure is an internal object used to describe *) (* subglyphs (for example, in the case of composites). *) (* *) (* *) (* The subglyph implementation is not part of the high-level API, *) (* hence the forward structure declaration. *) (* *) FT_SubGlyph = ^FT_SubGlyphRec; FT_SubGlyphRec = record // internal end; (*************************************************************************) (* *) (* *) (* FT_GlyphSlotRec *) (* *) (* *) (* FreeType root glyph slot class structure. A glyph slot is a *) (* container where individual glyphs can be loaded, be they *) (* vectorial or bitmap/graymaps. *) (* *) (* *) (* library :: A handle to the FreeType library instance *) (* this slot belongs to. *) (* *) (* face :: A handle to the parent face object. *) (* *) (* next :: In some cases (like some font tools), several *) (* glyph slots per face object can be a good *) (* thing. As this is rare, the glyph slots are *) (* listed through a direct, single-linked list *) (* using its `next' field. *) (* *) (* generic :: A typeless pointer which is unused by the *) (* FreeType library or any of its drivers. It *) (* can be used by client applications to link *) (* their own data to each glyph slot object. *) (* *) (* metrics :: The metrics of the last loaded glyph in the *) (* slot. The returned values depend on the last *) (* load flags (see the @FT_Load_Glyph API *) (* function) and can be expressed either in 26.6 *) (* fractional pixels or font units. *) (* *) (* Note that even when the glyph image is *) (* transformed, the metrics are not. *) (* *) (* linearHoriAdvance :: For scalable formats only, this field holds *) (* the linearly scaled horizontal advance width *) (* for the glyph (i.e. the scaled and unhinted *) (* value of the hori advance). This can be *) (* important to perform correct WYSIWYG layout. *) (* *) (* Note that this value is expressed by default *) (* in 16.16 pixels. However, when the glyph is *) (* loaded with the FT_LOAD_LINEAR_DESIGN flag, *) (* this field contains simply the value of the *) (* advance in original font units. *) (* *) (* linearVertAdvance :: For scalable formats only, this field holds *) (* the linearly scaled vertical advance height *) (* for the glyph. See linearHoriAdvance for *) (* comments. *) (* *) (* advance :: This is the transformed advance width for the *) (* glyph. *) (* *) (* format :: This field indicates the format of the image *) (* contained in the glyph slot. Typically *) (* FT_GLYPH_FORMAT_BITMAP, *) (* FT_GLYPH_FORMAT_OUTLINE, and *) (* FT_GLYPH_FORMAT_COMPOSITE, but others are *) (* possible. *) (* *) (* bitmap :: This field is used as a bitmap descriptor *) (* when the slot format is *) (* FT_GLYPH_FORMAT_BITMAP. Note that the *) (* address and content of the bitmap buffer can *) (* change between calls of @FT_Load_Glyph and a *) (* few other functions. *) (* *) (* bitmap_left :: This is the bitmap's left bearing expressed *) (* in integer pixels. Of course, this is only *) (* valid if the format is *) (* FT_GLYPH_FORMAT_BITMAP. *) (* *) (* bitmap_top :: This is the bitmap's top bearing expressed in *) (* integer pixels. Remember that this is the *) (* distance from the baseline to the top-most *) (* glyph scanline, upwards y-coordinates being *) (* *positive*. *) (* *) (* outline :: The outline descriptor for the current glyph *) (* image if its format is *) (* FT_GLYPH_FORMAT_OUTLINE. *) (* *) (* num_subglyphs :: The number of subglyphs in a composite glyph. *) (* This field is only valid for the composite *) (* glyph format that should normally only be *) (* loaded with the @FT_LOAD_NO_RECURSE flag. *) (* For now this is internal to FreeType. *) (* *) (* subglyphs :: An array of subglyph descriptors for *) (* composite glyphs. There are `num_subglyphs' *) (* elements in there. Currently internal to *) (* FreeType. *) (* *) (* control_data :: Certain font drivers can also return the *) (* control data for a given glyph image (e.g. *) (* TrueType bytecode, Type 1 charstrings, etc.). *) (* This field is a pointer to such data. *) (* *) (* control_len :: This is the length in bytes of the control *) (* data. *) (* *) (* other :: Really wicked formats can use this pointer to *) (* present their own glyph image to client apps. *) (* Note that the app will need to know about the *) (* image format. *) (* *) (* lsb_delta :: The difference between hinted and unhinted *) (* left side bearing while autohinting is *) (* active. Zero otherwise. *) (* *) (* rsb_delta :: The difference between hinted and unhinted *) (* right side bearing while autohinting is *) (* active. Zero otherwise. *) (* *) (* *) (* If @FT_Load_Glyph is called with default flags (see *) (* @FT_LOAD_DEFAULT) the glyph image is loaded in the glyph slot in *) (* its native format (e.g. a vectorial outline for TrueType and *) (* Type 1 formats). *) (* *) (* This image can later be converted into a bitmap by calling *) (* @FT_Render_Glyph. This function finds the current renderer for *) (* the native image's format then invokes it. *) (* *) (* The renderer is in charge of transforming the native image through *) (* the slot's face transformation fields, then convert it into a *) (* bitmap that is returned in `slot->bitmap'. *) (* *) (* Note that `slot->bitmap_left' and `slot->bitmap_top' are also used *) (* to specify the position of the bitmap relative to the current pen *) (* position (e.g. coordinates [0,0] on the baseline). Of course, *) (* `slot->format' is also changed to `FT_GLYPH_FORMAT_BITMAP' . *) (* *) (* *) (* Here a small pseudo code fragment which shows how to use *) (* `lsb_delta' and `rsb_delta': *) (* *) (* { *) (* FT_Pos origin_x = 0; *) (* FT_Pos prev_rsb_delta = 0; *) (* *) (* *) (* for all glyphs do *) (* *) (* *) (* *) (* *) (* if ( prev_rsb_delta - face->glyph->lsb_delta >= 32 ) *) (* origin_x -= 64; *) (* else if ( prev_rsb_delta - face->glyph->lsb_delta < -32 ) *) (* origin_x += 64; *) (* *) (* prev_rsb_delta = face->glyph->rsb_delta; *) (* *) (* *) (* *) (* origin_x += face->glyph->advance.x; *) (* endfor *) (* } *) (* *) FT_GlyphSlotRec = record alibrary : FT_Library; face : FT_Face; next : FT_GlyphSlot; flags : FT_UInt; generic : FT_Generic; metrics : FT_Glyph_Metrics; linearHoriAdvance , linearVertAdvance : FT_Fixed; advance : FT_Vector; format : FT_Glyph_Format; bitmap : FT_Bitmap; bitmap_left , bitmap_top : FT_Int; outline : FT_Outline; num_subglyphs : FT_UInt; subglyphs : FT_SubGlyph; control_data : pointer; control_len : clong; lsb_delta: FT_Pos; rsb_delta: FT_Pos; other : pointer; //internal: FT_Slot_Internal; end; (*************************************************************************) (* *) (* *) (* FT_Size_Metrics *) (* *) (* *) (* The size metrics structure returned scaled important distances for *) (* a given size object. *) (* *) (* *) (* x_ppem :: The character width, expressed in integer pixels. *) (* This is the width of the EM square expressed in *) (* pixels, hence the term `ppem' (pixels per EM). *) (* *) (* y_ppem :: The character height, expressed in integer pixels. *) (* This is the height of the EM square expressed in *) (* pixels, hence the term `ppem' (pixels per EM). *) (* *) (* x_scale :: A simple 16.16 fixed point format coefficient used *) (* to scale horizontal distances expressed in font *) (* units to fractional (26.6) pixel coordinates. *) (* *) (* y_scale :: A simple 16.16 fixed point format coefficient used *) (* to scale vertical distances expressed in font *) (* units to fractional (26.6) pixel coordinates. *) (* *) (* ascender :: The ascender, expressed in 26.6 fixed point *) (* pixels. Positive for ascenders above the *) (* baseline. *) (* *) (* descender :: The descender, expressed in 26.6 fixed point *) (* pixels. Negative for descenders below the *) (* baseline. *) (* *) (* height :: The text height, expressed in 26.6 fixed point *) (* pixels. Always positive. *) (* *) (* max_advance :: Maximum horizontal advance, expressed in 26.6 *) (* fixed point pixels. Always positive. *) (* *) (* *) (* For scalable fonts, the values of `ascender', `descender', and *) (* `height' are scaled versions of `face->ascender', *) (* `face->descender', and `face->height', respectively. *) (* *) (* Unfortunately, due to glyph hinting, these values might not be *) (* exact for certain fonts. They thus must be treated as unreliable *) (* with an error margin of at least one pixel! *) (* *) (* Indeed, the only way to get the exact pixel ascender and descender *) (* is to render _all_ glyphs. As this would be a definite *) (* performance hit, it is up to client applications to perform such *) (* computations. *) (* *) FT_Size_Metrics = record x_ppem, (* horizontal pixels per EM *) y_ppem: FT_UShort; (* vertical pixels per EM *) x_scale, (* scaling values used to convert font *) y_scale: FT_Fixed; (* units to 26.6 fractional pixels *) ascender, (* ascender in 26.6 frac. pixels *) descender: FT_Pos; (* descender in 26.6 frac. pixels *) height: FT_Pos; (* text height in 26.6 frac. pixels *) max_advance: FT_Pos; (* max horizontal advance, in 26.6 pixels *) end; (*************************************************************************) (* *) (* *) (* FT_Size *) (* *) (* *) (* A handle to a given size object. Such an object models the data *) (* that depends on the current _resolution_ and _character size_ in a *) (* given @FT_Face. *) (* *) (* *) (* Each face object owns one or more sizes. There is however a *) (* single _active_ size for the face at any time that will be used by *) (* functions like @FT_Load_Glyph, @FT_Get_Kerning, etc. *) (* *) (* You can use the @FT_Activate_Size API to change the current *) (* active size of any given face. *) (* *) (* *) (* The @FT_SizeRec structure details the publicly accessible fields *) (* of a given face object. *) (* *) FT_Size = ^FT_SizeRec; (*************************************************************************) (* *) (* *) (* FT_SizeRec *) (* *) (* *) (* FreeType root size class structure. A size object models the *) (* resolution and pointsize dependent data of a given face. *) (* *) (* *) (* face :: Handle to the parent face object. *) (* *) (* generic :: A typeless pointer, which is unused by the FreeType *) (* library or any of its drivers. It can be used by *) (* client applications to link their own data to each size *) (* object. *) (* *) (* metrics :: Metrics for this size object. This field is read-only. *) (* *) FT_SizeRec = record face : FT_Face; generic : FT_Generic; metrics : FT_Size_Metrics; //internal : FT_Size_Internal; end; (*************************************************************************) (* *) (* *) (* FT_FaceRec *) (* *) (* *) (* FreeType root face class structure. A face object models the *) (* resolution and point-size independent data found in a font file. *) (* *) (* *) (* num_faces :: In the case where the face is located in a *) (* collection (i.e., a file which embeds *) (* several faces), this is the total number of *) (* faces found in the resource. 1 by default. *) (* Accessing non-existent face indices causes *) (* an error. *) (* *) (* face_index :: The index of the face in its font file. *) (* Usually, this is 0 for all normal font *) (* formats. It can be > 0 in the case of *) (* collections (which embed several fonts in a *) (* single resource/file). *) (* *) (* face_flags :: A set of bit flags that give important *) (* information about the face; see the *) (* @FT_FACE_FLAG_XXX constants for details. *) (* *) (* style_flags :: A set of bit flags indicating the style of *) (* the face (i.e., italic, bold, underline, *) (* etc). See the @FT_STYLE_FLAG_XXX *) (* constants. *) (* *) (* num_glyphs :: The total number of glyphs in the face. *) (* *) (* family_name :: The face's family name. This is an ASCII *) (* string, usually in English, which describes *) (* the typeface's family (like `Times New *) (* Roman', `Bodoni', `Garamond', etc). This *) (* is a least common denominator used to list *) (* fonts. Some formats (TrueType & OpenType) *) (* provide localized and Unicode versions of *) (* this string. Applications should use the *) (* format specific interface to access them. *) (* *) (* style_name :: The face's style name. This is an ASCII *) (* string, usually in English, which describes *) (* the typeface's style (like `Italic', *) (* `Bold', `Condensed', etc). Not all font *) (* formats provide a style name, so this field *) (* is optional, and can be set to NULL. As *) (* for `family_name', some formats provide *) (* localized/Unicode versions of this string. *) (* Applications should use the format specific *) (* interface to access them. *) (* *) (* num_fixed_sizes :: The number of fixed sizes available in this *) (* face. This should be set to 0 for scalable *) (* fonts, unless its face includes a set of *) (* glyphs (called a `strike') for the *) (* specified sizes. *) (* *) (* available_sizes :: An array of sizes specifying the available *) (* bitmap/graymap sizes that are contained in *) (* in the font face. Should be set to NULL if *) (* the field `num_fixed_sizes' is set to 0. *) (* *) (* num_charmaps :: The total number of character maps in the *) (* face. *) (* *) (* charmaps :: A table of pointers to the face's charmaps. *) (* Used to scan the list of available charmaps *) (* -- this table might change after a call to *) (* @FT_Attach_File or @FT_Attach_Stream (e.g. *) (* if used to hook an additional encoding or *) (* CMap to the face object). *) (* *) (* generic :: A field reserved for client uses. See the *) (* @FT_Generic type description. *) (* *) (* bbox :: The font bounding box. Coordinates are *) (* expressed in font units (see units_per_EM). *) (* The box is large enough to contain any *) (* glyph from the font. Thus, bbox.yMax can *) (* be seen as the `maximal ascender', *) (* bbox.yMin as the `minimal descender', and *) (* the maximal glyph width is given by *) (* `bbox.xMax-bbox.xMin' (not to be confused *) (* with the maximal _advance_width_). Only *) (* relevant for scalable formats. *) (* *) (* units_per_EM :: The number of font units per EM square for *) (* this face. This is typically 2048 for *) (* TrueType fonts, 1000 for Type1 fonts, and *) (* should be set to the (unrealistic) value 1 *) (* for fixed-sizes fonts. Only relevant for *) (* scalable formats. *) (* *) (* ascender :: The face's ascender is the vertical *) (* distance from the baseline to the topmost *) (* point of any glyph in the face. This *) (* field's value is positive, expressed in *) (* font units. Some font designs use a value *) (* different from `bbox.yMax'. Only relevant *) (* for scalable formats. *) (* *) (* descender :: The face's descender is the vertical *) (* distance from the baseline to the *) (* bottommost point of any glyph in the face. *) (* This field's value is *negative* for values *) (* below the baseline. It is expressed in *) (* font units. Some font designs use a value *) (* different from `bbox.yMin'. Only relevant *) (* for scalable formats. *) (* *) (* height :: The face's height is the vertical distance *) (* from one baseline to the next when writing *) (* several lines of text. Its value is always *) (* positive, expressed in font units. The *) (* value can be computed as *) (* `ascender+descender+line_gap' where the *) (* value of `line_gap' is also called *) (* `external leading'. Only relevant for *) (* scalable formats. *) (* *) (* max_advance_width :: The maximal advance width, in font units, *) (* for all glyphs in this face. This can be *) (* used to make word wrapping computations *) (* faster. Only relevant for scalable *) (* formats. *) (* *) (* max_advance_height :: The maximal advance height, in font units, *) (* for all glyphs in this face. This is only *) (* relevant for vertical layouts, and should *) (* be set to the `height' for fonts that do *) (* not provide vertical metrics. Only *) (* relevant for scalable formats. *) (* *) (* underline_position :: The position, in font units, of the *) (* underline line for this face. It's the *) (* center of the underlining stem. Only *) (* relevant for scalable formats. *) (* *) (* underline_thickness :: The thickness, in font units, of the *) (* underline for this face. Only relevant for *) (* scalable formats. *) (* *) (* glyph :: The face's associated glyph slot(s). This *) (* object is created automatically with a new *) (* face object. However, certain kinds of *) (* applications (mainly tools like converters) *) (* can need more than one slot to ease their *) (* task. *) (* *) (* size :: The current active size for this face. *) (* *) (* charmap :: The current active charmap for this face. *) (* *) FT_FaceRec = record num_faces : FT_Long; face_index : FT_Long; face_flags : FT_Long; style_flags : FT_Long; num_glyphs : FT_Long; family_name : PFT_String; style_name : PFT_String; num_fixed_sizes : FT_Int; available_sizes : PAFT_Bitmap_Size; // is array num_charmaps : FT_Int; charmaps : PAFT_CharMap; // is array generic : FT_Generic; (*# the following are only relevant to scalable outlines *) bbox : FT_BBox; units_per_EM : FT_UShort; ascender : FT_Short; descender : FT_Short; height : FT_Short; max_advance_width : FT_Short; max_advance_height : FT_Short; underline_position : FT_Short; underline_thickness : FT_Short; glyph : FT_GlyphSlot; size : FT_Size; charmap : FT_CharMap; end; (*************************************************************************) (* *) (* *) (* FT_CharMapRec *) (* *) (* *) (* The base charmap structure. *) (* *) (* *) (* face :: A handle to the parent face object. *) (* *) (* encoding :: An @FT_Encoding tag identifying the charmap. Use *) (* this with @FT_Select_Charmap. *) (* *) (* platform_id :: An ID number describing the platform for the *) (* following encoding ID. This comes directly from *) (* the TrueType specification and should be emulated *) (* for other formats. *) (* *) (* encoding_id :: A platform specific encoding number. This also *) (* comes from the TrueType specification and should be *) (* emulated similarly. *) (* *) FT_CharMapRec = record face : FT_Face; encoding : FT_Encoding; platform_id : FT_UShort; encoding_id : FT_UShort; end; {$I ftconfig.inc} {$I fttypes.inc} {$I ftimage.inc} {$I ftglyph.inc} {$I ftstroke.inc} {$I ftoutln.inc} { GLOBAL PROCEDURES } (*************************************************************************) (* *) (* @macro: *) (* FT_HAS_KERNING( face ) *) (* *) (* @description: *) (* A macro that returns true whenever a face object contains kerning *) (* data that can be accessed with @FT_Get_Kerning. *) (* *) function FT_HAS_KERNING(face : FT_Face ) : cbool; (*************************************************************************) (* *) (* @macro: *) (* FT_IS_SCALABLE( face ) *) (* *) (* @description: *) (* A macro that returns true whenever a face object contains a *) (* scalable font face (true for TrueType, Type 1, CID, and *) (* OpenType/CFF font formats. *) (* *) function FT_IS_SCALABLE(face : FT_Face ) : cbool; (*************************************************************************) (* *) (* *) (* FT_Init_FreeType *) (* *) (* *) (* Initializes a new FreeType library object. The set of modules *) (* that are registered by this function is determined at build time. *) (* *) (* *) (* alibrary :: A handle to a new library object. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) function FT_Init_FreeType(out alibrary : FT_Library ) : FT_Error; cdecl; external ft_lib name 'FT_Init_FreeType'; (*************************************************************************) (* *) (* *) (* FT_Done_FreeType *) (* *) (* *) (* Destroys a given FreeType library object and all of its childs, *) (* including resources, drivers, faces, sizes, etc. *) (* *) (* *) (* library :: A handle to the target library object. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) function FT_Done_FreeType(alibrary : FT_Library ) : FT_Error; cdecl; external ft_lib name 'FT_Done_FreeType'; (*************************************************************************) (* *) (* *) (* FT_Attach_File *) (* *) (* *) (* `Attaches' a given font file to an existing face. This is usually *) (* to read additional information for a single face object. For *) (* example, it is used to read the AFM files that come with Type 1 *) (* fonts in order to add kerning data and other metrics. *) (* *) (* *) (* face :: The target face object. *) (* *) (* *) (* filepathname :: An 8-bit pathname naming the `metrics' file. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* If your font file is in memory, or if you want to provide your *) (* own input stream object, use @FT_Attach_Stream. *) (* *) (* The meaning of the `attach' action (i.e., what really happens when *) (* the new file is read) is not fixed by FreeType itself. It really *) (* depends on the font format (and thus the font driver). *) (* *) (* Client applications are expected to know what they are doing *) (* when invoking this function. Most drivers simply do not implement *) (* file attachments. *) (* *) function FT_Attach_File(face : FT_Face; filepathname : PChar ) : FT_Error; cdecl; external ft_lib name 'FT_Attach_File'; (*************************************************************************) (* *) (* *) (* FT_New_Memory_Face *) (* *) (* *) (* Creates a new face object from a given resource and typeface index *) (* using a font file already loaded into memory. *) (* *) (* *) (* library :: A handle to the library resource. *) (* *) (* *) (* file_base :: A pointer to the beginning of the font data. *) (* *) (* file_size :: The size of the memory chunk used by the font data. *) (* *) (* face_index :: The index of the face within the resource. The *) (* first face has index 0. *) (* *) (* *) (* aface :: A handle to a new face object. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* The font data bytes are used _directly_ by the @FT_Face object. *) (* This means that they are not copied, and that the client is *) (* responsible for releasing/destroying them _after_ the *) (* corresponding call to @FT_Done_Face . *) (* *) (* Unlike FreeType 1.x, this function automatically creates a glyph *) (* slot for the face object which can be accessed directly through *) (* `face->glyph'. *) (* *) (* @FT_New_Memory_Face can be used to determine and/or check the font *) (* format of a given font resource. If the `face_index' field is *) (* negative, the function will _not_ return any face handle in *) (* `aface'; the return value is 0 if the font format is recognized, *) (* or non-zero otherwise. *) (* *) function FT_New_Memory_Face( library_ : FT_Library; file_base : PFT_Byte; file_size , face_index : FT_Long; out aface : FT_Face ) : FT_Error; cdecl; external ft_lib name 'FT_New_Memory_Face'; (*************************************************************************) (* *) (* *) (* FT_New_Face *) (* *) (* *) (* Creates a new face object from a given resource and typeface index *) (* using a pathname to the font file. *) (* *) (* *) (* library :: A handle to the library resource. *) (* *) (* *) (* pathname :: A path to the font file. *) (* *) (* face_index :: The index of the face within the resource. The *) (* first face has index 0. *) (* *) (* *) (* aface :: A handle to a new face object. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* Unlike FreeType 1.x, this function automatically creates a glyph *) (* slot for the face object which can be accessed directly through *) (* `face->glyph'. *) (* *) (* @FT_New_Face can be used to determine and/or check the font format *) (* of a given font resource. If the `face_index' field is negative, *) (* the function will _not_ return any face handle in `aface'; the *) (* return value is 0 if the font format is recognized, or non-zero *) (* otherwise. *) (* *) (* Each new face object created with this function also owns a *) (* default @FT_Size object, accessible as `face->size'. *) (* *) function FT_New_Face( library_ : FT_Library; filepathname : PChar; face_index : FT_Long; out aface : FT_Face ) : FT_Error; cdecl; external ft_lib name 'FT_New_Face'; (*************************************************************************) (* *) (* *) (* FT_Done_Face *) (* *) (* *) (* Discards a given face object, as well as all of its child slots *) (* and sizes. *) (* *) (* *) (* face :: A handle to a target face object. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) function FT_Done_Face(face : FT_Face ) : FT_Error; cdecl; external ft_lib name 'FT_Done_Face'; (*************************************************************************) (* *) (* *) (* FT_Select_Charmap *) (* *) (* *) (* Selects a given charmap by its encoding tag (as listed in *) (* `freetype.h'). *) (* *) (* *) (* face :: A handle to the source face object. *) (* *) (* *) (* encoding :: A handle to the selected charmap. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* This function will return an error if no charmap in the face *) (* corresponds to the encoding queried here. *) (* *) function FT_Select_Charmap(face : FT_Face; encoding : FT_Encoding ) : FT_Error; cdecl; external ft_lib name 'FT_Select_Charmap'; (*************************************************************************) (* *) (* *) (* FT_Get_Char_Index *) (* *) (* *) (* Returns the glyph index of a given character code. This function *) (* uses a charmap object to do the translation. *) (* *) (* *) (* face :: A handle to the source face object. *) (* *) (* charcode :: The character code. *) (* *) (* *) (* The glyph index. 0 means `undefined character code'. *) (* *) (* *) (* FreeType computes its own glyph indices which are not necessarily *) (* the same as used in the font in case the font is based on glyph *) (* indices. Reason for this behaviour is to assure that index 0 is *) (* never used, representing the missing glyph. *) (* *) function FT_Get_Char_Index(face : FT_Face; charcode : FT_ULong ) : FT_UInt; cdecl; external ft_lib name 'FT_Get_Char_Index'; (*************************************************************************) (* *) (* *) (* FT_Load_Glyph *) (* *) (* *) (* A function used to load a single glyph within a given glyph slot, *) (* for a given size. *) (* *) (* *) (* face :: A handle to the target face object where the glyph *) (* will be loaded. *) (* *) (* *) (* glyph_index :: The index of the glyph in the font file. For *) (* CID-keyed fonts (either in PS or in CFF format) *) (* this argument specifies the CID value. *) (* *) (* load_flags :: A flag indicating what to load for this glyph. The *) (* @FT_LOAD_XXX constants can be used to control the *) (* glyph loading process (e.g., whether the outline *) (* should be scaled, whether to load bitmaps or not, *) (* whether to hint the outline, etc). *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* If the glyph image is not a bitmap, and if the bit flag *) (* FT_LOAD_IGNORE_TRANSFORM is unset, the glyph image will be *) (* transformed with the information passed to a previous call to *) (* @FT_Set_Transform. *) (* *) (* Note that this also transforms the `face.glyph.advance' field, but *) (* *not* the values in `face.glyph.metrics'. *) (* *) function FT_Load_Glyph( face : FT_Face; glyph_index : FT_UInt ; load_flags : FT_Int32 ) : FT_Error; cdecl; external ft_lib name 'FT_Load_Glyph'; (*************************************************************************) (* *) (* *) (* FT_Render_Glyph *) (* *) (* *) (* Converts a given glyph image to a bitmap. It does so by *) (* inspecting the glyph image format, find the relevant renderer, and *) (* invoke it. *) (* *) (* *) (* slot :: A handle to the glyph slot containing the image to *) (* convert. *) (* *) (* *) (* render_mode :: This is the render mode used to render the glyph *) (* image into a bitmap. See FT_Render_Mode for a list *) (* of possible values. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) function FT_Render_Glyph(slot : FT_GlyphSlot; render_mode : FT_Render_Mode ) : FT_Error; cdecl; external ft_lib name 'FT_Render_Glyph'; (*************************************************************************) (* *) (* *) (* FT_Kerning_Mode *) (* *) (* *) (* An enumeration used to specify which kerning values to return in *) (* @FT_Get_Kerning. *) (* *) (* *) (* FT_KERNING_DEFAULT :: Return scaled and grid-fitted kerning *) (* distances (value is 0). *) (* *) (* FT_KERNING_UNFITTED :: Return scaled but un-grid-fitted kerning *) (* distances. *) (* *) (* FT_KERNING_UNSCALED :: Return the kerning vector in original font *) (* units. *) (* *) const FT_KERNING_DEFAULT = 0; FT_KERNING_UNFITTED = 1; FT_KERNING_UNSCALED = 2; (*************************************************************************) (* *) (* *) (* FT_Get_Kerning *) (* *) (* *) (* Returns the kerning vector between two glyphs of a same face. *) (* *) (* *) (* face :: A handle to a source face object. *) (* *) (* left_glyph :: The index of the left glyph in the kern pair. *) (* *) (* right_glyph :: The index of the right glyph in the kern pair. *) (* *) (* kern_mode :: See @FT_Kerning_Mode for more information. *) (* Determines the scale/dimension of the returned *) (* kerning vector. *) (* *) (* *) (* akerning :: The kerning vector. This is in font units for *) (* scalable formats, and in pixels for fixed-sizes *) (* formats. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* Only horizontal layouts (left-to-right & right-to-left) are *) (* supported by this method. Other layouts, or more sophisticated *) (* kernings, are out of the scope of this API function -- they can be *) (* implemented through format-specific interfaces. *) (* *) function FT_Get_Kerning( face : FT_Face; left_glyph , right_glyph , kern_mode : FT_UInt; out akerning : FT_Vector ) : FT_Error; cdecl; external ft_lib name 'FT_Get_Kerning'; (*************************************************************************) (* *) (* *) (* FT_Set_Char_Size *) (* *) (* *) (* Sets the character dimensions of a given face object. The *) (* `char_width' and `char_height' values are used for the width and *) (* height, respectively, expressed in 26.6 fractional points. *) (* *) (* If the horizontal or vertical resolution values are zero, a *) (* default value of 72dpi is used. Similarly, if one of the *) (* character dimensions is zero, its value is set equal to the other. *) (* *) (* *) (* face :: A handle to a target face object. *) (* *) (* *) (* char_width :: The character width, in 26.6 fractional points. *) (* *) (* char_height :: The character height, in 26.6 fractional *) (* points. *) (* *) (* horz_resolution :: The horizontal resolution. *) (* *) (* vert_resolution :: The vertical resolution. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* When dealing with fixed-size faces (i.e., non-scalable formats), *) (* @FT_Set_Pixel_Sizes provides a more convenient interface. *) (* *) function FT_Set_Char_Size( face : FT_Face; char_width , char_height : FT_F26dot6; horz_res , vert_res : FT_UInt) : FT_Error; cdecl; external ft_lib name 'FT_Set_Char_Size'; (*************************************************************************) (* *) (* *) (* FT_Set_Pixel_Sizes *) (* *) (* *) (* Sets the character dimensions of a given face object. The width *) (* and height are expressed in integer pixels. *) (* *) (* If one of the character dimensions is zero, its value is set equal *) (* to the other. *) (* *) (* *) (* face :: A handle to the target face object. *) (* *) (* *) (* pixel_width :: The character width, in integer pixels. *) (* *) (* pixel_height :: The character height, in integer pixels. *) (* *) (* *) (* FreeType error code. 0 means success. *) (* *) (* *) (* The values of `pixel_width' and `pixel_height' correspond to the *) (* pixel values of the _typographic_ character size, which are NOT *) (* necessarily the same as the dimensions of the glyph `bitmap *) (* cells'. *) (* *) (* The `character size' is really the size of an abstract square *) (* called the `EM', used to design the font. However, depending *) (* on the font design, glyphs will be smaller or greater than the *) (* EM. *) (* *) (* This means that setting the pixel size to, say, 8x8 doesn't *) (* guarantee in any way that you will get glyph bitmaps that all fit *) (* within an 8x8 cell (sometimes even far from it). *) (* *) (* For bitmap fonts, `pixel_height' usually is a reliable value for *) (* the height of the bitmap cell. Drivers for bitmap font formats *) (* which contain a single bitmap strike only (BDF, PCF, FNT) ignore *) (* `pixel_width'. *) (* *) function FT_Set_Pixel_Sizes( face : FT_Face; pixel_width , pixel_height : FT_UInt ) : FT_Error; cdecl; external ft_lib name 'FT_Set_Pixel_Sizes'; const FT_ANGLE_PI = 180 shl 16; FT_ANGLE_2PI = FT_ANGLE_PI * 2; FT_ANGLE_PI2 = FT_ANGLE_PI div 2; FT_ANGLE_PI4 = FT_ANGLE_PI div 4; implementation { FT_CURVE_TAG } function FT_CURVE_TAG(flag: byte): byte; begin result := flag and 3; end; { FT_HAS_KERNING } function FT_HAS_KERNING(face : FT_Face ) : cbool; begin result := cbool(face.face_flags and FT_FACE_FLAG_KERNING ); end; { FT_IS_SCALABLE } function FT_IS_SCALABLE(face : FT_Face ) : cbool; begin result := cbool(face.face_flags and FT_FACE_FLAG_SCALABLE ); end; end.