forked from minhngoc25a/freetype2
2268 lines
96 KiB
C
2268 lines
96 KiB
C
/*******************************************************************
|
|
*
|
|
* 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 */
|