diff options
Diffstat (limited to 'Build/source/libs/libttf/ttapi.c')
-rw-r--r-- | Build/source/libs/libttf/ttapi.c | 2219 |
1 files changed, 2219 insertions, 0 deletions
diff --git a/Build/source/libs/libttf/ttapi.c b/Build/source/libs/libttf/ttapi.c new file mode 100644 index 00000000000..2f2d8204bb3 --- /dev/null +++ b/Build/source/libs/libttf/ttapi.c @@ -0,0 +1,2219 @@ +/******************************************************************* + * + * ttapi.c + * + * High-level interface implementation + * + * Copyright 1996-1999 by + * David Turner, Robert Wilhelm, and Werner Lemberg. + * + * This file is part of the FreeType project, and may only be used, + * modified, and distributed under the terms of the FreeType project + * license, LICENSE.TXT. By continuing to use, modify, or distribute + * this file you indicate that you have read the license and + * understand and accept it fully. + * + * Notes: + * + * This file is used to implement most of the functions that are + * defined in the file "freetype.h". However, two functions are + * implemented elsewhere : + * + * TT_MulDiv and TT_MulFix are in ttcalc.h/ttcalc.c + * + ******************************************************************/ + +#include "ttconfig.h" + +#include "freetype.h" +#include "ttengine.h" +#include "ttcalc.h" +#include "ttmemory.h" +#include "ttcache.h" +#include "ttfile.h" +#include "ttobjs.h" +#include "ttload.h" +#include "ttgload.h" +#include "ttraster.h" +#include "ttextend.h" + + +/* required by the tracing mode */ +#undef TT_COMPONENT +#define TT_COMPONENT trace_api + + +#ifdef TT_STATIC_RASTER +#define RAS_OPS /* void */ +#define RAS_OP /* void */ +#else +#define RAS_OPS ((TRaster_Instance*)_engine->raster_component), +#define RAS_OP ((TRaster_Instance*)_engine->raster_component) +#endif /* TT_STATIC_RASTER */ + + +#define RENDER_Glyph( glyph, target ) \ + Render_Glyph( RAS_OPS glyph, target ) + +#define RENDER_Gray_Glyph( glyph, target, palette ) \ + Render_Gray_Glyph( RAS_OPS glyph, target, palette ) + + + +/******************************************************************* + * + * Function : TT_FreeType_Version + * + * Description : Returns the major and minor version of the library. + * + * Input : major, minor addresses + * + * Output : Error code. + * + * MT-Note : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_FreeType_Version( int *major, int *minor ) + { + if ( !major || !minor ) + return TT_Err_Invalid_Argument; + + *major = TT_FREETYPE_MAJOR; + *minor = TT_FREETYPE_MINOR; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Init_FreeType + * + * Description : The library's engine initializer. This function + * must be called prior to any call. + * + * Input : engine pointer to a FreeType engine instance + * + * Output : Error code. + * + * MT-Note : This function should be called each time you want + * to create a TT_Engine. It is not necessarily thread + * safe depending on the implementations of ttmemory, + * ttfile and ttmutex, so take care. Their default + * implementations are safe, however. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Init_FreeType( TT_Engine* engine ) + { + PEngine_Instance _engine; + + TT_Error error; + int n; + + + /* first of all, initialize memory sub-system */ + error = TTMemory_Init(); + if ( error ) + return error; + + /* Allocate engine instance */ + if ( ALLOC( _engine, sizeof ( TEngine_Instance ) ) ) + return error; + +#undef TT_FAIL +#define TT_FAIL( x ) ( error = x (_engine) ) != TT_Err_Ok + + /* Initalize components */ + if ( TT_FAIL( TTFile_Init ) || + TT_FAIL( TTCache_Init ) || +#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE + TT_FAIL( TTExtend_Init ) || +#endif + TT_FAIL( TTObjs_Init ) || + TT_FAIL( TTRaster_Init ) ) + goto Fail; + +#undef TT_FAIL + + /* set the gray palette defaults: 0 to 4 */ + for ( n = 0; n < 5; n++ ) + _engine->raster_palette[n] = (Byte)n; /* Conversion ok, some warn */ + + /* create the engine lock */ + MUTEX_Create( _engine->lock ); + + HANDLE_Set( *engine, _engine ); + return TT_Err_Ok; + + Fail: + TT_Done_FreeType( *engine ); + HANDLE_Set( *engine, NULL ); + return error; + } + + +/******************************************************************* + * + * Function : TT_Done_FreeType + * + * Description : The library's engine finalizer. This function + * will discard all active face and glyph objects + * from the heap. + * + * Input : engine FreeType engine instance + * + * Output : Error code. + * + * MT-Note : Destroys an engine. Not necessarily thread-safe + * depending on the implementations of ttmemory, + * ttfile and ttmutex. The default implementations + * are safe, however. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Done_FreeType( TT_Engine engine ) + { + PEngine_Instance _engine = HANDLE_Engine( engine ); + + + if ( !_engine ) + return TT_Err_Ok; + + MUTEX_Destroy( _engine->lock ); + + TTRaster_Done( _engine ); + TTObjs_Done ( _engine ); +#ifdef TT_CONFIG_OPTION_EXTEND_ENGINE + TTExtend_Done( _engine ); +#endif + TTCache_Done ( _engine ); + TTFile_Done ( _engine ); + FREE( _engine ); + + TTMemory_Done(); + + return TT_Err_Ok; + } + + +#ifdef TT_CONFIG_OPTION_GRAY_SCALING + +/******************************************************************* + * + * Function : TT_Set_Raster_Gray_Palette + * + * Description : Sets the gray-levels palette used for font + * smoothing. + * + * Input : engine FreeType engine instance + * palette address of palette (a 5 byte array) + * + * Output : Invalid argument if 'palette' is NULL. + * + * MT-Note: NO! Unprotected modification of an engine's palette. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Raster_Gray_Palette( TT_Engine engine, + Byte* palette ) + { + int i; + + + if ( !palette ) + return TT_Err_Invalid_Argument; + + for ( i = 0; i < 5; i++ ) + HANDLE_Engine( engine )->raster_palette[i] = (Byte)palette[i]; + + return TT_Err_Ok; + } + +#endif /* TT_CONFIG_OPTION_GRAY_SCALING */ + + +/******************************************************************* + * + * Function : TT_Open_Face + * + * Description : Creates a new face object from a given font file. + * + * Input : engine FreeType engine instance + * fontPathName the font file's pathname + * face adress of returned face handle + * + * Output : Error code. + * + * Note : The face handle is set to NULL in case of failure. + * + * MT-Note : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Open_Face( TT_Engine engine, + const TT_Text* fontPathName, + TT_Face* face ) + { + PEngine_Instance _engine = HANDLE_Engine( engine ); + + TFont_Input input; + TT_Error error; + TT_Stream stream; + PFace _face; + + + if ( !_engine ) + return TT_Err_Invalid_Engine; + + /* open the file */ + error = TT_Open_Stream( fontPathName, &stream ); + if ( error ) + return error; + + input.stream = stream; + input.fontIndex = 0; + input.engine = _engine; + + /* Create and load the new face object - this is thread-safe */ + error = CACHE_New( _engine->objs_face_cache, + _face, + &input ); + + /* Set the handle */ + HANDLE_Set( *face, _face ); + + if ( error ) + goto Fail; + + return TT_Err_Ok; + + Fail: + TT_Close_Stream( &stream ); + return error; + } + + +/******************************************************************* + * + * Function : TT_Open_Collection + * + * Description : Creates a new face object from a given font file. + * + * Input : engine FreeType engine instance + * collectionPathName the font file's pathname + * fontIndex index of font in TrueType collection + * face adress of returned face handle + * + * Output : Error code. + * + * Note : The face handle is set to NULL in case of failure. + * + * MT-Note : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Open_Collection( TT_Engine engine, + const TT_Text* collectionPathName, + TT_ULong fontIndex, + TT_Face* face ) + { + PEngine_Instance _engine = HANDLE_Engine( engine ); + + TFont_Input input; + TT_Error error; + TT_Stream stream; + PFace _face; + + + if ( !_engine ) + return TT_Err_Invalid_Engine; + + /* open the file */ + error = TT_Open_Stream( collectionPathName, &stream ); + if ( error ) + return error; + + input.stream = stream; + input.fontIndex = fontIndex; + input.engine = _engine; + + /* Create and load the new face object - this is thread-safe */ + error = CACHE_New( _engine->objs_face_cache, + _face, + &input ); + + /* Set the handle */ + HANDLE_Set( *face, _face ); + + if ( error ) + goto Fail; + + return TT_Err_Ok; + + Fail: + TT_Close_Stream( &stream ); + + return error; + } + + +/******************************************************************* + * + * Function : TT_Get_Face_Properties + * + * Description : Returns face properties. + * + * Input : face the face handle + * properties address of target properties record + * + * Output : Error code. + * + * Note : Currently, max_Faces is always set to 0. + * + * MT-Note : YES! Reads only permanent data. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Face_Properties( TT_Face face, + TT_Face_Properties* properties ) + { + PFace _face = HANDLE_Face( face ); + + + if ( !_face ) + return TT_Err_Invalid_Face_Handle; + + properties->num_Glyphs = _face->numGlyphs; + properties->max_Points = _face->maxPoints; + properties->max_Contours = _face->maxContours; + properties->num_CharMaps = _face->numCMaps; + properties->num_Names = _face->nameTable.numNameRecords; + + if ( _face->ttcHeader.DirCount == 0 ) + properties->num_Faces = 1; + else + properties->num_Faces = _face->ttcHeader.DirCount; + + properties->header = &_face->fontHeader; + properties->horizontal = &_face->horizontalHeader; + + if ( _face->verticalInfo ) + properties->vertical = &_face->verticalHeader; + else + properties->vertical = NULL; + + properties->os2 = &_face->os2; + properties->postscript = &_face->postscript; + properties->hdmx = &_face->hdmx; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Set_Face_Pointer + * + * Description : Each face object has one pointer, which use is + * reserved to client applications. The TrueType + * engine never accesses or uses this field. + * + * This function is used to set the pointer. + * + * Input : face the given face handle + * data the generic pointer value + * + * Output : Error code. + * + * MT-Note : NO! But this function is reserved to "enlightened" + * developers, so it shouldn't be a problem. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Face_Pointer( TT_Face face, + void* data ) + { + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + else + faze->generic = data; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Face_Pointer + * + * Description : Each face object has one pointer, which use is + * reserved to client applications. The TrueType + * engine never access or use this field. + * + * This function is used to read the pointer. + * + * Input : face the given face handle + * data the generic pointer value + * + * Output : Error code. + * + * MT-Note : NO! But this function is reserved to "enlightened" + * developers, so it shouldn't be a problem. + * + ******************************************************************/ + + EXPORT_FUNC + void* TT_Get_Face_Pointer( TT_Face face ) + { + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return NULL; + else + return faze->generic; + } + + +/******************************************************************* + * + * Function : TT_Get_Face_Metrics + * + * Description : This function returns the original horizontal AND + * vertical metrics as found in the "hmtx" and "vmtx" + * tables. These are the glyphs' left-side-bearings + * and advance widths (horizontal), as well as top + * side bearings and advance heights (vertical). + * + * All are expressed in FONT UNITS, a.k.a. EM + * units. + * + * Input : face The given face handle. + * first Index of first glyph in table. + * last Index of last glyph in table. + * + * leftBearings A pointer to an array of TT_Shorts where the + * left side bearings for the glyphs 'first' + * to 'last' will be returned. If these metrics + * don't interest you, simply set it to NULL. + * + * widths A pointer to an array of TT_UShorts + * where the advance widths for the glyphs + * 'first' to 'last' will be returned. If these + * metrics don't interest you, simply set it + * to NULL. + * + * topBearings A pointer to an array of TT_Shorts where the + * top side bearings for the glyphs 'first' + * to 'last' will be returned. If these metrics + * don't interest you, simply set it to NULL. + * + * heights A pointer to an array of TT_UShorts + * where the advance heights for the glyphs + * 'first' to 'last' will be returned. If these + * metrics don't interest you, simply set it + * to NULL. + * + * Output : Error code. + * + * IMPORTANT NOTE : + * + * As vertical metrics are optional in a TrueType font, this + * function will return an error ( TT_Err_No_Vertical_Data ) + * whenever this function is called on such a face with non-NULL + * 'topBearings' or 'heights' arguments. + * + * When a font has no vertical data, the 'vertical' field in its + * properties structure is set to NULL. + * + * MT-Note : YES! Reads only permanent data. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Face_Metrics( TT_Face face, + TT_UShort firstGlyph, + TT_UShort lastGlyph, + TT_Short* leftBearings, + TT_UShort* widths, + TT_Short* topBearings, + TT_UShort* heights ) + { + PFace _face = HANDLE_Face( face ); + UShort num; + + + if ( !_face ) + return TT_Err_Invalid_Face_Handle; + + /* Check the glyph range */ + if ( lastGlyph >= _face->numGlyphs || firstGlyph > lastGlyph ) + return TT_Err_Invalid_Argument; + + num = lastGlyph - firstGlyph; /* number of elements-1 in each array */ + + /* store the left side bearings and advance widths first */ + { + UShort n; + Short left_bearing; + UShort advance_width; + + + for ( n = 0; n <= num; n++ ) + { + TT_Get_Metrics( &_face->horizontalHeader, + firstGlyph + n, &left_bearing, &advance_width ); + + if ( leftBearings ) leftBearings[n] = left_bearing; + if ( widths ) widths[n] = advance_width; + } + } + + /* check for vertical data if topBearings or heights is non-NULL */ + if ( !topBearings && !heights ) + return TT_Err_Ok; + + if ( !_face->verticalInfo ) + return TT_Err_No_Vertical_Data; + + /* store the top side bearings */ + { + UShort n; + Short top_bearing; + UShort advance_height; + + for ( n = 0; n <= num; n++ ) + { + TT_Get_Metrics( (TT_Horizontal_Header*)&_face->verticalHeader, + firstGlyph + n, &top_bearing, &advance_height ); + + if ( topBearings ) topBearings[n] = top_bearing; + if ( heights ) heights[n] = advance_height; + } + } + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Flush_Face + * + * Description : This function is used to close an active face's + * file handle or descriptor. This is useful to save + * system resources, if your application uses tons + * of fonts. + * + * Input : face the given face handle + * + * Output : Error code. + * + * MT-Note : YES! (If ttfile is.) + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Flush_Face( TT_Face face ) + { + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + else + return TT_Flush_Stream( &faze->stream ); + } + + +/******************************************************************* + * + * Function : TT_Close_Face + * + * Description : Closes an opened face object. This function + * will destroy all objects associated to the + * face, except the glyphs. + * + * Input : face the given face handle + * + * Output : Error code. + * + * NOTE : The handle is set to NULL on exit. + * + * MT-Note : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Close_Face( TT_Face face ) + { + PFace _face = HANDLE_Face( face ); + + + if ( !_face ) + return TT_Err_Invalid_Face_Handle; + + TT_Close_Stream( &_face->stream ); + + /* delete the face object -- this is thread-safe */ + return CACHE_Done( _face->engine->objs_face_cache, _face ); + } + + +/******************************************************************* + * + * Function : TT_New_Instance + * + * Description : Creates a new instance from a given face. + * + * Input : face parent face handle + * instance address of instance handle + * + * Output : Error code. + * + * Note : The handle is set to NULL in case of failure. + * + * MT-Note : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_New_Instance( TT_Face face, + TT_Instance* instance ) + { + TT_Error error; + PFace _face = HANDLE_Face( face ); + PInstance _ins; + + + if ( !_face ) + return TT_Err_Invalid_Face_Handle; + + /* get a new instance from the face's cache -- this is thread-safe */ + error = CACHE_New( &_face->instances, _ins, _face ); + + HANDLE_Set( *instance, _ins ); + + if ( !error ) + { + error = Instance_Init( _ins ); + if ( error ) + { + HANDLE_Set( *instance, NULL ); + CACHE_Done( &_face->instances, _ins ); + } + } + + return error; + } + + +/******************************************************************* + * + * Function : TT_Set_Instance_Resolutions + * + * Description : Resets an instance to a new device resolution. + * + * Input : instance the instance handle + * xResolution new horizontal device resolution in dpi + * yResolution new vertical device resolution in dpi + * + * Output : Error code. + * + * Note : There is no check for overflow; with other words, + * the product of glyph dimensions times the device + * resolutions must have reasonable values. + * + * MT-Note : You should set the charsize or pixel size immediately + * after this call in multi-threaded programs. This will + * force the instance data to be resetted. Otherwise, you + * may encounter corruption when loading two glyphs from + * the same instance concurrently! + * + * Happily, 99.99% will do just that :-) + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Instance_Resolutions( TT_Instance instance, + TT_UShort xResolution, + TT_UShort yResolution ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + + ins->metrics.x_resolution = xResolution; + ins->metrics.y_resolution = yResolution; + ins->valid = FALSE; + + /* In the case of a thread-safe implementation, we immediately */ + /* call Instance_Reset in order to change the instance's variable */ + + /* In the case of a non-threaded build, we simply set the 'valid' */ + /* flag to FALSE, which will force the instance's resetting at */ + /* the next glyph loading */ + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Set_Instance_CharSizes + * + * Description : Resets an instance to new point size. + * + * Input : instance the instance handle + * charWidth the new width in 26.6 char points + * charHeight the new height in 26.6 char points + * + * Output : Error code. + * + * Note : There is no check for overflow; with other words, + * the product of glyph dimensions times the device + * resolution must have reasonable values. + * + * MT-Note : NO! This should be called only when setting/resetting + * instances, so there is no need to protect. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Instance_CharSizes( TT_Instance instance, + TT_F26Dot6 charWidth, + TT_F26Dot6 charHeight ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + + if ( charWidth < 1 * 64 ) + charWidth = 1 * 64; + + if ( charHeight < 1 * 64 ) + charHeight = 1 * 64; + + ins->metrics.x_scale1 = ( charWidth * ins->metrics.x_resolution ) / 72; + ins->metrics.x_scale2 = ins->owner->fontHeader.Units_Per_EM; + + ins->metrics.y_scale1 = ( charHeight * ins->metrics.y_resolution ) / 72; + ins->metrics.y_scale2 = ins->owner->fontHeader.Units_Per_EM; + + if ( ins->owner->fontHeader.Flags & 8 ) + { + ins->metrics.x_scale1 = (ins->metrics.x_scale1+32) & -64; + ins->metrics.y_scale1 = (ins->metrics.y_scale1+32) & -64; + } + + ins->metrics.x_ppem = ins->metrics.x_scale1 / 64; + ins->metrics.y_ppem = ins->metrics.y_scale1 / 64; + + if ( charWidth > charHeight ) + ins->metrics.pointSize = charWidth; + else + ins->metrics.pointSize = charHeight; + + ins->valid = FALSE; + + return Instance_Reset( ins ); + } + + +/******************************************************************* + * + * Function : TT_Set_Instance_CharSize + * + * Description : Resets an instance to new point size. + * + * Input : instance the instance handle + * charSize the new character size in 26.6 char points + * + * Output : Error code. + * + * Note : There is no check for overflow; with other words, + * the product of glyph dimensions times the device + * resolution must have reasonable values. + * + * MT-Note : NO! This should be called only when setting/resetting + * instances, so there is no need to protect. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Instance_CharSize( TT_Instance instance, + TT_F26Dot6 charSize ) + { + return TT_Set_Instance_CharSizes( instance, charSize, charSize ); + } + + +/******************************************************************* + * + * Function : TT_Set_Instance_PixelSizes + * + * Description : Resets an instance to new pixel sizes + * + * Input : instance the instance handle + * pixelWidth the new width in pixels + * pixelHeight the new height in pixels + * + * Output : Error code. + * + * Note : There is no check for overflow; with other words, + * the product of glyph dimensions times the device + * resolution must have reasonable values. + * + * MT-Note : NO! This should be called only when setting/resetting + * instances, so there is no need to protect. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Instance_PixelSizes( TT_Instance instance, + TT_UShort pixelWidth, + TT_UShort pixelHeight, + TT_F26Dot6 pointSize ) + { + PInstance ins = HANDLE_Instance( instance ); + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + + if ( pixelWidth < 1 ) pixelWidth = 1; + if ( pixelHeight < 1 ) pixelHeight = 1; + + ins->metrics.x_ppem = pixelWidth; + ins->metrics.y_ppem = pixelHeight; + ins->metrics.pointSize = pointSize; + + ins->metrics.x_scale1 = ins->metrics.x_ppem * 64L; + ins->metrics.x_scale2 = ins->owner->fontHeader.Units_Per_EM; + ins->metrics.y_scale1 = ins->metrics.y_ppem * 64L; + ins->metrics.y_scale2 = ins->owner->fontHeader.Units_Per_EM; + + ins->valid = FALSE; + + return Instance_Reset( ins ); + } + + +/******************************************************************* + * + * Function : TT_Set_Instance_Transform_Flags + * + * Description : Informs the interpreter about the transformations + * that will be applied to the rendered glyphs. + * + * Input : instance the instance handle + * rotated set to TRUE if the glyph are rotated + * stretched set to TRUE if the glyph are stretched + * + * Output : Error code. + * + * Note : This function is deprecated! It's much better to + * control hinting manually when calling TT_Load_Glyph + * than relying on the font programs... + * + * Never use it, unless calling for trouble ;-) + * + * MT-Note : NO! This should be called only when setting/resetting + * instances, so there is no need to protect. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Instance_Transform_Flags( TT_Instance instance, + TT_Bool rotated, + TT_Bool stretched ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + + ins->metrics.rotated = rotated; + ins->metrics.stretched = stretched; + ins->valid = FALSE; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Instance_Metrics + * + * Description : Returns instance metrics. + * + * Input : instance the instance handle + * metrics address of target instance metrics record + * + * Output : Error code. + * + * MT-Note : YES! Reads only semi-permanent data. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Instance_Metrics( TT_Instance instance, + TT_Instance_Metrics* metrics ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + + if ( !ins->valid ) + Instance_Reset( ins ); + + metrics->pointSize = ins->metrics.pointSize; + + metrics->x_scale = TT_MulDiv( 0x10000, + ins->metrics.x_scale1, + ins->metrics.x_scale2 ); + + metrics->y_scale = TT_MulDiv( 0x10000, + ins->metrics.y_scale1, + ins->metrics.y_scale2 ); + + metrics->x_resolution = ins->metrics.x_resolution; + metrics->y_resolution = ins->metrics.y_resolution; + metrics->x_ppem = ins->metrics.x_ppem; + metrics->y_ppem = ins->metrics.y_ppem; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Set_Instance_Pointer + * + * Description : Each instance has one pointer, which use is + * reserved to client applications. The TrueType + * engine never accesses or uses this field. + * + * This function is used to set the pointer. + * + * Input : face the given face handle + * data the generic pointer value + * + * Output : Error code. + * + * MT-Note : NO! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Set_Instance_Pointer( TT_Instance instance, + void* data ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + else + ins->generic = data; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Instance_Pointer + * + * Description : Each instance has one pointer, which use is + * reserved to client applications. The TrueType + * engine never accesses or uses this field. + * + * This function is used to read the pointer. + * + * Input : face the given face handle + * data the generic pointer value + * + * Output : Error code. + * + * MT-Safe : NO! + * + ******************************************************************/ + + EXPORT_FUNC + void* TT_Get_Instance_Pointer( TT_Instance instance ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return NULL; + else + return ins->generic; + } + + +/******************************************************************* + * + * Function : TT_Done_Instance + * + * Description : Closes a given instance. + * + * Input : instance address of instance handle + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Done_Instance( TT_Instance instance ) + { + PInstance ins = HANDLE_Instance( instance ); + + + if ( !ins ) + return TT_Err_Invalid_Instance_Handle; + + /* delete the instance -- this is thread-safe */ + return CACHE_Done( &ins->owner->instances, ins ); + } + + +/******************************************************************* + * + * Function : TT_New_Glyph + * + * Description : Creates a new glyph object related to a given + * face. + * + * Input : face the face handle + * glyph address of target glyph handle + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_New_Glyph( TT_Face face, + TT_Glyph* glyph ) + { + TT_Error error; + PFace _face = HANDLE_Face( face ); + PGlyph _glyph; + + + if ( !_face ) + return TT_Err_Invalid_Face_Handle; + + /* get a new glyph from the face's cache -- this is thread-safe */ + error = CACHE_New( &_face->glyphs, _glyph, _face ); + + HANDLE_Set( *glyph, _glyph ); + + return error; + } + + +/******************************************************************* + * + * Function : TT_Done_Glyph + * + * Description : Destroys a given glyph object. + * + * Input : glyph the glyph handle + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Done_Glyph( TT_Glyph glyph ) + { + PGlyph _glyph = HANDLE_Glyph( glyph ); + + + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + /* delete the engine -- this is thread-safe */ + return CACHE_Done( &_glyph->face->glyphs, _glyph ); + } + + +/******************************************************************* + * + * Function : TT_Load_Glyph + * + * Description : Loads a glyph. + * + * Input : instance the instance handle + * glyph the glyph handle + * glyphIndex the glyph index + * loadFlags flags controlling how to load the glyph + * (none, scaled, hinted, both) + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Load_Glyph( TT_Instance instance, + TT_Glyph glyph, + TT_UShort glyphIndex, + TT_UShort loadFlags ) + { + PInstance _ins; + PGlyph _glyph; + TT_Error error; + + + _ins = HANDLE_Instance( instance ); + + if ( !_ins ) + loadFlags &= ~(TTLOAD_SCALE_GLYPH | TTLOAD_HINT_GLYPH); + + if ( (loadFlags & TTLOAD_SCALE_GLYPH) == 0 ) + _ins = 0; + + _glyph = HANDLE_Glyph( glyph ); + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + if ( _ins ) + { + if ( _ins->owner != _glyph->face ) + return TT_Err_Invalid_Face_Handle; + + if ( !_ins->valid ) + { + /* This code can only be called in non thread-safe builds */ + error = Instance_Reset( _ins ); + if ( error ) + return error; + } + } + + return Load_TrueType_Glyph( _ins, _glyph, glyphIndex, loadFlags ); + } + + +/******************************************************************* + * + * Function : TT_Get_Glyph_Outline + * + * Description : Returns the glyph's outline data. + * + * Input : glyph the glyph handle + * outline address where the glyph outline will be returned + * + * Output : Error code. + * + * MT-Safe : YES! Reads only semi-permanent data. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Glyph_Outline( TT_Glyph glyph, + TT_Outline* outline ) + { + PGlyph _glyph = HANDLE_Glyph( glyph ); + + + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + *outline = _glyph->outline; + outline->owner = FALSE; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Glyph_Metrics + * + * Description : Extracts the glyph's horizontal metrics information. + * + * Input : glyph glyph object handle + * metrics address where metrics will be returned + * + * Output : Error code. + * + * MT-Safe : NO! Glyph containers can't be shared. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Glyph_Metrics( TT_Glyph glyph, + TT_Glyph_Metrics* metrics ) + { + PGlyph _glyph = HANDLE_Glyph( glyph ); + + + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + metrics->bbox = _glyph->metrics.bbox; + metrics->bearingX = _glyph->metrics.horiBearingX; + metrics->bearingY = _glyph->metrics.horiBearingY; + metrics->advance = _glyph->metrics.horiAdvance; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Glyph_Big_Metrics + * + * Description : Extracts the glyph's big metrics information. + * + * Input : glyph glyph object handle + * metrics address where big metrics will be returned + * + * Output : Error code. + * + * MT-Safe : NO! Glyph containers can't be shared. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Glyph_Big_Metrics( TT_Glyph glyph, + TT_Big_Glyph_Metrics* metrics ) + { + PGlyph _glyph = HANDLE_Glyph( glyph ); + + + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + *metrics = _glyph->metrics; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Glyph_Bitmap + * + * Description : Produces a bitmap from a glyph outline. + * + * Input : glyph the glyph container's handle + * bitmap target bitmap description block + * xOffset x offset in fractional pixels (26.6 format) + * yOffset y offset in fractional pixels (26.6 format) + * + * Output : Error code. + * + * Note : Only use integer pixel offsets if you want to preserve + * the fine hints applied to the outline. This means that + * xOffset and yOffset must be multiples of 64! + * + * MT-Safe : NO! Glyph containers can't be shared. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Glyph_Bitmap( TT_Glyph glyph, + TT_Raster_Map* bitmap, + TT_F26Dot6 xOffset, + TT_F26Dot6 yOffset ) + { + PEngine_Instance _engine; + TT_Engine engine; + TT_Error error; + PGlyph _glyph = HANDLE_Glyph( glyph ); + + TT_Outline outline; + + + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + _engine = _glyph->face->engine; + HANDLE_Set( engine, _engine ); + + outline = _glyph->outline; + /* XXX : For now, use only dropout mode 2 */ + /* outline.dropout_mode = _glyph->scan_type; */ + outline.dropout_mode = 2; + + TT_Translate_Outline( &outline, xOffset, yOffset ); + error = TT_Get_Outline_Bitmap( engine, &outline, bitmap ); + TT_Translate_Outline( &outline, -xOffset, -yOffset ); + + return error; + } + + +#ifdef TT_CONFIG_OPTION_GRAY_SCALING + +/******************************************************************* + * + * Function : TT_Get_Glyph_Pixmap + * + * Description : Produces a grayscaled pixmap from a glyph + * outline. + * + * Input : glyph the glyph container's handle + * pixmap target pixmap description block + * xOffset x offset in fractional pixels (26.6 format) + * yOffset y offset in fractional pixels (26.6 format) + * + * Output : Error code. + * + * Note : Only use integer pixel offsets to preserve the fine + * hinting of the glyph and the 'correct' anti-aliasing + * (where vertical and horizontal stems aren't grayed). + * This means that xOffset and yOffset must be multiples + * of 64! + * + * You can experiment with offsets of +32 to get 'blurred' + * versions of the glyphs (a nice effect at large sizes that + * some graphic designers may appreciate :) + * + * MT-Safe : NO! Glyph containers can't be shared. + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Glyph_Pixmap( TT_Glyph glyph, + TT_Raster_Map* pixmap, + TT_F26Dot6 xOffset, + TT_F26Dot6 yOffset ) + { + PEngine_Instance _engine; + TT_Engine engine; + TT_Error error; + PGlyph _glyph = HANDLE_Glyph( glyph ); + + TT_Outline outline; + + + if ( !_glyph ) + return TT_Err_Invalid_Glyph_Handle; + + _engine = _glyph->face->engine; + HANDLE_Set(engine,_engine); + + outline = _glyph->outline; + /* XXX : For now, use only dropout mode 2 */ + /* outline.dropout_mode = _glyph->scan_type; */ + outline.dropout_mode = 2; + + TT_Translate_Outline( &outline, xOffset, yOffset ); + error = TT_Get_Outline_Pixmap( engine, &outline, pixmap ); + TT_Translate_Outline( &outline, -xOffset, -yOffset ); + + return error; + } + +#endif /* TT_CONFIG_OPTION_GRAY_SCALING */ + + + static const TT_Outline null_outline + = { 0, 0, NULL, NULL, NULL, 0, 0, 0, 0 }; + + +/******************************************************************* + * + * Function : TT_New_Outline + * + * Description : Creates a new TrueType outline, reserving + * array space for a given number of points and + * contours. + * + * Input : numPoints number of points + * numContours number of contours + * outline address of target outline structure + * + * Output : Error code + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_New_Outline( TT_UShort numPoints, + TT_Short numContours, + TT_Outline* outline ) + { + TT_Error error; + + + if ( !outline ) + return TT_Err_Invalid_Argument; + + *outline = null_outline; + + if ( ALLOC( outline->points, numPoints*2*sizeof ( TT_F26Dot6 ) ) || + ALLOC( outline->flags, numPoints *sizeof ( Byte ) ) || + ALLOC( outline->contours, numContours*sizeof ( UShort ) ) ) + goto Fail; + + outline->n_points = numPoints; + outline->n_contours = numContours; + outline->owner = TRUE; + return TT_Err_Ok; + + Fail: + outline->owner = TRUE; + TT_Done_Outline( outline ); + return error; + } + + +/******************************************************************* + * + * Function : TT_Done_Outline + * + * Description : Deletes an outline created through TT_New_Outline(). + * Calling this function for outlines returned + * by TT_Get_Glyph_Outline() yields an error. + * + * Input : outline address of outline + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Done_Outline( TT_Outline* outline ) + { + if ( outline ) + { + if ( outline->owner ) + { + FREE( outline->points ); + FREE( outline->flags ); + FREE( outline->contours ); + } + *outline = null_outline; + return TT_Err_Ok; + } + else + return TT_Err_Invalid_Argument; + } + + +/******************************************************************* + * + * Function : TT_Get_Outline_Bitmap + * + * Description : Render a TrueType outline into a bitmap. + * Note that the bitmap must be created by the caller. + * + * Input : outline the outline to render + * bitmap the target bitmap + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Outline_Bitmap( TT_Engine engine, + TT_Outline* outline, + TT_Raster_Map* bitmap ) + { + PEngine_Instance _engine = HANDLE_Engine( engine ); + TT_Error error; + + + if ( !_engine ) + return TT_Err_Invalid_Engine; + + if ( !outline || !bitmap ) + return TT_Err_Invalid_Argument; + + MUTEX_Lock( _engine->raster_lock ); + error = RENDER_Glyph( outline, bitmap ); + MUTEX_Release( _engine->raster_lock ); + + return error; + } + + +#ifdef TT_CONFIG_OPTION_GRAY_SCALING + +/******************************************************************* + * + * Function : TT_Get_Outline_Pixmap + * + * Description : Render a TrueType outline into a pixmap. + * Note that the pixmap must be created by the caller. + * + * Input : outline the outline to render + * pixmap the target pixmap + * + * Output : Error code + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Outline_Pixmap( TT_Engine engine, + TT_Outline* outline, + TT_Raster_Map* pixmap ) + { + PEngine_Instance _engine = HANDLE_Engine( engine ); + TT_Error error; + + + if ( !_engine ) + return TT_Err_Invalid_Engine; + + if ( !outline || !pixmap ) + return TT_Err_Invalid_Argument; + + MUTEX_Lock( _engine->raster_lock ); + error = RENDER_Gray_Glyph( outline, pixmap, _engine->raster_palette ); + MUTEX_Release( _engine->raster_lock ); + return error; + } + +#endif /* TT_CONFIG_OPTION_GRAY_SCALING */ + + +/******************************************************************* + * + * Function : TT_Copy_Outline + * + * Description : Copy an outline into another. The source and + * target outlines must have the same points and + * contours numbers. + * + * Input : source address of source outline + * target address of target outline + * + * Output : Error code + * + * Note : This function doesn't touch the target outline's 'owner' + * field. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Copy_Outline( TT_Outline* source, + TT_Outline* target ) + { + if ( !source || !target || + source->n_points != target->n_points || + source->n_contours != target->n_contours ) + return TT_Err_Invalid_Argument; + + MEM_Copy( target->points, source->points, + source->n_points * 2 * sizeof ( TT_F26Dot6 ) ); + + MEM_Copy( target->flags, source->flags, + source->n_points * sizeof ( Byte ) ); + + MEM_Copy( target->contours, source->contours, + source->n_contours * sizeof ( Short ) ); + + target->high_precision = source->high_precision; + target->second_pass = target->second_pass; + target->dropout_mode = source->dropout_mode; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Transform_Outline + * + * Description : Applies a simple transformation to an outline. + * + * Input : outline the glyph's outline. Can be extracted + * from a glyph container through + * TT_Get_Glyph_Outline(). + * + * matrix simple matrix with 16.16 fixed floats + * + * Output : Error code (always TT_Err_Ok). + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + void TT_Transform_Outline( TT_Outline* outline, + TT_Matrix* matrix ) + { + UShort n; + TT_F26Dot6 x, y; + TT_Vector* vec; + + + vec = outline->points; + for ( n = 0; n < outline->n_points; n++ ) + { + x = TT_MulFix( vec->x, matrix->xx ) + + TT_MulFix( vec->y, matrix->xy ); + + y = TT_MulFix( vec->x, matrix->yx ) + + TT_MulFix( vec->y, matrix->yy ); + + vec->x = x; + vec->y = y; + vec++; + } + } + + +/******************************************************************* + * + * Function : TT_Transform_Vector + * + * Description : Apply a simple transform to a vector + * + * Input : x, y the vector. + * + * matrix simple matrix with 16.16 fixed floats + * + * Output : None. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + void TT_Transform_Vector( TT_F26Dot6* x, + TT_F26Dot6* y, + TT_Matrix* matrix ) + { + TT_F26Dot6 xz, yz; + + + xz = TT_MulFix( *x, matrix->xx ) + + TT_MulFix( *y, matrix->xy ); + + yz = TT_MulFix( *x, matrix->yx ) + + TT_MulFix( *y, matrix->yy ); + + *x = xz; + *y = yz; + } + + +/******************************************************************* + * + * Function : TT_Translate_Outline + * + * Description : Applies a simple translation. + * + * Input : outline no comment :) + * xOffset + * yOffset + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + void TT_Translate_Outline( TT_Outline* outline, + TT_F26Dot6 xOffset, + TT_F26Dot6 yOffset ) + { + UShort n; + TT_Vector* vec = outline->points; + + + for ( n = 0; n < outline->n_points; n++ ) + { + vec->x += xOffset; + vec->y += yOffset; + vec++; + } + } + + +/******************************************************************* + * + * Function : TT_Get_Outline_BBox + * + * Description : Returns an outline's bounding box. + * + * Input : outline no comment :) + * bbox address where the bounding box is returned + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Outline_BBox( TT_Outline* outline, + TT_BBox* bbox ) + { + TT_F26Dot6 x, y; + UShort k; + + + if ( outline && bbox ) + { + if ( outline->n_points == 0 ) + { + bbox->xMin = 0; + bbox->yMin = 0; + bbox->xMax = 0; + bbox->yMax = 0; + } + else + { + TT_Vector* vec = outline->points; + + bbox->xMin = bbox->xMax = vec->x; + bbox->yMin = bbox->yMax = vec->y; + vec++; + + for ( k = 1; k < outline->n_points; k++ ) + { + x = vec->x; + if ( x < bbox->xMin ) bbox->xMin = x; + if ( x > bbox->xMax ) bbox->xMax = x; + y = vec->y; + if ( y < bbox->yMin ) bbox->yMin = y; + if ( y > bbox->yMax ) bbox->yMax = y; + vec++; + } + } + return TT_Err_Ok; + } + else + return TT_Err_Invalid_Argument; + } + + + + /* ----------------- character mappings support ------------- */ + +/******************************************************************* + * + * Function : TT_Get_CharMap_Count + * + * Description : Returns the number of charmaps in a given face. + * + * Input : face face object handle + * + * Output : Number of tables. -1 in case of error (bad handle). + * + * Note : DON'T USE THIS FUNCTION! IT HAS BEEN DEPRECATED! + * + * It is retained for backwards compatibility only and will + * fail on 16bit systems. + * + * MT-Safe : YES ! + * + ******************************************************************/ + + EXPORT_FUNC + int TT_Get_CharMap_Count( TT_Face face ) + { + PFace faze = HANDLE_Face( face ); + + return ( faze ? faze->numCMaps : -1 ); + } + + +/******************************************************************* + * + * Function : TT_Get_CharMap_ID + * + * Description : Returns the ID of a given charmap. + * + * Input : face face object handle + * charmapIndex index of charmap in directory + * platformID address of returned platform ID + * encodingID address of returned encoding ID + * + * Output : error code + * + * MT-Safe : YES ! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_CharMap_ID( TT_Face face, + TT_UShort charmapIndex, + TT_UShort* platformID, + TT_UShort* encodingID ) + { + PCMapTable cmap; + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + + if ( charmapIndex >= faze->numCMaps ) + return TT_Err_Invalid_Argument; + + cmap = faze->cMaps + charmapIndex; + + *platformID = cmap->platformID; + *encodingID = cmap->platformEncodingID; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_CharMap + * + * Description : Looks up a charmap. + * + * Input : face face object handle + * charmapIndex index of charmap in directory + * charMap address of returned charmap handle + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_CharMap( TT_Face face, + TT_UShort charmapIndex, + TT_CharMap* charMap ) + { + TT_Error error; + TT_Stream stream; + PCMapTable cmap; + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + + if ( charmapIndex >= faze->numCMaps ) + return TT_Err_Invalid_Argument; + + cmap = faze->cMaps + charmapIndex; + + /* Load table if needed */ + error = TT_Err_Ok; + + /* MT-NOTE: We're modifying the face object, so protect it. */ + MUTEX_Lock( faze->lock ); + + if ( !cmap->loaded ) + { + (void)USE_Stream( faze->stream, stream ); + if ( !error ) + { + error = CharMap_Load( cmap, stream ); + DONE_Stream( stream ); + } + + if ( error ) + cmap = NULL; + else + cmap->loaded = TRUE; + } + MUTEX_Release( faze->lock ); + + HANDLE_Set( *charMap, cmap ); + + return error; + } + + +/******************************************************************* + * + * Function : TT_Char_Index + * + * Description : Returns the glyph index corresponding to + * a given character code defined for the 'charmap'. + * + * Input : charMap charmap handle + * charcode character code + * + * Output : glyph index. + * + * Notes : Character code 0 is the unknown glyph, which should never + * be displayed. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_UShort TT_Char_Index( TT_CharMap charMap, + TT_ULong charCode ) + { + PCMapTable cmap = HANDLE_CharMap( charMap ); + + + if ( !cmap ) + return 0; /* we return 0 in case of invalid char map */ + + return CharMap_Index( cmap, charCode ); + } + + +/******************************************************************* + * + * Function : TT_Get_Name_Count + * + * Description : Returns the number of strings found in the + * name table. + * + * Input : face face handle + * + * Output : number of strings. + * + * Notes : Returns -1 on error (invalid handle). + * + * DON'T USE THIS FUNCTION! IT HAS BEEN DEPRECATED! + * + * It is retained for backwards compatibility only and will + * fail on 16bit systems. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + int TT_Get_Name_Count( TT_Face face ) + { + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return -1; + + return faze->nameTable.numNameRecords; + } + + +/******************************************************************* + * + * Function : TT_Get_Name_ID + * + * Description : Returns the IDs of the string number 'nameIndex' + * in the name table of a given face. + * + * Input : face face handle + * nameIndex index of string. First is 0 + * platformID addresses of returned IDs + * encodingID + * languageID + * nameID + * + * Output : Error code. + * + * Notes : Some files have a corrupt or unusual name table, with some + * entries having a platformID > 3. These can usually + * be ignored by a client application. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Name_ID( TT_Face face, + TT_UShort nameIndex, + TT_UShort* platformID, + TT_UShort* encodingID, + TT_UShort* languageID, + TT_UShort* nameID ) + { + TNameRec* namerec; + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + + if ( nameIndex >= faze->nameTable.numNameRecords ) + return TT_Err_Invalid_Argument; + + namerec = faze->nameTable.names + nameIndex; + + *platformID = namerec->platformID; + *encodingID = namerec->encodingID; + *languageID = namerec->languageID; + *nameID = namerec->nameID; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Name_String + * + * Description : Returns the address and length of a given + * string found in the name table. + * + * Input : face face handle + * nameIndex string index + * stringPtr address of returned pointer to string + * length address of returned string length + * + * Output : Error code. + * + * Notes : If the string's platformID is invalid, + * stringPtr is NULL, and length is 0. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Name_String( TT_Face face, + TT_UShort nameIndex, + TT_String** stringPtr, + TT_UShort* length ) + { + TNameRec* namerec; + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + + if ( nameIndex >= faze->nameTable.numNameRecords ) + return TT_Err_Invalid_Argument; + + namerec = faze->nameTable.names + nameIndex; + + *stringPtr = (String*)namerec->string; + *length = namerec->stringLength; + + return TT_Err_Ok; + } + + +/******************************************************************* + * + * Function : TT_Get_Font_Data + * + * Description : Loads any font table into client memory. + * + * Input : face Face object to look for. + * + * tag Tag of table to load. Use the value 0 if you + * want to access the whole font file, else set + * this parameter to a valid TrueType table tag + * that you can forge with the MAKE_TT_TAG + * macro. + * + * offset Starting offset in the table (or the file + * if tag == 0). + * + * buffer Address of target buffer + * + * length Address of decision variable: + * + * if length == NULL: + * Load the whole table. Returns an + * error if 'offset' != 0. + * + * if *length == 0 : + * Exit immediately, returning the + * length of the given table, or of + * the font file, depending on the + * value of 'tag'. + * + * if *length != 0 : + * Load the next 'length' bytes of + * table or font, starting at offset + * 'offset' (in table or font too). + * + * Output : Error code. + * + * MT-Safe : YES! + * + ******************************************************************/ + + EXPORT_FUNC + TT_Error TT_Get_Font_Data( TT_Face face, + TT_ULong tag, + TT_Long offset, + void* buffer, + TT_Long* length ) + { + PFace faze = HANDLE_Face( face ); + + + if ( !faze ) + return TT_Err_Invalid_Face_Handle; + + return Load_TrueType_Any( faze, tag, offset, buffer, length ); + } + + + /************************ callback definition ******************/ + + /* Register a new callback to the TrueType engine -- this should */ + /* only be used by higher-level libraries, not typical clients */ + /* */ + /* This is not part of the current FreeType release, thus */ + /* undefined... */ + +#if 0 + EXPORT_FUNC + TT_Error TT_Register_Callback( TT_Engine engine, + int callback_id, + void* callback_ptr ) + { + PEngine_Instance eng = HANDLE_Engine( engine ); + + + if ( !eng ) + return TT_Err_Invalid_Argument; + + /* currently, we only support one callback */ + if (callback_id != TT_Callback_Glyph_Outline_Load) + return TT_Err_Invalid_Argument; + + eng->glCallback = (TT_Glyph_Loader_Callback)callback_ptr; + return TT_Err_Ok; + } +#endif /* 0 */ + + +/* END */ |