ftccmap.c File Reference

#include <freetype/freetype.h>
#include <freetype/ftcache.h>
#include "ftcmanag.h"
#include <freetype/internal/ftmemory.h>
#include <freetype/internal/ftobjs.h>
#include <freetype/internal/ftdebug.h>
#include "ftccback.h"
#include "ftcerror.h"

Include dependency graph for ftccmap.c:

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

Go to the source code of this file.

Classes
struct	FTC_CMapQueryRec_
struct	FTC_CMapNodeRec_

Macros
#define	FT_COMPONENT   cache
#define	FTC_CMAP_INDICES_MAX   128
#define	FTC_CMAP_HASH(faceid, index, charcode)
#define	FTC_CMAP_QUERY(x)   ((FTC_CMapQuery)(x))
#define	FTC_CMAP_NODE(x)   ( (FTC_CMapNode)( x ) )
#define	FTC_CMAP_UNKNOWN   (FT_UInt16)~0

Typedefs
typedef struct FTC_CMapQueryRec_	FTC_CMapQueryRec
typedef struct FTC_CMapQueryRec_ *	FTC_CMapQuery
typedef struct FTC_CMapNodeRec_	FTC_CMapNodeRec
typedef struct FTC_CMapNodeRec_ *	FTC_CMapNode

Functions
	ftc_cmap_node_free (FTC_Node ftcnode, FTC_Cache cache)
	ftc_cmap_node_new (FTC_Node *ftcanode, FT_Pointer ftcquery, FTC_Cache cache)
	ftc_cmap_node_weight (FTC_Node cnode, FTC_Cache cache)
	ftc_cmap_node_compare (FTC_Node ftcnode, FT_Pointer ftcquery, FTC_Cache cache, FT_Bool *list_changed)
	ftc_cmap_node_remove_faceid (FTC_Node ftcnode, FT_Pointer ftcface_id, FTC_Cache cache, FT_Bool *list_changed)
	FTC_CMapCache_New (FTC_Manager manager, FTC_CMapCache *acache)
	FTC_CMapCache_Lookup (FTC_CMapCache cmap_cache, FTC_FaceID face_id, FT_Int cmap_index, FT_UInt32 char_code)

Variables
static const FTC_CacheClassRec	ftc_cmap_cache_class

Macro Definition Documentation

FT_COMPONENT

#define FT_COMPONENT   cache

Definition at line 30 of file ftccmap.c.

FTC_CMAP_HASH

#define FTC_CMAP_HASH	(		faceid,
			index,
			charcode
	)

Value:

          ( FTC_FACE_ID_HASH( faceid ) + 211 * (index) + \
            ( (charcode) / FTC_CMAP_INDICES_MAX )      )

Definition at line 51 of file ftccmap.c.

FTC_CMAP_INDICES_MAX

#define FTC_CMAP_INDICES_MAX   128

Definition at line 48 of file ftccmap.c.

FTC_CMAP_NODE

#define FTC_CMAP_NODE

(

x

)

( (FTC_CMapNode)( x ) )

Definition at line 77 of file ftccmap.c.

FTC_CMAP_QUERY

#define FTC_CMAP_QUERY

(

x

)

((FTC_CMapQuery)(x))

Definition at line 64 of file ftccmap.c.

FTC_CMAP_UNKNOWN

#define FTC_CMAP_UNKNOWN   (FT_UInt16)~0

Definition at line 81 of file ftccmap.c.

Typedef Documentation

FTC_CMapNode

typedef struct FTC_CMapNodeRec_ * FTC_CMapNode

FTC_CMapNodeRec

typedef struct FTC_CMapNodeRec_ FTC_CMapNodeRec

FTC_CMapQuery

typedef struct FTC_CMapQueryRec_ * FTC_CMapQuery

FTC_CMapQueryRec

typedef struct FTC_CMapQueryRec_ FTC_CMapQueryRec

Function Documentation

ftc_cmap_node_compare()

ftc_cmap_node_compare	(	FTC_Node	ftcnode,
		FT_Pointer	ftcquery,
		FTC_Cache	cache,
		FT_Bool *	list_changed
	)

Definition at line 149 of file ftccmap.c.

  {
    FTC_CMapNode   node  = (FTC_CMapNode)ftcnode;
    FTC_CMapQuery  query = (FTC_CMapQuery)ftcquery;
    FT_UNUSED( cache );
 
 
    if ( list_changed )
      *list_changed = FALSE;
    if ( node->face_id    == query->face_id    &&
         node->cmap_index == query->cmap_index )
    {
      FT_UInt32  offset = (FT_UInt32)( query->char_code - node->first );
 
 
      return FT_BOOL( offset < FTC_CMAP_INDICES_MAX );
    }
 
    return 0;
  }

Referenced by FTC_CMapCache_Lookup().

ftc_cmap_node_free()

ftc_cmap_node_free	(	FTC_Node	ftcnode,
		FTC_Cache	cache
	)

Definition at line 94 of file ftccmap.c.

  {
    FTC_CMapNode  node   = (FTC_CMapNode)ftcnode;
    FT_Memory     memory = cache->memory;
 
 
    FT_FREE( node );
  }

ftc_cmap_node_new()

ftc_cmap_node_new	(	FTC_Node *	ftcanode,
		FT_Pointer	ftcquery,
		FTC_Cache	cache
	)

Definition at line 107 of file ftccmap.c.

  {
    FTC_CMapNode  *anode  = (FTC_CMapNode*)ftcanode;
    FTC_CMapQuery  query  = (FTC_CMapQuery)ftcquery;
    FT_Error       error;
    FT_Memory      memory = cache->memory;
    FTC_CMapNode   node   = NULL;
    FT_UInt        nn;
 
 
    if ( !FT_NEW( node ) )
    {
      node->face_id    = query->face_id;
      node->cmap_index = query->cmap_index;
      node->first      = (query->char_code / FTC_CMAP_INDICES_MAX) *
                         FTC_CMAP_INDICES_MAX;
 
      for ( nn = 0; nn < FTC_CMAP_INDICES_MAX; nn++ )
        node->indices[nn] = FTC_CMAP_UNKNOWN;
    }
 
    *anode = node;
    return error;
  }

ftc_cmap_node_remove_faceid()

ftc_cmap_node_remove_faceid	(	FTC_Node	ftcnode,
		FT_Pointer	ftcface_id,
		FTC_Cache	cache,
		FT_Bool *	list_changed
	)

Definition at line 175 of file ftccmap.c.

  {
    FTC_CMapNode  node    = (FTC_CMapNode)ftcnode;
    FTC_FaceID    face_id = (FTC_FaceID)ftcface_id;
    FT_UNUSED( cache );
 
 
    if ( list_changed )
      *list_changed = FALSE;
    return FT_BOOL( node->face_id == face_id );
  }

ftc_cmap_node_weight()

ftc_cmap_node_weight	(	FTC_Node	cnode,
		FTC_Cache	cache
	)

Definition at line 137 of file ftccmap.c.

  {
    FT_UNUSED( cnode );
    FT_UNUSED( cache );
 
    return sizeof ( *cnode );
  }

FTC_CMapCache_Lookup()

FTC_CMapCache_Lookup	(	FTC_CMapCache	cmap_cache,
		FTC_FaceID	face_id,
		FT_Int	cmap_index,
		FT_UInt32	char_code
	)

Definition at line 230 of file ftccmap.c.

  {
    FTC_Cache         cache = FTC_CACHE( cmap_cache );
    FTC_CMapQueryRec  query;
    FTC_Node          node;
    FT_Error          error;
    FT_UInt           gindex = 0;
    FT_Offset         hash;
    FT_Int            no_cmap_change = 0;
 
 
    if ( cmap_index < 0 )
    {
      /* Treat a negative cmap index as a special value, meaning that you */
      /* don't want to change the FT_Face's character map through this    */
      /* call.  This can be useful if the face requester callback already */
      /* sets the face's charmap to the appropriate value.                */
 
      no_cmap_change = 1;
      cmap_index     = 0;
    }
 
    if ( !cache )
    {
      FT_TRACE0(( "FTC_CMapCache_Lookup: bad arguments, returning 0\n" ));
      return 0;
    }
 
    query.face_id    = face_id;
    query.cmap_index = (FT_UInt)cmap_index;
    query.char_code  = char_code;
 
    hash = FTC_CMAP_HASH( face_id, (FT_UInt)cmap_index, char_code );
 
#if 1
    FTC_CACHE_LOOKUP_CMP( cache, ftc_cmap_node_compare, hash, &query,
                          node, error );
#else
    error = FTC_Cache_Lookup( cache, hash, &query, &node );
#endif
    if ( error )
      goto Exit;
 
    FT_ASSERT( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first ) <
                FTC_CMAP_INDICES_MAX );
 
    /* something rotten can happen with rogue clients */
    if ( (FT_UInt)( char_code - FTC_CMAP_NODE( node )->first >=
                    FTC_CMAP_INDICES_MAX ) )
      return 0; /* XXX: should return appropriate error */
 
    gindex = FTC_CMAP_NODE( node )->indices[char_code -
                                            FTC_CMAP_NODE( node )->first];
    if ( gindex == FTC_CMAP_UNKNOWN )
    {
      FT_Face  face;
 
 
      gindex = 0;
 
      error = FTC_Manager_LookupFace( cache->manager,
                                      FTC_CMAP_NODE( node )->face_id,
                                      &face );
      if ( error )
        goto Exit;
 
      if ( (FT_UInt)cmap_index < (FT_UInt)face->num_charmaps )
      {
        FT_CharMap  old, cmap  = NULL;
 
 
        old  = face->charmap;
        cmap = face->charmaps[cmap_index];
 
        if ( old != cmap && !no_cmap_change )
          FT_Set_Charmap( face, cmap );
 
        gindex = FT_Get_Char_Index( face, char_code );
 
        if ( old != cmap && !no_cmap_change )
          FT_Set_Charmap( face, old );
      }
 
      FTC_CMAP_NODE( node )->indices[char_code -
                                     FTC_CMAP_NODE( node )->first]
        = (FT_UShort)gindex;
    }
 
  Exit:
    return gindex;
  }

FTC_CMapCache_New()

FTC_CMapCache_New	(	FTC_Manager	manager,
		FTC_CMapCache *	acache
	)

Definition at line 218 of file ftccmap.c.

  {
    return FTC_Manager_RegisterCache( manager,
                                      &ftc_cmap_cache_class,
                                      FTC_CACHE_P( acache ) );
  }

Variable Documentation

ftc_cmap_cache_class

const FTC_CacheClassRec ftc_cmap_cache_class

static

Initial value:

=
  {
    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_init,              
    ftc_cache_done,              
  }

Definition at line 201 of file ftccmap.c.

Referenced by FTC_CMapCache_New().