/***************************************************************************/ /* */ /* ftobjs.c */ /* */ /* The FreeType private base classes (base). */ /* */ /* Copyright 1996-2000 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. */ /* */ /***************************************************************************/ #include #include #include #include #include /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /**** ****/ /**** ****/ /**** M E M O R Y ****/ /**** ****/ /**** ****/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_memory /*************************************************************************/ /* */ /* */ /* FT_Alloc */ /* */ /* */ /* Allocates a new block of memory. The returned area is always */ /* zero-filled; this is a strong convention in many FreeType parts. */ /* */ /* */ /* memory :: A handle to a given `memory object' where allocation */ /* occurs. */ /* */ /* size :: The size in bytes of the block to allocate. */ /* */ /* */ /* P :: A pointer to the fresh new block. It should be set to */ /* NULL if `size' is 0, or in case of error. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ BASE_FUNC(FT_Error) FT_Alloc( FT_Memory memory, FT_Long size, void** P ) { FT_Assert( P != 0 ); if ( size > 0 ) { *P = memory->alloc( memory, size ); if ( !*P ) { FT_ERROR(( "FT.Alloc:" )); FT_ERROR(( " Out of memory? (%ld requested)\n", size )); return FT_Err_Out_Of_Memory; } MEM_Set( *P, 0, size ); } else *P = NULL; FT_TRACE2(( "FT_Alloc:" )); FT_TRACE2(( " size = %ld, block = 0x%08p, ref = 0x%08p\n", size, *P, P )); return FT_Err_Ok; } /*************************************************************************/ /* */ /* */ /* FT_Realloc */ /* */ /* */ /* Reallocates a block of memory pointed to by `*P' to `Size' bytes */ /* from the heap, possibly changing `*P'. */ /* */ /* */ /* memory :: A handle to a given `memory object' where allocation */ /* occurs. */ /* */ /* current :: The current block size in bytes. */ /* size :: The new block size in bytes. */ /* */ /* */ /* P :: A pointer to the fresh new block. It should be set to */ /* NULL if `size' is 0, or in case of error. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* All callers of FT_Realloc() _must_ provide the current block size */ /* as well as the new one. */ /* */ /* If the memory object's flag FT_SYSTEM_FLAG_NO_REALLOC is set, this */ /* function will try to emulate a reallocation using FT_Alloc() and */ /* FT_Free(). Otherwise, it will call the system-specific `realloc' */ /* implementation. */ /* */ /* (Some embedded systems do not have a working realloc function). */ /* */ BASE_FUNC(FT_Error) FT_Realloc( FT_Memory memory, FT_Long current, FT_Long size, void** P ) { void* Q; FT_Assert( P != 0 ); /* if the original pointer is NULL, call FT_Alloc() */ if ( !*P ) return FT_Alloc( memory, size, P ); /* if the new block if zero-sized, clear the current one */ if ( size <= 0 ) { FT_Free( memory, P ); return FT_Err_Ok; } Q = memory->realloc( memory, current, size, *P ); if ( !Q ) goto Fail; *P = Q; return FT_Err_Ok; Fail: FT_ERROR(( "FT.Realloc:" )); FT_ERROR(( " Failed (current %ld, requested %ld)\n", current, size )); return FT_Err_Out_Of_Memory; } /*************************************************************************/ /* */ /* */ /* FT_Free */ /* */ /* */ /* Releases a given block of memory allocated through FT_Alloc(). */ /* */ /* */ /* memory :: A handle to a given `memory object' where allocation */ /* occurred. */ /* */ /* P :: This is the _address_ of a _pointer_ which points to the */ /* allocated block. It is always set to NULL on exit. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* If P or *P are NULL, this function should return successfully. */ /* This is a strong convention within all of FreeType and its */ /* drivers. */ /* */ BASE_FUNC(void) FT_Free( FT_Memory memory, void** P ) { FT_TRACE2(( "FT_Free:" )); FT_TRACE2(( " Freeing block 0x%08p, ref 0x%08p\n", P, (P ? *P : (void*)0) )); FT_Assert( P != 0 ); if ( *P ) { memory->free( memory, *P ); *P = 0; } } /*************************************************************************/ /* */ /* */ /* ft_new_input_stream */ /* */ /* */ /* Creates a new input stream object from an FT_Open_Args structure. */ /* */ static FT_Error ft_new_input_stream( FT_Library library, FT_Open_Args* args, FT_Stream *astream ) { FT_Error error; FT_Memory memory; FT_Stream stream; *astream = 0; memory = library->memory; if ( ALLOC( stream, sizeof ( *stream ) ) ) goto Exit; stream->memory = memory; /* now, look at the stream flags */ if ( args->flags & ft_open_memory ) { error = 0; FT_New_Memory_Stream( library, args->memory_base, args->memory_size, stream ); } else if (args->flags & ft_open_pathname) { error = FT_New_Stream( args->pathname, stream ); stream->pathname.pointer = args->pathname; } else if (args->flags & ft_open_stream && args->stream) { *stream = *(args->stream); stream->memory = memory; } else { error = FT_Err_Invalid_Argument; } if ( error ) FREE( stream ); *astream = stream; Exit: return error; } /*************************************************************************/ /* */ /* */ /* FT_Done_Stream */ /* */ /* */ /* Closes and destroys a stream object. */ /* */ EXPORT_FUNC(void) FT_Done_Stream( FT_Stream stream ) { if ( stream->close ) stream->close( stream ); } static void ft_done_stream( FT_Stream* astream ) { FT_Stream stream = *astream; FT_Memory memory = stream->memory; if ( stream->close ) stream->close( stream ); FREE( stream ); *astream = 0; } /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /**** ****/ /**** ****/ /**** O B J E C T M A N A G E M E N T ****/ /**** ****/ /**** ****/ /*************************************************************************/ /*************************************************************************/ /*************************************************************************/ /* destructor for sizes list */ static void destroy_size( FT_Memory memory, FT_Size size, FT_Driver driver ) { /* finalize format-specific stuff */ driver->interface.done_size( size ); FREE( size ); } /* destructor for faces list */ static void destroy_face( FT_Memory memory, FT_Face face, FT_Driver driver ) { /* Discard glyph slots for this face */ /* XXX: Beware! FT_Done_GlyphSlot() changes the field `face->slot' */ while ( face->glyph ) FT_Done_GlyphSlot( face->glyph ); /* Discard all sizes for this face */ FT_List_Finalize( &face->sizes_list, (FT_List_Destructor)destroy_size, memory, driver ); face->size = 0; /* finalize format-specific stuff */ driver->interface.done_face( face ); /* Now discard client data */ if ( face->generic.finalizer ) face->generic.finalizer( face ); /* close the stream for this face */ ft_done_stream( &face->stream ); /* get rid of it */ FREE( face ); } /*************************************************************************/ /* */ /* */ /* Destroy_Driver */ /* */ /* */ /* Destroys a given driver object. This also destroys all child */ /* faces. */ /* */ /* */ /* driver :: A handle to the target driver object. */ /* */ /* */ /* The driver _must_ be LOCKED! */ /* */ static void Destroy_Driver( FT_Driver driver ) { FT_Memory memory = driver->memory; /* now, finalize all faces in the driver list */ FT_List_Finalize( &driver->faces_list, (FT_List_Destructor)destroy_face, memory, driver ); /* finalize the driver object */ if ( driver->interface.done_driver ) driver->interface.done_driver( driver ); /* finalize client-data */ if ( driver->generic.finalizer ) driver->generic.finalizer( driver ); /* discard it */ FREE( driver ); } /************************************************************************* * * * FT_Get_Raster * * * Return a pointer to the raster corresponding to a given glyph * format tag. * * * library :: handle to source library object * glyph_format :: glyph format tag * * * raster_funcs :: if this field is not 0, returns the raster's interface * * * a pointer to the corresponding raster object. * *************************************************************************/ EXPORT_FUNC(FT_Raster) FT_Get_Raster( FT_Library library, FT_Glyph_Format glyph_format, FT_Raster_Funcs *raster_funcs ) { FT_Int n; for ( n = 0; n < FT_MAX_GLYPH_FORMATS; n++ ) { FT_Raster_Funcs* funcs = &library->raster_funcs[n]; if (funcs->glyph_format == glyph_format) { if (raster_funcs) *raster_funcs = *funcs; return library->rasters[n]; } } return 0; } /*************************************************************************/ /* */ /* */ /* FT_Set_Raster */ /* */ /* */ /* Register a given raster to the library. */ /* */ /* */ /* library :: A handle to a target library object. */ /* raster_funcs :: pointer to the raster's interface */ /* */ /* */ /* Error code. 0 means success. */ /* */ /* */ /* This function will do the following: */ /* */ /* - a new raster object is created through raster_func.raster_new */ /* if this fails, then the function returns */ /* */ /* - if a raster is already registered for the glyph format */ /* specified in raster_funcs, it will be destroyed */ /* */ /* - the new raster is registered for the glyph format */ /* */ EXPORT_FUNC(FT_Error) FT_Set_Raster( FT_Library library, FT_Raster_Funcs* raster_funcs ) { FT_Glyph_Format glyph_format = raster_funcs->glyph_format; FT_Raster_Funcs* funcs; FT_Raster raster; FT_Error error; FT_Int n, index; if ( glyph_format == ft_glyph_format_none) return FT_Err_Invalid_Argument; /* create a new raster object */ error = raster_funcs->raster_new( library->memory, &raster ); if (error) goto Exit; raster_funcs->raster_reset( raster, library->raster_pool, library->raster_pool_size ); index = -1; for (n = 0; n < FT_MAX_GLYPH_FORMATS; n++) { FT_Raster_Funcs* funcs = library->raster_funcs + n; /* record the first vacant entry in "index" */ if (index < 0 && funcs->glyph_format == ft_glyph_format_none) index = n; /* compare this entry's glyph format with the one we need */ if (funcs->glyph_format == glyph_format) { /* a raster already exists for this glyph format, we will */ /* destroy it before updating its entry in the table */ funcs->raster_done( library->rasters[n] ); index = n; break; } } if (index < 0) { /* the table is full and has no vacant entries */ error = FT_Err_Too_Many_Glyph_Formats; goto Fail; } funcs = library->raster_funcs + index; *funcs = *raster_funcs; library->rasters[index] = raster; Exit: return error; Fail: raster_funcs->raster_done( raster ); goto Exit; } /*************************************************************************/ /* */ /* */ /* FT_Unset_Raster */ /* */ /* */ /* Removes a given raster from the library. */ /* */ /* */ /* library :: A handle to a target library object. */ /* raster_funcs :: pointer to the raster's interface */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_DEF(FT_Error) FT_Unset_Raster( FT_Library library, FT_Raster_Funcs* raster_funcs ) { FT_Glyph_Format glyph_format = raster_funcs->glyph_format; FT_Error error; FT_Int n; error = FT_Err_Invalid_Argument; if ( glyph_format == ft_glyph_format_none) goto Exit; for (n = 0; n < FT_MAX_GLYPH_FORMATS; n++) { FT_Raster_Funcs* funcs = library->raster_funcs + n; if (funcs->glyph_format == glyph_format) { funcs->raster_done( library->rasters[n] ); library->rasters[n] = 0; library->raster_funcs[n].glyph_format = ft_glyph_format_none; error = FT_Err_Ok; break; } } Exit: return error; } /*************************************************************************/ /* */ /* */ /* FT_Set_Raster_Mode */ /* */ /* */ /* Set a raster-specific mode. */ /* */ /* */ /* library :: A handle to a target library object. */ /* format :: the glyph format used to select the raster */ /* mode :: the raster-specific mode descriptor */ /* args :: the mode arguments */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Set_Raster_Mode( FT_Library library, FT_Glyph_Format format, unsigned long mode, void* args ) { FT_Raster_Funcs funcs; FT_Raster raster; raster = FT_Get_Raster( library, format, &funcs ); if (raster && funcs.raster_set_mode ) return funcs.raster_set_mode( raster, mode, args ); else return FT_Err_Invalid_Argument; } /*************************************************************************/ /* */ /* */ /* FT_Set_Debug_Hook */ /* */ /* */ /* Sets a debug hook function for debugging the interpreter of a */ /* font format. */ /* */ /* */ /* library :: A handle to the library object. */ /* hook_index :: The index of the debug hook. You should use the */ /* values defined in ftobjs.h, e.g. */ /* FT_DEBUG_HOOK_TRUETYPE */ /* debug_hook :: The function used to debug the interpreter. */ /* */ /* */ /* Currently, four debug hook slots are available, but only two (for */ /* the TrueType and the Type 1 interpreter) are defined. */ /* */ EXPORT_FUNC(void) FT_Set_Debug_Hook( FT_Library library, FT_UInt hook_index, FT_DebugHook_Func debug_hook ) { if ( hook_index < ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) ) library->debug_hooks[hook_index] = debug_hook; } /*************************************************************************/ /* */ /* */ /* FT_New_Library */ /* */ /* */ /* This function is used to create a new FreeType library instance */ /* from a given memory object. It is thus possible to use libraries */ /* with distinct memory allocators within the same program. */ /* */ /* */ /* memory :: A handle to the original memory object. */ /* */ /* */ /* alibrary :: A pointer to handle of a new library object. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_New_Library( FT_Memory memory, FT_Library* alibrary ) { FT_Library library = 0; FT_Error error; /* first of all, allocate the library object */ if ( ALLOC( library, sizeof ( *library ) ) ) return error; library->memory = memory; /* allocate the render pool */ library->raster_pool_size = FT_RENDER_POOL_SIZE; if ( ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) ) goto Fail; /* now register the default raster for the `outline' glyph image format */ /* for now, ignore the error... */ error = FT_Set_Raster( library, &ft_default_raster ); /* That's ok now */ *alibrary = library; return FT_Err_Ok; Fail: FREE( library ); return error; } /*************************************************************************/ /* */ /* */ /* FT_Done_Library */ /* */ /* */ /* Discards a given library object. This closes all drivers and */ /* discards all resource objects. */ /* */ /* */ /* library :: A handle to the target library */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Done_Library( FT_Library library ) { FT_Memory memory; FT_Int n; if ( !library ) return FT_Err_Invalid_Library_Handle; memory = library->memory; /* Discard client-data */ if ( library->generic.finalizer ) library->generic.finalizer( library ); /* Close all drivers in the library */ for ( n = 0; n < library->num_drivers; n++ ) { FT_Driver driver = library->drivers[n]; if ( driver ) { Destroy_Driver( driver ); library->drivers[n] = 0; } } /* Destroy raster objects */ FREE( library->raster_pool ); library->raster_pool_size = 0; { FT_Raster_Funcs* cur = library->raster_funcs; FT_Raster_Funcs* limit = cur + FT_MAX_GLYPH_FORMATS; FT_Raster* raster = library->rasters; for ( ; cur < limit; cur++, raster++ ) { if ( cur->glyph_format != ft_glyph_format_none ) { cur->raster_done( *raster ); *raster = 0; cur->glyph_format = ft_glyph_format_none; } } } FREE( library ); return FT_Err_Ok; } /*************************************************************************/ /* */ /* */ /* FT_Add_Driver */ /* */ /* */ /* Registers a new driver in a given library object. This function */ /* takes only a pointer to a driver interface; it uses it to create */ /* the new driver, then sets up some important fields. */ /* */ /* */ /* library :: A handle to the target library object. */ /* */ /* */ /* driver_interface :: A pointer to a driver interface table. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* This function doesn't check whether the driver is already */ /* installed! */ /* */ EXPORT_FUNC(FT_Error) FT_Add_Driver( FT_Library library, const FT_DriverInterface* driver_interface ) { FT_Error error; FT_Driver driver; FT_Memory memory; if ( !library || !driver_interface ) return FT_Err_Invalid_Library_Handle; memory = library->memory; error = FT_Err_Ok; if ( library->num_drivers >= FT_MAX_DRIVERS ) error = FT_Err_Too_Many_Drivers; else { if ( ALLOC( driver, driver_interface->driver_object_size ) ) goto Exit; driver->library = library; driver->memory = memory; driver->interface = *driver_interface; if ( driver_interface->init_driver ) { error = driver_interface->init_driver( driver ); if ( error ) goto Fail; } library->drivers[library->num_drivers++] = driver; goto Exit; Fail: FREE( driver ); } Exit: return error; } /*************************************************************************/ /* */ /* */ /* FT_Remove_Driver */ /* */ /* */ /* Unregisters a given driver. This closes the driver, which in turn */ /* destroys all faces, sizes, slots, etc. associated with it. */ /* */ /* This function also DESTROYS the driver object. */ /* */ /* */ /* driver :: A handle to target driver object. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Remove_Driver( FT_Driver driver ) { FT_Library library; FT_Memory memory; FT_Driver *cur, *last; FT_Error error; if ( !driver ) return FT_Err_Invalid_Driver_Handle; library = driver->library; memory = driver->memory; if ( !library || !memory ) return FT_Err_Invalid_Driver_Handle; /* look-up driver entry in library table */ error = FT_Err_Invalid_Driver_Handle; cur = library->drivers; last = cur + library->num_drivers - 1; for ( ; cur <= last; cur++ ) { if ( *cur == driver ) { /* destroy the driver object */ Destroy_Driver( driver ); /* now move the last driver in the table to the vacant slot */ if ( cur < last ) { *cur = *last; *last = 0; } library->num_drivers--; /* exit loop */ error = FT_Err_Ok; break; } } return error; } /*************************************************************************/ /* */ /* */ /* FT_Get_Driver */ /* */ /* */ /* Returns the handle of the driver responsible for a given format */ /* (or service) according to its `name'. */ /* */ /* */ /* library :: A handle to the library object. */ /* driver_name :: The name of the driver to look up. */ /* */ /* */ /* A handle to the driver object, 0 otherwise. */ /* */ EXPORT_FUNC(FT_Driver) FT_Get_Driver( FT_Library library, char* driver_name ) { FT_Driver *cur, *limit; if ( !library || !driver_name ) return 0; cur = library->drivers; limit = cur + library->num_drivers; for ( ; cur < limit; cur++ ) { if ( strcmp( (*cur)->interface.driver_name, driver_name ) == 0 ) return *cur; } return 0; } /*************************************************************************/ /* */ /* */ /* open_face */ /* */ /* */ /* This function does some work for FT_Open_Face(). */ /* */ static FT_Error open_face( FT_Driver driver, FT_Stream stream, FT_Long face_index, FT_Int num_params, FT_Parameter* params, FT_Face* aface ) { FT_Memory memory; FT_DriverInterface* interface; FT_Face face = 0; FT_Error error; interface = &driver->interface; memory = driver->memory; /* allocate the face object, and perform basic initialization */ if ( ALLOC( face, interface->face_object_size ) ) goto Fail; face->driver = driver; face->memory = memory; face->stream = stream; error = interface->init_face( stream, face, face_index, num_params, params ); if ( error ) goto Fail; *aface = face; Fail: if ( error ) { interface->done_face( face ); FREE( face ); *aface = 0; } return error; } /*************************************************************************/ /* */ /* */ /* FT_New_Face */ /* */ /* */ /* Creates a new face object from a given resource and typeface index */ /* using a pathname to the font file. */ /* */ /* */ /* library :: A handle to the library resource. */ /* */ /* */ /* pathname :: A path to the font file. */ /* face_index :: The index of the face within the resource. The */ /* first face has index 0. */ /* */ /* face :: A handle to a new face object. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* Unlike FreeType 1.x, this function automatically creates a glyph */ /* slot for the face object which can be accessed directly through */ /* `face->glyph'. */ /* */ /* Note that additional slots can be added to each face with the */ /* FT_New_GlyphSlot() API function. Slots are linked in a single */ /* list through their `next' field. */ /* */ /* FT_New_Face() can be used to determine and/or check the font */ /* format of a given font resource. If the `face_index' field is */ /* negative, the function will _not_ return any face handle in */ /* `*face'. Its return value should be 0 if the resource is */ /* recognized, or non-zero if not. */ /* */ EXPORT_FUNC(FT_Error) FT_New_Face( FT_Library library, const char* pathname, FT_Long face_index, FT_Face* aface ) { FT_Open_Args args; args.flags = ft_open_pathname; args.pathname = (char*)pathname; return FT_Open_Face( library, &args, face_index, aface ); } /*************************************************************************/ /* */ /* */ /* FT_New_Memory_Face */ /* */ /* */ /* Creates a new face object from a given resource and typeface index */ /* using a font file already loaded into memory. */ /* */ /* */ /* library :: A handle to the library resource. */ /* */ /* */ /* file_base :: A pointer to the beginning of the font data. */ /* file_size :: The size of the memory chunk used by the font data. */ /* face_index :: The index of the face within the resource. The */ /* first face has index 0. */ /* */ /* face :: A handle to a new face object. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* Unlike FreeType 1.x, this function automatically creates a glyph */ /* slot for the face object which can be accessed directly through */ /* `face->glyph'. */ /* */ /* Note that additional slots can be added to each face with the */ /* FT_New_GlyphSlot() API function. Slots are linked in a single */ /* list through their `next' field. */ /* */ /* FT_New_Memory_Face() can be used to determine and/or check the */ /* font format of a given font resource. If the `face_index' field */ /* is negative, the function will _not_ return any face handle in */ /* `*face'. Its return value should be 0 if the resource is */ /* recognized, or non-zero if not. */ /* */ EXPORT_FUNC(FT_Error) FT_New_Memory_Face( FT_Library library, void* file_base, FT_Long file_size, FT_Long face_index, FT_Face* face ) { FT_Open_Args args; args.flags = ft_open_memory; args.memory_base = file_base; args.memory_size = file_size; return FT_Open_Face( library, &args, face_index, face ); } /*************************************************************************/ /* */ /* */ /* FT_Open_Face */ /* */ /* */ /* Opens a face object from a given resource and typeface index using */ /* an `FT_Open_Args' structure. If the face object doesn't exist, it */ /* will be created. */ /* */ /* */ /* library :: A handle to the library resource. */ /* */ /* */ /* args :: A pointer to an `FT_Open_Args' structure which must */ /* be filled by the caller. */ /* face_index :: The index of the face within the resource. The */ /* first face has index 0. */ /* */ /* face :: A handle to a new face object. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* Unlike FreeType 1.x, this function automatically creates a glyph */ /* slot for the face object which can be accessed directly through */ /* `face->glyph'. */ /* */ /* Note that additional slots can be added to each face with the */ /* FT_New_GlyphSlot() API function. Slots are linked in a single */ /* list through their `next' field. */ /* */ /* FT_Open_Face() can be used to determine and/or check the font */ /* format of a given font resource. If the `face_index' field is */ /* negative, the function will _not_ return any face handle in */ /* `*face'. Its return value should be 0 if the resource is */ /* recognized, or non-zero if not. */ /* */ EXPORT_FUNC(FT_Error) FT_Open_Face( FT_Library library, FT_Open_Args* args, FT_Long face_index, FT_Face* aface ) { FT_Error error; FT_Driver driver; FT_Memory memory; FT_Stream stream; FT_Face face = 0; FT_ListNode node = 0; *aface = 0; if ( !library ) return FT_Err_Invalid_Handle; /* create input stream */ error = ft_new_input_stream( library, args, &stream ); if ( error ) goto Exit; memory = library->memory; /* if the font driver is specified in the `args' structure, use */ /* it. Otherwise, we'll scan the list of registered drivers. */ if ( args->flags & ft_open_driver && args->driver ) { driver = args->driver; /* not all drivers directly support face objects, so check... */ if ( driver->interface.face_object_size ) { FT_Int num_params = 0; FT_Parameter* params = 0; if ( args->flags & ft_open_params ) { num_params = args->num_params; params = args->params; } error = open_face( driver, stream, face_index, num_params, params, &face ); if ( !error ) goto Success; } else error = FT_Err_Invalid_Handle; goto Fail; } else { /* check each font driver for an appropriate format */ FT_Driver* cur = library->drivers; FT_Driver* limit = cur + library->num_drivers; for ( ; cur < limit; cur++ ) { driver = *cur; /* not all drivers directly support face objects, so check... */ if ( driver->interface.face_object_size ) { FT_Int num_params = 0; FT_Parameter* params = 0; if ( args->flags & ft_open_params ) { num_params = args->num_params; params = args->params; } error = open_face( driver, stream, face_index, num_params, params, &face ); if ( !error ) goto Success; if ( error != FT_Err_Unknown_File_Format ) goto Fail; } } /* no driver is able to handle this format */ error = FT_Err_Unknown_File_Format; goto Fail; } Success: FT_TRACE4(( "FT_New_Face: New face object, adding to list\n" )); /* add the face object to its driver's list */ if ( ALLOC( node, sizeof ( *node ) ) ) goto Fail; node->data = face; /* don't assume driver is the same as face->driver, so use face->driver instead. (JvR 3/5/2000) */ FT_List_Add( &face->driver->faces_list, node ); /* now allocate a glyph slot object for the face */ { FT_GlyphSlot slot; FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" )); error = FT_New_GlyphSlot( face, &slot ); if ( error ) goto Fail; } /* finally allocate a size object for the face */ { FT_Size size; FT_TRACE4(( "FT_Open_Face: Creating size object\n" )); error = FT_New_Size( face, &size ); if ( error ) goto Fail; } /* initialize transform for convenience functions */ face->transform_matrix.xx = 0x10000L; face->transform_matrix.xy = 0; face->transform_matrix.yx = 0; face->transform_matrix.yy = 0x10000L; face->transform_delta.x = 0; face->transform_delta.y = 0; *aface = face; goto Exit; Fail: FT_Done_Face( face ); Exit: FT_TRACE4(( "FT_Open_Face: Return %d\n", error )); return error; } /*************************************************************************/ /* */ /* */ /* FT_Attach_File */ /* */ /* */ /* `Attaches' a given font file to an existing face. This is usually */ /* to read additional information for a single face object. For */ /* example, it is used to read the AFM files that come with Type 1 */ /* fonts in order to add kerning data and other metrics. */ /* */ /* */ /* face :: The target face object. */ /* */ /* */ /* filepathname :: An 8-bit pathname naming the `metrics' file. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* If your font file is in memory, or if you want to provide your */ /* own input stream object, use FT_Attach_Stream(). */ /* */ /* The meaning of the `attach' action (i.e., what really happens when */ /* the new file is read) is not fixed by FreeType itself. It really */ /* depends on the font format (and thus the font driver). */ /* */ /* Client applications are expected to know what they are doing */ /* when invoking this function. Most drivers simply do not implement */ /* file attachments. */ /* */ EXPORT_FUNC(FT_Error) FT_Attach_File( FT_Face face, const char* filepathname ) { FT_Open_Args open; open.flags = ft_open_pathname; open.pathname = (char*)filepathname; return FT_Attach_Stream( face, &open ); } /*************************************************************************/ /* */ /* */ /* FT_Attach_Stream */ /* */ /* */ /* This function is similar to FT_Attach_File with the exception */ /* that it reads the attachment from an arbitrary stream. */ /* */ /* */ /* face :: target face object */ /* */ /* args :: a pointer to an FT_Open_Args structure used to describe */ /* the input stream to FreeType */ /* */ /* Error code. 0 means success. */ /* */ /* The meaning of the "attach" (i.e. what really happens when the */ /* new file is read) is not fixed by FreeType itself. It really */ /* depends on the font format (and thus the font driver). */ /* */ /* Client applications are expected to know what they're doing */ /* when invoking this function. Most drivers simply do not implement */ /* file attachments.. */ /* */ EXPORT_FUNC(FT_Error) FT_Attach_Stream( FT_Face face, FT_Open_Args* parameters ) { FT_Stream stream; FT_Error error; FT_Driver driver; FTDriver_getInterface get_interface; if ( !face || !face->driver ) return FT_Err_Invalid_Handle; driver = face->driver; error = ft_new_input_stream( driver->library, parameters, &stream ); if (error) goto Exit; /* we implement FT_Attach_Stream in each driver through the */ /* "attach_file" interface.. */ error = FT_Err_Unimplemented_Feature; get_interface = driver->interface.get_interface; if (get_interface) { FT_Attach_Reader reader; reader = (FT_Attach_Reader)(get_interface( driver, "attach_file" )); if (reader) error = reader( face, stream ); } /* close the attached stream */ ft_done_stream( &stream ); Exit: return error; } /*************************************************************************/ /* */ /* */ /* FT_Done_Face */ /* */ /* */ /* Discards a given face object, as well as all of its child slots */ /* and sizes. */ /* */ /* */ /* face :: A handle to a target face object. */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Done_Face( FT_Face face ) { FT_Error error; FT_Driver driver; FT_Memory memory; FT_DriverInterface* interface; FT_ListNode node; if (!face || !face->driver ) return FT_Err_Invalid_Face_Handle; driver = face->driver; interface = &driver->interface; memory = driver->memory; /* find face in driver's list */ node = FT_List_Find( &driver->faces_list, face ); if ( node ) { /* remove face object from the driver's list */ FT_List_Remove( &driver->faces_list, node ); FREE( node ); /* now destroy the object proper */ destroy_face( memory, face, driver ); error = FT_Err_Ok; } else error = FT_Err_Invalid_Face_Handle; return error; } /*************************************************************************/ /* */ /* */ /* FT_New_Size */ /* */ /* */ /* Creates a new size object from a given face object. */ /* */ /* */ /* face :: A handle to a parent face object. */ /* */ /* */ /* size :: A handle to a new size object. */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_New_Size( FT_Face face, FT_Size* asize ) { FT_Error error; FT_Memory memory; FT_Driver driver; FT_DriverInterface* interface; FT_Size size = 0; FT_ListNode node = 0; if ( !face || !face->driver ) return FT_Err_Invalid_Face_Handle; *asize = 0; driver = face->driver; interface = &driver->interface; memory = face->memory; /* Allocate new size object and perform basic initialisation */ if ( ALLOC( size, interface->size_object_size ) || ALLOC( node, sizeof ( FT_ListNodeRec ) ) ) goto Exit; size->face = face; error = interface->init_size( size ); /* in case of success, add to the face's list */ if ( !error ) { *asize = size; node->data = size; FT_List_Add( &face->sizes_list, node ); /* record as current size for the face */ face->size = size; } Exit: if ( error ) { FREE( node ); FREE( size ); } return error; } /*************************************************************************/ /* */ /* */ /* FT_Done_Size */ /* */ /* */ /* Discards a given size object. */ /* */ /* */ /* size :: A handle to a target size object */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Done_Size( FT_Size size ) { FT_Error error; FT_Driver driver; FT_Memory memory; FT_Face face; FT_ListNode node; if ( !size || !size->face ) return FT_Err_Invalid_Size_Handle; driver = size->face->driver; if ( !driver ) return FT_Err_Invalid_Driver_Handle; memory = driver->memory; error = FT_Err_Ok; face = size->face; node = FT_List_Find( &face->sizes_list, size ); if ( node ) { FT_List_Remove( &face->sizes_list, node ); FREE( node ); if (face->size == size) { face->size = 0; if (face->sizes_list.head) face->size = (FT_Size)(face->sizes_list.head->data); } destroy_size( memory, size, driver ); } else error = FT_Err_Invalid_Size_Handle; return FT_Err_Ok; } /*************************************************************************/ /* */ /* */ /* FT_Set_Char_Size */ /* */ /* */ /* Sets the character dimensions of a given size object. The */ /* `char_size' value is used for the width and height, expressed in */ /* 26.6 fractional points. 1 point = 1/72 inch. */ /* */ /* */ /* size :: A handle to a target size object. */ /* char_size :: The character size, in 26.6 fractional points. */ /* */ /* */ /* Error code. 0 means success. */ /* */ /* */ /* When dealing with fixed-size faces (i.e., non-scalable formats), */ /* use the function FT_Set_Pixel_Sizes(). */ /* */ EXPORT_FUNC(FT_Error) FT_Set_Char_Size( FT_Face face, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt horz_resolution, FT_UInt vert_resolution ) { FT_Error error; FT_Driver driver; FT_Memory memory; FT_DriverInterface* interface; FT_Size_Metrics* metrics = &face->size->metrics; FT_Long dim_x, dim_y; if ( !face || !face->size || !face->driver) return FT_Err_Invalid_Face_Handle; if (!char_width) char_width = char_height; else if (!char_height) char_height = char_width; if (!horz_resolution) horz_resolution = 72; if (!vert_resolution) vert_resolution = 72; driver = face->driver; interface = &driver->interface; memory = driver->memory; /* default processing - this can be overriden by the driver */ if ( char_width < 1*64 ) char_width = 1*64; if ( char_height < 1*64 ) char_height = 1*64; /* Compute pixel sizes in 26.6 units */ dim_x = (((char_width * horz_resolution) / 72) + 32) & -64; dim_y = (((char_height * vert_resolution) / 72) + 32) & -64; metrics->x_ppem = (FT_UShort)(dim_x >> 6); metrics->y_ppem = (FT_UShort)(dim_y >> 6); metrics->x_scale = 0x10000; metrics->y_scale = 0x10000; if ( face->face_flags & FT_FACE_FLAG_SCALABLE) { metrics->x_scale = FT_DivFix( dim_x, face->units_per_EM ); metrics->y_scale = FT_DivFix( dim_y, face->units_per_EM ); } error = interface->set_char_sizes( face->size, char_width, char_height, horz_resolution, vert_resolution ); return error; } /*************************************************************************/ /* */ /* */ /* FT_Set_Pixel_Sizes */ /* */ /* */ /* Sets the character dimensions of a given size object. The width */ /* and height are expressed in integer pixels. */ /* */ /* */ /* size :: A handle to a target size object. */ /* pixel_width :: The character width, in integer pixels. */ /* pixel_height :: The character height, in integer pixels. */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Set_Pixel_Sizes( FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height ) { FT_Error error; FT_Driver driver; FT_Memory memory; FT_DriverInterface* interface; FT_Size_Metrics* metrics = &face->size->metrics; if ( !face || !face->size || !face->driver ) return FT_Err_Invalid_Face_Handle; driver = face->driver; interface = &driver->interface; memory = driver->memory; /* default processing - this can be overriden by the driver */ if ( pixel_width < 1 ) pixel_width = 1; if ( pixel_height < 1 ) pixel_height = 1; metrics->x_ppem = pixel_width; metrics->y_ppem = pixel_height; if ( face->face_flags & FT_FACE_FLAG_SCALABLE ) { metrics->x_scale = FT_DivFix( metrics->x_ppem << 6, face->units_per_EM ); metrics->y_scale = FT_DivFix( metrics->y_ppem << 6, face->units_per_EM ); } error = interface->set_pixel_sizes( face->size, pixel_width, pixel_height ); return error; } /*************************************************************************/ /* */ /* */ /* FT_New_GlyphSlot */ /* */ /* */ /* It is sometimes useful to have more than one glyph slot for a */ /* given face object. This function is used to create additional */ /* slots. All of them are automatically discarded when the face is */ /* destroyed. */ /* */ /* */ /* face :: A handle to a parent face object. */ /* */ /* */ /* aslot :: A handle to a new glyph slot object. */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_New_GlyphSlot( FT_Face face, FT_GlyphSlot* aslot ) { FT_Error error; FT_Driver driver; FT_DriverInterface* interface; FT_Memory memory; FT_GlyphSlot slot; *aslot = 0; if ( !face || !face->driver ) return FT_Err_Invalid_Face_Handle; driver = face->driver; interface = &driver->interface; memory = driver->memory; FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" )); if ( ALLOC( slot, interface->slot_object_size ) ) goto Exit; slot->face = face; slot->max_subglyphs = 0; slot->num_subglyphs = 0; slot->subglyphs = 0; error = interface->init_glyph_slot( slot ); if ( !error ) { /* in case of success, add slot to the face's list */ slot->next = face->glyph; face->glyph = slot; *aslot = slot; } if ( error ) FREE( slot ); Exit: FT_TRACE4(( "FT_New_GlyphSlot: Return %d\n", error )); return error; } /*************************************************************************/ /* */ /* */ /* FT_Done_GlyphSlot */ /* */ /* */ /* Destroys a given glyph slot. Remember however that all slots are */ /* automatically destroyed with its parent. Using this function is */ /* not always mandatory. */ /* */ /* */ /* slot :: A handle to a target glyph slot. */ /* */ EXPORT_FUNC(void) FT_Done_GlyphSlot( FT_GlyphSlot slot ) { if (slot) { FT_Driver driver = slot->face->driver; FT_Memory memory = driver->memory; FT_GlyphSlot* parent; FT_GlyphSlot cur; /* Remove slot from its parent face's list */ parent = &slot->face->glyph; cur = *parent; while ( cur ) { if ( cur == slot ) { *parent = cur->next; break; } cur = cur->next; } driver->interface.done_glyph_slot( slot ); FREE( slot ); } } /*************************************************************************/ /* */ /* */ /* FT_Load_Glyph */ /* */ /* */ /* A function used to load a single glyph within a given glyph slot, */ /* for a given size. */ /* */ /* */ /* slot :: A handle to a target slot object where the glyph */ /* will be loaded. */ /* */ /* size :: A handle to the source face size at which the glyph */ /* must be scaled/loaded. */ /* */ /* glyph_index :: The index of the glyph in the font file. */ /* */ /* load_flags :: A flag indicating what to load for this glyph. The */ /* FT_LOAD_XXX constants can be used to control the */ /* glyph loading process (e.g., whether the outline */ /* should be scaled, whether to load bitmaps or not, */ /* whether to hint the outline, etc). */ /* */ /* result :: A set of bit flags indicating the type of data that */ /* was loaded in the glyph slot (outline or bitmap, */ /* etc). */ /* */ /* You can set this field to 0 if you don't want this */ /* information. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Load_Glyph( FT_Face face, FT_UInt glyph_index, FT_Int load_flags ) { FT_Error error; FT_Driver driver; if ( !face || !face->size || !face->glyph ) return FT_Err_Invalid_Face_Handle; driver = face->driver; /* when the flag NO_RECURSE is set, we disable hinting and scaling */ if (load_flags & FT_LOAD_NO_RECURSE) load_flags |= FT_LOAD_NO_SCALE | FT_LOAD_NO_HINTING; error = driver->interface.load_glyph( face->glyph, face->size, glyph_index, load_flags ); return error; } EXPORT_FUNC(FT_Error) FT_Load_Char( FT_Face face, FT_ULong char_code, FT_Int load_flags ) { FT_Error error; FT_Driver driver; FT_UInt glyph_index; if (!face || !face->size || !face->glyph || !face->charmap ) return FT_Err_Invalid_Face_Handle; driver = face->driver; glyph_index = FT_Get_Char_Index( face, char_code ); if (glyph_index == 0) error = FT_Err_Invalid_Character_Code; else error = driver->interface.load_glyph( face->glyph, face->size, glyph_index, load_flags ); return error; } /*************************************************************************/ /* */ /* */ /* FT_Get_Kerning */ /* */ /* */ /* Returns the kerning vector between two glyphs of a same face. */ /* */ /* */ /* face :: A handle to a source face object. */ /* */ /* left_glyph :: The index of the left glyph in the kern pair. */ /* */ /* right_glyph :: The index of the right glyph in the kern pair. */ /* */ /* */ /* kerning :: The kerning vector. This is in font units for */ /* scalable formats, and in pixels for fixed-sizes */ /* formats. */ /* */ /* */ /* FreeType error code. 0 means success. */ /* */ /* */ /* Only horizontal layouts (left-to-right & right-to-left) are */ /* supported by this method. Other layouts, or more sophisticated */ /* kernings, are out of the scope of this API function -- they can be */ /* implemented through format-specific interfaces. */ /* */ EXPORT_FUNC(FT_Error) FT_Get_Kerning( FT_Face face, FT_UInt left_glyph, FT_UInt right_glyph, FT_Vector* kerning ) { FT_Error error; FT_Driver driver; FT_Memory memory; if ( !face ) { error = FT_Err_Invalid_Face_Handle; goto Exit; } driver = face->driver; memory = driver->memory; if ( driver->interface.get_kerning ) { error = driver->interface.get_kerning( face, left_glyph, right_glyph, kerning ); } else { kerning->x = 0; kerning->y = 0; error = FT_Err_Ok; } Exit: return error; } /*************************************************************************/ /* */ /* */ /* FT_Select_Charmap */ /* */ /* */ /* Selects a given charmap by its encoding tag. */ /* */ /* */ /* face :: A handle to the source face object. */ /* encoding :: handle to the selected charmap */ /* */ /* */ /* Error code. 0 means success. */ /* */ /* */ /* This function will return an error if no charmap in the face */ /* corresponds to the encoding queried here */ /* */ EXPORT_FUNC(FT_Error) FT_Select_Charmap( FT_Face face, FT_Encoding encoding ) { FT_CharMap* cur = face->charmaps; FT_CharMap* limit = cur + face->num_charmaps; for ( ; cur < limit; cur++ ) { if ( cur[0]->encoding == encoding ) { face->charmap = cur[0]; return 0; } } return FT_Err_Invalid_Argument; } /*************************************************************************/ /* */ /* */ /* FT_Set_Charmap */ /* */ /* */ /* Selects a given charmap for character code to glyph index */ /* decoding. */ /* */ /* */ /* face :: A handle to the source face object. */ /* charmap :: handle to the selected charmap */ /* */ /* */ /* Error code. 0 means success. */ /* */ /* */ /* this function will return an error when the charmap is not part */ /* of the face (i.e. if it is not listed in the face->charmaps[] */ /* table). */ /* */ EXPORT_FUNC(FT_Error) FT_Set_Charmap( FT_Face face, FT_CharMap charmap ) { FT_CharMap* cur = face->charmaps; FT_CharMap* limit = cur + face->num_charmaps; for ( ; cur < limit; cur++ ) { if ( cur[0] == charmap ) { face->charmap = cur[0]; return 0; } } return FT_Err_Invalid_Argument; } /*************************************************************************/ /* */ /* */ /* FT_Get_Char_Index */ /* */ /* */ /* Returns the glyph index of a given character code. This function */ /* uses a charmap object to do the translation. */ /* */ /* */ /* charmap :: A handle to a filter charmap object. */ /* charcode :: The character code. */ /* */ /* */ /* The glyph index. 0 means `undefined character code'. */ /* */ EXPORT_FUNC(FT_UInt) FT_Get_Char_Index( FT_Face face, FT_ULong charcode ) { FT_UInt result; FT_Driver driver; result = 0; if ( face && face->charmap ) { driver = face->driver; result = driver->interface.get_char_index( face->charmap, charcode ); } return result; } /*************************************************************************** * * * FT_Get_Sfnt_Table * * * Returns a pointer to a given SFNT table within a face. * * * face :: handle to source * tag :: index if SFNT table * * * type-less pointer to the table. This will be 0 in case of error, or * when the corresponding table was not found *OR* loaded from the file. * * * The table is owned by the face object, and disappears with it. * * This function is only useful to access Sfnt tables that are loaded * by the sfnt/truetype/opentype drivers. See FT_Sfnt_tag for a list. * * You can load any table with a different function.. XXX * ***************************************************************************/ EXPORT_FUNC(void*) FT_Get_Sfnt_Table( FT_Face face, FT_Sfnt_Tag tag ) { void* table = 0; FT_Get_Sfnt_Table_Func func; FT_Driver driver; if (!face || !FT_IS_SFNT(face)) goto Exit; driver = face->driver; func = (FT_Get_Sfnt_Table_Func)driver->interface.get_interface( driver, "get_sfnt" ); if (func) table = func(face,tag); Exit: return table; } /*************************************************************************/ /* */ /* */ /* FT_Done_FreeType */ /* */ /* */ /* Destroys a given FreeType library object and all of its childs, */ /* including resources, drivers, faces, sizes, etc. */ /* */ /* */ /* library :: A handle to the target library object. */ /* */ /* */ /* Error code. 0 means success. */ /* */ EXPORT_FUNC(FT_Error) FT_Done_FreeType( FT_Library library ) { /* Discard the library object */ FT_Done_Library( library ); return FT_Err_Ok; } /* END */