| OLD | NEW |
|---|
| (Empty) | |
| 1 /***************************************************************************/ |
| 2 /* */ |
| 3 /* ftcglyph.h */ |
| 4 /* */ |
| 5 /* FreeType abstract glyph cache (specification). */ |
| 6 /* */ |
| 7 /* Copyright 2000-2001, 2003, 2004, 2006, 2007, 2011 by */ |
| 8 /* David Turner, Robert Wilhelm, and Werner Lemberg. */ |
| 9 /* */ |
| 10 /* This file is part of the FreeType project, and may only be used, */ |
| 11 /* modified, and distributed under the terms of the FreeType project */ |
| 12 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ |
| 13 /* this file you indicate that you have read the license and */ |
| 14 /* understand and accept it fully. */ |
| 15 /* */ |
| 16 /***************************************************************************/ |
| 17 |
| 18 |
| 19 /* |
| 20 * |
| 21 * FTC_GCache is an _abstract_ cache object optimized to store glyph |
| 22 * data. It works as follows: |
| 23 * |
| 24 * - It manages FTC_GNode objects. Each one of them can hold one or more |
| 25 * glyph `items'. Item types are not specified in the FTC_GCache but |
| 26 * in classes that extend it. |
| 27 * |
| 28 * - Glyph attributes, like face ID, character size, render mode, etc., |
| 29 * can be grouped into abstract `glyph families'. This avoids storing |
| 30 * the attributes within the FTC_GCache, since it is likely that many |
| 31 * FTC_GNodes will belong to the same family in typical uses. |
| 32 * |
| 33 * - Each FTC_GNode is thus an FTC_Node with two additional fields: |
| 34 * |
| 35 * * gindex: A glyph index, or the first index in a glyph range. |
| 36 * * family: A pointer to a glyph `family'. |
| 37 * |
| 38 * - Family types are not fully specific in the FTC_Family type, but |
| 39 * by classes that extend it. |
| 40 * |
| 41 * Note that both FTC_ImageCache and FTC_SBitCache extend FTC_GCache. |
| 42 * They share an FTC_Family sub-class called FTC_BasicFamily which is |
| 43 * used to store the following data: face ID, pixel/point sizes, load |
| 44 * flags. For more details see the file `src/cache/ftcbasic.c'. |
| 45 * |
| 46 * Client applications can extend FTC_GNode with their own FTC_GNode |
| 47 * and FTC_Family sub-classes to implement more complex caches (e.g., |
| 48 * handling automatic synthesis, like obliquing & emboldening, colored |
| 49 * glyphs, etc.). |
| 50 * |
| 51 * See also the FTC_ICache & FTC_SCache classes in `ftcimage.h' and |
| 52 * `ftcsbits.h', which both extend FTC_GCache with additional |
| 53 * optimizations. |
| 54 * |
| 55 * A typical FTC_GCache implementation must provide at least the |
| 56 * following: |
| 57 * |
| 58 * - FTC_GNode sub-class, e.g. MyNode, with relevant methods: |
| 59 * my_node_new (must call FTC_GNode_Init) |
| 60 * my_node_free (must call FTC_GNode_Done) |
| 61 * my_node_compare (must call FTC_GNode_Compare) |
| 62 * my_node_remove_faceid (must call ftc_gnode_unselect in case |
| 63 * of match) |
| 64 * |
| 65 * - FTC_Family sub-class, e.g. MyFamily, with relevant methods: |
| 66 * my_family_compare |
| 67 * my_family_init |
| 68 * my_family_reset (optional) |
| 69 * my_family_done |
| 70 * |
| 71 * - FTC_GQuery sub-class, e.g. MyQuery, to hold cache-specific query |
| 72 * data. |
| 73 * |
| 74 * - Constant structures for a FTC_GNodeClass. |
| 75 * |
| 76 * - MyCacheNew() can be implemented easily as a call to the convenience |
| 77 * function FTC_GCache_New. |
| 78 * |
| 79 * - MyCacheLookup with a call to FTC_GCache_Lookup. This function will |
| 80 * automatically: |
| 81 * |
| 82 * - Search for the corresponding family in the cache, or create |
| 83 * a new one if necessary. Put it in FTC_GQUERY(myquery).family |
| 84 * |
| 85 * - Call FTC_Cache_Lookup. |
| 86 * |
| 87 * If it returns NULL, you should create a new node, then call |
| 88 * ftc_cache_add as usual. |
| 89 */ |
| 90 |
| 91 |
| 92 /*************************************************************************/ |
| 93 /* */ |
| 94 /* Important: The functions defined in this file are only used to */ |
| 95 /* implement an abstract glyph cache class. You need to */ |
| 96 /* provide additional logic to implement a complete cache. */ |
| 97 /* */ |
| 98 /*************************************************************************/ |
| 99 |
| 100 |
| 101 /*************************************************************************/ |
| 102 /*************************************************************************/ |
| 103 /*************************************************************************/ |
| 104 /*************************************************************************/ |
| 105 /*************************************************************************/ |
| 106 /********* *********/ |
| 107 /********* WARNING, THIS IS BETA CODE. *********/ |
| 108 /********* *********/ |
| 109 /*************************************************************************/ |
| 110 /*************************************************************************/ |
| 111 /*************************************************************************/ |
| 112 /*************************************************************************/ |
| 113 /*************************************************************************/ |
| 114 |
| 115 |
| 116 #ifndef __FTCGLYPH_H__ |
| 117 #define __FTCGLYPH_H__ |
| 118 |
| 119 |
| 120 #include <ft2build.h> |
| 121 #include "ftcmanag.h" |
| 122 |
| 123 |
| 124 FT_BEGIN_HEADER |
| 125 |
| 126 |
| 127 /* |
| 128 * We can group glyphs into `families'. Each family correspond to a |
| 129 * given face ID, character size, transform, etc. |
| 130 * |
| 131 * Families are implemented as MRU list nodes. They are |
| 132 * reference-counted. |
| 133 */ |
| 134 |
| 135 typedef struct FTC_FamilyRec_ |
| 136 { |
| 137 FTC_MruNodeRec mrunode; |
| 138 FT_UInt num_nodes; /* current number of nodes in this family */ |
| 139 FTC_Cache cache; |
| 140 FTC_MruListClass clazz; |
| 141 |
| 142 } FTC_FamilyRec, *FTC_Family; |
| 143 |
| 144 #define FTC_FAMILY(x) ( (FTC_Family)(x) ) |
| 145 #define FTC_FAMILY_P(x) ( (FTC_Family*)(x) ) |
| 146 |
| 147 |
| 148 typedef struct FTC_GNodeRec_ |
| 149 { |
| 150 FTC_NodeRec node; |
| 151 FTC_Family family; |
| 152 FT_UInt gindex; |
| 153 |
| 154 } FTC_GNodeRec, *FTC_GNode; |
| 155 |
| 156 #define FTC_GNODE( x ) ( (FTC_GNode)(x) ) |
| 157 #define FTC_GNODE_P( x ) ( (FTC_GNode*)(x) ) |
| 158 |
| 159 |
| 160 typedef struct FTC_GQueryRec_ |
| 161 { |
| 162 FT_UInt gindex; |
| 163 FTC_Family family; |
| 164 |
| 165 } FTC_GQueryRec, *FTC_GQuery; |
| 166 |
| 167 #define FTC_GQUERY( x ) ( (FTC_GQuery)(x) ) |
| 168 |
| 169 |
| 170 /*************************************************************************/ |
| 171 /* */ |
| 172 /* These functions are exported so that they can be called from */ |
| 173 /* user-provided cache classes; otherwise, they are really part of the */ |
| 174 /* cache sub-system internals. */ |
| 175 /* */ |
| 176 |
| 177 /* must be called by derived FTC_Node_InitFunc routines */ |
| 178 FT_LOCAL( void ) |
| 179 FTC_GNode_Init( FTC_GNode node, |
| 180 FT_UInt gindex, /* glyph index for node */ |
| 181 FTC_Family family ); |
| 182 |
| 183 #ifdef FTC_INLINE |
| 184 |
| 185 /* returns TRUE iff the query's glyph index correspond to the node; */ |
| 186 /* this assumes that the `family' and `hash' fields of the query are */ |
| 187 /* already correctly set */ |
| 188 FT_LOCAL( FT_Bool ) |
| 189 FTC_GNode_Compare( FTC_GNode gnode, |
| 190 FTC_GQuery gquery, |
| 191 FTC_Cache cache, |
| 192 FT_Bool* list_changed ); |
| 193 |
| 194 #endif |
| 195 |
| 196 /* call this function to clear a node's family -- this is necessary */ |
| 197 /* to implement the `node_remove_faceid' cache method correctly */ |
| 198 FT_LOCAL( void ) |
| 199 FTC_GNode_UnselectFamily( FTC_GNode gnode, |
| 200 FTC_Cache cache ); |
| 201 |
| 202 /* must be called by derived FTC_Node_DoneFunc routines */ |
| 203 FT_LOCAL( void ) |
| 204 FTC_GNode_Done( FTC_GNode node, |
| 205 FTC_Cache cache ); |
| 206 |
| 207 |
| 208 FT_LOCAL( void ) |
| 209 FTC_Family_Init( FTC_Family family, |
| 210 FTC_Cache cache ); |
| 211 |
| 212 typedef struct FTC_GCacheRec_ |
| 213 { |
| 214 FTC_CacheRec cache; |
| 215 FTC_MruListRec families; |
| 216 |
| 217 } FTC_GCacheRec, *FTC_GCache; |
| 218 |
| 219 #define FTC_GCACHE( x ) ((FTC_GCache)(x)) |
| 220 |
| 221 |
| 222 #if 0 |
| 223 /* can be used as @FTC_Cache_InitFunc */ |
| 224 FT_LOCAL( FT_Error ) |
| 225 FTC_GCache_Init( FTC_GCache cache ); |
| 226 #endif |
| 227 |
| 228 |
| 229 #if 0 |
| 230 /* can be used as @FTC_Cache_DoneFunc */ |
| 231 FT_LOCAL( void ) |
| 232 FTC_GCache_Done( FTC_GCache cache ); |
| 233 #endif |
| 234 |
| 235 |
| 236 /* the glyph cache class adds fields for the family implementation */ |
| 237 typedef struct FTC_GCacheClassRec_ |
| 238 { |
| 239 FTC_CacheClassRec clazz; |
| 240 FTC_MruListClass family_class; |
| 241 |
| 242 } FTC_GCacheClassRec; |
| 243 |
| 244 typedef const FTC_GCacheClassRec* FTC_GCacheClass; |
| 245 |
| 246 #define FTC_GCACHE_CLASS( x ) ((FTC_GCacheClass)(x)) |
| 247 |
| 248 #define FTC_CACHE__GCACHE_CLASS( x ) \ |
| 249 FTC_GCACHE_CLASS( FTC_CACHE(x)->org_class ) |
| 250 #define FTC_CACHE__FAMILY_CLASS( x ) \ |
| 251 ( (FTC_MruListClass)FTC_CACHE__GCACHE_CLASS( x )->family_class ) |
| 252 |
| 253 |
| 254 /* convenience function; use it instead of FTC_Manager_Register_Cache */ |
| 255 FT_LOCAL( FT_Error ) |
| 256 FTC_GCache_New( FTC_Manager manager, |
| 257 FTC_GCacheClass clazz, |
| 258 FTC_GCache *acache ); |
| 259 |
| 260 #ifndef FTC_INLINE |
| 261 FT_LOCAL( FT_Error ) |
| 262 FTC_GCache_Lookup( FTC_GCache cache, |
| 263 FT_PtrDist hash, |
| 264 FT_UInt gindex, |
| 265 FTC_GQuery query, |
| 266 FTC_Node *anode ); |
| 267 #endif |
| 268 |
| 269 |
| 270 /* */ |
| 271 |
| 272 |
| 273 #define FTC_FAMILY_FREE( family, cache ) \ |
| 274 FTC_MruList_Remove( &FTC_GCACHE((cache))->families, \ |
| 275 (FTC_MruNode)(family) ) |
| 276 |
| 277 |
| 278 #ifdef FTC_INLINE |
| 279 |
| 280 #define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \ |
| 281 gindex, query, node, error ) \ |
| 282 FT_BEGIN_STMNT \ |
| 283 FTC_GCache _gcache = FTC_GCACHE( cache ); \ |
| 284 FTC_GQuery _gquery = (FTC_GQuery)( query ); \ |
| 285 FTC_MruNode_CompareFunc _fcompare = (FTC_MruNode_CompareFunc)(famcmp); \ |
| 286 FTC_MruNode _mrunode; \ |
| 287 \ |
| 288 \ |
| 289 _gquery->gindex = (gindex); \ |
| 290 \ |
| 291 FTC_MRULIST_LOOKUP_CMP( &_gcache->families, _gquery, _fcompare, \ |
| 292 _mrunode, error ); \ |
| 293 _gquery->family = FTC_FAMILY( _mrunode ); \ |
| 294 if ( !error ) \ |
| 295 { \ |
| 296 FTC_Family _gqfamily = _gquery->family; \ |
| 297 \ |
| 298 \ |
| 299 _gqfamily->num_nodes++; \ |
| 300 \ |
| 301 FTC_CACHE_LOOKUP_CMP( cache, nodecmp, hash, query, node, error ); \ |
| 302 \ |
| 303 if ( --_gqfamily->num_nodes == 0 ) \ |
| 304 FTC_FAMILY_FREE( _gqfamily, _gcache ); \ |
| 305 } \ |
| 306 FT_END_STMNT |
| 307 /* */ |
| 308 |
| 309 #else /* !FTC_INLINE */ |
| 310 |
| 311 #define FTC_GCACHE_LOOKUP_CMP( cache, famcmp, nodecmp, hash, \ |
| 312 gindex, query, node, error ) \ |
| 313 FT_BEGIN_STMNT \ |
| 314 \ |
| 315 error = FTC_GCache_Lookup( FTC_GCACHE( cache ), hash, gindex, \ |
| 316 FTC_GQUERY( query ), &node ); \ |
| 317 \ |
| 318 FT_END_STMNT |
| 319 |
| 320 #endif /* !FTC_INLINE */ |
| 321 |
| 322 |
| 323 FT_END_HEADER |
| 324 |
| 325 |
| 326 #endif /* __FTCGLYPH_H__ */ |
| 327 |
| 328 |
| 329 /* END */ |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 89753003:
Update freetype to latest version of ASOP. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src/third_party/freetype.git@master