| /******************************************************************* |
| * |
| * ttapi.c |
| * |
| * High-level interface implementation |
| * |
| * Copyright 1996-1998 by |
| * David Turner, Robert Wilhelm, and Werner Lemberg. |
| * |
| * This file is part of the FreeType project, and may only be used, |
| * modified, and distributed under the terms of the FreeType project |
| * license, LICENSE.TXT. By continuing to use, modify, or distribute |
| * this file you indicate that you have read the license and |
| * understand and accept it fully. |
| * |
| * 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 : |
| * |
| ******************************************************************/ |
| |
| #include <freetype/freetype.h> |
| |
| #include <freetype/internal/ftdebug.h> |
| #include <freetype/internal/ftstream.h> |
| #include <freetype/internal/ftcalc.h> |
| #include <freetype/internal/ftlist.h> |
| #include <freetype/internal/ftraster.h> |
| |
| #include <../truetype/ttdriver.h> |
| #include <../truetype/ttobjs.h> |
| #include <../truetype/ttcmap.h> |
| |
| #define _TRUETYPE_ |
| #include <truetype.h> /* backwards compatible interface */ |
| |
| |
| |
| /* required by the tracing mode */ |
| #undef FT_COMPONENT |
| #define FT_COMPONENT trace_ttapi |
| |
| |
| #define RENDER_POOL_SIZE 64000 |
| |
| static |
| const FT_DriverInterface* tt_interface = &tt_driver_interface; |
| |
| static |
| const TT_DriverInterface* tt_extension = &tt_format_interface; |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Init_FreeType */ |
| /* */ |
| /* <Description> */ |
| /* Creates a new TrueType driver/engine object. */ |
| /* */ |
| /* <Output> */ |
| /* engine :: handle to the new engine object */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* This function is provided for stand-alone compiles of the */ |
| /* TrueType driver. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Init_FreeType( TT_Engine* engine ) |
| { |
| FT_Library library; |
| FT_System system; |
| TT_Error error; |
| |
| *engine = 0; |
| |
| error = FT_New_System( &system ); |
| if (error) return error; |
| |
| error = FT_New_Library( system, &library ); |
| if (!error) |
| /* Now create a new TrueType driver object */ |
| error = FT_Add_Driver( library, |
| (FT_DriverInterface*)&tt_driver_interface ); |
| if (error) |
| FT_Done_Library(library); |
| else |
| *engine = (TT_Engine)library; |
| |
| return error; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Done_FreeType */ |
| /* */ |
| /* <Description> */ |
| /* Destroys a given TrueType engine object created with */ |
| /* TT_Init_FreeType. All associated objects, (i.e. faces, outlines */ |
| /* and charmaps) will be destroyed.. */ |
| /* */ |
| /* <Input> */ |
| /* engine :: handle to the engine object */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* This function is provided for stand-alone compiles of the */ |
| /* TrueType driver. The FreeType library uses the TT_Done_Engine */ |
| /* API. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Done_FreeType( TT_Engine engine ) |
| { |
| FT_Library library = (FT_Library)engine; |
| |
| FT_Done_FreeType( library ); |
| return FT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Raster_Gray_Palette */ |
| /* */ |
| /* <Description> */ |
| /* Sets the raster's gray 5-levels palette. Entry 0 correspond to */ |
| /* the background, Entry 4 to the foreground. Intermediate entries */ |
| /* correspond to gray levels.. */ |
| /* */ |
| /* <Input> */ |
| /* engine :: handle to the engine object */ |
| /* palette :: an array of 5 bytes used to render 8-bit pixmaps */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* This function is provided for stand-alone compiles of the */ |
| /* TrueType driver. The FreeType library accesses directly the */ |
| /* raster object to set the palette. */ |
| /* */ |
| /* This function ONLY supports 5 levels of grays. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Set_Raster_Gray_Palette( TT_Engine engine, |
| const TT_Byte* palette ) |
| { |
| FT_Library library; |
| |
| if (!engine) |
| return TT_Err_Invalid_Engine; |
| |
| library = (FT_Library)engine; |
| return FT_Set_Raster_Palette( library, 5, (unsigned char*)palette ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Open_Face */ |
| /* */ |
| /* <Description> */ |
| /* Creates a new face object from a given resource. The file can */ |
| /* be either a TrueType file (ttf) or a TrueType collection (ttc). */ |
| /* In the latter case, only the first face is opened. The number */ |
| /* of faces in a collection can be obtained in the face's */ |
| /* properties field "num_Faces". Other faces can be opened with */ |
| /* TT_Open_Collection (see below). */ |
| /* */ |
| /* <Input> */ |
| /* engine :: the parent engine object where to create the face */ |
| /* object. */ |
| /* */ |
| /* pathname :: pathname for the font file. */ |
| /* */ |
| /* <Output> */ |
| /* face :: a handle to the fresh face object. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success.. */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| /* <Note> */ |
| /* This API is provided fro backwards compatibility. Please use */ |
| /* the functions TT_New_Face/TT_Done_Face now to create and */ |
| /* discard face objects.. */ |
| /* */ |
| |
| |
| static |
| TT_Error open_face( FT_Library library, |
| const TT_Text* pathname, |
| TT_Int face_index, |
| TT_Face *aface ) |
| { |
| TT_Error error; |
| FT_Resource resource; |
| |
| *aface = 0; |
| |
| error = FT_New_Resource( library, pathname, &resource ); |
| if (error) return error; |
| |
| #if 0 |
| error = FT_Add_Resource( library, resource ); |
| if (error) goto Fail_Install; |
| #endif |
| error = FT_New_Face( resource, face_index, (FT_Face*)aface ); |
| |
| /* Destroy glyph slot to comply with the 1.x API */ |
| if (!error) |
| FT_Done_GlyphSlot( (*aface)->root.slot ); |
| |
| if (error) |
| FT_Done_Resource(resource); |
| |
| return error; |
| } |
| |
| |
| EXPORT_DEF |
| TT_Error TT_Open_Face( TT_Engine engine, |
| const TT_Text* pathname, |
| TT_Face* aface ) |
| { |
| if (!engine) |
| return TT_Err_Invalid_Driver_Handle; |
| |
| return open_face( (FT_Library)engine, pathname, 0, aface ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Open_Collection */ |
| /* */ |
| /* <Description> */ |
| /* Loads a given face within a collection. */ |
| /* */ |
| /* <Input> */ |
| /* engine :: TrueType engine object where to load the face */ |
| /* pathname :: the collection's pathname */ |
| /* fontIndex :: index of face within the collection. first is 0 */ |
| /* */ |
| /* <Output> */ |
| /* face :: handle to the new face object. Always set to NULL */ |
| /* in case of error */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| /* <Note> */ |
| /* This API is provided for backwards compatibility. Please use */ |
| /* the functions TT_New_Collection/TT_Done_Face now to create and */ |
| /* discard face/collection objects. */ |
| /* */ |
| |
| EXPORT_DEF |
| TT_Error TT_Open_Collection( TT_Engine engine, |
| const TT_Text* pathname, |
| TT_ULong fontIndex, |
| TT_Face* aface ) |
| { |
| if (!engine) |
| return TT_Err_Invalid_Driver_Handle; |
| |
| return open_face( (FT_Library)engine, pathname, fontIndex, aface ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Close_Face */ |
| /* */ |
| /* <Description> */ |
| /* Destroys a given face object opened through either TT_Open_Face */ |
| /* of TT_Open_Collection. */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to the target face object */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* This API is provided for backwards compatibility. Please use */ |
| /* the functions TT_New_Face/TT_Done_Face now to create and */ |
| /* discard face/collection objects. */ |
| /* */ |
| |
| EXPORT_DEF |
| TT_Error TT_Close_Face( TT_Face face ) |
| { |
| FT_Resource resource; |
| |
| if (!face) |
| return TT_Err_Invalid_Face_Handle; |
| |
| resource = face->root.resource; |
| FT_Done_Face( (FT_Face)face ); |
| |
| /* uninstall corresponding resource */ |
| FT_Done_Resource( resource ); |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /*********** ***********/ |
| /*********** End of backwards compatible APIs.. ***********/ |
| /*********** ***********/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| /***********************************************************************/ |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Face_Properties */ |
| /* */ |
| /* <Description> */ |
| /* Return a given face's properties to the caller. */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to the source face object */ |
| /* */ |
| /* <Output> */ |
| /* properties :: target properties structure */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Get_Face_Properties( TT_Face face, |
| TT_Face_Properties* props ) |
| { |
| props->num_Glyphs = (TT_UShort)face->root.num_glyphs; |
| props->max_Points = (TT_UShort)face->root.max_points; |
| props->max_Contours = (TT_UShort)face->root.max_contours; |
| props->num_CharMaps = (TT_UShort)face->root.num_charmaps; |
| props->num_Faces = face->root.num_faces; |
| props->num_Names = face->num_names; |
| props->header = &face->header; |
| props->horizontal = &face->horizontal; |
| |
| /* The driver supports old Mac fonts where there are no OS/2 */ |
| /* tables present in the file. However, this is not true of */ |
| /* FreeType 1.1. For the sake of backwards compatibility, we */ |
| /* always return the address of the face's os2 table, even if */ |
| /* it is empty (in which case, the 'props.os2' field is set */ |
| /* to NULL.. */ |
| /* */ |
| /* Note however, that the 'os2->version' field is set to */ |
| /* 0xFFFF to indicate a missing table though... */ |
| /* */ |
| |
| props->os2 = &face->os2; |
| |
| props->postscript = &face->postscript; |
| props->hdmx = &face->hdmx; |
| props->vertical = ( face->vertical_info ? &face->vertical : 0 ); |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Face_Pointer. */ |
| /* */ |
| /* <Description> */ |
| /* Each face object contains a typeless pointer, which use is left */ |
| /* to client applications (or the high-level library). This API is */ |
| /* used to set this generic pointer. It is ignored by the driver. */ |
| /* */ |
| /* <Input> */ |
| /* face :: target face object */ |
| /* data :: generic pointer's value */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* The generic pointer is used by the HLib when using the driver */ |
| /* within the FreeType library. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Set_Face_Pointer( TT_Face face, |
| void* data ) |
| { |
| if ( !face ) |
| return TT_Err_Invalid_Face_Handle; |
| else |
| face->root.generic.data = data; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Face_Pointer */ |
| /* */ |
| /* <Description> */ |
| /* Each face object contains a typeless pointer, which use is left */ |
| /* to client applications (or the high-level library). This API is */ |
| /* used to retrieve this generic pointer, which is ignored by the */ |
| /* driver. */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to source face object */ |
| /* */ |
| /* <Return> */ |
| /* generic pointer value. NULL if the face handle is invalid.. */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| |
| EXPORT_FUNC |
| void* TT_Get_Face_Pointer( TT_Face face ) |
| { |
| return ( face ? face->root.generic.data : NULL ); |
| } |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Face_Metrics */ |
| /* */ |
| /* <Description> */ |
| /* Get the metrics of a given array of glyphs. Returns any number */ |
| /* of metrics arrays. */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to the source face object */ |
| /* firstGlyph :: index of first glyph in the array */ |
| /* lastGlyph :: index of last glyph in the array */ |
| /* */ |
| /* <Output> */ |
| /* leftBearings :: target array of shorts for the glyph left side */ |
| /* bearings. Set this field to NULL if you're not */ |
| /* interested in these metrics. */ |
| /* */ |
| /* widths :: target array of unsigned shorts for the glyph advance */ |
| /* widths. Set this field to NULL if you're not */ |
| /* interested in these metrics. */ |
| /* */ |
| /* topBearings :: target array of shorts for the glyph top side */ |
| /* bearings. Set this field to NULL if you're not */ |
| /* interested in these metrics. */ |
| /* */ |
| /* heights :: target array of unsigned shorts for the glyph advance */ |
| /* heights. Set this field to NULL if you're not */ |
| /* interested in these metrics. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| |
| /********************************************************/ |
| /* Return horizontal or vertical metrics in font units */ |
| /* for a given glyph. The metrics are the left side */ |
| /* bearing (resp. top side bearing) and advance width */ |
| /* (resp. advance height). */ |
| /* */ |
| /* This function will much probably move to another */ |
| /* component in the short future, but I haven't decided */ |
| /* which yet... */ |
| |
| static |
| void get_metrics( TT_HoriHeader* header, |
| TT_Int index, |
| TT_Short* bearing, |
| TT_UShort* advance ) |
| { |
| TT_LongMetrics* longs_m; |
| |
| TT_UShort k = header->number_Of_HMetrics; |
| |
| |
| if ( index < k ) |
| { |
| longs_m = (TT_LongMetrics*)header->long_metrics + index; |
| *bearing = longs_m->bearing; |
| *advance = longs_m->advance; |
| } |
| else |
| { |
| *bearing = ((TT_ShortMetrics*)header->short_metrics)[index - k]; |
| *advance = ((TT_LongMetrics*)header->long_metrics)[k - 1].advance; |
| } |
| } |
| |
| |
| |
| 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 ) |
| { |
| TT_UShort num; |
| |
| if ( !face ) |
| return TT_Err_Invalid_Face_Handle; |
| |
| /* Check the glyph range */ |
| if ( lastGlyph >= face->root.num_glyphs || 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 */ |
| { |
| TT_UShort n; |
| TT_Short left_bearing; |
| TT_UShort advance_width; |
| |
| |
| for ( n = 0; n <= num; n++ ) |
| { |
| get_metrics( &face->horizontal, |
| 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->vertical_info ) |
| return TT_Err_No_Vertical_Data; |
| |
| /* store the top side bearings */ |
| { |
| TT_UShort n; |
| TT_Short top_bearing; |
| TT_UShort advance_height; |
| |
| for ( n = 0; n <= num; n++ ) |
| { |
| get_metrics( (TT_HoriHeader*)&face->vertical, |
| firstGlyph + n, &top_bearing, &advance_height ); |
| |
| if ( topBearings ) topBearings[n] = top_bearing; |
| if ( heights ) heights[n] = advance_height; |
| } |
| } |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_New_Instance */ |
| /* */ |
| /* <Description> */ |
| /* Creates a new instance object from a given face */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to source/parent face object */ |
| /* */ |
| /* <Output> */ |
| /* instance :: handle to fresh object. Set to NULL in case of */ |
| /* error. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| /* <Note> */ |
| /* Any new instance uses a default resolution of 96x96 dpi, and */ |
| /* a default point size of 10 pts. You can change these anytime */ |
| /* with TT_Set_Instance_Resolutions/CharSize/CharSizes/PixelSizes */ |
| /* (see below). */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_New_Instance( TT_Face face, |
| TT_Instance* instance ) |
| { |
| return FT_New_Size( (FT_Face)face, (FT_Size*)instance ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Instance_Resolutions */ |
| /* */ |
| /* <Description> */ |
| /* Sets an instance resolutions in dot-per-inches. Default values */ |
| /* for "new" instances are 96x96 dpi, but these can be changed any */ |
| /* time by calling this API. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to target instance object */ |
| /* xResolution :: horizontal device resolution in dpi. */ |
| /* yResolution :: vertical device resolution in dpi. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* You should set the charsize or pixel size immediately after */ |
| /* call in multi-htreaded 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 ins, |
| TT_UShort xResolution, |
| TT_UShort yResolution ) |
| { |
| return FT_Set_Resolutions( (FT_Size)ins, xResolution, yResolution ); |
| } |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Instance_CharSizes */ |
| /* */ |
| /* <Description> */ |
| /* Same as TT_Set_Instance_CharSize, but used to specify distinct */ |
| /* horizontal and vertical coordinates. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to target instance object */ |
| /* charWidth :: horizontal character size (26.6 points) */ |
| /* charHeight :: vertical character size (26.6 points) */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* There is no check for overflow; with other words, the product */ |
| /* of glyph dimensions times the device resolution must have */ |
| /* reasonable values. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Set_Instance_CharSizes( TT_Instance ins, |
| TT_F26Dot6 charWidth, |
| TT_F26Dot6 charHeight ) |
| { |
| return FT_Set_Char_Sizes( (FT_Size)ins, charWidth, charHeight ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Instance_CharSize */ |
| /* */ |
| /* <Description> */ |
| /* Sets an instance's character size. The size is in fractional */ |
| /* (26.6) point units. This function sets the horizontal and */ |
| /* vertical sizes to be equal. Use TT_Set_Instance_CharSizes */ |
| /* for distinct X and Y char sizes. */ |
| /* */ |
| /* The default charsize of a new instance object is 10 pts. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to target instance object */ |
| /* charSize :: character size expressed in 26.6 fixed float */ |
| /* points. 1 point = 1/72 dpi. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| |
| 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> */ |
| /* This function is used to set an instance's pixel sizes directly */ |
| /* It ignores the instance's resolutions fields, and you'll have to */ |
| /* specify the corresponding pointsize in 26.6 fixed float point */ |
| /* units. The latter is a requirement of the TrueType bytecode */ |
| /* interpreter but can be ignored (or more safely, set to the */ |
| /* maximum pixel size multiplied by 64). */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to target instance object */ |
| /* pixelWidth :: horizontal pixel width (integer value) */ |
| /* pixelHeight :: vertical pixel height (integer value) */ |
| /* pointSize :: corresponding point size (26.6 points) */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Set_Instance_PixelSizes( TT_Instance ins, |
| TT_UShort pixelWidth, |
| TT_UShort pixelHeight, |
| TT_F26Dot6 pointSize ) |
| { |
| /* The point size is now ignored by the driver */ |
| (void)pointSize; |
| |
| return FT_Set_Pixel_Sizes( (FT_Size)ins, pixelWidth, pixelHeight ); |
| } |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Instance_Metrics */ |
| /* */ |
| /* <Description> */ |
| /* Returns an instance's metrics into caller space. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to source instance object */ |
| /* */ |
| /* <Output> */ |
| /* metrics :: target instance metrics structure */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* The TT_Instance_Metrics structure differs slightly from the */ |
| /* FT_Instance_Metrics one, which is why we re-implement this */ |
| /* function, rather than call a driver method for this.. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Get_Instance_Metrics( TT_Instance ins, |
| TT_Instance_Metrics* metrics ) |
| { |
| TT_Size size = (TT_Size)ins; |
| |
| if (!ins) |
| return TT_Err_Invalid_Instance_Handle; |
| |
| metrics->x_scale = size->root.metrics.x_scale; |
| metrics->y_scale = size->root.metrics.y_scale; |
| metrics->x_resolution = size->root.metrics.x_resolution; |
| metrics->y_resolution = size->root.metrics.y_resolution; |
| metrics->x_ppem = size->root.metrics.x_ppem; |
| metrics->y_ppem = size->root.metrics.y_ppem; |
| |
| metrics->pointSize = size->root.metrics.pointSize; |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Instance_Pointer */ |
| /* */ |
| /* <Description> */ |
| /* Each instance object contains a typeless pointer, which use is */ |
| /* left to client applications (or the high-level library). This */ |
| /* API is used to set this generic pointer. It is ignored by the */ |
| /* driver. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to the target instance object */ |
| /* data :: value of the generic pointer */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Set_Instance_Pointer( TT_Instance ins, |
| void* data ) |
| { |
| if ( !ins ) |
| return TT_Err_Invalid_Instance_Handle; |
| else |
| ((FT_Size)ins)->generic.data = data; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Instance_Pointer */ |
| /* */ |
| /* <Description> */ |
| /* Each instance object contains a typeless pointer, which use is */ |
| /* left to client applications (or the high-level library). This */ |
| /* API is used to retrieve this generic pointer. It is ignored by */ |
| /* the driver. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to source instance object */ |
| /* */ |
| /* <Return> */ |
| /* value of generic pointer. NULL if invalid instance */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| |
| EXPORT_FUNC |
| void* TT_Get_Instance_Pointer( TT_Instance instance ) |
| { |
| if ( !instance ) |
| return NULL; |
| else |
| return ((FT_Size)instance)->generic.data; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Done_Instance */ |
| /* */ |
| /* <Description> */ |
| /* Destroys a given instance object. All instances are destroyed */ |
| /* automatically when their parent face object is discarded. */ |
| /* However, this API can be used to save memory. */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to target instance object */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Done_Instance( TT_Instance ins ) |
| { |
| FT_Done_Size( (FT_Size)ins ); |
| return TT_Err_Ok; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Set_Instance_Transform_Flags */ |
| /* */ |
| /* <Description> */ |
| /* Nothing. This function has been deprecated... */ |
| /* */ |
| /* <Input> */ |
| /* instance :: handle to target instance object */ |
| /* rotated :: 'rotation' flag.. */ |
| /* stretched :: 'stretch' flag.. */ |
| /* */ |
| /* <Return> */ |
| /* Always 0. */ |
| /* */ |
| /* <Note> */ |
| /* This function has been deprecated !! Do not use it, it doesn't */ |
| /* do anything now.. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Set_Instance_Transform_Flags( TT_Instance instance, |
| TT_Bool rotated, |
| TT_Bool stretched ) |
| { |
| (void)instance; /* the parameters are unused, the (void) prevents */ |
| (void)rotated; /* warnings from pedantic compilers.. */ |
| (void)stretched; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* */ |
| /* <Description> */ |
| /* */ |
| /* */ |
| /* <Input> */ |
| /* */ |
| /* */ |
| /* <Output> */ |
| /* */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* */ |
| /* <MT-Note> */ |
| /* */ |
| /* */ |
| /* */ |
| /* <Note> */ |
| /* */ |
| /* */ |
| /* */ |
| /******************************************************************* |
| * |
| * 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* aglyph ) |
| { |
| return FT_New_GlyphSlot( (FT_Face)face, (FT_GlyphSlot*)aglyph ); |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| FT_Done_GlyphSlot( (FT_GlyphSlot)glyph ); |
| return TT_Err_Ok; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| TT_Int result, flags; |
| |
| flags = 0; |
| |
| /* Convert load flags */ |
| if ( (loadFlags & TTLOAD_SCALE_GLYPH) == 0 ) |
| flags = FT_LOAD_NO_SCALE; |
| |
| else if ( (loadFlags & TTLOAD_HINT_GLYPH) == 0 ) |
| flags = FT_LOAD_NO_HINTING; |
| |
| else |
| flags = FT_LOAD_DEFAULT; |
| |
| flags |= FT_LOAD_NO_BITMAP | /* prevent bitmap loading for */ |
| FT_LOAD_LINEAR; /* compatibility purposes.. */ |
| |
| return FT_Load_Glyph( (FT_GlyphSlot)glyph, |
| (FT_Size)instance, |
| glyphIndex, |
| flags, |
| &result ); |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| FT_GlyphSlot slot = (FT_GlyphSlot)glyph; |
| |
| if (!glyph) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| /* the structures TT_Outline and FT_Outline are equivalent */ |
| *((FT_Outline*)outline) = slot->outline; |
| 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 ) |
| { |
| FT_GlyphSlot slot = (FT_GlyphSlot)glyph; |
| |
| if (!glyph) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| /* TT_Glyph_Metrics and FT_Glyph_Metrics are slightly different */ |
| metrics->bbox.xMin = slot->metrics.horiBearingX; |
| |
| metrics->bbox.xMax = slot->metrics.horiBearingX + |
| slot->metrics.width; |
| |
| metrics->bbox.yMax = slot->metrics.horiBearingY; |
| |
| metrics->bbox.yMin = slot->metrics.horiBearingY - |
| slot->metrics.height; |
| |
| metrics->bearingX = slot->metrics.horiBearingX; |
| metrics->bearingY = slot->metrics.horiBearingY; |
| metrics->advance = slot->metrics.horiAdvance; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * Function : TT_Get_Big_Glyph_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 ) |
| { |
| FT_GlyphSlot slot = (FT_GlyphSlot)glyph; |
| FT_Glyph_Metrics* met; |
| FT_Glyph_Metrics* met2; |
| |
| if (!glyph) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| met = &slot->metrics; |
| met2 = &slot->metrics2; |
| |
| metrics->bbox.xMin = met->horiBearingX; |
| metrics->bbox.xMax = met->horiBearingX + met->width; |
| metrics->bbox.yMin = met->horiBearingY - met->height; |
| metrics->bbox.yMax = met->horiBearingY; |
| |
| metrics->horiBearingX = met->horiBearingX; |
| metrics->horiBearingY = met->horiBearingY; |
| metrics->horiAdvance = met->horiAdvance; |
| |
| metrics->vertBearingX = met->vertBearingX; |
| metrics->vertBearingY = met->vertBearingY; |
| metrics->vertAdvance = met->vertAdvance; |
| |
| metrics->linearHoriAdvance = met2->horiAdvance; |
| metrics->linearHoriBearingX = met2->horiBearingX; |
| |
| metrics->linearVertAdvance = met2->vertAdvance; |
| metrics->linearVertBearingY = met2->vertBearingY; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * Function : TT_Get_Glyph_Bitmap |
| * |
| * Description : Produces a bitmap from a glyph outline. |
| * |
| * Input : glyph the glyph container's handle |
| * map 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 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* map, |
| TT_F26Dot6 xOffset, |
| TT_F26Dot6 yOffset ) |
| { |
| FT_Library library; |
| TT_Error error; |
| FT_GlyphSlot slot = (FT_GlyphSlot)glyph; |
| FT_Outline outline; |
| FT_Raster_Map bitmap; |
| |
| if ( !glyph ) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| library = slot->face->resource->library; |
| outline = slot->outline; |
| |
| /* XXX : For now, use only dropout mode 2 */ |
| /* outline.dropout_mode = _glyph->scan_type; */ |
| outline.dropout_mode = 2; |
| |
| bitmap.width = map->width; |
| bitmap.rows = map->rows; |
| bitmap.cols = map->cols; |
| bitmap.flow = map->flow; |
| bitmap.pix_bits = 1; |
| bitmap.buffer = map->bitmap; |
| |
| FT_Translate_Outline( &outline, xOffset, yOffset ); |
| |
| error = FT_Get_Outline_Bitmap( library, &outline, &bitmap ); |
| |
| FT_Translate_Outline( &outline, -xOffset, -yOffset ); |
| |
| return error; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * Function : TT_Get_Glyph_Pixmap |
| * |
| * Description : Produces a grayscaled pixmap from a glyph |
| * outline. |
| * |
| * Input : glyph the glyph container's handle |
| * map 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* map, |
| TT_F26Dot6 xOffset, |
| TT_F26Dot6 yOffset ) |
| { |
| FT_Library library; |
| TT_Error error; |
| FT_GlyphSlot slot = (FT_GlyphSlot)glyph; |
| FT_Outline outline; |
| FT_Raster_Map bitmap; |
| |
| if ( !glyph ) |
| return TT_Err_Invalid_Glyph_Handle; |
| |
| library = slot->face->resource->library; |
| outline = slot->outline; |
| |
| /* XXX : For now, use only dropout mode 2 */ |
| /* outline.dropout_mode = _glyph->scan_type; */ |
| outline.dropout_mode = 2; |
| |
| bitmap.width = map->width; |
| bitmap.rows = map->rows; |
| bitmap.cols = map->cols; |
| bitmap.flow = map->flow; |
| bitmap.pix_bits = 8; |
| bitmap.buffer = map->bitmap; |
| |
| FT_Translate_Outline( &outline, xOffset, yOffset ); |
| |
| error = FT_Get_Outline_Bitmap( library, &outline, &bitmap ); |
| |
| FT_Translate_Outline( &outline, -xOffset, -yOffset ); |
| |
| return error; |
| } |
| |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Outline_Bitmap */ |
| /* */ |
| /* <Description> */ |
| /* Renders an outline within a bitmap. The outline's image is */ |
| /* simply or-ed to the target bitmap. */ |
| /* */ |
| /* <Input> */ |
| /* engine :: handle to the TrueType driver object */ |
| /* outline :: pointer to the source outline descriptor */ |
| /* raster :: pointer to the target bitmap descriptor */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Get_Outline_Bitmap( TT_Engine engine, |
| TT_Outline* outline, |
| TT_Raster_Map* map ) |
| { |
| FT_Library library = (FT_Library)engine; |
| FT_Raster_Map bitmap; |
| |
| if ( !engine ) |
| return TT_Err_Invalid_Engine; |
| |
| if ( !outline || !map ) |
| return TT_Err_Invalid_Argument; |
| |
| bitmap.width = map->width; |
| bitmap.rows = map->rows; |
| bitmap.cols = map->cols; |
| bitmap.flow = map->flow; |
| bitmap.pix_bits = 1; |
| bitmap.buffer = map->bitmap; |
| |
| return FT_Get_Outline_Bitmap( library, (FT_Outline*)outline, &bitmap ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Get_Outline_Pixmap */ |
| /* */ |
| /* <Description> */ |
| /* Renders an outline within a pixmap. The outline's image is */ |
| /* simply or-ed to the target pixmap. */ |
| /* */ |
| /* <Input> */ |
| /* engine :: handle to the TrueType driver object */ |
| /* outline :: pointer to the source outline descriptor */ |
| /* raster :: pointer to the target pixmap descriptor */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success. */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Get_Outline_Pixmap( TT_Engine engine, |
| TT_Outline* outline, |
| TT_Raster_Map* map ) |
| { |
| FT_Library library = (FT_Library)engine; |
| FT_Raster_Map bitmap; |
| |
| if ( !engine ) |
| return TT_Err_Invalid_Engine; |
| |
| if ( !outline || !map ) |
| return TT_Err_Invalid_Argument; |
| |
| bitmap.width = map->width; |
| bitmap.rows = map->rows; |
| bitmap.cols = map->cols; |
| bitmap.flow = map->flow; |
| bitmap.pix_bits = 8; |
| bitmap.buffer = map->bitmap; |
| |
| return FT_Get_Outline_Bitmap( library, (FT_Outline*)outline, &bitmap ); |
| } |
| |
| |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_New_Outline */ |
| /* */ |
| /* <Description> */ |
| /* Creates a new outline of a given size. */ |
| /* */ |
| /* <Input> */ |
| /* numPoints :: maximum number of points within the outline */ |
| /* */ |
| /* numContours :: maximum number of contours within the outline */ |
| /* */ |
| /* <Output> */ |
| /* outline :: target outline descriptor. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* Yes. */ |
| /* */ |
| /* <Note> */ |
| /* This function uses 'malloc' to allocate the outline's array, */ |
| /* _unlike_ all other functions in the TrueType API. This means */ |
| /* that the outline won't be destroyed when the TrueType engine */ |
| /* is finalized.. */ |
| /* */ |
| /* It is provided for backwards compatibility ONLY. Use the new */ |
| /* FT_New_Outline function defined in "ftoutln.h" instead if you're */ |
| /* working with the FreeType 2.0 API. */ |
| /* */ |
| |
| #include <stdlib.h> /* for malloc and free */ |
| |
| static TT_Outline null_api_outline = { 0, 0, NULL, NULL, NULL, |
| 0, 0, 0, 0 }; |
| |
| EXPORT_FUNC |
| TT_Error TT_New_Outline( TT_UShort numPoints, |
| TT_Short numContours, |
| TT_Outline* outline ) |
| { |
| if ( !outline ) |
| return TT_Err_Invalid_Argument; |
| |
| *outline = null_api_outline; |
| |
| if ( numPoints > 0 && numContours > 0 ) |
| { |
| outline->points = (TT_Vector*)malloc( numPoints * sizeof(TT_Vector) ); |
| outline->flags = (TT_Byte*) malloc( numPoints * sizeof(TT_Char) ); |
| outline->contours = (TT_UShort*)malloc( numPoints * sizeof(TT_UShort) ); |
| |
| if ( !outline->points || !outline->flags || !outline->contours ) |
| 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 TT_Err_Out_Of_Memory; |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Done_Outline */ |
| /* */ |
| /* <Description> */ |
| /* Destroys an outline created with FT_New_Outline */ |
| /* */ |
| /* <Input> */ |
| /* outline :: */ |
| /* pointer to the outline destructor to discard. This function */ |
| /* doesn't destroy the TT_Outline sturcture, only the data it */ |
| /* contains/own. */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| /* <MT-Note> */ |
| /* No. */ |
| /* */ |
| /* <Note> */ |
| /* This function uses 'free' to discard the outline's arrays. */ |
| /* You should only discard outline allocated with TT_New_Outline. */ |
| /* */ |
| /* It is provided for backwards compatibility ONLY. Use the new */ |
| /* FT_Done_Outline function defined in "ftoutln.h" instead if you're*/ |
| /* working with the FreeType 2.0 API. */ |
| /* */ |
| |
| 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_api_outline; |
| return TT_Err_Ok; |
| } |
| else |
| return TT_Err_Invalid_Argument; |
| } |
| |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> TT_Copy_Outline */ |
| /* */ |
| /* <Description> */ |
| /* Copy an outline into another one. Both objects must have */ |
| /* the same sizes ( num. points & num. contours ) when this */ |
| /* function is called.. */ |
| /* */ |
| /* <Input> */ |
| /* source :: handle to source outline */ |
| /* target :: handle to target outline */ |
| /* */ |
| /* <Return> */ |
| /* TrueType error code. 0 means success */ |
| /* */ |
| |
| EXPORT_FUNC |
| TT_Error TT_Copy_Outline( TT_Outline* source, |
| TT_Outline* target ) |
| { |
| return FT_Copy_Outline( (FT_Outline*)source, |
| (FT_Outline*)target ); |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| FT_Transform_Outline( (FT_Outline*)outline, (FT_Matrix*)matrix ); |
| } |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| FT_Transform_Vector( x, y, (FT_Matrix*) matrix ); |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| FT_Translate_Outline( (FT_Outline*)outline, xOffset, yOffset ); |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| return FT_Get_Outline_CBox( (FT_Outline*)outline, (FT_BBox*)bbox ); |
| } |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* */ |
| /* <Description> */ |
| /* */ |
| /* */ |
| /* <Input> */ |
| /* */ |
| /* */ |
| /* <Output> */ |
| /* */ |
| /* */ |
| /* <Return> */ |
| /* */ |
| /* */ |
| /* <MT-Note> */ |
| /* */ |
| /* */ |
| /* */ |
| /* <Note> */ |
| /* */ |
| /* */ |
| /* */ |
| /* Compute A*B/C with 64 bits intermediate precision. */ |
| |
| EXPORT_FUNC |
| TT_Long TT_MulDiv( TT_Long A, TT_Long B, TT_Long C ) |
| { |
| return FT_MulDiv( A, B, C ); |
| } |
| |
| |
| /***********************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* */ |
| /* <Description> */ |
| /* */ |
| /* */ |
| /* <Input> */ |
| /* */ |
| /* */ |
| /* <Output> */ |
| /* */ |
| /* */ |
| /* <Return> */ |
| /* */ |
| /* */ |
| /* <MT-Note> */ |
| /* */ |
| /* */ |
| /* */ |
| /* <Note> */ |
| /* */ |
| /* */ |
| /* */ |
| /* Compute A*B/0x10000 with 64 bits intermediate precision. */ |
| /* Useful to multiply by a 16.16 fixed float value. */ |
| |
| EXPORT_FUNC |
| TT_Long TT_MulFix( TT_Long A, TT_Long B ) |
| { |
| return FT_MulFix( A, B ); |
| } |
| |
| /* ----------------- 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 ) |
| { |
| FT_Face _face = (FT_Face)face; |
| |
| return ( _face ? _face->num_charmaps : -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 ) |
| { |
| TT_CharMap cmap; |
| |
| if ( !face ) |
| return TT_Err_Invalid_Face_Handle; |
| |
| if ( charmapIndex >= face->num_charmaps ) |
| return TT_Err_Bad_Argument; |
| |
| cmap = (TT_CharMap)face->charmaps + charmapIndex; |
| |
| *platformID = cmap->root.platform_id; |
| *encodingID = cmap->root.encoding_id; |
| |
| 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 ) |
| { |
| if ( !face ) |
| return TT_Err_Invalid_Face_Handle; |
| |
| if ( charmapIndex >= face->num_charmaps ) |
| return TT_Err_Bad_Argument; |
| |
| *charMap = (TT_CharMap)face->charmaps + charmapIndex; |
| return TT_Err_Ok; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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_UShort charCode ) |
| { |
| return tt_interface->get_char_index( (FT_CharMap)charMap, 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 ) |
| { |
| if ( !face ) |
| return -1; |
| |
| return face->num_names; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * 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 ) |
| { |
| TT_NameRec* name; |
| |
| if (!face) |
| return TT_Err_Invalid_Face_Handle; |
| |
| if ( nameIndex >= face->num_names ) |
| return TT_Err_Bad_Argument; |
| |
| name = face->name_table.names + nameIndex; |
| |
| *platformID = name->platformID; |
| *encodingID = name->encodingID; |
| *languageID = name->languageID; |
| *nameID = name->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 ) |
| { |
| TT_NameRec* name; |
| |
| if (!face) |
| return TT_Err_Invalid_Face_Handle; |
| |
| if ( nameIndex >= face->num_names ) |
| return TT_Err_Bad_Argument; |
| |
| name = face->name_table.names + nameIndex; |
| |
| *stringPtr = (TT_String*)name->string; |
| *length = name->stringLength; |
| |
| return TT_Err_Ok; |
| } |
| |
| |
| /******************************************************************* |
| * |
| * Function : TT_Get_Font_Data |
| * |
| * Description : Loads any font table in client memory. Used by |
| * the TT_Get_Font_Data(). |
| * |
| * 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 |
| * 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 ) |
| { |
| return tt_extension->get_font_data( face, tag, offset, buffer, length ); |
| } |
| |
| |
| |
| |
| |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* */ |
| /* */ |
| /* Postscript Names extension */ |
| /* */ |
| /* */ |
| /* */ |
| /*******************************************************************/ |
| |
| /* Initialise the Postscript Names extension */ |
| EXPORT_FUNC |
| TT_Error TT_Init_Post_Extension( TT_Engine engine ) |
| { |
| (void)engine; |
| return TT_Err_Ok; |
| } |
| |
| /* Load the Postscript Names table - notice that the 'post' parameter */ |
| /* will be ignored in 2.0. */ |
| EXPORT_DEF |
| TT_Error TT_Load_PS_Names( TT_Face face, |
| void* post ) |
| { |
| (void)post; |
| (void)face; |
| |
| /* the names are now loaded on demand in 2.0 */ |
| return TT_Err_Ok; |
| } |
| |
| |
| /* The following is directly implemented in the TrueType driver */ |
| #if 0 |
| /* Gets the postscript name of a single glyph */ |
| EXPORT_DEF |
| TT_Error TT_Get_PS_Name( TT_Face face, |
| TT_UShort index, |
| TT_String** PSname ); |
| #endif |
| |
| |
| |
| |
| /*******************************************************************/ |
| /* */ |
| /* */ |
| /* */ |
| /* Embedded Bitmap (sbits) extension */ |
| /* */ |
| /* */ |
| /* */ |
| /*******************************************************************/ |
| |
| |
| /*************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Init_SBit_Extension */ |
| /* */ |
| /* <Description> */ |
| /* Initialise the embedded bitmaps extension for the */ |
| /* FreeType engine. */ |
| /* */ |
| /* <Input> */ |
| /* engine :: handle to current FreeType library instance */ |
| /* */ |
| /* <Return> */ |
| /* Error code. 0 means success. */ |
| /* */ |
| EXPORT_FUNC |
| TT_Error TT_Init_SBit_Extension( TT_Engine engine ) |
| { |
| (void)engine; |
| return TT_Err_Ok; |
| } |
| |
| |
| /*************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Get_Face_Bitmaps */ |
| /* */ |
| /* <Description> */ |
| /* Loads the "EBLC" table from a font file, if any. */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to the source TrueType font/face */ |
| /* */ |
| /* <Output> */ |
| /* eblc_table :: a descriptor for the EBLC table */ |
| /* */ |
| /* <Return> */ |
| /* Error code. 0 means success. */ |
| /* */ |
| /* <Note> */ |
| /* This function returns TT_Err_Table_Missing when the */ |
| /* font contains no embedded bitmaps. All fields in */ |
| /* "eblc_table" will then be set to 0. */ |
| /* */ |
| EXPORT_FUNC |
| TT_Error TT_Get_Face_Bitmaps( TT_Face face, |
| TT_EBLC *eblc_table ) |
| { |
| if (!face) |
| return FT_Err_Invalid_Face_Handle; |
| |
| eblc_table->num_strikes = face->num_sbit_strikes; |
| eblc_table->strikes = face->sbit_strikes; |
| |
| if ( face->num_sbit_strikes > 0 ) |
| { |
| eblc_table->version = 0x00002000; |
| return TT_Err_Ok; |
| } |
| |
| eblc_table->version = 0; |
| return TT_Err_Table_Missing; |
| } |
| |
| |
| /*************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_New_SBit_Image */ |
| /* */ |
| /* <Description> */ |
| /* Allocates a new embedded bitmap container */ |
| /* */ |
| /* <Output> */ |
| /* image :: sbit image */ |
| /* */ |
| /* <Return> */ |
| /* Error code. 0 means success. */ |
| /* */ |
| EXPORT_DEF |
| TT_Error TT_New_SBit_Image( TT_SBit_Image* *image ) |
| { |
| *image = (TT_SBit_Image*)malloc( sizeof(**image) ); |
| if ( !*image ) |
| return TT_Err_Out_Of_Memory; |
| |
| MEM_Set( *image, sizeof(**image), 0 ); |
| return TT_Err_Ok; |
| } |
| |
| |
| /*************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Done_SBit_Image */ |
| /* */ |
| /* <Description> */ |
| /* Releases an embedded bitmap container */ |
| /* */ |
| /* <Input> */ |
| /* image :: sbit image */ |
| /* */ |
| EXPORT_DEF |
| void TT_Done_SBit_Image( TT_SBit_Image* image ) |
| { |
| free( image->map.bitmap ); |
| free( image ); |
| } |
| |
| |
| /*************************************************************/ |
| /* */ |
| /* <Function> */ |
| /* TT_Load_Glyph_Bitmap */ |
| /* */ |
| /* <Description> */ |
| /* Loads a given glyph embedded bitmap */ |
| /* */ |
| /* <Input> */ |
| /* face :: handle to the source TrueType font/face */ |
| /* instance :: current size/transform instance */ |
| /* glyph_index :: index of source glyph */ |
| /* bitmap :: target embedded bitmap descriptor */ |
| /* */ |
| /* <Return> */ |
| /* Error code. 0 means success. */ |
| /* */ |
| /* <Note> */ |
| /* This function returns an error if there is no */ |
| /* embedded bitmap for the glyph at the given */ |
| /* instance. */ |
| /* */ |
| EXPORT_FUNC |
| TT_Error TT_Load_Glyph_Bitmap( TT_Face face, |
| TT_Instance instance, |
| TT_UShort glyph_index, |
| TT_SBit_Image* bitmap ) |
| { |
| FT_GlyphSlot slot; |
| TT_Error error; |
| |
| error = FT_New_GlyphSlot( (FT_Face)face, &slot ); |
| if (error) goto Exit; |
| |
| error = FT_Load_Glyph( slot, (FT_Size)instance, glyph_index, |
| FT_LOAD_NO_OUTLINE, 0 ); |
| if (!error) |
| { |
| /* copy bitmap */ |
| bitmap->map.width = slot->bitmap.width; |
| bitmap->map.rows = slot->bitmap.rows; |
| bitmap->map.cols = slot->bitmap.cols; |
| bitmap->map.flow = slot->bitmap.flow; |
| bitmap->bit_depth = slot->bitmap.pix_bits; |
| bitmap->map.bitmap = slot->bitmap.buffer; |
| |
| /* copy metrics */ |
| bitmap->metrics.bbox.xMin = slot->metrics.horiBearingX >> 6; |
| bitmap->metrics.bbox.xMax = bitmap->metrics.bbox.xMin + |
| (slot->metrics.width >> 6); |
| bitmap->metrics.bbox.yMax = slot->metrics.horiBearingY >> 6; |
| bitmap->metrics.bbox.yMin = bitmap->metrics.bbox.yMax - |
| (slot->metrics.height >> 6); |
| |
| bitmap->metrics.horiBearingX = bitmap->metrics.bbox.xMin; |
| bitmap->metrics.horiBearingY = bitmap->metrics.bbox.yMax; |
| bitmap->metrics.horiAdvance = slot->metrics.horiAdvance >> 6; |
| |
| bitmap->metrics.vertBearingX = slot->metrics.vertBearingX >> 6; |
| bitmap->metrics.vertBearingY = slot->metrics.vertBearingY >> 6; |
| bitmap->metrics.vertAdvance = slot->metrics.vertAdvance >> 6; |
| |
| slot->bitmap.buffer = 0; |
| } |
| |
| FT_Done_GlyphSlot( slot ); |
| Exit: |
| return error; |
| } |
| |
| /* END */ |
