ftcbasic.c File Reference

#include <ft2build.h>
#include "ftcglyph.h"
#include "ftcimage.h"
#include "ftcsbits.h"
#include "ftccback.h"
#include "ftcerror.h"

Include dependency graph for ftcbasic.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FTC_BasicAttrRec_
struct	FTC_BasicQueryRec_
struct	FTC_BasicFamilyRec_

Macros
#define	FT_COMPONENT   trace_cache
#define	FTC_BASIC_ATTR_COMPARE(a, b)
#define	FTC_BASIC_ATTR_HASH(a)    ( FTC_SCALER_HASH( &(a)->scaler ) + 31 * (a)->load_flags )

Typedefs
typedef struct FTC_BasicAttrRec_	FTC_BasicAttrRec
typedef struct FTC_BasicAttrRec_ *	FTC_BasicAttrs
typedef struct FTC_BasicQueryRec_	FTC_BasicQueryRec
typedef struct FTC_BasicQueryRec_ *	FTC_BasicQuery
typedef struct FTC_BasicFamilyRec_	FTC_BasicFamilyRec
typedef struct FTC_BasicFamilyRec_ *	FTC_BasicFamily

Functions
	ftc_basic_family_compare (FTC_MruNode ftcfamily, FT_Pointer ftcquery)
	ftc_basic_family_init (FTC_MruNode ftcfamily, FT_Pointer ftcquery, FT_Pointer ftccache)
	ftc_basic_family_get_count (FTC_Family ftcfamily, FTC_Manager manager)
	ftc_basic_family_load_bitmap (FTC_Family ftcfamily, FT_UInt gindex, FTC_Manager manager, FT_Face *aface)
	ftc_basic_family_load_glyph (FTC_Family ftcfamily, FT_UInt gindex, FTC_Cache cache, FT_Glyph *aglyph)
	ftc_basic_gnode_compare_faceid (FTC_Node ftcgnode, FT_Pointer ftcface_id, FTC_Cache cache, FT_Bool *list_changed)
	FTC_ImageCache_New (FTC_Manager manager, FTC_ImageCache *acache)
	FTC_ImageCache_Lookup (FTC_ImageCache cache, FTC_ImageType type, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode)
	FTC_ImageCache_LookupScaler (FTC_ImageCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FT_Glyph *aglyph, FTC_Node *anode)
	FTC_SBitCache_New (FTC_Manager manager, FTC_SBitCache *acache)
	FTC_SBitCache_Lookup (FTC_SBitCache cache, FTC_ImageType type, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode)
	FTC_SBitCache_LookupScaler (FTC_SBitCache cache, FTC_Scaler scaler, FT_ULong load_flags, FT_UInt gindex, FTC_SBit *ansbit, FTC_Node *anode)

Variables
static const FTC_IFamilyClassRec	ftc_basic_image_family_class
static const FTC_GCacheClassRec	ftc_basic_image_cache_class
static const FTC_SFamilyClassRec	ftc_basic_sbit_family_class
static const FTC_GCacheClassRec	ftc_basic_sbit_cache_class

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   trace_cache

Definition at line 30 of file ftcbasic.c.

FTC_BASIC_ATTR_COMPARE

#define FTC_BASIC_ATTR_COMPARE	(		a,
			b
	)

Value:

          FT_BOOL( FTC_SCALER_COMPARE( &(a)->scaler, &(b)->scaler ) && \
                   (a)->load_flags == (b)->load_flags               )

Definition at line 44 of file ftcbasic.c.

FTC_BASIC_ATTR_HASH

#define FTC_BASIC_ATTR_HASH

(

a

)

( FTC_SCALER_HASH( &(a)->scaler ) + 31 * (a)->load_flags )

Definition at line 48 of file ftcbasic.c.

Typedef Documentation

FTC_BasicAttrRec

typedef struct FTC_BasicAttrRec_ FTC_BasicAttrRec

FTC_BasicAttrs

typedef struct FTC_BasicAttrRec_ * FTC_BasicAttrs

FTC_BasicFamily

typedef struct FTC_BasicFamilyRec_ * FTC_BasicFamily

FTC_BasicFamilyRec

typedef struct FTC_BasicFamilyRec_ FTC_BasicFamilyRec

FTC_BasicQuery

typedef struct FTC_BasicQueryRec_ * FTC_BasicQuery

FTC_BasicQueryRec

typedef struct FTC_BasicQueryRec_ FTC_BasicQueryRec

Function Documentation

ftc_basic_family_compare()

ftc_basic_family_compare	(	FTC_MruNode	ftcfamily,
		FT_Pointer	ftcquery
	)

Definition at line 69 of file ftcbasic.c.

  {
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
    FTC_BasicQuery   query  = (FTC_BasicQuery)ftcquery;
 
 
    return FTC_BASIC_ATTR_COMPARE( &family->attrs, &query->attrs );
  }

Referenced by FTC_ImageCache_Lookup(), FTC_ImageCache_LookupScaler(), FTC_SBitCache_Lookup(), and FTC_SBitCache_LookupScaler().

ftc_basic_family_get_count()

ftc_basic_family_get_count	(	FTC_Family	ftcfamily,
		FTC_Manager	manager
	)

Definition at line 97 of file ftcbasic.c.

  {
    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,
                                    &face );
 
    if ( error || !face )
      return result;
 
    if ( (FT_ULong)face->num_glyphs > FT_UINT_MAX || 0 > face->num_glyphs )
      FT_TRACE1(( "ftc_basic_family_get_count:"
                  " too large number of glyphs in this face, truncated\n",
                  face->num_glyphs ));
 
    if ( !error )
      result = (FT_UInt)face->num_glyphs;
 
    return result;
  }

ftc_basic_family_init()

ftc_basic_family_init	(	FTC_MruNode	ftcfamily,
		FT_Pointer	ftcquery,
		FT_Pointer	ftccache
	)

Definition at line 81 of file ftcbasic.c.

  {
    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;
  }

ftc_basic_family_load_bitmap()

ftc_basic_family_load_bitmap	(	FTC_Family	ftcfamily,
		FT_UInt	gindex,
		FTC_Manager	manager,
		FT_Face *	aface
	)

Definition at line 125 of file ftcbasic.c.

  {
    FTC_BasicFamily  family = (FTC_BasicFamily)ftcfamily;
    FT_Error         error;
    FT_Size          size;
 
 
    error = FTC_Manager_LookupSize( manager, &family->attrs.scaler, &size );
    if ( !error )
    {
      FT_Face  face = size->face;
 
 
      error = FT_Load_Glyph(
                face,
                gindex,
                (FT_Int)family->attrs.load_flags | FT_LOAD_RENDER );
      if ( !error )
        *aface = face;
    }
 
    return error;
  }

ftc_basic_family_load_glyph()

ftc_basic_family_load_glyph	(	FTC_Family	ftcfamily,
		FT_UInt	gindex,
		FTC_Cache	cache,
		FT_Glyph *	aglyph
	)

Definition at line 154 of file ftcbasic.c.

  {
    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 */
    error = FTC_Manager_LookupSize( cache->manager,
                                    scaler,
                                    &size );
    if ( !error )
    {
      face = size->face;
 
      error = FT_Load_Glyph( face,
                             gindex,
                             (FT_Int)family->attrs.load_flags );
      if ( !error )
      {
        if ( face->glyph->format == FT_GLYPH_FORMAT_BITMAP  ||
             face->glyph->format == FT_GLYPH_FORMAT_OUTLINE )
        {
          /* ok, copy it */
          FT_Glyph  glyph;
 
 
          error = FT_Get_Glyph( face->glyph, &glyph );
          if ( !error )
          {
            *aglyph = glyph;
            goto Exit;
          }
        }
        else
          error = FT_THROW( Invalid_Argument );
      }
    }
 
  Exit:
    return error;
  }

ftc_basic_gnode_compare_faceid()

ftc_basic_gnode_compare_faceid	(	FTC_Node	ftcgnode,
		FT_Pointer	ftcface_id,
		FTC_Cache	cache,
		FT_Bool *	list_changed
	)

Definition at line 204 of file ftcbasic.c.

  {
    FTC_GNode        gnode   = (FTC_GNode)ftcgnode;
    FTC_FaceID       face_id = (FTC_FaceID)ftcface_id;
    FTC_BasicFamily  family  = (FTC_BasicFamily)gnode->family;
    FT_Bool          result;
 
 
    if ( list_changed )
      *list_changed = FALSE;
    result = FT_BOOL( family->attrs.scaler.face_id == face_id );
    if ( result )
    {
      /* we must call this function to avoid this node from appearing
       * in later lookups with the same face_id!
       */
      FTC_GNode_UnselectFamily( gnode, cache );
    }
    return result;
  }

FTC_ImageCache_Lookup()

FTC_ImageCache_Lookup	(	FTC_ImageCache	cache,
		FTC_ImageType	type,
		FT_UInt	gindex,
		FT_Glyph *	aglyph,
		FTC_Node *	anode
	)

Definition at line 284 of file ftcbasic.c.

  {
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Error           error;
    FT_Offset          hash;
 
 
    /* some argument checks are delayed to `FTC_Cache_Lookup' */
    if ( !aglyph )
    {
      error = FT_THROW( Invalid_Argument );
      goto Exit;
    }
 
    *aglyph = NULL;
    if ( anode )
      *anode  = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_ImageType->flags' is of type `FT_Int32'.
     *
     * On 16bit systems, higher bits of type->flags cannot be handled.
     */
#if 0xFFFFFFFFUL > FT_UINT_MAX
    if ( (type->flags & (FT_ULong)FT_UINT_MAX) )
      FT_TRACE1(( "FTC_ImageCache_Lookup:"
                  " higher bits in load_flags 0x%x are dropped\n",
                  (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler.face_id = type->face_id;
    query.attrs.scaler.width   = type->width;
    query.attrs.scaler.height  = type->height;
    query.attrs.load_flags     = (FT_UInt)type->flags;
 
    query.attrs.scaler.pixel = 1;
    query.attrs.scaler.x_res = 0;  /* make compilers happy */
    query.attrs.scaler.y_res = 0;
 
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 
#if 1  /* inlining is about 50% faster! */
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_GNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
#else
    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
                               hash, gindex,
                               FTC_GQUERY( &query ),
                               &node );
#endif
    if ( !error )
    {
      *aglyph = FTC_INODE( node )->glyph;
 
      if ( anode )
      {
        *anode = node;
        node->ref_count++;
      }
    }
 
  Exit:
    return error;
  }

FTC_ImageCache_LookupScaler()

FTC_ImageCache_LookupScaler	(	FTC_ImageCache	cache,
		FTC_Scaler	scaler,
		FT_ULong	load_flags,
		FT_UInt	gindex,
		FT_Glyph *	aglyph,
		FTC_Node *	anode
	)

Definition at line 364 of file ftcbasic.c.

  {
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Error           error;
    FT_Offset          hash;
 
 
    /* some argument checks are delayed to `FTC_Cache_Lookup' */
    if ( !aglyph || !scaler )
    {
      error = FT_THROW( Invalid_Argument );
      goto Exit;
    }
 
    *aglyph = NULL;
    if ( anode )
      *anode  = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_Face->face_flags' is of type `FT_Long'.
     *
     * On long > int systems, higher bits of load_flags cannot be handled.
     */
#if FT_ULONG_MAX > FT_UINT_MAX
    if ( load_flags > FT_UINT_MAX )
      FT_TRACE1(( "FTC_ImageCache_LookupScaler:"
                  " higher bits in load_flags 0x%x are dropped\n",
                  load_flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler     = scaler[0];
    query.attrs.load_flags = (FT_UInt)load_flags;
 
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) + gindex;
 
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_GNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
    if ( !error )
    {
      *aglyph = FTC_INODE( node )->glyph;
 
      if ( anode )
      {
        *anode = node;
        node->ref_count++;
      }
    }
 
  Exit:
    return error;
  }

FTC_ImageCache_New()

FTC_ImageCache_New	(	FTC_Manager	manager,
		FTC_ImageCache *	acache
	)

Definition at line 273 of file ftcbasic.c.

  {
    return FTC_GCache_New( manager, &ftc_basic_image_cache_class,
                           (FTC_GCache*)acache );
  }

FTC_SBitCache_Lookup()

FTC_SBitCache_Lookup	(	FTC_SBitCache	cache,
		FTC_ImageType	type,
		FT_UInt	gindex,
		FTC_SBit *	ansbit,
		FTC_Node *	anode
	)

Definition at line 484 of file ftcbasic.c.

  {
    FT_Error           error;
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Offset          hash;
 
 
    if ( anode )
      *anode = NULL;
 
    /* other argument checks delayed to `FTC_Cache_Lookup' */
    if ( !ansbit )
      return FT_THROW( Invalid_Argument );
 
    *ansbit = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_ImageType->flags' is of type `FT_Int32'.
     *
     * On 16bit systems, higher bits of type->flags cannot be handled.
     */
#if 0xFFFFFFFFUL > FT_UINT_MAX
    if ( (type->flags & (FT_ULong)FT_UINT_MAX) )
      FT_TRACE1(( "FTC_ImageCache_Lookup:"
                  " higher bits in load_flags 0x%x are dropped\n",
                  (FT_ULong)type->flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler.face_id = type->face_id;
    query.attrs.scaler.width   = type->width;
    query.attrs.scaler.height  = type->height;
    query.attrs.load_flags     = (FT_UInt)type->flags;
 
    query.attrs.scaler.pixel = 1;
    query.attrs.scaler.x_res = 0;  /* make compilers happy */
    query.attrs.scaler.y_res = 0;
 
    /* beware, the hash must be the same for all glyph ranges! */
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
           gindex / FTC_SBIT_ITEMS_PER_NODE;
 
#if 1  /* inlining is about 50% faster! */
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_SNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
#else
    error = FTC_GCache_Lookup( FTC_GCACHE( cache ),
                               hash,
                               gindex,
                               FTC_GQUERY( &query ),
                               &node );
#endif
    if ( error )
      goto Exit;
 
    *ansbit = FTC_SNODE( node )->sbits +
              ( gindex - FTC_GNODE( node )->gindex );
 
    if ( anode )
    {
      *anode = node;
      node->ref_count++;
    }
 
  Exit:
    return error;
  }

FTC_SBitCache_LookupScaler()

FTC_SBitCache_LookupScaler	(	FTC_SBitCache	cache,
		FTC_Scaler	scaler,
		FT_ULong	load_flags,
		FT_UInt	gindex,
		FTC_SBit *	ansbit,
		FTC_Node *	anode
	)

Definition at line 566 of file ftcbasic.c.

  {
    FT_Error           error;
    FTC_BasicQueryRec  query;
    FTC_Node           node = 0; /* make compiler happy */
    FT_Offset          hash;
 
 
    if ( anode )
        *anode = NULL;
 
    /* other argument checks delayed to `FTC_Cache_Lookup' */
    if ( !ansbit || !scaler )
        return FT_THROW( Invalid_Argument );
 
    *ansbit = NULL;
 
    /*
     * Internal `FTC_BasicAttr->load_flags' is of type `FT_UInt',
     * but public `FT_Face->face_flags' is of type `FT_Long'.
     *
     * On long > int systems, higher bits of load_flags cannot be handled.
     */
#if FT_ULONG_MAX > FT_UINT_MAX
    if ( load_flags > FT_UINT_MAX )
      FT_TRACE1(( "FTC_ImageCache_LookupScaler:"
                  " higher bits in load_flags 0x%x are dropped\n",
                  load_flags & ~((FT_ULong)FT_UINT_MAX) ));
#endif
 
    query.attrs.scaler     = scaler[0];
    query.attrs.load_flags = (FT_UInt)load_flags;
 
    /* beware, the hash must be the same for all glyph ranges! */
    hash = FTC_BASIC_ATTR_HASH( &query.attrs ) +
             gindex / FTC_SBIT_ITEMS_PER_NODE;
 
    FTC_GCACHE_LOOKUP_CMP( cache,
                           ftc_basic_family_compare,
                           FTC_SNode_Compare,
                           hash, gindex,
                           &query,
                           node,
                           error );
    if ( error )
      goto Exit;
 
    *ansbit = FTC_SNODE( node )->sbits +
              ( gindex - FTC_GNODE( node )->gindex );
 
    if ( anode )
    {
      *anode = node;
      node->ref_count++;
    }
 
  Exit:
    return error;
  }

FTC_SBitCache_New()

FTC_SBitCache_New	(	FTC_Manager	manager,
		FTC_SBitCache *	acache
	)

Definition at line 473 of file ftcbasic.c.

  {
    return FTC_GCache_New( manager, &ftc_basic_sbit_cache_class,
                           (FTC_GCache*)acache );
  }

Variable Documentation

ftc_basic_image_cache_class

const FTC_GCacheClassRec ftc_basic_image_cache_class

static

Initial value:

=
  {
    {
      ftc_inode_new,                  
      ftc_inode_weight,               
      ftc_gnode_compare,              
      ftc_basic_gnode_compare_faceid, 
      ftc_inode_free,                 
 
      sizeof ( FTC_GCacheRec ),
      ftc_gcache_init,                
      ftc_gcache_done                 
    },
 
    (FTC_MruListClass)&ftc_basic_image_family_class
  }

Definition at line 252 of file ftcbasic.c.

Referenced by FTC_ImageCache_New().

ftc_basic_image_family_class

const FTC_IFamilyClassRec ftc_basic_image_family_class

static

Initial value:

=
  {
    {
      sizeof ( FTC_BasicFamilyRec ),
 
      ftc_basic_family_compare, 
      ftc_basic_family_init,    
      NULL,                     
      NULL                      
    },
 
    ftc_basic_family_load_glyph 
  }

Definition at line 236 of file ftcbasic.c.

ftc_basic_sbit_cache_class

const FTC_GCacheClassRec ftc_basic_sbit_cache_class

static

Initial value:

=
  {
    {
      ftc_snode_new,                  
      ftc_snode_weight,               
      ftc_snode_compare,              
      ftc_basic_gnode_compare_faceid, 
      ftc_snode_free,                 
 
      sizeof ( FTC_GCacheRec ),
      ftc_gcache_init,                
      ftc_gcache_done                 
    },
 
    (FTC_MruListClass)&ftc_basic_sbit_family_class
  }

Definition at line 452 of file ftcbasic.c.

Referenced by FTC_SBitCache_New().

ftc_basic_sbit_family_class

const FTC_SFamilyClassRec ftc_basic_sbit_family_class

static

Initial value:

=
  {
    {
      sizeof ( FTC_BasicFamilyRec ),
      ftc_basic_family_compare,     
      ftc_basic_family_init,        
      NULL,                         
      NULL                          
    },
 
    ftc_basic_family_get_count,
    ftc_basic_family_load_bitmap
  }

Definition at line 436 of file ftcbasic.c.