diff options
| author | Mike Gabriel <mike.gabriel@das-netzwerkteam.de> | 2015-02-02 15:02:49 +0100 |
|---|---|---|
| committer | Mike Gabriel <mike.gabriel@das-netzwerkteam.de> | 2015-02-02 15:02:49 +0100 |
| commit | b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73 (patch) | |
| tree | 4361edef0d42d5bf5ac984ef72b4fac35426eae7 /nx-X11/extras/freetype2/include/freetype/cache | |
| parent | 0d5a83e986f39982c0924652a3662e60b1f23162 (diff) | |
| download | nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.tar.gz nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.tar.bz2 nx-libs-b16b9e4656e7199c2aec74a4c8ebc7a875d3ba73.zip | |
massive reduction of unneeded files
Diffstat (limited to 'nx-X11/extras/freetype2/include/freetype/cache')
7 files changed, 0 insertions, 1404 deletions
diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftccache.h b/nx-X11/extras/freetype2/include/freetype/cache/ftccache.h deleted file mode 100644 index 7c7688dba..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftccache.h +++ /dev/null @@ -1,272 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftccache.h */ -/* */ -/* FreeType internal cache interface (specification). */ -/* */ -/* Copyright 2000-2001, 2002, 2003, 2004 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. */ -/* */ -/***************************************************************************/ - - -#ifndef __FTCCACHE_H__ -#define __FTCCACHE_H__ - - -#include FT_CACHE_INTERNAL_MRU_H - -FT_BEGIN_HEADER - - /* handle to cache object */ - typedef struct FTC_CacheRec_* FTC_Cache; - - /* handle to cache class */ - typedef const struct FTC_CacheClassRec_* FTC_CacheClass; - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** CACHE NODE DEFINITIONS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /*************************************************************************/ - /* */ - /* Each cache controls one or more cache nodes. Each node is part of */ - /* the global_lru list of the manager. Its `data' field however is used */ - /* as a reference count for now. */ - /* */ - /* A node can be anything, depending on the type of information held by */ - /* the cache. It can be an individual glyph image, a set of bitmaps */ - /* glyphs for a given size, some metrics, etc. */ - /* */ - /*************************************************************************/ - - /* structure size should be 20 bytes on 32-bits machines */ - typedef struct FTC_NodeRec_ - { - FTC_MruNodeRec mru; /* circular mru list pointer */ - FTC_Node link; /* used for hashing */ - FT_UInt32 hash; /* used for hashing too */ - FT_UShort cache_index; /* index of cache the node belongs to */ - FT_Short ref_count; /* reference count for this node */ - - } FTC_NodeRec; - - -#define FTC_NODE( x ) ( (FTC_Node)(x) ) -#define FTC_NODE_P( x ) ( (FTC_Node*)(x) ) - -#define FTC_NODE__NEXT(x) FTC_NODE( (x)->mru.next ) -#define FTC_NODE__PREV(x) FTC_NODE( (x)->mru.prev ) - - - /*************************************************************************/ - /* */ - /* These functions are exported so that they can be called from */ - /* user-provided cache classes; otherwise, they are really part of the */ - /* cache sub-system internals. */ - /* */ - - /* reserved for manager's use */ - FT_EXPORT( void ) - ftc_node_destroy( FTC_Node node, - FTC_Manager manager ); - - - /*************************************************************************/ - /*************************************************************************/ - /***** *****/ - /***** CACHE DEFINITIONS *****/ - /***** *****/ - /*************************************************************************/ - /*************************************************************************/ - - /* initialize a new cache node */ - typedef FT_Error - (*FTC_Node_NewFunc)( FTC_Node *pnode, - FT_Pointer query, - FTC_Cache cache ); - - typedef FT_ULong - (*FTC_Node_WeightFunc)( FTC_Node node, - FTC_Cache cache ); - - /* compare a node to a given key pair */ - typedef FT_Bool - (*FTC_Node_CompareFunc)( FTC_Node node, - FT_Pointer key, - FTC_Cache cache ); - - - typedef void - (*FTC_Node_FreeFunc)( FTC_Node node, - FTC_Cache cache ); - - typedef FT_Error - (*FTC_Cache_InitFunc)( FTC_Cache cache ); - - typedef void - (*FTC_Cache_DoneFunc)( FTC_Cache cache ); - - - typedef struct FTC_CacheClassRec_ - { - FTC_Node_NewFunc node_new; - FTC_Node_WeightFunc node_weight; - FTC_Node_CompareFunc node_compare; - FTC_Node_CompareFunc node_remove_faceid; - FTC_Node_FreeFunc node_free; - - FT_UInt cache_size; - FTC_Cache_InitFunc cache_init; - FTC_Cache_DoneFunc cache_done; - - } FTC_CacheClassRec; - - - /* each cache really implements a dynamic hash table to manage its nodes */ - typedef struct FTC_CacheRec_ - { - FT_UFast p; - FT_UFast mask; - FT_Long slack; - FTC_Node* buckets; - - FTC_CacheClassRec clazz; /* local copy, for speed */ - - FTC_Manager manager; - FT_Memory memory; - FT_UInt index; /* in manager's table */ - - FTC_CacheClass org_class; /* original class pointer */ - - } FTC_CacheRec; - - -#define FTC_CACHE( x ) ( (FTC_Cache)(x) ) -#define FTC_CACHE_P( x ) ( (FTC_Cache*)(x) ) - - - /* default cache initialize */ - FT_EXPORT( FT_Error ) - FTC_Cache_Init( FTC_Cache cache ); - - /* default cache finalizer */ - FT_EXPORT( void ) - FTC_Cache_Done( FTC_Cache cache ); - - /* Call this function to lookup the cache. If no corresponding - * node is found, a new one is automatically created. This function - * is capable of flushing the cache adequately to make room for the - * new cache object. - */ - FT_EXPORT( FT_Error ) - FTC_Cache_Lookup( FTC_Cache cache, - FT_UInt32 hash, - FT_Pointer query, - FTC_Node *anode ); - - FT_EXPORT( FT_Error ) - FTC_Cache_NewNode( FTC_Cache cache, - FT_UInt32 hash, - FT_Pointer query, - FTC_Node *anode ); - - /* Remove all nodes that relate to a given face_id. This is useful - * when un-installing fonts. Note that if a cache node relates to - * the face_id, but is locked (i.e., has 'ref_count > 0'), the node - * will _not_ be destroyed, but its internal face_id reference will - * be modified. - * - * The final result will be that the node will never come back - * in further lookup requests, and will be flushed on demand from - * the cache normally when its reference count reaches 0. - */ - FT_EXPORT( void ) - FTC_Cache_RemoveFaceID( FTC_Cache cache, - FTC_FaceID face_id ); - - -#ifdef FTC_INLINE - -#define FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ) \ - FT_BEGIN_STMNT \ - FTC_Node *_bucket, *_pnode, _node; \ - FTC_Cache _cache = FTC_CACHE(cache); \ - FT_UInt32 _hash = (FT_UInt32)(hash); \ - FTC_Node_CompareFunc _nodcomp = (FTC_Node_CompareFunc)(nodecmp); \ - FT_UInt _idx; \ - \ - \ - error = 0; \ - node = NULL; \ - _idx = _hash & _cache->mask; \ - if ( _idx < _cache->p ) \ - _idx = _hash & ( _cache->mask*2 + 1 ); \ - \ - _bucket = _pnode = _cache->buckets + _idx; \ - for (;;) \ - { \ - _node = *_pnode; \ - if ( _node == NULL ) \ - goto _NewNode; \ - \ - if ( _node->hash == _hash && _nodcomp( _node, query, _cache ) ) \ - break; \ - \ - _pnode = &_node->link; \ - } \ - \ - if ( _node != *_bucket ) \ - { \ - *_pnode = _node->link; \ - _node->link = *_bucket; \ - *_bucket = _node; \ - } \ - \ - { \ - FTC_Manager _manager = _cache->manager; \ - \ - \ - if ( _node != _manager->nodes_list ) \ - FTC_MruNode_Up( (FTC_MruNode*)&_manager->nodes_list, \ - (FTC_MruNode)_node ); \ - } \ - goto _Ok; \ - \ - _NewNode: \ - error = FTC_Cache_NewNode( _cache, _hash, query, &_node ); \ - \ - _Ok: \ - *(FTC_Node*)&(node) = _node; \ - FT_END_STMNT - -#else /* !FTC_INLINE */ - -#define FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ) \ - FT_BEGIN_STMNT \ - error = FTC_Cache_Lookup( FTC_CACHE( cache ), hash, query, \ - (FTC_Node*)&(node) ); \ - FT_END_STMNT - -#endif /* !FTC_INLINE */ - - /* */ - -FT_END_HEADER - - -#endif /* __FTCCACHE_H__ */ - - -/* END */ diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftccmap.h b/nx-X11/extras/freetype2/include/freetype/cache/ftccmap.h deleted file mode 100644 index a41989b28..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftccmap.h +++ /dev/null @@ -1,216 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftccmap.h */ -/* */ -/* FreeType charmap cache (specification). */ -/* */ -/* Copyright 2000-2001, 2003 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. */ -/* */ -/***************************************************************************/ - - -#ifndef __FTCCMAP_H__ -#define __FTCCMAP_H__ - -#include <ft2build.h> -#include FT_CACHE_H - - -FT_BEGIN_HEADER - - - /*************************************************************************/ - /* */ - /* <Section> */ - /* cache_subsystem */ - /* */ - /*************************************************************************/ - - /*************************************************************************/ - /* */ - /* @type: */ - /* FTC_CMapCache */ - /* */ - /* @description: */ - /* An opaque handle used to manager a charmap cache. This cache is */ - /* to hold character codes -> glyph indices mappings. */ - /* */ - typedef struct FTC_CMapCacheRec_* FTC_CMapCache; - - - /*************************************************************************/ - /* */ - /* @type: */ - /* FTC_CMapDesc */ - /* */ - /* @description: */ - /* A handle to an @FTC_CMapDescRec structure used to describe a given */ - /* charmap in a charmap cache. */ - /* */ - /* Each @FTC_CMapDesc describes which charmap (of which @FTC_FaceID) */ - /* we want to use in @FTC_CMapCache_Lookup. */ - /* */ - typedef struct FTC_CMapDescRec_* FTC_CMapDesc; - - - /*************************************************************************/ - /* */ - /* @enum: */ - /* FTC_CMapType */ - /* */ - /* @description: */ - /* The list of valid @FTC_CMapDesc types. They indicate how we want */ - /* to address a charmap within an @FTC_FaceID. */ - /* */ - /* @values: */ - /* FTC_CMAP_BY_INDEX :: */ - /* Address a charmap by its index in the corresponding @FT_Face. */ - /* */ - /* FTC_CMAP_BY_ENCODING :: */ - /* Use a @FT_Face charmap that corresponds to a given encoding. */ - /* */ - /* FTC_CMAP_BY_ID :: */ - /* Use an @FT_Face charmap that corresponds to a given */ - /* (platform,encoding) ID. See @FTC_CMapIdRec. */ - /* */ - typedef enum FTC_CMapType_ - { - FTC_CMAP_BY_INDEX = 0, - FTC_CMAP_BY_ENCODING = 1, - FTC_CMAP_BY_ID = 2 - - } FTC_CMapType; - - - /*************************************************************************/ - /* */ - /* @struct: */ - /* FTC_CMapIdRec */ - /* */ - /* @description: */ - /* A short structure to identify a charmap by a (platform,encoding) */ - /* pair of values. */ - /* */ - /* @fields: */ - /* platform :: The platform ID. */ - /* */ - /* encoding :: The encoding ID. */ - /* */ - typedef struct FTC_CMapIdRec_ - { - FT_UInt platform; - FT_UInt encoding; - - } FTC_CMapIdRec; - - - /*************************************************************************/ - /* */ - /* @struct: */ - /* FTC_CMapDescRec */ - /* */ - /* @description: */ - /* A structure to describe a given charmap to @FTC_CMapCache. */ - /* */ - /* @fields: */ - /* face_id :: @FTC_FaceID of the face this charmap belongs to. */ - /* */ - /* type :: The type of charmap, see @FTC_CMapType. */ - /* */ - /* u.index :: For @FTC_CMAP_BY_INDEX types, this is the charmap */ - /* index (within a @FT_Face) we want to use. */ - /* */ - /* u.encoding :: For @FTC_CMAP_BY_ENCODING types, this is the charmap */ - /* encoding we want to use. see @FT_Encoding. */ - /* */ - /* u.id :: For @FTC_CMAP_BY_ID types, this is the */ - /* (platform,encoding) pair we want to use. see */ - /* @FTC_CMapIdRec and @FT_CharMapRec. */ - /* */ - typedef struct FTC_CMapDescRec_ - { - FTC_FaceID face_id; - FTC_CMapType type; - - union - { - FT_UInt index; - FT_Encoding encoding; - FTC_CMapIdRec id; - - } u; - - } FTC_CMapDescRec; - - - /*************************************************************************/ - /* */ - /* @function: */ - /* FTC_CMapCache_New */ - /* */ - /* @description: */ - /* Creates a new charmap cache. */ - /* */ - /* @input: */ - /* manager :: A handle to the cache manager. */ - /* */ - /* @output: */ - /* acache :: A new cache handle. NULL in case of error. */ - /* */ - /* @return: */ - /* FreeType error code. 0 means success. */ - /* */ - /* @note: */ - /* Like all other caches, this one will be destroyed with the cache */ - /* manager. */ - /* */ - FT_EXPORT( FT_Error ) - FTC_CMapCache_New( FTC_Manager manager, - FTC_CMapCache *acache ); - - - /*************************************************************************/ - /* */ - /* @function: */ - /* FTC_CMapCache_Lookup */ - /* */ - /* @description: */ - /* Translates a character code into a glyph index, using the charmap */ - /* cache. */ - /* */ - /* @input: */ - /* cache :: A charmap cache handle. */ - /* */ - /* cmap_desc :: A charmap descriptor handle. */ - /* */ - /* char_code :: The character code (in the corresponding charmap). */ - /* */ - /* @return: */ - /* Glyph index. 0 means "no glyph". */ - /* */ - /* @note: */ - /* This function doesn't return @FTC_Node handles, since there is no */ - /* real use for them with typical uses of charmaps. */ - /* */ - FT_EXPORT( FT_UInt ) - FTC_CMapCache_Lookup( FTC_CMapCache cache, - FTC_CMapDesc cmap_desc, - FT_UInt32 char_code ); - - /* */ - - -FT_END_HEADER - - -#endif /* __FTCCMAP_H__ */ - - -/* END */ diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftcglyph.h b/nx-X11/extras/freetype2/include/freetype/cache/ftcglyph.h deleted file mode 100644 index be237f934..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftcglyph.h +++ /dev/null @@ -1,295 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftcglyph.h */ -/* */ -/* FreeType abstract glyph cache (specification). */ -/* */ -/* Copyright 2000-2001, 2003, 2004 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. */ -/* */ -/***************************************************************************/ - - - /* - * - * FTC_GCache is an _abstract_ cache object optimized to store glyph - * data. It works as follows: - * - * - It manages FTC_GNode objects. Each one of them can hold one or more - * glyph `items'. Item types are not specified in the FTC_GCache but - * in classes that extend it. - * - * - Glyph attributes, like face ID, character size, render mode, etc., - * can be grouped into abstract `glyph families'. This avoids storing - * the attributes within the FTC_GCache, since it is likely that many - * FTC_GNodes will belong to the same family in typical uses. - * - * - Each FTC_GNode is thus an FTC_Node with two additional fields: - * - * * gindex: A glyph index, or the first index in a glyph range. - * * family: A pointer to a glyph `family'. - * - * - Family types are not fully specific in the FTC_Family type, but - * by classes that extend it. - * - * Note that both FTC_ImageCache and FTC_SBitCache extend FTC_GCache. - * They share an FTC_Family sub-class called FTC_BasicFamily which is - * used to store the following data: face ID, pixel/point sizes, load - * flags. For more details see the file `src/cache/ftcbasic.c'. - * - * Client applications can extend FTC_GNode with their own FTC_GNode - * and FTC_Family sub-classes to implement more complex caches (e.g., - * handling automatic synthesis, like obliquing & emboldening, colored - * glyphs, etc.). - * - * See also the FTC_ICache & FTC_SCache classes in `ftcimage.h' and - * `ftcsbits.h', which both extend FTC_GCache with additional - * optimizations. - * - * A typical FTC_GCache implementation must provide at least the - * following: - * - * - FTC_GNode sub-class, e.g. MyNode, with relevant methods: - * my_node_new (must call FTC_GNode_Init) - * my_node_free (must call FTC_GNode_Done) - * my_node_compare (must call FTC_GNode_Compare) - * my_node_remove_faceid (must call ftc_gnode_unselect in case - * of match) - * - * - FTC_Family sub-class, e.g. MyFamily, with relevant methods: - * my_family_compare - * my_family_init - * my_family_reset (optional) - * my_family_done - * - * - FTC_GQuery sub-class, e.g. MyQuery, to hold cache-specific query - * data. - * - * - Constant structures for a FTC_GNodeClass. - * - * - MyCacheNew() can be implemented easily as a call to the convenience - * function FTC_GCache_New. - * - * - MyCacheLookup with a call to FTC_GCache_Lookup. This function will - * automatically: - * - * - Search for the corresponding family in the cache, or create - * a new one if necessary. Put it in FTC_GQUERY(myquery).family - * - * - Call FTC_Cache_Lookup. - * - * If it returns NULL, you should create a new node, then call - * ftc_cache_add as usual. - */ - - - /*************************************************************************/ - /* */ - /* Important: The functions defined in this file are only used to */ - /* implement an abstract glyph cache class. You need to */ - /* provide additional logic to implement a complete cache. */ - /* */ - /*************************************************************************/ - - - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /********* *********/ - /********* WARNING, THIS IS BETA CODE. *********/ - /********* *********/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - - -#ifndef __FTCGLYPH_H__ -#define __FTCGLYPH_H__ - - -#include <ft2build.h> -#include FT_CACHE_INTERNAL_MANAGER_H - - -FT_BEGIN_HEADER - - - /* - * We can group glyphs into `families'. Each family correspond to a - * given face ID, character size, transform, etc. - * - * Families are implemented as MRU list nodes. They are - * reference-counted. - */ - - typedef struct FTC_FamilyRec_ - { - FTC_MruNodeRec mrunode; - FT_UInt num_nodes; /* current number of nodes in this family */ - FTC_Cache cache; - FTC_MruListClass clazz; - - } FTC_FamilyRec, *FTC_Family; - -#define FTC_FAMILY(x) ( (FTC_Family)(x) ) -#define FTC_FAMILY_P(x) ( (FTC_Family*)(x) ) - - - typedef struct FTC_GNodeRec_ - { - FTC_NodeRec node; - FTC_Family family; - FT_UInt gindex; - - } FTC_GNodeRec, *FTC_GNode; - -#define FTC_GNODE( x ) ( (FTC_GNode)(x) ) -#define FTC_GNODE_P( x ) ( (FTC_GNode*)(x) ) - - - typedef struct FTC_GQueryRec_ - { - FT_UInt gindex; - FTC_Family family; - - } FTC_GQueryRec, *FTC_GQuery; - -#define FTC_GQUERY( x ) ( (FTC_GQuery)(x) ) - - - /*************************************************************************/ - /* */ - /* These functions are exported so that they can be called from */ - /* user-provided cache classes; otherwise, they are really part of the */ - /* cache sub-system internals. */ - /* */ - - /* must be called by derived FTC_Node_InitFunc routines */ - FT_EXPORT( void ) - FTC_GNode_Init( FTC_GNode node, - FT_UInt gindex, /* glyph index for node */ - FTC_Family family ); - - /* returns TRUE iff the query's glyph index correspond to the node; */ - /* this assumes that the "family" and "hash" fields of the query are */ - /* already correctly set */ - FT_EXPORT( FT_Bool ) - FTC_GNode_Compare( FTC_GNode gnode, - FTC_GQuery gquery ); - - /* call this function to clear a node's family -- this is necessary */ - /* to implement the `node_remove_faceid' cache method correctly */ - FT_EXPORT( void ) - FTC_GNode_UnselectFamily( FTC_GNode gnode, - FTC_Cache cache ); - - /* must be called by derived FTC_Node_DoneFunc routines */ - FT_EXPORT( void ) - FTC_GNode_Done( FTC_GNode node, - FTC_Cache cache ); - - - FT_EXPORT( void ) - FTC_Family_Init( FTC_Family family, - FTC_Cache cache ); - - typedef struct FTC_GCacheRec_ - { - FTC_CacheRec cache; - FTC_MruListRec families; - - } FTC_GCacheRec, *FTC_GCache; - -#define FTC_GCACHE( x ) ((FTC_GCache)(x)) - - - /* can be used as @FTC_Cache_InitFunc */ - FT_EXPORT( FT_Error ) - FTC_GCache_Init( FTC_GCache cache ); - - - /* can be used as @FTC_Cache_DoneFunc */ - FT_EXPORT( void ) - FTC_GCache_Done( FTC_GCache cache ); - - - /* the glyph cache class adds fields for the family implementation */ - typedef struct FTC_GCacheClassRec_ - { - FTC_CacheClassRec clazz; - FTC_MruListClass family_class; - - } FTC_GCacheClassRec; - - typedef const FTC_GCacheClassRec* FTC_GCacheClass; - -#define FTC_GCACHE_CLASS( x ) ((FTC_GCacheClass)(x)) - -#define FTC_CACHE__GCACHE_CLASS( x ) \ - FTC_GCACHE_CLASS( FTC_CACHE(x)->org_class ) -#define FTC_CACHE__FAMILY_CLASS( x ) \ - ((FTC_MruListClass) FTC_CACHE__GCACHE_CLASS(x)->family_class) - - - /* convenience function; use it instead of FTC_Manager_Register_Cache */ - FT_EXPORT( FT_Error ) - FTC_GCache_New( FTC_Manager manager, - FTC_GCacheClass clazz, - FTC_GCache *acache ); - - FT_EXPORT( FT_Error ) - FTC_GCache_Lookup( FTC_GCache cache, - FT_UInt32 hash, - FT_UInt gindex, - FTC_GQuery query, - FTC_Node *anode ); - - -#ifdef FTC_INLINE - -#define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \ - gindex, query, node, error ) \ - FT_BEGIN_STMNT \ - FTC_GCache _gcache = FTC_GCACHE( cache ); \ - FTC_GQuery _gquery = (FTC_GQuery)( query ); \ - FTC_MruNode_CompareFunc _fcompare = (FTC_MruNode_CompareFunc)(famcmp); \ - \ - \ - _gquery->gindex = (gindex); \ - \ - FTC_MRULIST_LOOKUP_CMP( &_gcache->families, _gquery, _fcompare, \ - _gquery->family, error ); \ - if ( !error ) \ - FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ); \ - FT_END_STMNT - /* */ - -#else /* !FTC_INLINE */ - -#define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \ - gindex, query, node, error ) \ - FT_BEGIN_STMNT \ - error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, \ - FTC_GQUERY( query ), (FTC_Node*)&(node) ); \ - FT_END_STMNT - -#endif /* !FTC_INLINE */ - - -FT_END_HEADER - - -#endif /* __FTCGLYPH_H__ */ - - -/* END */ diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftcimage.h b/nx-X11/extras/freetype2/include/freetype/cache/ftcimage.h deleted file mode 100644 index 1bf12db13..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftcimage.h +++ /dev/null @@ -1,104 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftcimage.h */ -/* */ -/* FreeType Generic Image cache (specification) */ -/* */ -/* Copyright 2000-2001, 2002, 2003 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. */ -/* */ -/***************************************************************************/ - - - /* - * FTC_ICache is an _abstract_ cache used to store a single FT_Glyph - * image per cache node. - * - * FTC_ICache extends FTC_GCache. For an implementation example, - * see FTC_ImageCache in `src/cache/ftbasic.c'. - */ - - - /*************************************************************************/ - /* */ - /* Each image cache really manages FT_Glyph objects. */ - /* */ - /*************************************************************************/ - - -#ifndef __FTCIMAGE_H__ -#define __FTCIMAGE_H__ - - -#include <ft2build.h> -#include FT_CACHE_H -#include FT_CACHE_INTERNAL_GLYPH_H - -FT_BEGIN_HEADER - - - /* the FT_Glyph image node type - we store only 1 glyph per node */ - typedef struct FTC_INodeRec_ - { - FTC_GNodeRec gnode; - FT_Glyph glyph; - - } FTC_INodeRec, *FTC_INode; - -#define FTC_INODE( x ) ( (FTC_INode)( x ) ) -#define FTC_INODE_GINDEX( x ) FTC_GNODE(x)->gindex -#define FTC_INODE_FAMILY( x ) FTC_GNODE(x)->family - - typedef FT_Error - (*FTC_IFamily_LoadGlyphFunc)( FTC_Family family, - FT_UInt gindex, - FTC_Cache cache, - FT_Glyph *aglyph ); - - typedef struct FTC_IFamilyClassRec_ - { - FTC_MruListClassRec clazz; - FTC_IFamily_LoadGlyphFunc family_load_glyph; - - } FTC_IFamilyClassRec; - - typedef const FTC_IFamilyClassRec* FTC_IFamilyClass; - -#define FTC_IFAMILY_CLASS( x ) ((FTC_IFamilyClass)(x)) - -#define FTC_CACHE__IFAMILY_CLASS( x ) \ - FTC_IFAMILY_CLASS( FTC_CACHE__GCACHE_CLASS(x)->family_class ) - - - /* can be used as a @FTC_Node_FreeFunc */ - FT_EXPORT( void ) - FTC_INode_Free( FTC_INode inode, - FTC_Cache cache ); - - /* Can be used as @FTC_Node_NewFunc. `gquery.index' and `gquery.family' - * must be set correctly. This function will call the `family_load_glyph' - * method to load the FT_Glyph into the cache node. - */ - FT_EXPORT( FT_Error ) - FTC_INode_New( FTC_INode *pinode, - FTC_GQuery gquery, - FTC_Cache cache ); - - /* can be used as @FTC_Node_WeightFunc */ - FT_EXPORT( FT_ULong ) - FTC_INode_Weight( FTC_INode inode ); - - /* */ - -FT_END_HEADER - -#endif /* __FTCIMAGE_H__ */ - - -/* END */ diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftcmanag.h b/nx-X11/extras/freetype2/include/freetype/cache/ftcmanag.h deleted file mode 100644 index 526584822..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftcmanag.h +++ /dev/null @@ -1,175 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftcmanag.h */ -/* */ -/* FreeType Cache Manager (specification). */ -/* */ -/* Copyright 2000-2001, 2003, 2004 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. */ -/* */ -/***************************************************************************/ - - - /*************************************************************************/ - /* */ - /* A cache manager is in charge of the following: */ - /* */ - /* - Maintain a mapping between generic FTC_FaceIDs and live FT_Face */ - /* objects. The mapping itself is performed through a user-provided */ - /* callback. However, the manager maintains a small cache of FT_Face */ - /* and FT_Size objects in order to speed up things considerably. */ - /* */ - /* - Manage one or more cache objects. Each cache is in charge of */ - /* holding a varying number of `cache nodes'. Each cache node */ - /* represents a minimal amount of individually accessible cached */ - /* data. For example, a cache node can be an FT_Glyph image */ - /* containing a vector outline, or some glyph metrics, or anything */ - /* else. */ - /* */ - /* Each cache node has a certain size in bytes that is added to the */ - /* total amount of `cache memory' within the manager. */ - /* */ - /* All cache nodes are located in a global LRU list, where the oldest */ - /* node is at the tail of the list. */ - /* */ - /* Each node belongs to a single cache, and includes a reference */ - /* count to avoid destroying it (due to caching). */ - /* */ - /*************************************************************************/ - - - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /********* *********/ - /********* WARNING, THIS IS BETA CODE. *********/ - /********* *********/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - /*************************************************************************/ - - -#ifndef __FTCMANAG_H__ -#define __FTCMANAG_H__ - - -#include <ft2build.h> -#include FT_CACHE_H -#include FT_CACHE_INTERNAL_MRU_H -#include FT_CACHE_INTERNAL_CACHE_H - - -FT_BEGIN_HEADER - - - /*************************************************************************/ - /* */ - /* <Section> */ - /* cache_subsystem */ - /* */ - /*************************************************************************/ - - -#define FTC_MAX_FACES_DEFAULT 2 -#define FTC_MAX_SIZES_DEFAULT 4 -#define FTC_MAX_BYTES_DEFAULT 200000L /* ~200kByte by default */ - - /* maximum number of caches registered in a single manager */ -#define FTC_MAX_CACHES 16 - - - typedef struct FTC_ManagerRec_ - { - FT_Library library; - FT_Memory memory; - - FTC_Node nodes_list; - FT_ULong max_weight; - FT_ULong cur_weight; - FT_UInt num_nodes; - - FTC_Cache caches[FTC_MAX_CACHES]; - FT_UInt num_caches; - - FTC_MruListRec faces; - FTC_MruListRec sizes; - - FT_Pointer request_data; - FTC_Face_Requester request_face; - - } FTC_ManagerRec; - - - /*************************************************************************/ - /* */ - /* <Function> */ - /* FTC_Manager_Compress */ - /* */ - /* <Description> */ - /* This function is used to check the state of the cache manager if */ - /* its `num_bytes' field is greater than its `max_bytes' field. It */ - /* will flush as many old cache nodes as possible (ignoring cache */ - /* nodes with a non-zero reference count). */ - /* */ - /* <InOut> */ - /* manager :: A handle to the cache manager. */ - /* */ - /* <Note> */ - /* Client applications should not call this function directly. It is */ - /* normally invoked by specific cache implementations. */ - /* */ - /* The reason this function is exported is to allow client-specific */ - /* cache classes. */ - /* */ - FT_EXPORT( void ) - FTC_Manager_Compress( FTC_Manager manager ); - - - /* try to flush `count' old nodes from the cache; return the number - * of really flushed nodes - */ - FT_EXPORT( FT_UInt ) - FTC_Manager_FlushN( FTC_Manager manager, - FT_UInt count ); - - - /* this must be used internally for the moment */ - FT_EXPORT( FT_Error ) - FTC_Manager_RegisterCache( FTC_Manager manager, - FTC_CacheClass clazz, - FTC_Cache *acache ); - - /* */ - -#define FTC_SCALER_COMPARE( a, b ) \ - ( (a)->face_id == (b)->face_id && \ - (a)->width == (b)->width && \ - (a)->height == (b)->height && \ - ((a)->pixel != 0) == ((b)->pixel != 0) && \ - ( (a)->pixel || \ - ( (a)->x_res == (b)->x_res && \ - (a)->y_res == (b)->y_res ) ) ) - -#define FTC_SCALER_HASH( q ) \ - ( FTC_FACE_ID_HASH( (q)->face_id ) + \ - (q)->width + (q)->height*7 + \ - ( (q)->pixel ? 0 : ( (q)->x_res*33 ^ (q)->y_res*61 ) ) ) - - /* */ - -FT_END_HEADER - -#endif /* __FTCMANAG_H__ */ - - -/* END */ diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftcmru.h b/nx-X11/extras/freetype2/include/freetype/cache/ftcmru.h deleted file mode 100644 index d70c5cce7..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftcmru.h +++ /dev/null @@ -1,246 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftcmru.h */ -/* */ -/* Simple MRU list-cache (specification). */ -/* */ -/* Copyright 2000-2001, 2003, 2004 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. */ -/* */ -/***************************************************************************/ - - - /*************************************************************************/ - /* */ - /* An MRU is a list that cannot hold more than a certain number of */ - /* elements (`max_elements'). All elements in the list are sorted in */ - /* least-recently-used order, i.e., the `oldest' element is at the tail */ - /* of the list. */ - /* */ - /* When doing a lookup (either through `Lookup()' or `Lookup_Node()'), */ - /* the list is searched for an element with the corresponding key. If */ - /* it is found, the element is moved to the head of the list and is */ - /* returned. */ - /* */ - /* If no corresponding element is found, the lookup routine will try to */ - /* obtain a new element with the relevant key. If the list is already */ - /* full, the oldest element from the list is discarded and replaced by a */ - /* new one; a new element is added to the list otherwise. */ - /* */ - /* Note that it is possible to pre-allocate the element list nodes. */ - /* This is handy if `max_elements' is sufficiently small, as it saves */ - /* allocations/releases during the lookup process. */ - /* */ - /*************************************************************************/ - - -#ifndef __FTCMRU_H__ -#define __FTCMRU_H__ - - -#include <ft2build.h> -#include FT_FREETYPE_H - -#ifdef FREETYPE_H -#error "freetype.h of FreeType 1 has been loaded!" -#error "Please fix the directory search order for header files" -#error "so that freetype.h of FreeType 2 is found first." -#endif - -#define xxFT_DEBUG_ERROR -#define FTC_INLINE - -FT_BEGIN_HEADER - - typedef struct FTC_MruNodeRec_* FTC_MruNode; - - typedef struct FTC_MruNodeRec_ - { - FTC_MruNode next; - FTC_MruNode prev; - - } FTC_MruNodeRec; - - - FT_EXPORT( void ) - FTC_MruNode_Prepend( FTC_MruNode *plist, - FTC_MruNode node ); - - FT_EXPORT( void ) - FTC_MruNode_Up( FTC_MruNode *plist, - FTC_MruNode node ); - - FT_EXPORT( void ) - FTC_MruNode_Remove( FTC_MruNode *plist, - FTC_MruNode node ); - - - typedef struct FTC_MruListRec_* FTC_MruList; - - typedef struct FTC_MruListClassRec_ const * FTC_MruListClass; - - - typedef FT_Bool - (*FTC_MruNode_CompareFunc)( FTC_MruNode node, - FT_Pointer key ); - - typedef FT_Error - (*FTC_MruNode_InitFunc)( FTC_MruNode node, - FT_Pointer key, - FT_Pointer data ); - - typedef FT_Error - (*FTC_MruNode_ResetFunc)( FTC_MruNode node, - FT_Pointer key, - FT_Pointer data ); - - typedef void - (*FTC_MruNode_DoneFunc)( FTC_MruNode node, - FT_Pointer data ); - - - typedef struct FTC_MruListClassRec_ - { - FT_UInt node_size; - FTC_MruNode_CompareFunc node_compare; - FTC_MruNode_InitFunc node_init; - FTC_MruNode_ResetFunc node_reset; - FTC_MruNode_DoneFunc node_done; - - } FTC_MruListClassRec; - - typedef struct FTC_MruListRec_ - { - FT_UInt num_nodes; - FT_UInt max_nodes; - FTC_MruNode nodes; - FT_Pointer data; - FTC_MruListClassRec clazz; - FT_Memory memory; - - } FTC_MruListRec; - - - FT_EXPORT( void ) - FTC_MruList_Init( FTC_MruList list, - FTC_MruListClass clazz, - FT_UInt max_nodes, - FT_Pointer data, - FT_Memory memory ); - - FT_EXPORT( void ) - FTC_MruList_Reset( FTC_MruList list ); - - - FT_EXPORT( void ) - FTC_MruList_Done( FTC_MruList list ); - - FT_EXPORT( FTC_MruNode ) - FTC_MruList_Find( FTC_MruList list, - FT_Pointer key ); - - FT_EXPORT( FT_Error ) - FTC_MruList_New( FTC_MruList list, - FT_Pointer key, - FTC_MruNode *anode ); - - FT_EXPORT( FT_Error ) - FTC_MruList_Lookup( FTC_MruList list, - FT_Pointer key, - FTC_MruNode *pnode ); - - - FT_EXPORT( void ) - FTC_MruList_Remove( FTC_MruList list, - FTC_MruNode node ); - - FT_EXPORT( void ) - FTC_MruList_RemoveSelection( FTC_MruList list, - FTC_MruNode_CompareFunc selection, - FT_Pointer key ); - - -#ifdef FTC_INLINE - -#define FTC_MRULIST_LOOKUP_CMP( list, key, compare, node, error ) \ - FT_BEGIN_STMNT \ - FTC_MruNode* _pfirst = &(list)->nodes; \ - FTC_MruNode_CompareFunc _compare = (FTC_MruNode_CompareFunc)(compare); \ - FTC_MruNode _first, _node; \ - \ - \ - error = 0; \ - _first = *(_pfirst); \ - _node = NULL; \ - \ - if ( _first ) \ - { \ - _node = _first; \ - do \ - { \ - if ( _compare( _node, (key) ) ) \ - { \ - if ( _node != _first ) \ - FTC_MruNode_Up( _pfirst, _node ); \ - \ - *(FTC_MruNode*)&(node) = _node; \ - goto _MruOk; \ - } \ - _node = _node->next; \ - \ - } while ( _node != _first) ; \ - } \ - \ - error = FTC_MruList_New( (list), (key), (FTC_MruNode*)&(node) ); \ - _MruOk: \ - ; \ - FT_END_STMNT - -#define FTC_MRULIST_LOOKUP( list, key, node, error ) \ - FTC_MRULIST_LOOKUP_CMP( list, key, (list)->clazz.node_compare, node, error ) - -#else /* !FTC_INLINE */ - -#define FTC_MRULIST_LOOKUP( list, key, node, error ) \ - error = FTC_MruList_Lookup( (list), (key), (FTC_MruNode*)&(node) ) - -#endif /* !FTC_INLINE */ - - -#define FTC_MRULIST_LOOP( list, node ) \ - FT_BEGIN_STMNT \ - FTC_MruNode _first = (list)->nodes; \ - \ - \ - if ( _first ) \ - { \ - FTC_MruNode _node = _first; \ - \ - \ - do \ - { \ - *(FTC_MruNode*)&(node) = _node; - - -#define FTC_MRULIST_LOOP_END() \ - _node = _node->next; \ - \ - } while ( _node != _first ); \ - } \ - FT_END_STMNT - - /* */ - -FT_END_HEADER - - -#endif /* __FTCMRU_H__ */ - - -/* END */ diff --git a/nx-X11/extras/freetype2/include/freetype/cache/ftcsbits.h b/nx-X11/extras/freetype2/include/freetype/cache/ftcsbits.h deleted file mode 100644 index b2ef0f181..000000000 --- a/nx-X11/extras/freetype2/include/freetype/cache/ftcsbits.h +++ /dev/null @@ -1,96 +0,0 @@ -/***************************************************************************/ -/* */ -/* ftcsbits.h */ -/* */ -/* A small-bitmap cache (specification). */ -/* */ -/* Copyright 2000-2001, 2002, 2003 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. */ -/* */ -/***************************************************************************/ - - -#ifndef __FTCSBITS_H__ -#define __FTCSBITS_H__ - - -#include <ft2build.h> -#include FT_CACHE_H -#include FT_CACHE_INTERNAL_GLYPH_H - - -FT_BEGIN_HEADER - -#define FTC_SBIT_ITEMS_PER_NODE 16 - - typedef struct FTC_SNodeRec_ - { - FTC_GNodeRec gnode; - FT_UInt count; - FTC_SBitRec sbits[FTC_SBIT_ITEMS_PER_NODE]; - - } FTC_SNodeRec, *FTC_SNode; - - -#define FTC_SNODE( x ) ( (FTC_SNode)( x ) ) -#define FTC_SNODE_GINDEX( x ) FTC_GNODE( x )->gindex -#define FTC_SNODE_FAMILY( x ) FTC_GNODE( x )->family - - typedef FT_UInt - (*FTC_SFamily_GetCountFunc)( FTC_Family family, - FTC_Manager manager ); - - typedef FT_Error - (*FTC_SFamily_LoadGlyphFunc)( FTC_Family family, - FT_UInt gindex, - FTC_Manager manager, - FT_Face *aface ); - - typedef struct FTC_SFamilyClassRec_ - { - FTC_MruListClassRec clazz; - FTC_SFamily_GetCountFunc family_get_count; - FTC_SFamily_LoadGlyphFunc family_load_glyph; - - } FTC_SFamilyClassRec; - - typedef const FTC_SFamilyClassRec* FTC_SFamilyClass; - -#define FTC_SFAMILY_CLASS( x ) ((FTC_SFamilyClass)(x)) - -#define FTC_CACHE__SFAMILY_CLASS( x ) \ - FTC_SFAMILY_CLASS( FTC_CACHE__GCACHE_CLASS( x )->family_class ) - - - FT_EXPORT( void ) - FTC_SNode_Free( FTC_SNode snode, - FTC_Cache cache ); - - FT_EXPORT( FT_Error ) - FTC_SNode_New( FTC_SNode *psnode, - FTC_GQuery gquery, - FTC_Cache cache ); - - FT_EXPORT( FT_ULong ) - FTC_SNode_Weight( FTC_SNode inode ); - - - FT_EXPORT( FT_Bool ) - FTC_SNode_Compare( FTC_SNode snode, - FTC_GQuery gquery, - FTC_Cache cache ); - - /* */ - -FT_END_HEADER - -#endif /* __FTCSBITS_H__ */ - - -/* END */ |