minhngoc25a
/
freetype2
mirror of git://git.savannah.gnu.org/freetype/freetype2.git
2
1
Fork 2
Code Issues 9 Releases Wiki Activity

* src/cache/ftcbasic.c (ftc_basic_family_compare, 

ftc_basic_family_init, ftc_basic_family_get_count,
ftc_basic_family_load_bitmap, ftc_basic_family_load_glyph,
ftc_basic_gnode_compare_faceid): Adjust parameters and return types
to prototypes given in header files from include/freetype/cache.
Use casts to proper types locally.
(ftc_basic_image_family_class, ftc_basic_image_cache_class,
ftc_basic_sbit_family_class, ftc_basic_sbit_cache_class): Remove
casts.

* src/cache/ftccback.h: Adjust parameters and return types to
prototypes given in header files from include/freetype/cache.

* src/cache/ftcimage.c (ftc_inode_free, ftc_inode_new,
ftc_inode_weight): Adjust parameters and return types to prototypes
given in header files from include/freetype/cache.  Use casts to
proper types locally.

* src/cache/ftcsbits.c (ftc_snode_free, ftc_snode_new,
ftc_snode_weight, ftc_snode_compare): Adjust parameters and return
types to prototypes given in header files from
include/freetype/cache.  Use casts to proper types locally.

* src/cache/ftccmap.c (ftc_cmap_node_free, ftc_cmap_node_new,
ftc_cmap_node_weight, ftc_cmap_node_compare,
ftc_cmap_node_remove_faceid): Adjust parameters and return types to
prototypes given in header files from include/freetype/cache.  Use
casts to proper types locally.
(ftc_cmap_cache_class): Remove casts.

* src/cache/ftcglyph.c (ftc_gnode_compare, ftc_gcache_init,
ftc_gcache_done): Adjust parameters and return types to prototypes
given in header files from include/freetype/cache.  Use casts to
proper types locally.

* src/cache/ftcmanag.c (ftc_size_node_done, ftc_size_node_compare,
ftc_size_node_init, ftc_size_node_reset,
ftc_size_node_compare_faceid, ftc_face_node_init,
ftc_face_node_done, ftc_face_node_compare: Adjust parameters and
return types to prototypes given in header files from
include/freetype/cache.  Use casts to proper types locally.

(ftc_size_list_class, ftc_face_list_class): Remove casts.


* src/autohint/ahmodule.c (ft_autohinter_init, ft_autohinter_done):
Use FT_Module as parameter and do a cast to FT_AutoHinter locally.
(autohint_module_class): Remove casts.

* src/base/ftglyph.c (ft_bitmap_glyph_init, ft_bitmap_glyph_copy,
ft_bitmap_glyph_done, ft_bitmap_glyph_bbox, ft_outline_glyph_init,
ft_outline_glyph_done, ft_outline_glyph_copy,
ft_outline_glyph_transform, ft_outline_glyph_bbox,
ft_outline_glyph_prepare): Use FT_Glyph as parameter and do a cast
to FT_XXXGlyph locally.
Use FT_CALLBACK_DEF throughout.
(ft_bitmap_glyph_class, ft_outline_glyph_class): Remove casts.

* src/bdf/bdfdrivr.c (bdf_cmap_init, bdf_cmap_done,
bdf_cmap_char_index, bdf_cmap_char_next): Use FT_CMap as parameter
and do a cast to BDF_CMap locally.
(bdf_cmap_class): Remove casts.
This commit is contained in:
Werner Lemberg 2004-05-17 09:25:04 +00:00
parent f258627e83
commit e260d2538d
11 changed files with 438 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
ChangeLog
View File

@ -1,6 +1,72 @@
2004-05-14 Werner Lemberg <wl@gnu.org>
* src/cache/ftcbasic.c (ftc_basic_family_compare,
ftc_basic_family_init, ftc_basic_family_get_count,
ftc_basic_family_load_bitmap, ftc_basic_family_load_glyph,
ftc_basic_gnode_compare_faceid): Adjust parameters and return types
to prototypes given in header files from include/freetype/cache.
Use casts to proper types locally.
(ftc_basic_image_family_class, ftc_basic_image_cache_class,
ftc_basic_sbit_family_class, ftc_basic_sbit_cache_class): Remove
casts.
* src/cache/ftccback.h: Adjust parameters and return types to
prototypes given in header files from include/freetype/cache.
* src/cache/ftcimage.c (ftc_inode_free, ftc_inode_new,
ftc_inode_weight): Adjust parameters and return types to prototypes
given in header files from include/freetype/cache. Use casts to
proper types locally.
* src/cache/ftcsbits.c (ftc_snode_free, ftc_snode_new,
ftc_snode_weight, ftc_snode_compare): Adjust parameters and return
types to prototypes given in header files from
include/freetype/cache. Use casts to proper types locally.
* src/cache/ftccmap.c (ftc_cmap_node_free, ftc_cmap_node_new,
ftc_cmap_node_weight, ftc_cmap_node_compare,
ftc_cmap_node_remove_faceid): Adjust parameters and return types to
prototypes given in header files from include/freetype/cache. Use
casts to proper types locally.
(ftc_cmap_cache_class): Remove casts.
* src/cache/ftcglyph.c (ftc_gnode_compare, ftc_gcache_init,
ftc_gcache_done): Adjust parameters and return types to prototypes
given in header files from include/freetype/cache. Use casts to
proper types locally.
* src/cache/ftcmanag.c (ftc_size_node_done, ftc_size_node_compare,
ftc_size_node_init, ftc_size_node_reset,
ftc_size_node_compare_faceid, ftc_face_node_init,
ftc_face_node_done, ftc_face_node_compare: Adjust parameters and
return types to prototypes given in header files from
include/freetype/cache. Use casts to proper types locally.
(ftc_size_list_class, ftc_face_list_class): Remove casts.
2004-05-13 Werner Lemberg <wl@gnu.org>
* src/autohint/ahmodule.c (ft_autohinter_init, ft_autohinter_done):
Use FT_Module as parameter and do a cast to FT_AutoHinter locally.
(autohint_module_class): Remove casts.
* src/base/ftglyph.c (ft_bitmap_glyph_init, ft_bitmap_glyph_copy,
ft_bitmap_glyph_done, ft_bitmap_glyph_bbox, ft_outline_glyph_init,
ft_outline_glyph_done, ft_outline_glyph_copy,
ft_outline_glyph_transform, ft_outline_glyph_bbox,
ft_outline_glyph_prepare): Use FT_Glyph as parameter and do a cast
to FT_XXXGlyph locally.
Use FT_CALLBACK_DEF throughout.
(ft_bitmap_glyph_class, ft_outline_glyph_class): Remove casts.
* src/bdf/bdfdrivr.c (bdf_cmap_init, bdf_cmap_done,
bdf_cmap_char_index, bdf_cmap_char_next): Use FT_CMap as parameter
and do a cast to BDF_CMap locally.
(bdf_cmap_class): Remove casts.
2004-05-12 Werner Lemberg <wl@gnu.org>
* src/cff/cffgload.h (CFF_Builder): Remove `error'
* src/cff/cffgload.h (CFF_Builder): Remove `error'.
* src/cff/cffgload.c (cff_decoder_parse_charstrings): Replace
`Memory_Error' with `Fail' und update all users.

26
src/autohint/ahmodule.c
View File

@ -4,7 +4,7 @@
/* */
/* Auto-hinting module implementation (declaration). */
/* */
/* Copyright 2000-2001, 2002, 2003 Catharon Productions Inc. */
/* Copyright 2000-2001, 2002, 2003, 2004 Catharon Productions Inc. */
/* Author: David Turner */
/* */
/* This file is part of the Catharon Typography Project and shall only */
@ -39,24 +39,30 @@
FT_CALLBACK_DEF( FT_Error )
ft_autohinter_init( FT_AutoHinter module )
ft_autohinter_init( FT_Module module ) /* FT_AutoHinter */
{
FT_Error error;
FT_AutoHinter autohinter = (FT_AutoHinter)module;
FT_Error error;
error = ah_hinter_new( module->root.library, &module->hinter );
error = ah_hinter_new( module->library, &autohinter->hinter );
#ifdef DEBUG_HINTER
if ( !error )
ah_debug_hinter = module->hinter;
ah_debug_hinter = autohinter->hinter;
#endif
return error;
}
FT_CALLBACK_DEF( void )
ft_autohinter_done( FT_AutoHinter module )
ft_autohinter_done( FT_Module module )
{
ah_hinter_done( module->hinter );
FT_AutoHinter autohinter = (FT_AutoHinter)module;
ah_hinter_done( autohinter->hinter );
#ifdef DEBUG_HINTER
ah_debug_hinter = NULL;
@ -128,9 +134,9 @@
(const void*) &ft_autohinter_service,
(FT_Module_Constructor)ft_autohinter_init,
(FT_Module_Destructor) ft_autohinter_done,
(FT_Module_Requester) 0
ft_autohinter_init,
ft_autohinter_done,
0 /* FT_Module_Requester */
};

132
src/base/ftglyph.c
View File

@ -138,13 +138,14 @@
}
static FT_Error
ft_bitmap_glyph_init( FT_BitmapGlyph glyph,
FT_GlyphSlot slot )
FT_CALLBACK_DEF( FT_Error )
ft_bitmap_glyph_init( FT_Glyph bitmap_glyph,
FT_GlyphSlot slot )
{
FT_Error error = FT_Err_Ok;
FT_Library library = FT_GLYPH(glyph)->library;
FT_Memory memory = library->memory;
FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph;
FT_Error error = FT_Err_Ok;
FT_Library library = FT_GLYPH( glyph )->library;
FT_Memory memory = library->memory;
if ( slot->format != FT_GLYPH_FORMAT_BITMAP )
@ -171,11 +172,13 @@
}
static FT_Error
ft_bitmap_glyph_copy( FT_BitmapGlyph source,
FT_BitmapGlyph target )
FT_CALLBACK_DEF( FT_Error )
ft_bitmap_glyph_copy( FT_Glyph bitmap_source,
FT_Glyph bitmap_target )
{
FT_Memory memory = source->root.library->memory;
FT_BitmapGlyph source = (FT_BitmapGlyph)bitmap_source;
FT_BitmapGlyph target = (FT_BitmapGlyph)bitmap_target;
FT_Memory memory = bitmap_source->library->memory;
target->left = source->left;
@ -185,20 +188,24 @@
}
static void
ft_bitmap_glyph_done( FT_BitmapGlyph glyph )
FT_CALLBACK_DEF( void )
ft_bitmap_glyph_done( FT_Glyph bitmap_glyph )
{
FT_Memory memory = FT_GLYPH(glyph)->library->memory;
FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph;
FT_Memory memory = FT_GLYPH( glyph )->library->memory;
FT_FREE( glyph->bitmap.buffer );
}
static void
ft_bitmap_glyph_bbox( FT_BitmapGlyph glyph,
FT_BBox* cbox )
FT_CALLBACK_DEF( void )
ft_bitmap_glyph_bbox( FT_Glyph bitmap_glyph,
FT_BBox* cbox )
{
FT_BitmapGlyph glyph = (FT_BitmapGlyph)bitmap_glyph;
cbox->xMin = glyph->left << 6;
cbox->xMax = cbox->xMin + ( glyph->bitmap.width << 6 );
cbox->yMax = glyph->top << 6;
@ -209,15 +216,15 @@
FT_CALLBACK_TABLE_DEF
const FT_Glyph_Class ft_bitmap_glyph_class =
{
sizeof( FT_BitmapGlyphRec ),
sizeof ( FT_BitmapGlyphRec ),
FT_GLYPH_FORMAT_BITMAP,
(FT_Glyph_InitFunc) ft_bitmap_glyph_init,
(FT_Glyph_DoneFunc) ft_bitmap_glyph_done,
(FT_Glyph_CopyFunc) ft_bitmap_glyph_copy,
(FT_Glyph_TransformFunc)0,
(FT_Glyph_GetBBoxFunc) ft_bitmap_glyph_bbox,
(FT_Glyph_PrepareFunc) 0
ft_bitmap_glyph_init,
ft_bitmap_glyph_done,
ft_bitmap_glyph_copy,
0, /* FT_Glyph_TransformFunc */
ft_bitmap_glyph_bbox,
0 /* FT_Glyph_PrepareFunc */
};
@ -230,14 +237,15 @@
/*************************************************************************/
static FT_Error
ft_outline_glyph_init( FT_OutlineGlyph glyph,
FT_GlyphSlot slot )
FT_CALLBACK_DEF( FT_Error )
ft_outline_glyph_init( FT_Glyph outline_glyph,
FT_GlyphSlot slot )
{
FT_Error error = FT_Err_Ok;
FT_Library library = FT_GLYPH(glyph)->library;
FT_Outline* source = &slot->outline;
FT_Outline* target = &glyph->outline;
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
FT_Error error = FT_Err_Ok;
FT_Library library = FT_GLYPH( glyph )->library;
FT_Outline* source = &slot->outline;
FT_Outline* target = &glyph->outline;
/* check format in glyph slot */
@ -268,19 +276,24 @@
}
static void
ft_outline_glyph_done( FT_OutlineGlyph glyph )
FT_CALLBACK_DEF( void )
ft_outline_glyph_done( FT_Glyph outline_glyph )
{
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
FT_Outline_Done( FT_GLYPH( glyph )->library, &glyph->outline );
}
static FT_Error
ft_outline_glyph_copy( FT_OutlineGlyph source,
FT_OutlineGlyph target )
FT_CALLBACK_DEF( FT_Error )
ft_outline_glyph_copy( FT_Glyph outline_source,
FT_Glyph outline_target )
{
FT_Error error;
FT_Library library = FT_GLYPH( source )->library;
FT_OutlineGlyph source = (FT_OutlineGlyph)outline_source;
FT_OutlineGlyph target = (FT_OutlineGlyph)outline_target;
FT_Error error;
FT_Library library = FT_GLYPH( source )->library;
error = FT_Outline_New( library, source->outline.n_points,
@ -292,11 +305,14 @@
}
static void
ft_outline_glyph_transform( FT_OutlineGlyph glyph,
FT_Matrix* matrix,
FT_Vector* delta )
FT_CALLBACK_DEF( void )
ft_outline_glyph_transform( FT_Glyph outline_glyph,
FT_Matrix* matrix,
FT_Vector* delta )
{
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
if ( matrix )
FT_Outline_Transform( &glyph->outline, matrix );
@ -305,18 +321,24 @@
}
static void
ft_outline_glyph_bbox( FT_OutlineGlyph glyph,
FT_BBox* bbox )
FT_CALLBACK_DEF( void )
ft_outline_glyph_bbox( FT_Glyph outline_glyph,
FT_BBox* bbox )
{
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
FT_Outline_Get_CBox( &glyph->outline, bbox );
}
static FT_Error
ft_outline_glyph_prepare( FT_OutlineGlyph glyph,
FT_GlyphSlot slot )
FT_CALLBACK_DEF( FT_Error )
ft_outline_glyph_prepare( FT_Glyph outline_glyph,
FT_GlyphSlot slot )
{
FT_OutlineGlyph glyph = (FT_OutlineGlyph)outline_glyph;
slot->format = FT_GLYPH_FORMAT_OUTLINE;
slot->outline = glyph->outline;
slot->outline.flags &= ~FT_OUTLINE_OWNER;
@ -328,15 +350,15 @@
FT_CALLBACK_TABLE_DEF
const FT_Glyph_Class ft_outline_glyph_class =
{
sizeof( FT_OutlineGlyphRec ),
sizeof ( FT_OutlineGlyphRec ),
FT_GLYPH_FORMAT_OUTLINE,
(FT_Glyph_InitFunc) ft_outline_glyph_init,
(FT_Glyph_DoneFunc) ft_outline_glyph_done,
(FT_Glyph_CopyFunc) ft_outline_glyph_copy,
(FT_Glyph_TransformFunc)ft_outline_glyph_transform,
(FT_Glyph_GetBBoxFunc) ft_outline_glyph_bbox,
(FT_Glyph_PrepareFunc) ft_outline_glyph_prepare
ft_outline_glyph_init,
ft_outline_glyph_done,
ft_outline_glyph_copy,
ft_outline_glyph_transform,
ft_outline_glyph_bbox,
ft_outline_glyph_prepare
};
@ -644,7 +666,7 @@
goto Exit;
/* in case of success, copy the bitmap to the glyph bitmap */
error = ft_bitmap_glyph_init( bitmap, &dummy );
error = ft_bitmap_glyph_init( (FT_Glyph)bitmap, &dummy );
if ( error )
goto Exit;

31
src/bdf/bdfdrivr.c
View File

@ -60,9 +60,12 @@ THE SOFTWARE.
FT_CALLBACK_DEF( FT_Error )
bdf_cmap_init( BDF_CMap cmap )
bdf_cmap_init( FT_CMap bdfcmap,
FT_Pointer init_data )
{
BDF_CMap cmap = (BDF_CMap)bdfcmap;
BDF_Face face = (BDF_Face)FT_CMAP_FACE( cmap );
FT_UNUSED( init_data );
cmap->num_encodings = face->bdffont->glyphs_used;
@ -73,20 +76,24 @@ THE SOFTWARE.
FT_CALLBACK_DEF( void )
bdf_cmap_done( BDF_CMap cmap )
bdf_cmap_done( FT_CMap bdfcmap )
{
BDF_CMap cmap = (BDF_CMap)bdfcmap;
cmap->encodings = NULL;
cmap->num_encodings = 0;
}
FT_CALLBACK_DEF( FT_UInt )
bdf_cmap_char_index( BDF_CMap cmap,
bdf_cmap_char_index( FT_CMap bdfcmap,
FT_UInt32 charcode )
{
BDF_CMap cmap = (BDF_CMap)bdfcmap;
BDF_encoding_el* encodings = cmap->encodings;
FT_UInt min, max, mid;
FT_UInt result = 0;
FT_UInt result = 0;
min = 0;
@ -117,9 +124,10 @@ THE SOFTWARE.
FT_CALLBACK_DEF( FT_UInt )
bdf_cmap_char_next( BDF_CMap cmap,
bdf_cmap_char_next( FT_CMap bdfcmap,
FT_UInt32 *acharcode )
{
BDF_CMap cmap = (BDF_CMap)bdfcmap;
BDF_encoding_el* encodings = cmap->encodings;
FT_UInt min, max, mid;
FT_UInt32 charcode = *acharcode + 1;
@ -162,13 +170,14 @@ THE SOFTWARE.
}
FT_CALLBACK_TABLE_DEF const FT_CMap_ClassRec bdf_cmap_class =
FT_CALLBACK_TABLE_DEF
const FT_CMap_ClassRec bdf_cmap_class =
{
sizeof( BDF_CMapRec ),
(FT_CMap_InitFunc) bdf_cmap_init,
(FT_CMap_DoneFunc) bdf_cmap_done,
(FT_CMap_CharIndexFunc)bdf_cmap_char_index,
(FT_CMap_CharNextFunc) bdf_cmap_char_next
sizeof ( BDF_CMapRec ),
bdf_cmap_init,
bdf_cmap_done,
bdf_cmap_char_index,
bdf_cmap_char_next
};

128
src/cache/ftcbasic.c vendored
View File

@ -62,19 +62,28 @@
} FTC_BasicFamilyRec, *FTC_BasicFamily;
FT_CALLBACK_DEF( FT_Bool )
ftc_basic_family_compare( FTC_BasicFamily family,
FTC_BasicQuery query )
FT_CALLBACK_DEF( FT_Int )
ftc_basic_family_compare( FTC_MruNode ftcfamily,
FT_Pointer ftcquery )
{
return FT_BOOL( FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs ) );
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
FTC_BasicQuery query = (FTC_BasicQuery)ftcquery;
return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
}
FT_CALLBACK_DEF( FT_Error )
ftc_basic_family_init( FTC_BasicFamily family,
FTC_BasicQuery query,
FTC_Cache cache )
ftc_basic_family_init( FTC_MruNode ftcfamily,
FT_Pointer ftcquery,
FT_Pointer ftccache )
{
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
FTC_BasicQuery query = (FTC_BasicQuery)ftcquery;
FTC_Cache cache = (FTC_Cache)ftccache;
FTC_Family_Init( FTC_FAMILY( family ), cache );
family->attrs = query->attrs;
return 0;
@ -82,12 +91,13 @@
FT_CALLBACK_DEF( FT_UInt )
ftc_basic_family_get_count( FTC_BasicFamily family,
FTC_Manager manager )
ftc_basic_family_get_count( FTC_Family ftcfamily,
FTC_Manager manager )
{
FT_Error error;
FT_Face face;
FT_UInt result = 0;
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
FT_Error error;
FT_Face face;
FT_UInt result = 0;
error = FTC_Manager_LookupFace( manager, family->attrs.scaler.face_id,
@ -100,13 +110,14 @@
FT_CALLBACK_DEF( FT_Error )
ftc_basic_family_load_bitmap( FTC_BasicFamily family,
FT_UInt gindex,
FTC_Manager manager,
FT_Face *aface )
ftc_basic_family_load_bitmap( FTC_Family ftcfamily,
FT_UInt gindex,
FTC_Manager manager,
FT_Face *aface )
{
FT_Error error;
FT_Size size;
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
FT_Error error;
FT_Size size;
error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
@ -126,15 +137,16 @@
FT_CALLBACK_DEF( FT_Error )
ftc_basic_family_load_glyph( FTC_BasicFamily family,
FT_UInt gindex,
FTC_Cache cache,
FT_Glyph *aglyph )
ftc_basic_family_load_glyph( FTC_Family ftcfamily,
FT_UInt gindex,
FTC_Cache cache,
FT_Glyph *aglyph )
{
FT_Error error;
FTC_Scaler scaler = &family->attrs.scaler;
FT_Face face;
FT_Size size;
FTC_BasicFamily family = (FTC_BasicFamily)ftcfamily;
FT_Error error;
FTC_Scaler scaler = &family->attrs.scaler;
FT_Face face;
FT_Size size;
/* we will now load the glyph image */
@ -173,11 +185,13 @@
FT_CALLBACK_DEF( FT_Bool )
ftc_basic_gnode_compare_faceid( FTC_GNode gnode,
FTC_FaceID face_id,
ftc_basic_gnode_compare_faceid( FTC_Node ftcgnode,
FT_Pointer ftcface_id,
FTC_Cache cache )
{
FTC_BasicFamily family = (FTC_BasicFamily)gnode->family;
FTC_GNode gnode = (FTC_GNode)ftcgnode;
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
FTC_BasicFamily family = (FTC_BasicFamily)gnode->family;
FT_Bool result;
@ -203,13 +217,13 @@
const FTC_IFamilyClassRec ftc_basic_image_family_class =
{
{
sizeof( FTC_BasicFamilyRec ),
(FTC_MruNode_CompareFunc)ftc_basic_family_compare,
(FTC_MruNode_InitFunc) ftc_basic_family_init,
(FTC_MruNode_ResetFunc) NULL,
(FTC_MruNode_DoneFunc) NULL
sizeof ( FTC_BasicFamilyRec ),
ftc_basic_family_compare,
ftc_basic_family_init,
0, /* FTC_MruNode_ResetFunc */
0 /* FTC_MruNode_DoneFunc */
},
(FTC_IFamily_LoadGlyphFunc)ftc_basic_family_load_glyph
ftc_basic_family_load_glyph
};
@ -217,15 +231,15 @@
const FTC_GCacheClassRec ftc_basic_image_cache_class =
{
{
(FTC_Node_NewFunc) ftc_inode_new,
(FTC_Node_WeightFunc) ftc_inode_weight,
(FTC_Node_CompareFunc)ftc_gnode_compare,
(FTC_Node_CompareFunc)ftc_basic_gnode_compare_faceid,
(FTC_Node_FreeFunc) ftc_inode_free,
ftc_inode_new,
ftc_inode_weight,
ftc_gnode_compare,
ftc_basic_gnode_compare_faceid,
ftc_inode_free,
sizeof( FTC_GCacheRec ),
(FTC_Cache_InitFunc) ftc_gcache_init,
(FTC_Cache_DoneFunc) ftc_gcache_done
sizeof ( FTC_GCacheRec ),
ftc_gcache_init,
ftc_gcache_done
},
(FTC_MruListClass)&ftc_basic_image_family_class
};
@ -321,13 +335,13 @@
{
{
sizeof( FTC_BasicFamilyRec ),
(FTC_MruNode_CompareFunc)ftc_basic_family_compare,
(FTC_MruNode_InitFunc) ftc_basic_family_init,
(FTC_MruNode_ResetFunc) NULL,
(FTC_MruNode_DoneFunc) NULL
ftc_basic_family_compare,
ftc_basic_family_init,
0, /* FTC_MruNode_ResetFunc */
0 /* FTC_MruNode_DoneFunc */
},
(FTC_SFamily_GetCountFunc) ftc_basic_family_get_count,
(FTC_SFamily_LoadGlyphFunc)ftc_basic_family_load_bitmap
ftc_basic_family_get_count,
ftc_basic_family_load_bitmap
};
@ -335,15 +349,15 @@
const FTC_GCacheClassRec ftc_basic_sbit_cache_class =
{
{
(FTC_Node_NewFunc) ftc_snode_new,
(FTC_Node_WeightFunc) ftc_snode_weight,
(FTC_Node_CompareFunc)ftc_snode_compare,
(FTC_Node_CompareFunc)ftc_basic_gnode_compare_faceid,
(FTC_Node_FreeFunc) ftc_snode_free,
ftc_snode_new,
ftc_snode_weight,
ftc_snode_compare,
ftc_basic_gnode_compare_faceid,
ftc_snode_free,
sizeof( FTC_GCacheRec ),
(FTC_Cache_InitFunc) ftc_gcache_init,
(FTC_Cache_DoneFunc) ftc_gcache_done
sizeof ( FTC_GCacheRec ),
ftc_gcache_init,
ftc_gcache_done
},
(FTC_MruListClass)&ftc_basic_sbit_family_class
};

49
src/cache/ftccback.h vendored
View File

@ -28,46 +28,49 @@
FT_LOCAL( void )
ftc_inode_free( FTC_INode inode,
ftc_inode_free( FTC_Node inode,
FTC_Cache cache );
FT_LOCAL( FT_Error )
ftc_inode_new( FTC_INode *pinode,
FTC_GQuery gquery,
FTC_Cache cache );
FT_LOCAL( FT_ULong )
ftc_inode_weight( FTC_INode inode );
FT_LOCAL( void )
ftc_snode_free( FTC_SNode snode,
FTC_Cache cache );
FT_LOCAL( FT_Error )
ftc_snode_new( FTC_SNode *psnode,
FTC_GQuery gquery,
ftc_inode_new( FTC_Node *pinode,
FT_Pointer gquery,
FTC_Cache cache );
FT_LOCAL( FT_ULong )
ftc_snode_weight( FTC_SNode snode );
ftc_inode_weight( FTC_Node inode,
FTC_Cache cache );
FT_LOCAL( void )
ftc_snode_free( FTC_Node snode,
FTC_Cache cache );
FT_LOCAL( FT_Error )
ftc_snode_new( FTC_Node *psnode,
FT_Pointer gquery,
FTC_Cache cache );
FT_LOCAL( FT_ULong )
ftc_snode_weight( FTC_Node snode,
FTC_Cache cache );
FT_LOCAL( FT_Bool )
ftc_snode_compare( FTC_SNode snode,
FTC_GQuery gquery,
ftc_snode_compare( FTC_Node snode,
FT_Pointer gquery,
FTC_Cache cache );
FT_LOCAL( FT_Bool )
ftc_gnode_compare( FTC_GNode gnode,
FTC_GQuery gquery );
ftc_gnode_compare( FTC_Node gnode,
FT_Pointer gquery,
FTC_Cache cache );
FT_LOCAL( FT_Error )
ftc_gcache_init( FTC_GCache cache );
ftc_gcache_init( FTC_Cache cache );
FT_LOCAL( void )
ftc_gcache_done( FTC_GCache cache );
ftc_gcache_done( FTC_Cache cache );
FT_LOCAL( FT_Error )

60
src/cache/ftccmap.c vendored
View File

@ -98,10 +98,11 @@
/* no need for specific finalizer; we use `ftc_node_done' directly */
FT_CALLBACK_DEF( void )
ftc_cmap_node_free( FTC_CMapNode node,
FTC_Cache cache )
ftc_cmap_node_free( FTC_Node ftcnode,
FTC_Cache cache )
{
FT_Memory memory = cache->memory;
FTC_CMapNode node = (FTC_CMapNode)ftcnode;
FT_Memory memory = cache->memory;
FT_FREE( node );
@ -110,14 +111,16 @@
/* initialize a new cmap node */
FT_CALLBACK_DEF( FT_Error )
ftc_cmap_node_new( FTC_CMapNode *anode,
FTC_CMapQuery query,
FTC_Cache cache )
ftc_cmap_node_new( FTC_Node *ftcanode,
FT_Pointer ftcquery,
FTC_Cache cache )
{
FT_Error error;
FT_Memory memory = cache->memory;
FTC_CMapNode node;
FT_UInt nn;
FTC_CMapNode *anode = (FTC_CMapNode*)ftcanode;
FTC_CMapQuery query = (FTC_CMapQuery)ftcquery;
FT_Error error;
FT_Memory memory = cache->memory;
FTC_CMapNode node;
FT_UInt nn;
if ( !FT_NEW( node ) )
@ -138,9 +141,11 @@
/* compute the weight of a given cmap node */
FT_CALLBACK_DEF( FT_ULong )
ftc_cmap_node_weight( FTC_CMapNode cnode )
ftc_cmap_node_weight( FTC_Node cnode,
FTC_Cache cache )
{
FT_UNUSED( cnode );
FT_UNUSED( cache );
return sizeof ( *cnode );
}
@ -148,9 +153,15 @@
/* compare a cmap node to a given query */
FT_CALLBACK_DEF( FT_Bool )
ftc_cmap_node_compare( FTC_CMapNode node,
FTC_CMapQuery query )
ftc_cmap_node_compare( FTC_Node ftcnode,
FT_Pointer ftcquery,
FTC_Cache cache )
{
FTC_CMapNode node = (FTC_CMapNode)ftcnode;
FTC_CMapQuery query = (FTC_CMapQuery)ftcquery;
FT_UNUSED( cache );
if ( node->face_id == query->face_id &&
node->cmap_index == query->cmap_index )
{
@ -165,9 +176,14 @@
FT_CALLBACK_DEF( FT_Bool )
ftc_cmap_node_remove_faceid( FTC_CMapNode node,
FTC_FaceID face_id )
ftc_cmap_node_remove_faceid( FTC_Node ftcnode,
FT_Pointer ftcface_id,
FTC_Cache cache )
{
FTC_CMapNode node = (FTC_CMapNode)ftcnode;
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
FT_UNUSED( cache );
return FT_BOOL( node->face_id == face_id );
}
@ -184,15 +200,15 @@
FT_CALLBACK_TABLE_DEF
const FTC_CacheClassRec ftc_cmap_cache_class =
{
(FTC_Node_NewFunc) ftc_cmap_node_new,
(FTC_Node_WeightFunc) ftc_cmap_node_weight,
(FTC_Node_CompareFunc)ftc_cmap_node_compare,
(FTC_Node_CompareFunc)ftc_cmap_node_remove_faceid,
(FTC_Node_FreeFunc) ftc_cmap_node_free,
ftc_cmap_node_new,
ftc_cmap_node_weight,
ftc_cmap_node_compare,
ftc_cmap_node_remove_faceid,
ftc_cmap_node_free,
sizeof ( FTC_CacheRec ),
(FTC_Cache_InitFunc) ftc_cache_init,
(FTC_Cache_DoneFunc) ftc_cache_done,
ftc_cache_init,
ftc_cache_done,
};

20
src/cache/ftcglyph.c vendored
View File

@ -74,9 +74,15 @@
FT_LOCAL_DEF( FT_Bool )
ftc_gnode_compare( FTC_GNode gnode,
FTC_GQuery gquery )
ftc_gnode_compare( FTC_Node ftcgnode,
FT_Pointer ftcgquery,
FTC_Cache cache )
{
FTC_GNode gnode = (FTC_GNode)ftcgnode;
FTC_GQuery gquery = (FTC_GQuery)ftcgquery;
FT_UNUSED( cache );
return FTC_GNode_Compare( gnode, gquery );
}
@ -124,8 +130,11 @@
FT_LOCAL_DEF( FT_Error )
ftc_gcache_init( FTC_GCache cache )
ftc_gcache_init( FTC_Cache ftccache )
{
FTC_GCache cache = (FTC_GCache)ftccache;
return FTC_GCache_Init( cache );
}
@ -139,8 +148,11 @@
FT_LOCAL_DEF( void )
ftc_gcache_done( FTC_GCache cache )
ftc_gcache_done( FTC_Cache ftccache )
{
FTC_GCache cache = (FTC_GCache)ftccache;
FTC_GCache_Done( cache );
}

22
src/cache/ftcimage.c vendored
View File

@ -45,9 +45,12 @@
FT_LOCAL_DEF( void )
ftc_inode_free( FTC_INode inode,
ftc_inode_free( FTC_Node ftcinode,
FTC_Cache cache )
{
FTC_INode inode = (FTC_INode)ftcinode;
FTC_INode_Free( inode, cache );
}
@ -85,10 +88,14 @@
FT_LOCAL_DEF( FT_Error )
ftc_inode_new( FTC_INode *pinode,
FTC_GQuery gquery,
FTC_Cache cache )
ftc_inode_new( FTC_Node *ftcpinode,
FT_Pointer ftcgquery,
FTC_Cache cache )
{
FTC_INode *pinode = (FTC_INode*)ftcpinode;
FTC_GQuery gquery = (FTC_GQuery)ftcgquery;
return FTC_INode_New( pinode, gquery, cache );
}
@ -136,8 +143,13 @@
FT_LOCAL_DEF( FT_ULong )
ftc_inode_weight( FTC_INode inode )
ftc_inode_weight( FTC_Node ftcinode,
FTC_Cache ftccache )
{
FTC_INode inode = (FTC_INode)ftcinode;
FT_UNUSED( ftccache );
return FTC_INode_Weight( inode );
}

107
src/cache/ftcmanag.c vendored
View File

@ -79,9 +79,12 @@
FT_CALLBACK_DEF( void )
ftc_size_node_done( FTC_SizeNode node )
ftc_size_node_done( FTC_MruNode ftcnode,
FT_Pointer data )
{
FT_Size size = node->size;
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
FT_Size size = node->size;
FT_UNUSED( data );
if ( size )
@ -89,11 +92,13 @@
}
FT_CALLBACK_DEF( FT_Bool )
ftc_size_node_compare( FTC_SizeNode node,
FTC_Scaler scaler )
FT_CALLBACK_DEF( FT_Int )
ftc_size_node_compare( FTC_MruNode ftcnode,
FT_Pointer ftcscaler )
{
FTC_Scaler scaler0 = &node->scaler;
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
FTC_Scaler scaler0 = &node->scaler;
if ( FTC_SCALER_COMPARE( scaler0, scaler ) )
@ -106,10 +111,15 @@
FT_CALLBACK_DEF( FT_Error )
ftc_size_node_init( FTC_SizeNode node,
FTC_Scaler scaler,
FTC_Manager manager )
ftc_size_node_init( FTC_MruNode ftcnode,
FT_Pointer ftcscaler,
FT_Pointer ftcmanager )
{
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
FTC_Manager manager = (FTC_Manager)ftcmanager;
node->scaler = scaler[0];
return ftc_scaler_lookup_size( manager, scaler, &node->size );
@ -117,10 +127,15 @@
FT_CALLBACK_DEF( FT_Error )
ftc_size_node_reset( FTC_SizeNode node,
FTC_Scaler scaler,
FTC_Manager manager )
ftc_size_node_reset( FTC_MruNode ftcnode,
FT_Pointer ftcscaler,
FT_Pointer ftcmanager )
{
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
FTC_Manager manager = (FTC_Manager)ftcmanager;
FT_Done_Size( node->size );
node->scaler = scaler[0];
@ -132,20 +147,24 @@
FT_CALLBACK_TABLE_DEF
const FTC_MruListClassRec ftc_size_list_class =
{
sizeof( FTC_SizeNodeRec ),
(FTC_MruNode_CompareFunc)ftc_size_node_compare,
(FTC_MruNode_InitFunc) ftc_size_node_init,
(FTC_MruNode_ResetFunc) ftc_size_node_reset,
(FTC_MruNode_DoneFunc) ftc_size_node_done
sizeof ( FTC_SizeNodeRec ),
ftc_size_node_compare,
ftc_size_node_init,
ftc_size_node_reset,
ftc_size_node_done
};
/* helper function used by ftc_face_node_done */
static FT_Bool
ftc_size_node_compare_faceid( FTC_SizeNode node,
FTC_FaceID face_id )
static FT_Int
ftc_size_node_compare_faceid( FTC_MruNode ftcnode,
FT_Pointer ftcface_id )
{
return FT_BOOL( node->scaler.face_id == face_id );
FTC_SizeNode node = (FTC_SizeNode)ftcnode;
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
return node->scaler.face_id == face_id;
}
@ -202,11 +221,14 @@
FT_CALLBACK_DEF( FT_Error )
ftc_face_node_init( FTC_FaceNode node,
FTC_FaceID face_id,
FTC_Manager manager )
ftc_face_node_init( FTC_MruNode ftcnode,
FT_Pointer ftcface_id,
FT_Pointer ftcmanager )
{
FT_Error error;
FTC_FaceNode node = (FTC_FaceNode)ftcnode;
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
FTC_Manager manager = (FTC_Manager)ftcmanager;
FT_Error error;
node->face_id = face_id;
@ -227,15 +249,18 @@
FT_CALLBACK_DEF( void )
ftc_face_node_done( FTC_FaceNode node,
FTC_Manager manager )
ftc_face_node_done( FTC_MruNode ftcnode,
FT_Pointer ftcmanager )
{
FTC_FaceNode node = (FTC_FaceNode)ftcnode;
FTC_Manager manager = (FTC_Manager)ftcmanager;
/* we must begin by removing all scalers for the target face */
/* from the manager's list */
FTC_MruList_RemoveSelection(
& manager->sizes,
(FTC_MruNode_CompareFunc)ftc_size_node_compare_faceid,
node->face_id );
FTC_MruList_RemoveSelection( &manager->sizes,
ftc_size_node_compare_faceid,
node->face_id );
/* all right, we can discard the face now */
FT_Done_Face( node->face );
@ -244,10 +269,14 @@
}
FT_CALLBACK_DEF( FT_Bool )
ftc_face_node_compare( FTC_FaceNode node,
FTC_FaceID face_id )
FT_CALLBACK_DEF( FT_Int )
ftc_face_node_compare( FTC_MruNode ftcnode,
FT_Pointer ftcface_id )
{
FTC_FaceNode node = (FTC_FaceNode)ftcnode;
FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
return FT_BOOL( node->face_id == face_id );
}
@ -255,12 +284,12 @@
FT_CALLBACK_TABLE_DEF
const FTC_MruListClassRec ftc_face_list_class =
{
sizeof( FTC_FaceNodeRec),
sizeof ( FTC_FaceNodeRec),
(FTC_MruNode_CompareFunc)ftc_face_node_compare,
(FTC_MruNode_InitFunc) ftc_face_node_init,
(FTC_MruNode_ResetFunc) NULL,
(FTC_MruNode_DoneFunc) ftc_face_node_done
ftc_face_node_compare,
ftc_face_node_init,
0, /* FTC_MruNode_ResetFunc */
ftc_face_node_done
};

28
src/cache/ftcsbits.c vendored
View File

@ -77,9 +77,12 @@
FT_LOCAL_DEF( void )
ftc_snode_free( FTC_SNode snode,
ftc_snode_free( FTC_Node ftcsnode,
FTC_Cache cache )
{
FTC_SNode snode = (FTC_SNode)ftcsnode;
FTC_SNode_Free( snode, cache );
}
@ -240,10 +243,14 @@
FT_LOCAL_DEF( FT_Error )
ftc_snode_new( FTC_SNode *psnode,
FTC_GQuery gquery,
ftc_snode_new( FTC_Node *ftcpsnode,
FT_Pointer ftcgquery,
FTC_Cache cache )
{
FTC_SNode *psnode = (FTC_SNode*)ftcpsnode;
FTC_GQuery gquery = (FTC_GQuery)ftcgquery;
return FTC_SNode_New( psnode, gquery, cache );
}
@ -280,8 +287,13 @@
FT_LOCAL_DEF( FT_ULong )
ftc_snode_weight( FTC_SNode snode )
ftc_snode_weight( FTC_Node ftcsnode,
FTC_Cache cache )
{
FTC_SNode snode = (FTC_SNode)ftcsnode;
FT_UNUSED( cache );
return FTC_SNode_Weight( snode );
}
@ -322,10 +334,14 @@
FT_LOCAL_DEF( FT_Bool )
ftc_snode_compare( FTC_SNode snode,
FTC_GQuery gquery,
ftc_snode_compare( FTC_Node ftcsnode,
FT_Pointer ftcgquery,
FTC_Cache cache )
{
FTC_SNode snode = (FTC_SNode)ftcsnode;
FTC_GQuery gquery = (FTC_GQuery)ftcgquery;
return FTC_SNode_Compare( snode, gquery, cache );
}