#include <ft2build.h>

Include dependency graph for freetype.h:

Classes
struct	FT_Glyph_Metrics_

struct	FT_Bitmap_Size_

struct	FT_CharMapRec_

struct	FT_FaceRec_

struct	FT_Size_Metrics_

struct	FT_SizeRec_

struct	FT_GlyphSlotRec_

struct	FT_Parameter_

struct	FT_Open_Args_

struct	FT_Size_RequestRec_

Macros
#define	FT_ENC_TAG(value, a, b, c, d)

#define	ft_encoding_none FT_ENCODING_NONE

#define	ft_encoding_unicode FT_ENCODING_UNICODE

#define	ft_encoding_symbol FT_ENCODING_MS_SYMBOL

#define	ft_encoding_latin_1 FT_ENCODING_ADOBE_LATIN_1

#define	ft_encoding_latin_2 FT_ENCODING_OLD_LATIN_2

#define	ft_encoding_sjis FT_ENCODING_SJIS

#define	ft_encoding_gb2312 FT_ENCODING_PRC

#define	ft_encoding_big5 FT_ENCODING_BIG5

#define	ft_encoding_wansung FT_ENCODING_WANSUNG

#define	ft_encoding_johab FT_ENCODING_JOHAB

#define	ft_encoding_adobe_standard FT_ENCODING_ADOBE_STANDARD

#define	ft_encoding_adobe_expert FT_ENCODING_ADOBE_EXPERT

#define	ft_encoding_adobe_custom FT_ENCODING_ADOBE_CUSTOM

#define	ft_encoding_apple_roman FT_ENCODING_APPLE_ROMAN

#define	FT_FACE_FLAG_SCALABLE ( 1L << 0 )

#define	FT_FACE_FLAG_FIXED_SIZES ( 1L << 1 )

#define	FT_FACE_FLAG_FIXED_WIDTH ( 1L << 2 )

#define	FT_FACE_FLAG_SFNT ( 1L << 3 )

#define	FT_FACE_FLAG_HORIZONTAL ( 1L << 4 )

#define	FT_FACE_FLAG_VERTICAL ( 1L << 5 )

#define	FT_FACE_FLAG_KERNING ( 1L << 6 )

#define	FT_FACE_FLAG_FAST_GLYPHS ( 1L << 7 )

#define	FT_FACE_FLAG_MULTIPLE_MASTERS ( 1L << 8 )

#define	FT_FACE_FLAG_GLYPH_NAMES ( 1L << 9 )

#define	FT_FACE_FLAG_EXTERNAL_STREAM ( 1L << 10 )

#define	FT_FACE_FLAG_HINTER ( 1L << 11 )

#define	FT_FACE_FLAG_CID_KEYED ( 1L << 12 )

#define	FT_FACE_FLAG_TRICKY ( 1L << 13 )

#define	FT_FACE_FLAG_COLOR ( 1L << 14 )

#define	FT_FACE_FLAG_VARIATION ( 1L << 15 )

#define	FT_HAS_HORIZONTAL(face) ( (face)->face_flags & FT_FACE_FLAG_HORIZONTAL )

#define	FT_HAS_VERTICAL(face) ( (face)->face_flags & FT_FACE_FLAG_VERTICAL )

#define	FT_HAS_KERNING(face) ( (face)->face_flags & FT_FACE_FLAG_KERNING )

#define	FT_IS_SCALABLE(face) ( (face)->face_flags & FT_FACE_FLAG_SCALABLE )

#define	FT_IS_SFNT(face) ( (face)->face_flags & FT_FACE_FLAG_SFNT )

#define	FT_IS_FIXED_WIDTH(face) ( (face)->face_flags & FT_FACE_FLAG_FIXED_WIDTH )

#define	FT_HAS_FIXED_SIZES(face) ( (face)->face_flags & FT_FACE_FLAG_FIXED_SIZES )

#define	FT_HAS_FAST_GLYPHS(face) 0

#define	FT_HAS_GLYPH_NAMES(face) ( (face)->face_flags & FT_FACE_FLAG_GLYPH_NAMES )

#define	FT_HAS_MULTIPLE_MASTERS(face) ( (face)->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS )

#define	FT_IS_NAMED_INSTANCE(face) ( (face)->face_index & 0x7FFF0000L )

#define	FT_IS_VARIATION(face) ( (face)->face_flags & FT_FACE_FLAG_VARIATION )

#define	FT_IS_CID_KEYED(face) ( (face)->face_flags & FT_FACE_FLAG_CID_KEYED )

#define	FT_IS_TRICKY(face) ( (face)->face_flags & FT_FACE_FLAG_TRICKY )

#define	FT_HAS_COLOR(face) ( (face)->face_flags & FT_FACE_FLAG_COLOR )

#define	FT_STYLE_FLAG_ITALIC ( 1 << 0 )

#define	FT_STYLE_FLAG_BOLD ( 1 << 1 )

#define	FT_OPEN_MEMORY 0x1

#define	FT_OPEN_STREAM 0x2

#define	FT_OPEN_PATHNAME 0x4

#define	FT_OPEN_DRIVER 0x8

#define	FT_OPEN_PARAMS 0x10

#define	ft_open_memory FT_OPEN_MEMORY

#define	ft_open_stream FT_OPEN_STREAM

#define	ft_open_pathname FT_OPEN_PATHNAME

#define	ft_open_driver FT_OPEN_DRIVER

#define	ft_open_params FT_OPEN_PARAMS

#define	FT_LOAD_DEFAULT 0x0

#define	FT_LOAD_NO_SCALE ( 1L << 0 )

#define	FT_LOAD_NO_HINTING ( 1L << 1 )

#define	FT_LOAD_RENDER ( 1L << 2 )

#define	FT_LOAD_NO_BITMAP ( 1L << 3 )

#define	FT_LOAD_VERTICAL_LAYOUT ( 1L << 4 )

#define	FT_LOAD_FORCE_AUTOHINT ( 1L << 5 )

#define	FT_LOAD_CROP_BITMAP ( 1L << 6 )

#define	FT_LOAD_PEDANTIC ( 1L << 7 )

#define	FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ( 1L << 9 )

#define	FT_LOAD_NO_RECURSE ( 1L << 10 )

#define	FT_LOAD_IGNORE_TRANSFORM ( 1L << 11 )

#define	FT_LOAD_MONOCHROME ( 1L << 12 )

#define	FT_LOAD_LINEAR_DESIGN ( 1L << 13 )

#define	FT_LOAD_NO_AUTOHINT ( 1L << 15 )

#define	FT_LOAD_COLOR ( 1L << 20 )

#define	FT_LOAD_COMPUTE_METRICS ( 1L << 21 )

#define	FT_LOAD_BITMAP_METRICS_ONLY ( 1L << 22 )

#define	FT_LOAD_ADVANCE_ONLY ( 1L << 8 )

#define	FT_LOAD_SBITS_ONLY ( 1L << 14 )

#define	FT_LOAD_TARGET_(x) ( (FT_Int32)( (x) & 15 ) << 16 )

#define	FT_LOAD_TARGET_NORMAL FT_LOAD_TARGET_( FT_RENDER_MODE_NORMAL )

#define	FT_LOAD_TARGET_LIGHT FT_LOAD_TARGET_( FT_RENDER_MODE_LIGHT )

#define	FT_LOAD_TARGET_MONO FT_LOAD_TARGET_( FT_RENDER_MODE_MONO )

#define	FT_LOAD_TARGET_LCD FT_LOAD_TARGET_( FT_RENDER_MODE_LCD )

#define	FT_LOAD_TARGET_LCD_V FT_LOAD_TARGET_( FT_RENDER_MODE_LCD_V )

#define	FT_LOAD_TARGET_MODE(x) ( (FT_Render_Mode)( ( (x) >> 16 ) & 15 ) )

#define	ft_render_mode_normal FT_RENDER_MODE_NORMAL

#define	ft_render_mode_mono FT_RENDER_MODE_MONO

#define	ft_kerning_default FT_KERNING_DEFAULT

#define	ft_kerning_unfitted FT_KERNING_UNFITTED

#define	ft_kerning_unscaled FT_KERNING_UNSCALED

#define	FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS 1

#define	FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES 2

#define	FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID 4

#define	FT_SUBGLYPH_FLAG_SCALE 8

#define	FT_SUBGLYPH_FLAG_XY_SCALE 0x40

#define	FT_SUBGLYPH_FLAG_2X2 0x80

#define	FT_SUBGLYPH_FLAG_USE_MY_METRICS 0x200

#define	FT_FSTYPE_INSTALLABLE_EMBEDDING 0x0000

#define	FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING 0x0002

#define	FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING 0x0004

#define	FT_FSTYPE_EDITABLE_EMBEDDING 0x0008

#define	FT_FSTYPE_NO_SUBSETTING 0x0100

#define	FT_FSTYPE_BITMAP_EMBEDDING_ONLY 0x0200

#define	FREETYPE_MAJOR 2

#define	FREETYPE_MINOR 9

#define	FREETYPE_PATCH 0

Typedefs
typedef FT_BEGIN_HEADER struct FT_Glyph_Metrics_	FT_Glyph_Metrics

typedef struct FT_Bitmap_Size_	FT_Bitmap_Size

typedef struct FT_LibraryRec_ *	FT_Library

typedef struct FT_ModuleRec_ *	FT_Module

typedef struct FT_DriverRec_ *	FT_Driver

typedef struct FT_RendererRec_ *	FT_Renderer

typedef struct FT_FaceRec_ *	FT_Face

typedef struct FT_SizeRec_ *	FT_Size

typedef struct FT_GlyphSlotRec_ *	FT_GlyphSlot

typedef struct FT_CharMapRec_ *	FT_CharMap

typedef enum FT_Encoding_	FT_Encoding

typedef struct FT_CharMapRec_	FT_CharMapRec

typedef struct FT_Face_InternalRec_ *	FT_Face_Internal

typedef struct FT_FaceRec_	FT_FaceRec

typedef struct FT_Size_InternalRec_ *	FT_Size_Internal

typedef struct FT_Size_Metrics_	FT_Size_Metrics

typedef struct FT_SizeRec_	FT_SizeRec

typedef struct FT_SubGlyphRec_ *	FT_SubGlyph

typedef struct FT_Slot_InternalRec_ *	FT_Slot_Internal

typedef struct FT_GlyphSlotRec_	FT_GlyphSlotRec

typedef struct FT_Parameter_	FT_Parameter

typedef struct FT_Open_Args_	FT_Open_Args

typedef enum FT_Size_Request_Type_	FT_Size_Request_Type

typedef struct FT_Size_RequestRec_	FT_Size_RequestRec

typedef struct FT_Size_RequestRec_ *	FT_Size_Request

typedef enum FT_Render_Mode_	FT_Render_Mode

typedef enum FT_Kerning_Mode_	FT_Kerning_Mode

Enumerations
enum	FT_Encoding_ { FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENCODING_GB2312 = FT_ENCODING_PRC, FT_ENCODING_MS_SJIS = FT_ENCODING_SJIS, FT_ENCODING_MS_GB2312 = FT_ENCODING_PRC, FT_ENCODING_MS_BIG5 = FT_ENCODING_BIG5, FT_ENCODING_MS_WANSUNG = FT_ENCODING_WANSUNG, FT_ENCODING_MS_JOHAB = FT_ENCODING_JOHAB, FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ), FT_ENC_TAG =( FT_ENCODING_NONE, 0, 0, 0, 0 ) }

enum	FT_Size_Request_Type_ { FT_SIZE_REQUEST_TYPE_NOMINAL, FT_SIZE_REQUEST_TYPE_REAL_DIM, FT_SIZE_REQUEST_TYPE_BBOX, FT_SIZE_REQUEST_TYPE_CELL, FT_SIZE_REQUEST_TYPE_SCALES, FT_SIZE_REQUEST_TYPE_MAX }

enum	FT_Render_Mode_ { FT_RENDER_MODE_NORMAL = 0, FT_RENDER_MODE_LIGHT, FT_RENDER_MODE_MONO, FT_RENDER_MODE_LCD, FT_RENDER_MODE_LCD_V, FT_RENDER_MODE_MAX }

enum	FT_Kerning_Mode_ { FT_KERNING_DEFAULT = 0, FT_KERNING_UNFITTED, FT_KERNING_UNSCALED }

Functions
	FT_Init_FreeType (FT_Library *alibrary)

	FT_Done_FreeType (FT_Library library)

	FT_New_Face (FT_Library library, const char filepathname, FT_Long face_index, FT_Face aface)

	FT_New_Memory_Face (FT_Library library, const FT_Byte file_base, FT_Long file_size, FT_Long face_index, FT_Face aface)

	FT_Open_Face (FT_Library library, const FT_Open_Args args, FT_Long face_index, FT_Face aface)

	FT_Attach_File (FT_Face face, const char *filepathname)

	FT_Attach_Stream (FT_Face face, FT_Open_Args *parameters)

	FT_Reference_Face (FT_Face face)

	FT_Done_Face (FT_Face face)

	FT_Select_Size (FT_Face face, FT_Int strike_index)

	FT_Request_Size (FT_Face face, FT_Size_Request req)

	FT_Set_Char_Size (FT_Face face, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt horz_resolution, FT_UInt vert_resolution)

	FT_Set_Pixel_Sizes (FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height)

	FT_Load_Glyph (FT_Face face, FT_UInt glyph_index, FT_Int32 load_flags)

	FT_Load_Char (FT_Face face, FT_ULong char_code, FT_Int32 load_flags)

	FT_Set_Transform (FT_Face face, FT_Matrix matrix, FT_Vector delta)

	FT_Render_Glyph (FT_GlyphSlot slot, FT_Render_Mode render_mode)

	FT_Get_Kerning (FT_Face face, FT_UInt left_glyph, FT_UInt right_glyph, FT_UInt kern_mode, FT_Vector *akerning)

	FT_Get_Track_Kerning (FT_Face face, FT_Fixed point_size, FT_Int degree, FT_Fixed *akerning)

	FT_Get_Glyph_Name (FT_Face face, FT_UInt glyph_index, FT_Pointer buffer, FT_UInt buffer_max)

	FT_Get_Postscript_Name (FT_Face face)

	FT_Select_Charmap (FT_Face face, FT_Encoding encoding)

	FT_Set_Charmap (FT_Face face, FT_CharMap charmap)

	FT_Get_Charmap_Index (FT_CharMap charmap)

	FT_Get_Char_Index (FT_Face face, FT_ULong charcode)

	FT_Get_First_Char (FT_Face face, FT_UInt *agindex)

	FT_Get_Next_Char (FT_Face face, FT_ULong char_code, FT_UInt *agindex)

	FT_Face_Properties (FT_Face face, FT_UInt num_properties, FT_Parameter *properties)

	FT_Get_Name_Index (FT_Face face, FT_String *glyph_name)

	FT_Get_SubGlyph_Info (FT_GlyphSlot glyph, FT_UInt sub_index, FT_Int p_index, FT_UInt p_flags, FT_Int p_arg1, FT_Int p_arg2, FT_Matrix *p_transform)

	FT_Get_FSType_Flags (FT_Face face)

	FT_Face_GetCharVariantIndex (FT_Face face, FT_ULong charcode, FT_ULong variantSelector)

	FT_Face_GetCharVariantIsDefault (FT_Face face, FT_ULong charcode, FT_ULong variantSelector)

	FT_Face_GetVariantSelectors (FT_Face face)

	FT_Face_GetVariantsOfChar (FT_Face face, FT_ULong charcode)

	FT_Face_GetCharsOfVariant (FT_Face face, FT_ULong variantSelector)

	FT_MulDiv (FT_Long a, FT_Long b, FT_Long c)

	FT_MulFix (FT_Long a, FT_Long b)

	FT_DivFix (FT_Long a, FT_Long b)

	FT_RoundFix (FT_Fixed a)

	FT_CeilFix (FT_Fixed a)

	FT_FloorFix (FT_Fixed a)

	FT_Vector_Transform (FT_Vector vec, const FT_Matrix matrix)

	FT_Library_Version (FT_Library library, FT_Int amajor, FT_Int aminor, FT_Int *apatch)

	FT_Face_CheckTrueTypePatents (FT_Face face)

	FT_Face_SetUnpatentedHinting (FT_Face face, FT_Bool value)

Macro Definition Documentation

◆ FREETYPE_MAJOR

#define FREETYPE_MAJOR 2

Definition at line 4553 of file freetype.h.

◆ FREETYPE_MINOR

#define FREETYPE_MINOR 9

Definition at line 4554 of file freetype.h.

◆ FREETYPE_PATCH

#define FREETYPE_PATCH 0

Definition at line 4555 of file freetype.h.

◆ FT_ENC_TAG

#define FT_ENC_TAG	(	value,
		a,
		b,
		c,
		d
	)

Value:

value = ( ( (FT_UInt32)(a) << 24 ) |  \
                    ( (FT_UInt32)(b) << 16 ) |  \
                    ( (FT_UInt32)(c) <<  8 ) |  \
                      (FT_UInt32)(d)         )

Definition at line 613 of file freetype.h.

◆ ft_encoding_adobe_custom

#define ft_encoding_adobe_custom FT_ENCODING_ADOBE_CUSTOM

Definition at line 813 of file freetype.h.

◆ ft_encoding_adobe_expert

#define ft_encoding_adobe_expert FT_ENCODING_ADOBE_EXPERT

Definition at line 812 of file freetype.h.

◆ ft_encoding_adobe_standard

#define ft_encoding_adobe_standard FT_ENCODING_ADOBE_STANDARD

Definition at line 811 of file freetype.h.

◆ ft_encoding_apple_roman

#define ft_encoding_apple_roman FT_ENCODING_APPLE_ROMAN

Definition at line 814 of file freetype.h.

◆ ft_encoding_big5

#define ft_encoding_big5 FT_ENCODING_BIG5

Definition at line 807 of file freetype.h.

◆ ft_encoding_gb2312

#define ft_encoding_gb2312 FT_ENCODING_PRC

Definition at line 806 of file freetype.h.

◆ ft_encoding_johab

#define ft_encoding_johab FT_ENCODING_JOHAB

Definition at line 809 of file freetype.h.

◆ ft_encoding_latin_1

#define ft_encoding_latin_1 FT_ENCODING_ADOBE_LATIN_1

Definition at line 803 of file freetype.h.

◆ ft_encoding_latin_2

#define ft_encoding_latin_2 FT_ENCODING_OLD_LATIN_2

Definition at line 804 of file freetype.h.

◆ ft_encoding_none

#define ft_encoding_none FT_ENCODING_NONE

Definition at line 800 of file freetype.h.

◆ ft_encoding_sjis

#define ft_encoding_sjis FT_ENCODING_SJIS

Definition at line 805 of file freetype.h.

◆ ft_encoding_symbol

#define ft_encoding_symbol FT_ENCODING_MS_SYMBOL

Definition at line 802 of file freetype.h.

◆ ft_encoding_unicode

#define ft_encoding_unicode FT_ENCODING_UNICODE

Definition at line 801 of file freetype.h.

◆ ft_encoding_wansung

#define ft_encoding_wansung FT_ENCODING_WANSUNG

Definition at line 808 of file freetype.h.

◆ FT_FACE_FLAG_CID_KEYED

#define FT_FACE_FLAG_CID_KEYED ( 1L << 12 )

Definition at line 1250 of file freetype.h.

◆ FT_FACE_FLAG_COLOR

#define FT_FACE_FLAG_COLOR ( 1L << 14 )

Definition at line 1252 of file freetype.h.

◆ FT_FACE_FLAG_EXTERNAL_STREAM

#define FT_FACE_FLAG_EXTERNAL_STREAM ( 1L << 10 )

Definition at line 1248 of file freetype.h.

◆ FT_FACE_FLAG_FAST_GLYPHS

#define FT_FACE_FLAG_FAST_GLYPHS ( 1L << 7 )

Definition at line 1245 of file freetype.h.

◆ FT_FACE_FLAG_FIXED_SIZES

#define FT_FACE_FLAG_FIXED_SIZES ( 1L << 1 )

Definition at line 1239 of file freetype.h.

◆ FT_FACE_FLAG_FIXED_WIDTH

#define FT_FACE_FLAG_FIXED_WIDTH ( 1L << 2 )

Definition at line 1240 of file freetype.h.

◆ FT_FACE_FLAG_GLYPH_NAMES

#define FT_FACE_FLAG_GLYPH_NAMES ( 1L << 9 )

Definition at line 1247 of file freetype.h.

◆ FT_FACE_FLAG_HINTER

#define FT_FACE_FLAG_HINTER ( 1L << 11 )

Definition at line 1249 of file freetype.h.

◆ FT_FACE_FLAG_HORIZONTAL

#define FT_FACE_FLAG_HORIZONTAL ( 1L << 4 )

Definition at line 1242 of file freetype.h.

◆ FT_FACE_FLAG_KERNING

#define FT_FACE_FLAG_KERNING ( 1L << 6 )

Definition at line 1244 of file freetype.h.

◆ FT_FACE_FLAG_MULTIPLE_MASTERS

#define FT_FACE_FLAG_MULTIPLE_MASTERS ( 1L << 8 )

Definition at line 1246 of file freetype.h.

◆ FT_FACE_FLAG_SCALABLE

#define FT_FACE_FLAG_SCALABLE ( 1L << 0 )

Definition at line 1238 of file freetype.h.

◆ FT_FACE_FLAG_SFNT

#define FT_FACE_FLAG_SFNT ( 1L << 3 )

Definition at line 1241 of file freetype.h.

◆ FT_FACE_FLAG_TRICKY

#define FT_FACE_FLAG_TRICKY ( 1L << 13 )

Definition at line 1251 of file freetype.h.

◆ FT_FACE_FLAG_VARIATION

#define FT_FACE_FLAG_VARIATION ( 1L << 15 )

Definition at line 1253 of file freetype.h.

◆ FT_FACE_FLAG_VERTICAL

#define FT_FACE_FLAG_VERTICAL ( 1L << 5 )

Definition at line 1243 of file freetype.h.

◆ FT_FSTYPE_BITMAP_EMBEDDING_ONLY

#define FT_FSTYPE_BITMAP_EMBEDDING_ONLY 0x0200

Definition at line 4042 of file freetype.h.

◆ FT_FSTYPE_EDITABLE_EMBEDDING

#define FT_FSTYPE_EDITABLE_EMBEDDING 0x0008

Definition at line 4040 of file freetype.h.

◆ FT_FSTYPE_INSTALLABLE_EMBEDDING

#define FT_FSTYPE_INSTALLABLE_EMBEDDING 0x0000

Definition at line 4037 of file freetype.h.

◆ FT_FSTYPE_NO_SUBSETTING

#define FT_FSTYPE_NO_SUBSETTING 0x0100

Definition at line 4041 of file freetype.h.

◆ FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING

#define FT_FSTYPE_PREVIEW_AND_PRINT_EMBEDDING 0x0004

Definition at line 4039 of file freetype.h.

◆ FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING

#define FT_FSTYPE_RESTRICTED_LICENSE_EMBEDDING 0x0002

Definition at line 4038 of file freetype.h.

◆ FT_HAS_COLOR

#define FT_HAS_COLOR ( face ) ( (face)->face_flags & FT_FACE_FLAG_COLOR )

Definition at line 1491 of file freetype.h.

◆ FT_HAS_FAST_GLYPHS

#define FT_HAS_FAST_GLYPHS ( face ) 0

Definition at line 1374 of file freetype.h.

◆ FT_HAS_FIXED_SIZES

#define FT_HAS_FIXED_SIZES ( face ) ( (face)->face_flags & FT_FACE_FLAG_FIXED_SIZES )

Definition at line 1361 of file freetype.h.

◆ FT_HAS_GLYPH_NAMES

#define FT_HAS_GLYPH_NAMES ( face ) ( (face)->face_flags & FT_FACE_FLAG_GLYPH_NAMES )

Definition at line 1387 of file freetype.h.

◆ FT_HAS_HORIZONTAL

#define FT_HAS_HORIZONTAL ( face ) ( (face)->face_flags & FT_FACE_FLAG_HORIZONTAL )

Definition at line 1269 of file freetype.h.

◆ FT_HAS_KERNING

#define FT_HAS_KERNING ( face ) ( (face)->face_flags & FT_FACE_FLAG_KERNING )

Definition at line 1297 of file freetype.h.

◆ FT_HAS_MULTIPLE_MASTERS

#define FT_HAS_MULTIPLE_MASTERS ( face ) ( (face)->face_flags & FT_FACE_FLAG_MULTIPLE_MASTERS )

Definition at line 1402 of file freetype.h.

◆ FT_HAS_VERTICAL

#define FT_HAS_VERTICAL ( face ) ( (face)->face_flags & FT_FACE_FLAG_VERTICAL )

Definition at line 1283 of file freetype.h.

◆ FT_IS_CID_KEYED

#define FT_IS_CID_KEYED ( face ) ( (face)->face_flags & FT_FACE_FLAG_CID_KEYED )

Definition at line 1460 of file freetype.h.

◆ FT_IS_FIXED_WIDTH

#define FT_IS_FIXED_WIDTH ( face ) ( (face)->face_flags & FT_FACE_FLAG_FIXED_WIDTH )

Definition at line 1346 of file freetype.h.

◆ FT_IS_NAMED_INSTANCE

#define FT_IS_NAMED_INSTANCE ( face ) ( (face)->face_index & 0x7FFF0000L )

Definition at line 1424 of file freetype.h.

◆ FT_IS_SCALABLE

#define FT_IS_SCALABLE ( face ) ( (face)->face_flags & FT_FACE_FLAG_SCALABLE )

Definition at line 1312 of file freetype.h.

◆ FT_IS_SFNT

#define FT_IS_SFNT ( face ) ( (face)->face_flags & FT_FACE_FLAG_SFNT )

Definition at line 1331 of file freetype.h.

◆ FT_IS_TRICKY

#define FT_IS_TRICKY ( face ) ( (face)->face_flags & FT_FACE_FLAG_TRICKY )

Definition at line 1474 of file freetype.h.

◆ FT_IS_VARIATION

#define FT_IS_VARIATION ( face ) ( (face)->face_flags & FT_FACE_FLAG_VARIATION )

Definition at line 1442 of file freetype.h.

◆ ft_kerning_default

#define ft_kerning_default FT_KERNING_DEFAULT

Definition at line 3398 of file freetype.h.

◆ ft_kerning_unfitted

#define ft_kerning_unfitted FT_KERNING_UNFITTED

Definition at line 3399 of file freetype.h.

◆ ft_kerning_unscaled

#define ft_kerning_unscaled FT_KERNING_UNSCALED

Definition at line 3400 of file freetype.h.

◆ FT_LOAD_ADVANCE_ONLY

#define FT_LOAD_ADVANCE_ONLY ( 1L << 8 )

Definition at line 3031 of file freetype.h.

◆ FT_LOAD_BITMAP_METRICS_ONLY

#define FT_LOAD_BITMAP_METRICS_ONLY ( 1L << 22 )

Definition at line 3026 of file freetype.h.

◆ FT_LOAD_COLOR

#define FT_LOAD_COLOR ( 1L << 20 )

Definition at line 3024 of file freetype.h.

◆ FT_LOAD_COMPUTE_METRICS

#define FT_LOAD_COMPUTE_METRICS ( 1L << 21 )

Definition at line 3025 of file freetype.h.

◆ FT_LOAD_CROP_BITMAP

#define FT_LOAD_CROP_BITMAP ( 1L << 6 )

Definition at line 3015 of file freetype.h.

◆ FT_LOAD_DEFAULT

#define FT_LOAD_DEFAULT 0x0

Definition at line 3008 of file freetype.h.

◆ FT_LOAD_FORCE_AUTOHINT

#define FT_LOAD_FORCE_AUTOHINT ( 1L << 5 )

Definition at line 3014 of file freetype.h.

◆ FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH

#define FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH ( 1L << 9 )

Definition at line 3017 of file freetype.h.

◆ FT_LOAD_IGNORE_TRANSFORM

#define FT_LOAD_IGNORE_TRANSFORM ( 1L << 11 )

Definition at line 3019 of file freetype.h.

◆ FT_LOAD_LINEAR_DESIGN

#define FT_LOAD_LINEAR_DESIGN ( 1L << 13 )

Definition at line 3021 of file freetype.h.

◆ FT_LOAD_MONOCHROME

#define FT_LOAD_MONOCHROME ( 1L << 12 )

Definition at line 3020 of file freetype.h.

◆ FT_LOAD_NO_AUTOHINT

#define FT_LOAD_NO_AUTOHINT ( 1L << 15 )

Definition at line 3022 of file freetype.h.

◆ FT_LOAD_NO_BITMAP

#define FT_LOAD_NO_BITMAP ( 1L << 3 )

Definition at line 3012 of file freetype.h.

◆ FT_LOAD_NO_HINTING

#define FT_LOAD_NO_HINTING ( 1L << 1 )

Definition at line 3010 of file freetype.h.

◆ FT_LOAD_NO_RECURSE

#define FT_LOAD_NO_RECURSE ( 1L << 10 )

Definition at line 3018 of file freetype.h.

◆ FT_LOAD_NO_SCALE

#define FT_LOAD_NO_SCALE ( 1L << 0 )

Definition at line 3009 of file freetype.h.

◆ FT_LOAD_PEDANTIC

#define FT_LOAD_PEDANTIC ( 1L << 7 )

Definition at line 3016 of file freetype.h.

◆ FT_LOAD_RENDER

#define FT_LOAD_RENDER ( 1L << 2 )

Definition at line 3011 of file freetype.h.

◆ FT_LOAD_SBITS_ONLY

#define FT_LOAD_SBITS_ONLY ( 1L << 14 )

Definition at line 3032 of file freetype.h.

◆ FT_LOAD_TARGET_

#define FT_LOAD_TARGET_ ( x ) ( (FT_Int32)( (x) & 15 ) << 16 )

Definition at line 3118 of file freetype.h.

◆ FT_LOAD_TARGET_LCD

#define FT_LOAD_TARGET_LCD FT_LOAD_TARGET_( FT_RENDER_MODE_LCD )

Definition at line 3123 of file freetype.h.

◆ FT_LOAD_TARGET_LCD_V

#define FT_LOAD_TARGET_LCD_V FT_LOAD_TARGET_( FT_RENDER_MODE_LCD_V )

Definition at line 3124 of file freetype.h.

◆ FT_LOAD_TARGET_LIGHT

#define FT_LOAD_TARGET_LIGHT FT_LOAD_TARGET_( FT_RENDER_MODE_LIGHT )

Definition at line 3121 of file freetype.h.

◆ FT_LOAD_TARGET_MODE

#define FT_LOAD_TARGET_MODE ( x ) ( (FT_Render_Mode)( ( (x) >> 16 ) & 15 ) )

Definition at line 3137 of file freetype.h.

◆ FT_LOAD_TARGET_MONO

#define FT_LOAD_TARGET_MONO FT_LOAD_TARGET_( FT_RENDER_MODE_MONO )

Definition at line 3122 of file freetype.h.

◆ FT_LOAD_TARGET_NORMAL

#define FT_LOAD_TARGET_NORMAL FT_LOAD_TARGET_( FT_RENDER_MODE_NORMAL )

Definition at line 3120 of file freetype.h.

◆ FT_LOAD_VERTICAL_LAYOUT

#define FT_LOAD_VERTICAL_LAYOUT ( 1L << 4 )

Definition at line 3013 of file freetype.h.

◆ FT_OPEN_DRIVER

#define FT_OPEN_DRIVER 0x8

Definition at line 2037 of file freetype.h.

◆ ft_open_driver

#define ft_open_driver FT_OPEN_DRIVER

Definition at line 2046 of file freetype.h.

◆ FT_OPEN_MEMORY

#define FT_OPEN_MEMORY 0x1

Definition at line 2034 of file freetype.h.

◆ ft_open_memory

#define ft_open_memory FT_OPEN_MEMORY

Definition at line 2043 of file freetype.h.

◆ FT_OPEN_PARAMS

#define FT_OPEN_PARAMS 0x10

Definition at line 2038 of file freetype.h.

◆ ft_open_params

#define ft_open_params FT_OPEN_PARAMS

Definition at line 2047 of file freetype.h.

◆ FT_OPEN_PATHNAME

#define FT_OPEN_PATHNAME 0x4

Definition at line 2036 of file freetype.h.

◆ ft_open_pathname

#define ft_open_pathname FT_OPEN_PATHNAME

Definition at line 2045 of file freetype.h.

◆ FT_OPEN_STREAM

#define FT_OPEN_STREAM 0x2

Definition at line 2035 of file freetype.h.

◆ ft_open_stream

#define ft_open_stream FT_OPEN_STREAM

Definition at line 2044 of file freetype.h.

◆ ft_render_mode_mono

#define ft_render_mode_mono FT_RENDER_MODE_MONO

Definition at line 3248 of file freetype.h.

◆ ft_render_mode_normal

#define ft_render_mode_normal FT_RENDER_MODE_NORMAL

Definition at line 3247 of file freetype.h.

◆ FT_STYLE_FLAG_BOLD

#define FT_STYLE_FLAG_BOLD ( 1 << 1 )

Definition at line 1518 of file freetype.h.

◆ FT_STYLE_FLAG_ITALIC

#define FT_STYLE_FLAG_ITALIC ( 1 << 0 )

Definition at line 1517 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_2X2

#define FT_SUBGLYPH_FLAG_2X2 0x80

Definition at line 3927 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS

#define FT_SUBGLYPH_FLAG_ARGS_ARE_WORDS 1

Definition at line 3922 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES

#define FT_SUBGLYPH_FLAG_ARGS_ARE_XY_VALUES 2

Definition at line 3923 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID

#define FT_SUBGLYPH_FLAG_ROUND_XY_TO_GRID 4

Definition at line 3924 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_SCALE

#define FT_SUBGLYPH_FLAG_SCALE 8

Definition at line 3925 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_USE_MY_METRICS

#define FT_SUBGLYPH_FLAG_USE_MY_METRICS 0x200

Definition at line 3928 of file freetype.h.

◆ FT_SUBGLYPH_FLAG_XY_SCALE

#define FT_SUBGLYPH_FLAG_XY_SCALE 0x40

Definition at line 3926 of file freetype.h.

Typedef Documentation

◆ FT_Bitmap_Size

typedef struct FT_Bitmap_Size_ FT_Bitmap_Size

◆ FT_CharMap

typedef struct FT_CharMapRec_* FT_CharMap

Definition at line 588 of file freetype.h.

◆ FT_CharMapRec

typedef struct FT_CharMapRec_ FT_CharMapRec

◆ FT_Driver

typedef struct FT_DriverRec_* FT_Driver

Definition at line 449 of file freetype.h.

◆ FT_Encoding

typedef enum FT_Encoding_ FT_Encoding

◆ FT_Face

typedef struct FT_FaceRec_* FT_Face

Definition at line 503 of file freetype.h.

◆ FT_Face_Internal

typedef struct FT_Face_InternalRec_* FT_Face_Internal

Definition at line 871 of file freetype.h.

◆ FT_FaceRec

typedef struct FT_FaceRec_ FT_FaceRec

◆ FT_Glyph_Metrics

typedef FT_BEGIN_HEADER struct FT_Glyph_Metrics_ FT_Glyph_Metrics

◆ FT_GlyphSlot

typedef struct FT_GlyphSlotRec_* FT_GlyphSlot

Definition at line 554 of file freetype.h.

◆ FT_GlyphSlotRec

typedef struct FT_GlyphSlotRec_ FT_GlyphSlotRec

◆ FT_Kerning_Mode

typedef enum FT_Kerning_Mode_ FT_Kerning_Mode

◆ FT_Library

typedef struct FT_LibraryRec_* FT_Library

Definition at line 417 of file freetype.h.

◆ FT_Module

typedef struct FT_ModuleRec_* FT_Module

Definition at line 437 of file freetype.h.

◆ FT_Open_Args

typedef struct FT_Open_Args_ FT_Open_Args

◆ FT_Parameter

typedef struct FT_Parameter_ FT_Parameter

◆ FT_Render_Mode

typedef enum FT_Render_Mode_ FT_Render_Mode

◆ FT_Renderer

typedef struct FT_RendererRec_* FT_Renderer

Definition at line 463 of file freetype.h.

◆ FT_Size

typedef struct FT_SizeRec_* FT_Size

Definition at line 534 of file freetype.h.

◆ FT_Size_Internal

typedef struct FT_Size_InternalRec_* FT_Size_Internal

Definition at line 1530 of file freetype.h.

◆ FT_Size_Metrics

typedef struct FT_Size_Metrics_ FT_Size_Metrics

◆ FT_Size_Request

typedef struct FT_Size_RequestRec_* FT_Size_Request

Definition at line 2636 of file freetype.h.

◆ FT_Size_Request_Type

typedef enum FT_Size_Request_Type_ FT_Size_Request_Type

◆ FT_Size_RequestRec

typedef struct FT_Size_RequestRec_ FT_Size_RequestRec

◆ FT_SizeRec

typedef struct FT_SizeRec_ FT_SizeRec

◆ FT_Slot_Internal

typedef struct FT_Slot_InternalRec_* FT_Slot_Internal

Definition at line 1711 of file freetype.h.

◆ FT_SubGlyph

typedef struct FT_SubGlyphRec_* FT_SubGlyph

Definition at line 1699 of file freetype.h.

Enumeration Type Documentation

◆ FT_Encoding_

enum FT_Encoding_

Enumerator
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENCODING_GB2312
FT_ENCODING_MS_SJIS
FT_ENCODING_MS_GB2312
FT_ENCODING_MS_BIG5
FT_ENCODING_MS_WANSUNG
FT_ENCODING_MS_JOHAB
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG
FT_ENC_TAG

Definition at line 765 of file freetype.h.

   {
     FT_ENC_TAG( FT_ENCODING_NONE, 0, 0, 0, 0 ),
 
     FT_ENC_TAG( FT_ENCODING_MS_SYMBOL, 's', 'y', 'm', 'b' ),
     FT_ENC_TAG( FT_ENCODING_UNICODE,   'u', 'n', 'i', 'c' ),
 
     FT_ENC_TAG( FT_ENCODING_SJIS,    's', 'j', 'i', 's' ),
     FT_ENC_TAG( FT_ENCODING_PRC,     'g', 'b', ' ', ' ' ),
     FT_ENC_TAG( FT_ENCODING_BIG5,    'b', 'i', 'g', '5' ),
     FT_ENC_TAG( FT_ENCODING_WANSUNG, 'w', 'a', 'n', 's' ),
     FT_ENC_TAG( FT_ENCODING_JOHAB,   'j', 'o', 'h', 'a' ),
 
     /* for backward compatibility */
     FT_ENCODING_GB2312     = FT_ENCODING_PRC,
     FT_ENCODING_MS_SJIS    = FT_ENCODING_SJIS,
     FT_ENCODING_MS_GB2312  = FT_ENCODING_PRC,
     FT_ENCODING_MS_BIG5    = FT_ENCODING_BIG5,
     FT_ENCODING_MS_WANSUNG = FT_ENCODING_WANSUNG,
     FT_ENCODING_MS_JOHAB   = FT_ENCODING_JOHAB,
 
     FT_ENC_TAG( FT_ENCODING_ADOBE_STANDARD, 'A', 'D', 'O', 'B' ),
     FT_ENC_TAG( FT_ENCODING_ADOBE_EXPERT,   'A', 'D', 'B', 'E' ),
     FT_ENC_TAG( FT_ENCODING_ADOBE_CUSTOM,   'A', 'D', 'B', 'C' ),
     FT_ENC_TAG( FT_ENCODING_ADOBE_LATIN_1,  'l', 'a', 't', '1' ),
 
     FT_ENC_TAG( FT_ENCODING_OLD_LATIN_2, 'l', 'a', 't', '2' ),
 
     FT_ENC_TAG( FT_ENCODING_APPLE_ROMAN, 'a', 'r', 'm', 'n' )
 
   } FT_Encoding;

◆ FT_Kerning_Mode_

enum FT_Kerning_Mode_

Enumerator
FT_KERNING_DEFAULT
FT_KERNING_UNFITTED
FT_KERNING_UNSCALED

Definition at line 3387 of file freetype.h.

   {
     FT_KERNING_DEFAULT = 0,
     FT_KERNING_UNFITTED,
     FT_KERNING_UNSCALED
 
   } FT_Kerning_Mode;

◆ FT_Render_Mode_

enum FT_Render_Mode_

Enumerator
FT_RENDER_MODE_NORMAL
FT_RENDER_MODE_LIGHT
FT_RENDER_MODE_MONO
FT_RENDER_MODE_LCD
FT_RENDER_MODE_LCD_V
FT_RENDER_MODE_MAX

Definition at line 3232 of file freetype.h.

   {
     FT_RENDER_MODE_NORMAL = 0,
     FT_RENDER_MODE_LIGHT,
     FT_RENDER_MODE_MONO,
     FT_RENDER_MODE_LCD,
     FT_RENDER_MODE_LCD_V,
 
     FT_RENDER_MODE_MAX
 
   } FT_Render_Mode;

◆ FT_Size_Request_Type_

enum FT_Size_Request_Type_

Enumerator
FT_SIZE_REQUEST_TYPE_NOMINAL
FT_SIZE_REQUEST_TYPE_REAL_DIM
FT_SIZE_REQUEST_TYPE_BBOX
FT_SIZE_REQUEST_TYPE_CELL
FT_SIZE_REQUEST_TYPE_SCALES
FT_SIZE_REQUEST_TYPE_MAX

Definition at line 2568 of file freetype.h.

   {
     FT_SIZE_REQUEST_TYPE_NOMINAL,
     FT_SIZE_REQUEST_TYPE_REAL_DIM,
     FT_SIZE_REQUEST_TYPE_BBOX,
     FT_SIZE_REQUEST_TYPE_CELL,
     FT_SIZE_REQUEST_TYPE_SCALES,
 
     FT_SIZE_REQUEST_TYPE_MAX
 
   } FT_Size_Request_Type;

Function Documentation

◆ FT_Attach_File()

FT_Attach_File	(	FT_Face	face,
		const char *	filepathname
	)

Definition at line 2641 of file ftobjs.c.

   {
     FT_Open_Args  open;
 
 
     /* test for valid `face' delayed to `FT_Attach_Stream' */
 
     if ( !filepathname )
       return FT_THROW( Invalid_Argument );
 
     open.stream   = NULL;
     open.flags    = FT_OPEN_PATHNAME;
     open.pathname = (char*)filepathname;
 
     return FT_Attach_Stream( face, &open );
   }

◆ FT_Attach_Stream()

FT_Attach_Stream	(	FT_Face	face,
		FT_Open_Args *	parameters
	)

Definition at line 2663 of file ftobjs.c.

   {
     FT_Stream  stream;
     FT_Error   error;
     FT_Driver  driver;
 
     FT_Driver_Class  clazz;
 
 
     /* test for valid `parameters' delayed to `FT_Stream_New' */
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     driver = face->driver;
     if ( !driver )
       return FT_THROW( Invalid_Driver_Handle );
 
     error = FT_Stream_New( driver->root.library, parameters, &stream );
     if ( error )
       goto Exit;
 
     /* we implement FT_Attach_Stream in each driver through the */
     /* `attach_file' interface                                  */
 
     error = FT_ERR( Unimplemented_Feature );
     clazz = driver->clazz;
     if ( clazz->attach_file )
       error = clazz->attach_file( face, stream );
 
     /* close the attached stream */
     FT_Stream_Free( stream,
                     (FT_Bool)( parameters->stream &&
                                ( parameters->flags & FT_OPEN_STREAM ) ) );
 
   Exit:
     return error;
   }

Referenced by FT_Attach_File().

◆ FT_CeilFix()

FT_CeilFix ( FT_Fixed a )

Definition at line 97 of file ftcalc.c.

   {
     return ( ADD_LONG( a, 0xFFFFL ) ) & ~0xFFFFL;
   }

◆ FT_DivFix()

FT_DivFix	(	FT_Long	a,
		FT_Long	b
	)

Definition at line 608 of file ftcalc.c.

   {
     FT_Int     s = 1;
     FT_UInt32  a, b, q;
     FT_Long    q_;
 
 
     /* XXX: this function does not allow 64-bit arguments */
 
     a = (FT_UInt32)a_;
     b = (FT_UInt32)b_;
 
     FT_MOVE_SIGN( a_, a, s );
     FT_MOVE_SIGN( b_, b, s );
 
     if ( b == 0 )
     {
       /* check for division by 0 */
       q = 0x7FFFFFFFUL;
     }
     else if ( a <= 65535UL - ( b >> 17 ) )
     {
       /* compute result directly */
       q = ( ( a << 16 ) + ( b >> 1 ) ) / b;
     }
     else
     {
       /* we need more bits; we have to do it by hand */
       FT_Int64  temp, temp2;
 
 
       temp.hi  = a >> 16;
       temp.lo  = a << 16;
       temp2.hi = 0;
       temp2.lo = b >> 1;
 
       FT_Add64( &temp, &temp2, &temp );
       q = ft_div64by32( temp.hi, temp.lo, b );
     }
 
     q_ = (FT_Long)q;
 
     return s < 0 ? NEG_LONG( q_ ) : q_;
   }

Referenced by af_glyph_hints_align_strong_points(), af_iup_interp(), af_latin_hints_compute_edges(), af_loader_compute_darkening(), af_loader_embolden_glyph_in_slot(), af_loader_load_glyph(), cf2_blues_init(), cf2_checkTransform(), cf2_computeDarkening(), cf2_font_setup(), cf2_getBlueMetrics(), cf2_glyphpath_computeIntersection(), cf2_hintmap_adjustHints(), cf2_interpT2CharString(), cff_blend_build_vector(), cff_face_init(), cff_parse_fixed_dynamic(), cff_parse_real(), cid_parse_font_matrix(), compute_glyph_metrics(), FT_Matrix_Invert(), FT_Request_Metrics(), FT_Select_Metrics(), FT_Stroker_ConicTo(), FT_Stroker_CubicTo(), ft_stroker_inside(), ft_stroker_outside(), FT_Tan(), mm_axis_unmap(), pfr_get_metrics(), PS_Conv_ToFixed(), psh_globals_new(), psh_glyph_find_strong_points(), psh_glyph_interpolate_other_points(), t1_parse_font_matrix(), t42_parse_font_matrix(), and tt_size_reset().

◆ FT_Done_Face()

FT_Done_Face ( FT_Face face )

Definition at line 2721 of file ftobjs.c.

   {
     FT_Error     error;
     FT_Driver    driver;
     FT_Memory    memory;
     FT_ListNode  node;
 
 
     error = FT_ERR( Invalid_Face_Handle );
     if ( face && face->driver )
     {
       face->internal->refcount--;
       if ( face->internal->refcount > 0 )
         error = FT_Err_Ok;
       else
       {
         driver = face->driver;
         memory = driver->root.memory;
 
         /* find face in driver's list */
         node = FT_List_Find( &driver->faces_list, face );
         if ( node )
         {
           /* remove face object from the driver's list */
           FT_List_Remove( &driver->faces_list, node );
           FT_FREE( node );
 
           /* now destroy the object proper */
           destroy_face( memory, face, driver );
           error = FT_Err_Ok;
         }
       }
     }
 
     return error;
   }

Referenced by ExecuteTest(), FT_Done_Library(), ft_open_face_internal(), ftc_face_node_done(), FtfdQueryFont(), FtfdUnloadFontFile(), SharedFace_Release(), T42_Face_Done(), and TestFace().

◆ FT_Done_FreeType()

FT_Done_FreeType ( FT_Library library )

Definition at line 356 of file ftinit.c.

   {
     FT_Memory  memory;
 
 
     if ( !library )
       return FT_THROW( Invalid_Library_Handle );
 
     memory = library->memory;
 
     /* Discard the library object */
     FT_Done_Library( library );
 
     /* discard memory manager */
     FT_Done_Memory( memory );
 
     return FT_Err_Ok;
   }

Referenced by ExecuteTest(), and main().

◆ FT_Face_CheckTrueTypePatents()

FT_Face_CheckTrueTypePatents ( FT_Face face )

Definition at line 31 of file ftpatent.c.

   {
     FT_UNUSED( face );
 
     return FALSE;
   }

◆ FT_Face_GetCharsOfVariant()

FT_Face_GetCharsOfVariant	(	FT_Face	face,
		FT_ULong	variantSelector
	)

Definition at line 3984 of file ftobjs.c.

   {
     FT_UInt32  *result = NULL;
 
 
     if ( face )
     {
       FT_CharMap  charmap = find_variant_selector_charmap( face );
 
 
       if ( charmap )
       {
         FT_CMap    vcmap  = FT_CMAP( charmap );
         FT_Memory  memory = FT_FACE_MEMORY( face );
 
 
         if ( variantSelector > 0xFFFFFFFFUL )
         {
           FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" ));
           FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
         }
 
         result = vcmap->clazz->variantchar_list( vcmap, memory,
                                                  (FT_UInt32)variantSelector );
       }
     }
 
     return result;
   }

◆ FT_Face_GetCharVariantIndex()

FT_Face_GetCharVariantIndex	(	FT_Face	face,
		FT_ULong	charcode,
		FT_ULong	variantSelector
	)

Definition at line 3834 of file ftobjs.c.

   {
     FT_UInt  result = 0;
 
 
     if ( face                                           &&
          face->charmap                                  &&
          face->charmap->encoding == FT_ENCODING_UNICODE )
     {
       FT_CharMap  charmap = find_variant_selector_charmap( face );
       FT_CMap     ucmap = FT_CMAP( face->charmap );
 
 
       if ( charmap )
       {
         FT_CMap  vcmap = FT_CMAP( charmap );
 
 
         if ( charcode > 0xFFFFFFFFUL )
         {
           FT_TRACE1(( "FT_Face_GetCharVariantIndex:"
                       " too large charcode" ));
           FT_TRACE1(( " 0x%x is truncated\n", charcode ));
         }
         if ( variantSelector > 0xFFFFFFFFUL )
         {
           FT_TRACE1(( "FT_Face_GetCharVariantIndex:"
                       " too large variantSelector" ));
           FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
         }
 
         result = vcmap->clazz->char_var_index( vcmap, ucmap,
                                                (FT_UInt32)charcode,
                                                (FT_UInt32)variantSelector );
       }
     }
 
     return result;
   }

◆ FT_Face_GetCharVariantIsDefault()

FT_Face_GetCharVariantIsDefault	(	FT_Face	face,
		FT_ULong	charcode,
		FT_ULong	variantSelector
	)

Definition at line 3880 of file ftobjs.c.

   {
     FT_Int  result = -1;
 
 
     if ( face )
     {
       FT_CharMap  charmap = find_variant_selector_charmap( face );
 
 
       if ( charmap )
       {
         FT_CMap  vcmap = FT_CMAP( charmap );
 
 
         if ( charcode > 0xFFFFFFFFUL )
         {
           FT_TRACE1(( "FT_Face_GetCharVariantIsDefault:"
                       " too large charcode" ));
           FT_TRACE1(( " 0x%x is truncated\n", charcode ));
         }
         if ( variantSelector > 0xFFFFFFFFUL )
         {
           FT_TRACE1(( "FT_Face_GetCharVariantIsDefault:"
                       " too large variantSelector" ));
           FT_TRACE1(( " 0x%x is truncated\n", variantSelector ));
         }
 
         result = vcmap->clazz->char_var_default( vcmap,
                                                  (FT_UInt32)charcode,
                                                  (FT_UInt32)variantSelector );
       }
     }
 
     return result;
   }

◆ FT_Face_GetVariantSelectors()

FT_Face_GetVariantSelectors ( FT_Face face )

Definition at line 3923 of file ftobjs.c.

   {
     FT_UInt32  *result = NULL;
 
 
     if ( face )
     {
       FT_CharMap  charmap = find_variant_selector_charmap( face );
 
 
       if ( charmap )
       {
         FT_CMap    vcmap  = FT_CMAP( charmap );
         FT_Memory  memory = FT_FACE_MEMORY( face );
 
 
         result = vcmap->clazz->variant_list( vcmap, memory );
       }
     }
 
     return result;
   }

◆ FT_Face_GetVariantsOfChar()

FT_Face_GetVariantsOfChar	(	FT_Face	face,
		FT_ULong	charcode
	)

Definition at line 3950 of file ftobjs.c.

   {
     FT_UInt32  *result = NULL;
 
 
     if ( face )
     {
       FT_CharMap  charmap = find_variant_selector_charmap( face );
 
 
       if ( charmap )
       {
         FT_CMap    vcmap  = FT_CMAP( charmap );
         FT_Memory  memory = FT_FACE_MEMORY( face );
 
 
         if ( charcode > 0xFFFFFFFFUL )
         {
           FT_TRACE1(( "FT_Face_GetVariantsOfChar: too large charcode" ));
           FT_TRACE1(( " 0x%x is truncated\n", charcode ));
         }
 
         result = vcmap->clazz->charvariant_list( vcmap, memory,
                                                  (FT_UInt32)charcode );
       }
     }
     return result;
   }

◆ FT_Face_Properties()

FT_Face_Properties	(	FT_Face	face,
		FT_UInt	num_properties,
		FT_Parameter *	properties
	)

Definition at line 3755 of file ftobjs.c.

   {
     FT_Error  error = FT_Err_Ok;
 
 
     if ( num_properties > 0 && !properties )
     {
       error = FT_THROW( Invalid_Argument );
       goto Exit;
     }
 
     for ( ; num_properties > 0; num_properties-- )
     {
       if ( properties->tag == FT_PARAM_TAG_STEM_DARKENING )
       {
         if ( properties->data )
         {
           if ( *( (FT_Bool*)properties->data ) == TRUE )
             face->internal->no_stem_darkening = FALSE;
           else
             face->internal->no_stem_darkening = TRUE;
         }
         else
         {
           /* use module default */
           face->internal->no_stem_darkening = -1;
         }
       }
       else if ( properties->tag == FT_PARAM_TAG_LCD_FILTER_WEIGHTS )
       {
 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING
         if ( properties->data )
         {
           ft_memcpy( face->internal->lcd_weights,
                      properties->data,
                      FT_LCD_FILTER_FIVE_TAPS );
           face->internal->lcd_filter_func = ft_lcd_filter_fir;
         }
 #else
         error = FT_THROW( Unimplemented_Feature );
         goto Exit;
 #endif
       }
       else if ( properties->tag == FT_PARAM_TAG_RANDOM_SEED )
       {
         if ( properties->data )
         {
           face->internal->random_seed = *( (FT_Int32*)properties->data );
           if ( face->internal->random_seed < 0 )
             face->internal->random_seed = 0;
         }
         else
         {
           /* use module default */
           face->internal->random_seed = -1;
         }
       }
       else
       {
         error = FT_THROW( Invalid_Argument );
         goto Exit;
       }
 
       if ( error )
         break;
 
       properties++;
     }
 
   Exit:
     return error;
   }

◆ FT_Face_SetUnpatentedHinting()

FT_Face_SetUnpatentedHinting	(	FT_Face	face,
		FT_Bool	value
	)

Definition at line 42 of file ftpatent.c.

   {
     FT_UNUSED( face );
     FT_UNUSED( value );
 
     return FALSE;
   }

◆ FT_FloorFix()

FT_FloorFix ( FT_Fixed a )

Definition at line 106 of file ftcalc.c.

   {
     return a & ~0xFFFFL;
   }

◆ FT_Get_Char_Index()

FT_Get_Char_Index	(	FT_Face	face,
		FT_ULong	charcode
	)

Definition at line 3668 of file ftobjs.c.

   {
     FT_UInt  result = 0;
 
 
     if ( face && face->charmap )
     {
       FT_CMap  cmap = FT_CMAP( face->charmap );
 
 
       if ( charcode > 0xFFFFFFFFUL )
       {
         FT_TRACE1(( "FT_Get_Char_Index: too large charcode" ));
         FT_TRACE1(( " 0x%x is truncated\n", charcode ));
       }
 
       result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode );
       if ( result >= (FT_UInt)face->num_glyphs )
         result = 0;
     }
 
     return result;
   }

Referenced by af_face_globals_compute_style_coverage(), af_shaper_get_cluster(), FT_Get_First_Char(), FT_Load_Char(), FTC_CMapCache_Lookup(), get_glyph_index(), get_glyph_index_symbol(), and T1_Read_PFM().

◆ FT_Get_Charmap_Index()

FT_Get_Charmap_Index ( FT_CharMap charmap )

Definition at line 3534 of file ftobjs.c.

   {
     FT_Int  i;
 
 
     if ( !charmap || !charmap->face )
       return -1;
 
     for ( i = 0; i < charmap->face->num_charmaps; i++ )
       if ( charmap->face->charmaps[i] == charmap )
         break;
 
     FT_ASSERT( i < charmap->face->num_charmaps );
 
     return i;
   }

◆ FT_Get_First_Char()

FT_Get_First_Char	(	FT_Face	face,
		FT_UInt *	agindex
	)

Definition at line 3697 of file ftobjs.c.

   {
     FT_ULong  result = 0;
     FT_UInt   gindex = 0;
 
 
     /* only do something if we have a charmap, and we have glyphs at all */
     if ( face && face->charmap && face->num_glyphs )
     {
       gindex = FT_Get_Char_Index( face, 0 );
       if ( gindex == 0 )
         result = FT_Get_Next_Char( face, 0, &gindex );
     }
 
     if ( agindex )
       *agindex = gindex;
 
     return result;
   }

Referenced by FontFamilyFillInfo(), FtfdQueryFontTree(), ftGdiGetKerningPairs(), ftGdiGetTextCharsetInfo(), and ftGetFontUnicodeRanges().

◆ FT_Get_FSType_Flags()

FT_Get_FSType_Flags ( FT_Face face )

Definition at line 28 of file ftfstype.c.

   {
     TT_OS2*  os2;
 
 
     /* first, try to get the fs_type directly from the font */
     if ( face )
     {
       FT_Service_PsInfo  service = NULL;
 
 
       FT_FACE_FIND_SERVICE( face, service, POSTSCRIPT_INFO );
 
       if ( service && service->ps_get_font_extra )
       {
         PS_FontExtraRec  extra;
 
 
         if ( !service->ps_get_font_extra( face, &extra ) &&
              extra.fs_type != 0                          )
           return extra.fs_type;
       }
     }
 
     /* look at FSType before fsType for Type42 */
 
     if ( ( os2 = (TT_OS2*)FT_Get_Sfnt_Table( face, FT_SFNT_OS2 ) ) != NULL &&
          os2->version != 0xFFFFU                                           )
       return os2->fsType;
 
     return 0;
   }

◆ FT_Get_Glyph_Name()

FT_Get_Glyph_Name	(	FT_Face	face,
		FT_UInt	glyph_index,
		FT_Pointer	buffer,
		FT_UInt	buffer_max
	)

Definition at line 4047 of file ftobjs.c.

   {
     FT_Error              error;
     FT_Service_GlyphDict  service;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     if ( !buffer || buffer_max == 0 )
       return FT_THROW( Invalid_Argument );
 
     /* clean up buffer */
     ((FT_Byte*)buffer)[0] = '\0';
 
     if ( (FT_Long)glyph_index >= face->num_glyphs )
       return FT_THROW( Invalid_Glyph_Index );
 
     if ( !FT_HAS_GLYPH_NAMES( face ) )
       return FT_THROW( Invalid_Argument );
 
     FT_FACE_LOOKUP_SERVICE( face, service, GLYPH_DICT );
     if ( service && service->get_name )
       error = service->get_name( face, glyph_index, buffer, buffer_max );
     else
       error = FT_THROW( Invalid_Argument );
 
     return error;
   }

Referenced by tt_check_single_notdef().

◆ FT_Get_Kerning()

FT_Get_Kerning	(	FT_Face	face,
		FT_UInt	left_glyph,
		FT_UInt	right_glyph,
		FT_UInt	kern_mode,
		FT_Vector *	akerning
	)

Definition at line 3347 of file ftobjs.c.

   {
     FT_Error   error = FT_Err_Ok;
     FT_Driver  driver;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     if ( !akerning )
       return FT_THROW( Invalid_Argument );
 
     driver = face->driver;
 
     akerning->x = 0;
     akerning->y = 0;
 
     if ( driver->clazz->get_kerning )
     {
       error = driver->clazz->get_kerning( face,
                                           left_glyph,
                                           right_glyph,
                                           akerning );
       if ( !error )
       {
         if ( kern_mode != FT_KERNING_UNSCALED )
         {
           akerning->x = FT_MulFix( akerning->x, face->size->metrics.x_scale );
           akerning->y = FT_MulFix( akerning->y, face->size->metrics.y_scale );
 
           if ( kern_mode != FT_KERNING_UNFITTED )
           {
             FT_Pos  orig_x = akerning->x;
             FT_Pos  orig_y = akerning->y;
 
 
             /* we scale down kerning values for small ppem values */
             /* to avoid that rounding makes them too big.         */
             /* `25' has been determined heuristically.            */
             if ( face->size->metrics.x_ppem < 25 )
               akerning->x = FT_MulDiv( orig_x,
                                        face->size->metrics.x_ppem, 25 );
             if ( face->size->metrics.y_ppem < 25 )
               akerning->y = FT_MulDiv( orig_y,
                                        face->size->metrics.y_ppem, 25 );
 
             akerning->x = FT_PIX_ROUND( akerning->x );
             akerning->y = FT_PIX_ROUND( akerning->y );
 
 #ifdef FT_DEBUG_LEVEL_TRACE
             {
               FT_Pos  orig_x_rounded = FT_PIX_ROUND( orig_x );
               FT_Pos  orig_y_rounded = FT_PIX_ROUND( orig_y );
 
 
               if ( akerning->x != orig_x_rounded ||
                    akerning->y != orig_y_rounded )
                 FT_TRACE5(( "FT_Get_Kerning: horizontal kerning"
                             " (%d, %d) scaled down to (%d, %d) pixels\n",
                             orig_x_rounded / 64, orig_y_rounded / 64,
                             akerning->x / 64, akerning->y / 64 ));
             }
 #endif
           }
         }
       }
     }
 
     return error;
   }

Referenced by FT_Get_PFR_Kerning(), ftGdiGetKerningPairs(), IntExtTextOutW(), and TextIntGetTextExtentPoint().

◆ FT_Get_Name_Index()

FT_Get_Name_Index	(	FT_Face	face,
		FT_String *	glyph_name
	)

Definition at line 4019 of file ftobjs.c.

   {
     FT_UInt  result = 0;
 
 
     if ( face                       &&
          FT_HAS_GLYPH_NAMES( face ) &&
          glyph_name                 )
     {
       FT_Service_GlyphDict  service;
 
 
       FT_FACE_LOOKUP_SERVICE( face,
                               service,
                               GLYPH_DICT );
 
       if ( service && service->name_index )
         result = service->name_index( face, glyph_name );
     }
 
     return result;
   }

◆ FT_Get_Next_Char()

FT_Get_Next_Char	(	FT_Face	face,
		FT_ULong	char_code,
		FT_UInt *	agindex
	)

Definition at line 3722 of file ftobjs.c.

   {
     FT_ULong  result = 0;
     FT_UInt   gindex = 0;
 
 
     if ( face && face->charmap && face->num_glyphs )
     {
       FT_UInt32  code = (FT_UInt32)charcode;
       FT_CMap    cmap = FT_CMAP( face->charmap );
 
 
       do
       {
         gindex = cmap->clazz->char_next( cmap, &code );
 
       } while ( gindex >= (FT_UInt)face->num_glyphs );
 
       result = ( gindex == 0 ) ? 0 : code;
     }
 
     if ( agindex )
       *agindex = gindex;
 
     return result;
   }

Referenced by af_face_globals_compute_style_coverage(), FT_Get_First_Char(), FtfdQueryFontTree(), ftGdiGetKerningPairs(), and ftGetFontUnicodeRanges().

◆ FT_Get_Postscript_Name()

FT_Get_Postscript_Name ( FT_Face face )

Definition at line 4084 of file ftobjs.c.

   {
     const char*  result = NULL;
 
 
     if ( !face )
       goto Exit;
 
     if ( !result )
     {
       FT_Service_PsFontName  service;
 
 
       FT_FACE_LOOKUP_SERVICE( face,
                               service,
                               POSTSCRIPT_FONT_NAME );
 
       if ( service && service->get_ps_font_name )
         result = service->get_ps_font_name( face );
     }
 
   Exit:
     return result;
   }

◆ FT_Get_SubGlyph_Info()

FT_Get_SubGlyph_Info	(	FT_GlyphSlot	glyph,
		FT_UInt	sub_index,
		FT_Int *	p_index,
		FT_UInt *	p_flags,
		FT_Int *	p_arg1,
		FT_Int *	p_arg2,
		FT_Matrix *	p_transform
	)

Definition at line 5373 of file ftobjs.c.

   {
     FT_Error  error = FT_ERR( Invalid_Argument );
 
 
     if ( glyph                                      &&
          glyph->subglyphs                           &&
          glyph->format == FT_GLYPH_FORMAT_COMPOSITE &&
          sub_index < glyph->num_subglyphs           )
     {
       FT_SubGlyph  subg = glyph->subglyphs + sub_index;
 
 
       *p_index     = subg->index;
       *p_flags     = subg->flags;
       *p_arg1      = subg->arg1;
       *p_arg2      = subg->arg2;
       *p_transform = subg->transform;
 
       error = FT_Err_Ok;
     }
 
     return error;
   }

◆ FT_Get_Track_Kerning()

FT_Get_Track_Kerning	(	FT_Face	face,
		FT_Fixed	point_size,
		FT_Int	degree,
		FT_Fixed *	akerning
	)

Definition at line 3426 of file ftobjs.c.

   {
     FT_Service_Kerning  service;
     FT_Error            error = FT_Err_Ok;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     if ( !akerning )
       return FT_THROW( Invalid_Argument );
 
     FT_FACE_FIND_SERVICE( face, service, KERNING );
     if ( !service )
       return FT_THROW( Unimplemented_Feature );
 
     error = service->get_track( face,
                                 point_size,
                                 degree,
                                 akerning );
 
     return error;
   }

◆ FT_Init_FreeType()

FT_Init_FreeType ( FT_Library * alibrary )

Definition at line 320 of file ftinit.c.

   {
     FT_Error   error;
     FT_Memory  memory;
 
 
     /* check of `alibrary' delayed to `FT_New_Library' */
 
     /* First of all, allocate a new system object -- this function is part */
     /* of the system-specific component, i.e. `ftsystem.c'.                */
 
     memory = FT_New_Memory();
     if ( !memory )
     {
       FT_ERROR(( "FT_Init_FreeType: cannot find memory manager\n" ));
       return FT_THROW( Unimplemented_Feature );
     }
 
     /* build a library out of it, then fill it with the set of */
     /* default drivers.                                        */
 
     error = FT_New_Library( memory, alibrary );
     if ( error )
       FT_Done_Memory( memory );
     else
       FT_Add_Default_Modules( *alibrary );
 
     FT_Set_Default_Properties( *alibrary );
 
     return error;
   }

Referenced by ExecuteTest(), FtfdEnableDriver(), InitFontSupport(), and main().

◆ FT_Library_Version()

FT_Library_Version	(	FT_Library	library,
		FT_Int *	amajor,
		FT_Int *	aminor,
		FT_Int *	apatch
	)

Definition at line 5189 of file ftobjs.c.

   {
     FT_Int  major = 0;
     FT_Int  minor = 0;
     FT_Int  patch = 0;
 
 
     if ( library )
     {
       major = library->version_major;
       minor = library->version_minor;
       patch = library->version_patch;
     }
 
     if ( amajor )
       *amajor = major;
 
     if ( aminor )
       *aminor = minor;
 
     if ( apatch )
       *apatch = patch;
   }

◆ FT_Load_Char()

FT_Load_Char	(	FT_Face	face,
		FT_ULong	char_code,
		FT_Int32	load_flags
	)

Definition at line 1037 of file ftobjs.c.

   {
     FT_UInt  glyph_index;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     glyph_index = (FT_UInt)char_code;
     if ( face->charmap )
       glyph_index = FT_Get_Char_Index( face, char_code );
 
     return FT_Load_Glyph( face, glyph_index, load_flags );
   }

◆ FT_Load_Glyph()

FT_Load_Glyph	(	FT_Face	face,
		FT_UInt	glyph_index,
		FT_Int32	load_flags
	)

Definition at line 760 of file ftobjs.c.

   {
     FT_Error      error;
     FT_Driver     driver;
     FT_GlyphSlot  slot;
     FT_Library    library;
     FT_Bool       autohint = FALSE;
     FT_Module     hinter;
     TT_Face       ttface = (TT_Face)face;
 
 
     if ( !face || !face->size || !face->glyph )
       return FT_THROW( Invalid_Face_Handle );
 
     /* The validity test for `glyph_index' is performed by the */
     /* font drivers.                                           */
 
     slot = face->glyph;
     ft_glyphslot_clear( slot );
 
     driver  = face->driver;
     library = driver->root.library;
     hinter  = library->auto_hinter;
 
     /* resolve load flags dependencies */
 
     if ( load_flags & FT_LOAD_NO_RECURSE )
       load_flags |= FT_LOAD_NO_SCALE         |
                     FT_LOAD_IGNORE_TRANSFORM;
 
     if ( load_flags & FT_LOAD_NO_SCALE )
     {
       load_flags |= FT_LOAD_NO_HINTING |
                     FT_LOAD_NO_BITMAP;
 
       load_flags &= ~FT_LOAD_RENDER;
     }
 
     if ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY )
       load_flags &= ~FT_LOAD_RENDER;
 
     /*
      * Determine whether we need to auto-hint or not.
      * The general rules are:
      *
      * - Do only auto-hinting if we have
      *
      *   - a hinter module,
      *   - a scalable font format dealing with outlines,
      *   - not a tricky font, and
      *   - no transforms except simple slants and/or rotations by
      *     integer multiples of 90 degrees.
      *
      * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't
      *   have a native font hinter.
      *
      * - Otherwise, auto-hint for LIGHT hinting mode or if there isn't
      *   any hinting bytecode in the TrueType/OpenType font.
      *
      * - Exception: The font is `tricky' and requires the native hinter to
      *   load properly.
      */
 
     if ( hinter                                           &&
          !( load_flags & FT_LOAD_NO_HINTING )             &&
          !( load_flags & FT_LOAD_NO_AUTOHINT )            &&
          FT_DRIVER_IS_SCALABLE( driver )                  &&
          FT_DRIVER_USES_OUTLINES( driver )                &&
          !FT_IS_TRICKY( face )                            &&
          ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM )    ||
            ( face->internal->transform_matrix.yx == 0 &&
              face->internal->transform_matrix.xx != 0 ) ||
            ( face->internal->transform_matrix.xx == 0 &&
              face->internal->transform_matrix.yx != 0 ) ) )
     {
       if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) ||
            !FT_DRIVER_HAS_HINTER( driver )         )
         autohint = TRUE;
       else
       {
         FT_Render_Mode  mode = FT_LOAD_TARGET_MODE( load_flags );
         FT_Bool         is_light_type1;
 
 
         /* only the new Adobe engine (for both CFF and Type 1) is `light'; */
         /* we use `strstr' to catch both `Type 1' and `CID Type 1'         */
         is_light_type1 =
           ft_strstr( FT_Get_Font_Format( face ), "Type 1" ) != NULL   &&
           ((PS_Driver)driver)->hinting_engine == FT_HINTING_ADOBE;
 
         /* the check for `num_locations' assures that we actually    */
         /* test for instructions in a TTF and not in a CFF-based OTF */
         /*                                                           */
         /* since `maxSizeOfInstructions' might be unreliable, we     */
         /* check the size of the `fpgm' and `prep' tables, too --    */
         /* the assumption is that there don't exist real TTFs where  */
         /* both `fpgm' and `prep' tables are missing                 */
         if ( ( mode == FT_RENDER_MODE_LIGHT           &&
                ( !FT_DRIVER_HINTS_LIGHTLY( driver ) &&
                  !is_light_type1                    ) )         ||
              ( FT_IS_SFNT( face )                             &&
                ttface->num_locations                          &&
                ttface->max_profile.maxSizeOfInstructions == 0 &&
                ttface->font_program_size == 0                 &&
                ttface->cvt_program_size == 0                  ) )
           autohint = TRUE;
       }
     }
 
     if ( autohint )
     {
       FT_AutoHinter_Interface  hinting;
 
 
       /* try to load embedded bitmaps first if available            */
       /*                                                            */
       /* XXX: This is really a temporary hack that should disappear */
       /*      promptly with FreeType 2.1!                           */
       /*                                                            */
       if ( FT_HAS_FIXED_SIZES( face )              &&
            ( load_flags & FT_LOAD_NO_BITMAP ) == 0 )
       {
         error = driver->clazz->load_glyph( slot, face->size,
                                            glyph_index,
                                            load_flags | FT_LOAD_SBITS_ONLY );
 
         if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP )
           goto Load_Ok;
       }
 
       {
         FT_Face_Internal  internal        = face->internal;
         FT_Int            transform_flags = internal->transform_flags;
 
 
         /* since the auto-hinter calls FT_Load_Glyph by itself, */
         /* make sure that glyphs aren't transformed             */
         internal->transform_flags = 0;
 
         /* load auto-hinted outline */
         hinting = (FT_AutoHinter_Interface)hinter->clazz->module_interface;
 
         error   = hinting->load_glyph( (FT_AutoHinter)hinter,
                                        slot, face->size,
                                        glyph_index, load_flags );
 
         internal->transform_flags = transform_flags;
       }
     }
     else
     {
       error = driver->clazz->load_glyph( slot,
                                          face->size,
                                          glyph_index,
                                          load_flags );
       if ( error )
         goto Exit;
 
       if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
       {
         /* check that the loaded outline is correct */
         error = FT_Outline_Check( &slot->outline );
         if ( error )
           goto Exit;
 
 #ifdef GRID_FIT_METRICS
         if ( !( load_flags & FT_LOAD_NO_HINTING ) )
           ft_glyphslot_grid_fit_metrics( slot,
               FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) );
 #endif
       }
     }
 
   Load_Ok:
     /* compute the advance */
     if ( load_flags & FT_LOAD_VERTICAL_LAYOUT )
     {
       slot->advance.x = 0;
       slot->advance.y = slot->metrics.vertAdvance;
     }
     else
     {
       slot->advance.x = slot->metrics.horiAdvance;
       slot->advance.y = 0;
     }
 
     /* compute the linear advance in 16.16 pixels */
     if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0 &&
          FT_IS_SCALABLE( face )                      )
     {
       FT_Size_Metrics*  metrics = &face->size->metrics;
 
 
       /* it's tricky! */
       slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance,
                                            metrics->x_scale, 64 );
 
       slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance,
                                            metrics->y_scale, 64 );
     }
 
     if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 )
     {
       FT_Face_Internal  internal = face->internal;
 
 
       /* now, transform the glyph image if needed */
       if ( internal->transform_flags )
       {
         /* get renderer */
         FT_Renderer  renderer = ft_lookup_glyph_renderer( slot );
 
 
         if ( renderer )
           error = renderer->clazz->transform_glyph(
                                      renderer, slot,
                                      &internal->transform_matrix,
                                      &internal->transform_delta );
         else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE )
         {
           /* apply `standard' transformation if no renderer is available */
           if ( internal->transform_flags & 1 )
             FT_Outline_Transform( &slot->outline,
                                   &internal->transform_matrix );
 
           if ( internal->transform_flags & 2 )
             FT_Outline_Translate( &slot->outline,
                                   internal->transform_delta.x,
                                   internal->transform_delta.y );
         }
 
         /* transform advance */
         FT_Vector_Transform( &slot->advance, &internal->transform_matrix );
       }
     }
 
     /* do we need to render the image or preset the bitmap now? */
     if ( !error                                    &&
          ( load_flags & FT_LOAD_NO_SCALE ) == 0    &&
          slot->format != FT_GLYPH_FORMAT_BITMAP    &&
          slot->format != FT_GLYPH_FORMAT_COMPOSITE )
     {
       FT_Render_Mode  mode = FT_LOAD_TARGET_MODE( load_flags );
 
 
       if ( mode == FT_RENDER_MODE_NORMAL   &&
            load_flags & FT_LOAD_MONOCHROME )
         mode = FT_RENDER_MODE_MONO;
 
       if ( load_flags & FT_LOAD_RENDER )
         error = FT_Render_Glyph( slot, mode );
       else
         ft_glyphslot_preset_bitmap( slot, mode, NULL );
     }
 
     FT_TRACE5(( "FT_Load_Glyph: index %d, flags %x\n",
                 glyph_index, load_flags               ));
     FT_TRACE5(( "  x advance: %f\n", slot->advance.x / 64.0 ));
     FT_TRACE5(( "  y advance: %f\n", slot->advance.y / 64.0 ));
     FT_TRACE5(( "  linear x advance: %f\n",
                 slot->linearHoriAdvance / 65536.0 ));
     FT_TRACE5(( "  linear y advance: %f\n",
                 slot->linearVertAdvance / 65536.0 ));
     FT_TRACE5(( "  bitmap %dx%d, mode %d\n",
                 slot->bitmap.width, slot->bitmap.rows,
                 slot->bitmap.pixel_mode               ));
 
   Exit:
     return error;
   }

Referenced by af_latin_metrics_init_blues(), af_latin_metrics_init_widths(), af_loader_load_glyph(), FT_Get_Advances(), FT_Load_Char(), ftc_basic_family_load_bitmap(), ftc_basic_family_load_glyph(), ftGdiGetGlyphOutline(), gxv_ctlPoint_validate(), gxv_prop_zero_advance_validate(), IntExtTextOutW(), NtGdiGetCharABCWidthsW(), NtGdiGetCharWidthW(), TestFace(), and TextIntGetTextExtentPoint().

◆ FT_MulDiv()

FT_MulDiv	(	FT_Long	a,
		FT_Long	b,
		FT_Long	c
	)

Definition at line 416 of file ftcalc.c.

   {
     FT_Int     s = 1;
     FT_UInt32  a, b, c;
 
 
     /* XXX: this function does not allow 64-bit arguments */
 
     a = (FT_UInt32)a_;
     b = (FT_UInt32)b_;
     c = (FT_UInt32)c_;
 
     FT_MOVE_SIGN( a_, a, s );
     FT_MOVE_SIGN( b_, b, s );
     FT_MOVE_SIGN( c_, c, s );
 
     if ( c == 0 )
       a = 0x7FFFFFFFUL;
 
     else if ( a + b <= 129894UL - ( c >> 17 ) )
       a = ( a * b + ( c >> 1 ) ) / c;
 
     else
     {
       FT_Int64  temp, temp2;
 
 
       ft_multo64( a, b, &temp );
 
       temp2.hi = 0;
       temp2.lo = c >> 1;
 
       FT_Add64( &temp, &temp2, &temp );
 
       /* last attempt to ditch long division */
       a = ( temp.hi == 0 ) ? temp.lo / c
                            : ft_div64by32( temp.hi, temp.lo, c );
     }
 
     a_ = (FT_Long)a;
 
     return s < 0 ? NEG_LONG( a_ ) : a_;
   }

Referenced by _bdf_parse_glyphs(), _ft_face_scale_advances(), af_latin_hint_edges(), af_latin_metrics_scale_dim(), af_loader_compute_darkening(), BBox_Conic_Check(), BDF_Face_Init(), cf2_blues_init(), cf2_computeDarkening(), cff_face_init(), cff_size_request(), cff_slot_load(), FNT_Face_Init(), FT_Get_Kerning(), FT_Load_Glyph(), FT_Matrix_Multiply_Scaled(), FT_Outline_EmboldenXY(), FT_Request_Metrics(), ft_stroke_border_arcto(), FT_Stroker_ConicTo(), FT_Stroker_CubicTo(), ft_stroker_outside(), FT_Vector_Transform_Scaled(), IntRequestFontSize(), pcf_load_font(), pfr_get_kerning(), pfr_slot_load(), ps_hints_apply(), psh_glyph_interpolate_normal_points(), psh_glyph_interpolate_strong_points(), T1_Get_Track_Kerning(), T1_Set_MM_Design(), TT_Process_Simple_Glyph(), and tt_size_request().

◆ FT_MulFix()

FT_MulFix	(	FT_Long	a,
		FT_Long	b
	)

Definition at line 509 of file ftcalc.c.

   {
 #ifdef FT_MULFIX_ASSEMBLER
 
     return FT_MULFIX_ASSEMBLER( a_, b_ );
 
 #elif 0
 
     /*
      *  This code is nonportable.  See comment below.
      *
      *  However, on a platform where right-shift of a signed quantity fills
      *  the leftmost bits by copying the sign bit, it might be faster.
      */
 
     FT_Long    sa, sb;
     FT_UInt32  a, b;
 
 
     /*
      *  This is a clever way of converting a signed number `a' into its
      *  absolute value (stored back into `a') and its sign.  The sign is
      *  stored in `sa'; 0 means `a' was positive or zero, and -1 means `a'
      *  was negative.  (Similarly for `b' and `sb').
      *
      *  Unfortunately, it doesn't work (at least not portably).
      *
      *  It makes the assumption that right-shift on a negative signed value
      *  fills the leftmost bits by copying the sign bit.  This is wrong.
      *  According to K&R 2nd ed, section `A7.8 Shift Operators' on page 206,
      *  the result of right-shift of a negative signed value is
      *  implementation-defined.  At least one implementation fills the
      *  leftmost bits with 0s (i.e., it is exactly the same as an unsigned
      *  right shift).  This means that when `a' is negative, `sa' ends up
      *  with the value 1 rather than -1.  After that, everything else goes
      *  wrong.
      */
     sa = ( a_ >> ( sizeof ( a_ ) * 8 - 1 ) );
     a  = ( a_ ^ sa ) - sa;
     sb = ( b_ >> ( sizeof ( b_ ) * 8 - 1 ) );
     b  = ( b_ ^ sb ) - sb;
 
     a = (FT_UInt32)a_;
     b = (FT_UInt32)b_;
 
     if ( a + ( b >> 8 ) <= 8190UL )
       a = ( a * b + 0x8000U ) >> 16;
     else
     {
       FT_UInt32  al = a & 0xFFFFUL;
 
 
       a = ( a >> 16 ) * b + al * ( b >> 16 ) +
           ( ( al * ( b & 0xFFFFUL ) + 0x8000UL ) >> 16 );
     }
 
     sa ^= sb;
     a   = ( a ^ sa ) - sa;
 
     return (FT_Long)a;
 
 #else /* 0 */
 
     FT_Int     s = 1;
     FT_UInt32  a, b;
 
 
     /* XXX: this function does not allow 64-bit arguments */
 
     a = (FT_UInt32)a_;
     b = (FT_UInt32)b_;
 
     FT_MOVE_SIGN( a_, a, s );
     FT_MOVE_SIGN( b_, b, s );
 
     if ( a + ( b >> 8 ) <= 8190UL )
       a = ( a * b + 0x8000UL ) >> 16;
     else
     {
       FT_UInt32  al = a & 0xFFFFUL;
 
 
       a = ( a >> 16 ) * b + al * ( b >> 16 ) +
           ( ( al * ( b & 0xFFFFUL ) + 0x8000UL ) >> 16 );
     }
 
     a_ = (FT_Long)a;
 
     return s < 0 ? NEG_LONG( a_ ) : a_;
 
 #endif /* 0 */
 
   }

Referenced by af_glyph_hints_align_strong_points(), af_glyph_hints_reload(), af_iup_interp(), af_latin_hints_compute_blue_edges(), af_latin_hints_compute_edges(), af_latin_metrics_scale_dim(), af_loader_compute_darkening(), af_loader_embolden_glyph_in_slot(), af_loader_load_glyph(), cf2_blues_init(), cf2_computeDarkening(), cf2_doBlend(), cf2_glyphpath_computeIntersection(), cf2_glyphpath_computeOffset(), cf2_glyphpath_hintPoint(), cf2_hint_init(), cf2_hintmap_insertHint(), cf2_hintmap_map(), cf2_interpT2CharString(), cff_blend_build_vector(), cff_slot_load(), cid_slot_load_glyph(), compute_glyph_metrics(), FillTM(), FT_Get_Kerning(), FT_GlyphSlot_Embolden(), FT_Matrix_Invert(), FT_Matrix_Multiply(), FT_Outline_EmboldenXY(), ft_recompute_scaled_metrics(), FT_Request_Metrics(), ft_stroker_inside(), ft_stroker_outside(), FT_Vector_Transform(), IntWidthMatrix(), load_truetype_glyph(), pfr_glyph_load_rec(), pfr_slot_load(), ps_hints_apply(), psh_blues_scale_zones(), psh_globals_scale_widths(), psh_glyph_interpolate_normal_points(), psh_glyph_interpolate_other_points(), psh_glyph_interpolate_strong_points(), psh_hint_align(), T1_Load_Glyph(), t1_set_mm_blend(), TT_Load_Glyph(), tt_loader_init(), TT_Process_Composite_Component(), TT_Process_Simple_Glyph(), and tt_size_reset().

◆ FT_New_Face()

FT_New_Face	(	FT_Library	library,
		const char *	filepathname,
		FT_Long	face_index,
		FT_Face *	aface
	)

Definition at line 1406 of file ftobjs.c.

   {
     FT_Open_Args  args;
 
 
     /* test for valid `library' and `aface' delayed to `FT_Open_Face' */
     if ( !pathname )
       return FT_THROW( Invalid_Argument );
 
     args.flags    = FT_OPEN_PATHNAME;
     args.pathname = (char*)pathname;
     args.stream   = NULL;
 
     return ft_open_face_internal( library, &args, face_index, aface, 1 );
   }

Referenced by ExecuteTest().

◆ FT_New_Memory_Face()

FT_New_Memory_Face	(	FT_Library	library,
		const FT_Byte *	file_base,
		FT_Long	file_size,
		FT_Long	face_index,
		FT_Face *	aface
	)

Definition at line 1431 of file ftobjs.c.

   {
     FT_Open_Args  args;
 
 
     /* test for valid `library' and `face' delayed to `FT_Open_Face' */
     if ( !file_base )
       return FT_THROW( Invalid_Argument );
 
     args.flags       = FT_OPEN_MEMORY;
     args.memory_base = file_base;
     args.memory_size = file_size;
     args.stream      = NULL;
 
     return ft_open_face_internal( library, &args, face_index, aface, 1 );
   }

Referenced by FtfdLoadFontFile(), FtfdQueryFont(), FtfdQueryFontTree(), and IntGdiLoadFontsFromMemory().

◆ FT_Open_Face()

FT_Open_Face	(	FT_Library	library,
		const FT_Open_Args *	args,
		FT_Long	face_index,
		FT_Face *	aface
	)

Definition at line 2317 of file ftobjs.c.

   {
     return ft_open_face_internal( library, args, face_index, aface, 1 );
   }

Referenced by T42_Face_Init().

◆ FT_Reference_Face()

FT_Reference_Face ( FT_Face face )

Definition at line 2707 of file ftobjs.c.

   {
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     face->internal->refcount++;
 
     return FT_Err_Ok;
   }

◆ FT_Render_Glyph()

FT_Render_Glyph	(	FT_GlyphSlot	slot,
		FT_Render_Mode	render_mode
	)

Definition at line 4650 of file ftobjs.c.

   {
     FT_Library  library;
 
 
     if ( !slot || !slot->face )
       return FT_THROW( Invalid_Argument );
 
     library = FT_FACE_LIBRARY( slot->face );
 
     return FT_Render_Glyph_Internal( library, slot, render_mode );
   }

Referenced by FT_Load_Glyph(), and TestFace().

◆ FT_Request_Size()

FT_Request_Size	(	FT_Face	face,
		FT_Size_Request	req
	)

Definition at line 3192 of file ftobjs.c.

   {
     FT_Error         error = FT_Err_Ok;
     FT_Driver_Class  clazz;
     FT_ULong         strike_index;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     if ( !req || req->width < 0 || req->height < 0 ||
          req->type >= FT_SIZE_REQUEST_TYPE_MAX )
       return FT_THROW( Invalid_Argument );
 
     /* signal the auto-hinter to recompute its size metrics */
     /* (if requested)                                       */
     face->size->internal->autohint_metrics.x_scale = 0;
 
     clazz = face->driver->clazz;
 
     if ( clazz->request_size )
     {
       error = clazz->request_size( face->size, req );
 
       FT_TRACE5(( "FT_Request_Size (%s driver):\n",
                   face->driver->root.clazz->module_name ));
     }
     else if ( !FT_IS_SCALABLE( face ) && FT_HAS_FIXED_SIZES( face ) )
     {
       /*
        * The reason that a driver doesn't have `request_size' defined is
        * either that the scaling here suffices or that the supported formats
        * are bitmap-only and size matching is not implemented.
        *
        * In the latter case, a simple size matching is done.
        */
       error = FT_Match_Size( face, req, 0, &strike_index );
       if ( error )
         return error;
 
       return FT_Select_Size( face, (FT_Int)strike_index );
     }
     else
     {
       FT_Request_Metrics( face, req );
 
       FT_TRACE5(( "FT_Request_Size:\n" ));
     }
 
 #ifdef FT_DEBUG_LEVEL_TRACE
     {
       FT_Size_Metrics*  metrics = &face->size->metrics;
 
 
       FT_TRACE5(( "  x scale: %d (%f)\n",
                   metrics->x_scale, metrics->x_scale / 65536.0 ));
       FT_TRACE5(( "  y scale: %d (%f)\n",
                   metrics->y_scale, metrics->y_scale / 65536.0 ));
       FT_TRACE5(( "  ascender: %f\n",    metrics->ascender / 64.0 ));
       FT_TRACE5(( "  descender: %f\n",   metrics->descender / 64.0 ));
       FT_TRACE5(( "  height: %f\n",      metrics->height / 64.0 ));
       FT_TRACE5(( "  max advance: %f\n", metrics->max_advance / 64.0 ));
       FT_TRACE5(( "  x ppem: %d\n",      metrics->x_ppem ));
       FT_TRACE5(( "  y ppem: %d\n",      metrics->y_ppem ));
     }
 #endif
 
     return error;
   }

Referenced by FT_Set_Char_Size(), FT_Set_Pixel_Sizes(), IntRequestFontSize(), and T42_Size_Request().

◆ FT_RoundFix()

FT_RoundFix ( FT_Fixed a )

Definition at line 88 of file ftcalc.c.

   {
     return ( ADD_LONG( a, 0x8000L - ( a < 0 ) ) ) & ~0xFFFFL;
   }

Referenced by cff_parse_font_bbox(), and ps_parser_load_field().

◆ FT_Select_Charmap()

FT_Select_Charmap	(	FT_Face	face,
		FT_Encoding	encoding
	)

Definition at line 3457 of file ftobjs.c.

   {
     FT_CharMap*  cur;
     FT_CharMap*  limit;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     if ( encoding == FT_ENCODING_NONE )
       return FT_THROW( Invalid_Argument );
 
     /* FT_ENCODING_UNICODE is special.  We try to find the `best' Unicode */
     /* charmap available, i.e., one with UCS-4 characters, if possible.   */
     /*                                                                    */
     /* This is done by find_unicode_charmap() above, to share code.       */
     if ( encoding == FT_ENCODING_UNICODE )
       return find_unicode_charmap( face );
 
     cur = face->charmaps;
     if ( !cur )
       return FT_THROW( Invalid_CharMap_Handle );
 
     limit = cur + face->num_charmaps;
 
     for ( ; cur < limit; cur++ )
     {
       if ( cur[0]->encoding == encoding )
       {
         face->charmap = cur[0];
         return 0;
       }
     }
 
     return FT_THROW( Invalid_Argument );
   }

Referenced by af_face_globals_compute_style_coverage(), af_latin_metrics_init(), and FtfdLoadFontFile().

◆ FT_Select_Size()

FT_Select_Size	(	FT_Face	face,
		FT_Int	strike_index
	)

Definition at line 3138 of file ftobjs.c.

   {
     FT_Error         error = FT_Err_Ok;
     FT_Driver_Class  clazz;
 
 
     if ( !face || !FT_HAS_FIXED_SIZES( face ) )
       return FT_THROW( Invalid_Face_Handle );
 
     if ( strike_index < 0 || strike_index >= face->num_fixed_sizes )
       return FT_THROW( Invalid_Argument );
 
     clazz = face->driver->clazz;
 
     if ( clazz->select_size )
     {
       error = clazz->select_size( face->size, (FT_ULong)strike_index );
 
       FT_TRACE5(( "FT_Select_Size (%s driver):\n",
                   face->driver->root.clazz->module_name ));
     }
     else
     {
       FT_Select_Metrics( face, (FT_ULong)strike_index );
 
       FT_TRACE5(( "FT_Select_Size:\n" ));
     }
 
 #ifdef FT_DEBUG_LEVEL_TRACE
     {
       FT_Size_Metrics*  metrics = &face->size->metrics;
 
 
       FT_TRACE5(( "  x scale: %d (%f)\n",
                   metrics->x_scale, metrics->x_scale / 65536.0 ));
       FT_TRACE5(( "  y scale: %d (%f)\n",
                   metrics->y_scale, metrics->y_scale / 65536.0 ));
       FT_TRACE5(( "  ascender: %f\n",    metrics->ascender / 64.0 ));
       FT_TRACE5(( "  descender: %f\n",   metrics->descender / 64.0 ));
       FT_TRACE5(( "  height: %f\n",      metrics->height / 64.0 ));
       FT_TRACE5(( "  max advance: %f\n", metrics->max_advance / 64.0 ));
       FT_TRACE5(( "  x ppem: %d\n",      metrics->x_ppem ));
       FT_TRACE5(( "  y ppem: %d\n",      metrics->y_ppem ));
     }
 #endif
 
     return error;
   }

Referenced by FT_Request_Size(), and T42_Size_Select().

◆ FT_Set_Char_Size()

FT_Set_Char_Size	(	FT_Face	face,
		FT_F26Dot6	char_width,
		FT_F26Dot6	char_height,
		FT_UInt	horz_resolution,
		FT_UInt	vert_resolution
	)

Definition at line 3267 of file ftobjs.c.

   {
     FT_Size_RequestRec  req;
 
 
     /* check of `face' delayed to `FT_Request_Size' */
 
     if ( !char_width )
       char_width = char_height;
     else if ( !char_height )
       char_height = char_width;
 
     if ( !horz_resolution )
       horz_resolution = vert_resolution;
     else if ( !vert_resolution )
       vert_resolution = horz_resolution;
 
     if ( char_width  < 1 * 64 )
       char_width  = 1 * 64;
     if ( char_height < 1 * 64 )
       char_height = 1 * 64;
 
     if ( !horz_resolution )
       horz_resolution = vert_resolution = 72;
 
     req.type           = FT_SIZE_REQUEST_TYPE_NOMINAL;
     req.width          = char_width;
     req.height         = char_height;
     req.horiResolution = horz_resolution;
     req.vertResolution = vert_resolution;
 
     return FT_Request_Size( face, &req );
   }

Referenced by ftc_scaler_lookup_size(), and TestFace().

◆ FT_Set_Charmap()

FT_Set_Charmap	(	FT_Face	face,
		FT_CharMap	charmap
	)

Definition at line 3499 of file ftobjs.c.

   {
     FT_CharMap*  cur;
     FT_CharMap*  limit;
 
 
     if ( !face )
       return FT_THROW( Invalid_Face_Handle );
 
     cur = face->charmaps;
     if ( !cur || !charmap )
       return FT_THROW( Invalid_CharMap_Handle );
 
     if ( FT_Get_CMap_Format( charmap ) == 14 )
       return FT_THROW( Invalid_Argument );
 
     limit = cur + face->num_charmaps;
 
     for ( ; cur < limit; cur++ )
     {
       if ( cur[0] == charmap )
       {
         face->charmap = cur[0];
         return FT_Err_Ok;
       }
     }
 
     return FT_THROW( Invalid_Argument );
   }

Referenced by af_face_globals_compute_style_coverage(), af_latin_metrics_init(), FTC_CMapCache_Lookup(), NtGdiGetCharABCWidthsW(), NtGdiGetCharWidthW(), T1_Read_PFM(), and TextIntUpdateSize().

◆ FT_Set_Pixel_Sizes()

FT_Set_Pixel_Sizes	(	FT_Face	face,
		FT_UInt	pixel_width,
		FT_UInt	pixel_height
	)

Definition at line 3309 of file ftobjs.c.

   {
     FT_Size_RequestRec  req;
 
 
     /* check of `face' delayed to `FT_Request_Size' */
 
     if ( pixel_width == 0 )
       pixel_width = pixel_height;
     else if ( pixel_height == 0 )
       pixel_height = pixel_width;
 
     if ( pixel_width  < 1 )
       pixel_width  = 1;
     if ( pixel_height < 1 )
       pixel_height = 1;
 
     /* use `>=' to avoid potential compiler warning on 16bit platforms */
     if ( pixel_width >= 0xFFFFU )
       pixel_width = 0xFFFFU;
     if ( pixel_height >= 0xFFFFU )
       pixel_height = 0xFFFFU;
 
     req.type           = FT_SIZE_REQUEST_TYPE_NOMINAL;
     req.width          = (FT_Long)( pixel_width << 6 );
     req.height         = (FT_Long)( pixel_height << 6 );
     req.horiResolution = 0;
     req.vertResolution = 0;
 
     return FT_Request_Size( face, &req );
   }

Referenced by ftc_scaler_lookup_size().

◆ FT_Set_Transform()

FT_Set_Transform	(	FT_Face	face,
		FT_Matrix *	matrix,
		FT_Vector *	delta
	)

Definition at line 653 of file ftobjs.c.

   {
     FT_Face_Internal  internal;
 
 
     if ( !face )
       return;
 
     internal = face->internal;
 
     internal->transform_flags = 0;
 
     if ( !matrix )
     {
       internal->transform_matrix.xx = 0x10000L;
       internal->transform_matrix.xy = 0;
       internal->transform_matrix.yx = 0;
       internal->transform_matrix.yy = 0x10000L;
 
       matrix = &internal->transform_matrix;
     }
     else
       internal->transform_matrix = *matrix;
 
     /* set transform_flags bit flag 0 if `matrix' isn't the identity */
     if ( ( matrix->xy | matrix->yx ) ||
          matrix->xx != 0x10000L      ||
          matrix->yy != 0x10000L      )
       internal->transform_flags |= 1;
 
     if ( !delta )
     {
       internal->transform_delta.x = 0;
       internal->transform_delta.y = 0;
 
       delta = &internal->transform_delta;
     }
     else
       internal->transform_delta = *delta;
 
     /* set transform_flags bit flag 1 if `delta' isn't the null vector */
     if ( delta->x | delta->y )
       internal->transform_flags |= 2;
   }

Referenced by FtSetCoordinateTransform().

◆ FT_Vector_Transform()

FT_Vector_Transform	(	FT_Vector *	vec,
		const FT_Matrix *	matrix
	)

Definition at line 688 of file ftoutln.c.

   {
     FT_Pos  xz, yz;
 
 
     if ( !vector || !matrix )
       return;
 
     xz = FT_MulFix( vector->x, matrix->xx ) +
          FT_MulFix( vector->y, matrix->xy );
 
     yz = FT_MulFix( vector->x, matrix->yx ) +
          FT_MulFix( vector->y, matrix->yy );
 
     vector->x = xz;
     vector->y = yz;
   }

Referenced by af_loader_load_glyph(), FT_Glyph_Transform(), FT_Load_Glyph(), FT_Outline_Transform(), and ftGdiGetGlyphOutline().

Classes

Macros

Typedefs

Enumerations

Functions