ReactOS  0.4.14-dev-98-gb0d4763
ftcmanag.c
Go to the documentation of this file.
1 /***************************************************************************/
2 /* */
3 /* ftcmanag.c */
4 /* */
5 /* FreeType Cache Manager (body). */
6 /* */
7 /* Copyright 2000-2018 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 #include <ft2build.h>
20 #include FT_CACHE_H
21 #include "ftcmanag.h"
22 #include FT_INTERNAL_OBJECTS_H
23 #include FT_INTERNAL_DEBUG_H
24 #include FT_SIZES_H
25 
26 #include "ftccback.h"
27 #include "ftcerror.h"
28 
29 #ifdef FT_CONFIG_OPTION_PIC
30 #error "cache system does not support PIC yet"
31 #endif
32 
33 
34 #undef FT_COMPONENT
35 #define FT_COMPONENT trace_cache
36 
37 
38  static FT_Error
40  FTC_Scaler scaler,
41  FT_Size *asize )
42  {
43  FT_Face face;
44  FT_Size size = NULL;
46 
47 
48  error = FTC_Manager_LookupFace( manager, scaler->face_id, &face );
49  if ( error )
50  goto Exit;
51 
52  error = FT_New_Size( face, &size );
53  if ( error )
54  goto Exit;
55 
57 
58  if ( scaler->pixel )
59  error = FT_Set_Pixel_Sizes( face, scaler->width, scaler->height );
60  else
62  (FT_F26Dot6)scaler->width,
63  (FT_F26Dot6)scaler->height,
64  scaler->x_res,
65  scaler->y_res );
66  if ( error )
67  {
68  FT_Done_Size( size );
69  size = NULL;
70  }
71 
72  Exit:
73  *asize = size;
74  return error;
75  }
76 
77 
78  typedef struct FTC_SizeNodeRec_
79  {
83 
85 
86 #define FTC_SIZE_NODE( x ) ( (FTC_SizeNode)( x ) )
87 
88 
89  FT_CALLBACK_DEF( void )
92  {
93  FTC_SizeNode node = (FTC_SizeNode)ftcnode;
94  FT_Size size = node->size;
95  FT_UNUSED( data );
96 
97 
98  if ( size )
99  FT_Done_Size( size );
100  }
101 
102 
105  FT_Pointer ftcscaler )
106  {
107  FTC_SizeNode node = (FTC_SizeNode)ftcnode;
108  FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
109  FTC_Scaler scaler0 = &node->scaler;
110 
111 
112  if ( FTC_SCALER_COMPARE( scaler0, scaler ) )
113  {
114  FT_Activate_Size( node->size );
115  return 1;
116  }
117  return 0;
118  }
119 
120 
123  FT_Pointer ftcscaler,
124  FT_Pointer ftcmanager )
125  {
126  FTC_SizeNode node = (FTC_SizeNode)ftcnode;
127  FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
128  FTC_Manager manager = (FTC_Manager)ftcmanager;
129 
130 
131  node->scaler = scaler[0];
132 
133  return ftc_scaler_lookup_size( manager, scaler, &node->size );
134  }
135 
136 
139  FT_Pointer ftcscaler,
140  FT_Pointer ftcmanager )
141  {
142  FTC_SizeNode node = (FTC_SizeNode)ftcnode;
143  FTC_Scaler scaler = (FTC_Scaler)ftcscaler;
144  FTC_Manager manager = (FTC_Manager)ftcmanager;
145 
146 
147  FT_Done_Size( node->size );
148 
149  node->scaler = scaler[0];
150 
151  return ftc_scaler_lookup_size( manager, scaler, &node->size );
152  }
153 
154 
155  static
157  {
158  sizeof ( FTC_SizeNodeRec ),
159 
160  ftc_size_node_compare, /* FTC_MruNode_CompareFunc node_compare */
161  ftc_size_node_init, /* FTC_MruNode_InitFunc node_init */
162  ftc_size_node_reset, /* FTC_MruNode_ResetFunc node_reset */
163  ftc_size_node_done /* FTC_MruNode_DoneFunc node_done */
164  };
165 
166 
167  /* helper function used by ftc_face_node_done */
168  static FT_Bool
170  FT_Pointer ftcface_id )
171  {
172  FTC_SizeNode node = (FTC_SizeNode)ftcnode;
173  FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
174 
175 
176  return FT_BOOL( node->scaler.face_id == face_id );
177  }
178 
179 
180  /* documentation is in ftcache.h */
181 
184  FTC_Scaler scaler,
185  FT_Size *asize )
186  {
187  FT_Error error;
188  FTC_MruNode mrunode;
189 
190 
191  if ( !asize || !scaler )
192  return FT_THROW( Invalid_Argument );
193 
194  *asize = NULL;
195 
196  if ( !manager )
197  return FT_THROW( Invalid_Cache_Handle );
198 
199 #ifdef FTC_INLINE
200 
201  FTC_MRULIST_LOOKUP_CMP( &manager->sizes, scaler, ftc_size_node_compare,
202  mrunode, error );
203 
204 #else
205  error = FTC_MruList_Lookup( &manager->sizes, scaler, &mrunode );
206 #endif
207 
208  if ( !error )
209  *asize = FTC_SIZE_NODE( mrunode )->size;
210 
211  return error;
212  }
213 
214 
215  /*************************************************************************/
216  /*************************************************************************/
217  /***** *****/
218  /***** FACE MRU IMPLEMENTATION *****/
219  /***** *****/
220  /*************************************************************************/
221  /*************************************************************************/
222 
223  typedef struct FTC_FaceNodeRec_
224  {
228 
230 
231 #define FTC_FACE_NODE( x ) ( ( FTC_FaceNode )( x ) )
232 
233 
236  FT_Pointer ftcface_id,
237  FT_Pointer ftcmanager )
238  {
239  FTC_FaceNode node = (FTC_FaceNode)ftcnode;
240  FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
241  FTC_Manager manager = (FTC_Manager)ftcmanager;
242  FT_Error error;
243 
244 
245  node->face_id = face_id;
246 
247  error = manager->request_face( face_id,
248  manager->library,
249  manager->request_data,
250  &node->face );
251  if ( !error )
252  {
253  /* destroy initial size object; it will be re-created later */
254  if ( node->face->size )
255  FT_Done_Size( node->face->size );
256  }
257 
258  return error;
259  }
260 
261 
262  FT_CALLBACK_DEF( void )
264  FT_Pointer ftcmanager )
265  {
266  FTC_FaceNode node = (FTC_FaceNode)ftcnode;
267  FTC_Manager manager = (FTC_Manager)ftcmanager;
268 
269 
270  /* we must begin by removing all scalers for the target face */
271  /* from the manager's list */
274  node->face_id );
275 
276  /* all right, we can discard the face now */
277  FT_Done_Face( node->face );
278  node->face = NULL;
279  node->face_id = NULL;
280  }
281 
282 
285  FT_Pointer ftcface_id )
286  {
287  FTC_FaceNode node = (FTC_FaceNode)ftcnode;
288  FTC_FaceID face_id = (FTC_FaceID)ftcface_id;
289 
290 
291  return FT_BOOL( node->face_id == face_id );
292  }
293 
294 
295  static
297  {
298  sizeof ( FTC_FaceNodeRec),
299 
300  ftc_face_node_compare, /* FTC_MruNode_CompareFunc node_compare */
301  ftc_face_node_init, /* FTC_MruNode_InitFunc node_init */
302  NULL, /* FTC_MruNode_ResetFunc node_reset */
303  ftc_face_node_done /* FTC_MruNode_DoneFunc node_done */
304  };
305 
306 
307  /* documentation is in ftcache.h */
308 
311  FTC_FaceID face_id,
312  FT_Face *aface )
313  {
314  FT_Error error;
315  FTC_MruNode mrunode;
316 
317 
318  if ( !aface )
319  return FT_THROW( Invalid_Argument );
320 
321  *aface = NULL;
322 
323  if ( !manager )
324  return FT_THROW( Invalid_Cache_Handle );
325 
326  /* we break encapsulation for the sake of speed */
327 #ifdef FTC_INLINE
328 
329  FTC_MRULIST_LOOKUP_CMP( &manager->faces, face_id, ftc_face_node_compare,
330  mrunode, error );
331 
332 #else
333  error = FTC_MruList_Lookup( &manager->faces, face_id, &mrunode );
334 #endif
335 
336  if ( !error )
337  *aface = FTC_FACE_NODE( mrunode )->face;
338 
339  return error;
340  }
341 
342 
343  /*************************************************************************/
344  /*************************************************************************/
345  /***** *****/
346  /***** CACHE MANAGER ROUTINES *****/
347  /***** *****/
348  /*************************************************************************/
349  /*************************************************************************/
350 
351 
352  /* documentation is in ftcache.h */
353 
356  FT_UInt max_faces,
357  FT_UInt max_sizes,
358  FT_ULong max_bytes,
359  FTC_Face_Requester requester,
360  FT_Pointer req_data,
361  FTC_Manager *amanager )
362  {
363  FT_Error error;
365  FTC_Manager manager = 0;
366 
367 
368  if ( !library )
369  return FT_THROW( Invalid_Library_Handle );
370 
371  if ( !amanager || !requester )
372  return FT_THROW( Invalid_Argument );
373 
374  memory = library->memory;
375 
376  if ( FT_NEW( manager ) )
377  goto Exit;
378 
379  if ( max_faces == 0 )
380  max_faces = FTC_MAX_FACES_DEFAULT;
381 
382  if ( max_sizes == 0 )
383  max_sizes = FTC_MAX_SIZES_DEFAULT;
384 
385  if ( max_bytes == 0 )
386  max_bytes = FTC_MAX_BYTES_DEFAULT;
387 
388  manager->library = library;
389  manager->memory = memory;
390  manager->max_weight = max_bytes;
391 
392  manager->request_face = requester;
393  manager->request_data = req_data;
394 
395  FTC_MruList_Init( &manager->faces,
397  max_faces,
398  manager,
399  memory );
400 
401  FTC_MruList_Init( &manager->sizes,
403  max_sizes,
404  manager,
405  memory );
406 
407  *amanager = manager;
408 
409  Exit:
410  return error;
411  }
412 
413 
414  /* documentation is in ftcache.h */
415 
416  FT_EXPORT_DEF( void )
418  {
420  FT_UInt idx;
421 
422 
423  if ( !manager || !manager->library )
424  return;
425 
426  memory = manager->memory;
427 
428  /* now discard all caches */
429  for (idx = manager->num_caches; idx-- > 0; )
430  {
431  FTC_Cache cache = manager->caches[idx];
432 
433 
434  if ( cache )
435  {
436  cache->clazz.cache_done( cache );
437  FT_FREE( cache );
438  manager->caches[idx] = NULL;
439  }
440  }
441  manager->num_caches = 0;
442 
443  /* discard faces and sizes */
444  FTC_MruList_Done( &manager->sizes );
445  FTC_MruList_Done( &manager->faces );
446 
447  manager->library = NULL;
448  manager->memory = NULL;
449 
450  FT_FREE( manager );
451  }
452 
453 
454  /* documentation is in ftcache.h */
455 
456  FT_EXPORT_DEF( void )
458  {
459  if ( !manager )
460  return;
461 
462  FTC_MruList_Reset( &manager->sizes );
463  FTC_MruList_Reset( &manager->faces );
464 
465  FTC_Manager_FlushN( manager, manager->num_nodes );
466  }
467 
468 
469 #ifdef FT_DEBUG_ERROR
470 
471  static void
472  FTC_Manager_Check( FTC_Manager manager )
473  {
475 
476 
477  first = manager->nodes_list;
478 
479  /* check node weights */
480  if ( first )
481  {
482  FT_Offset weight = 0;
483 
484 
485  node = first;
486 
487  do
488  {
489  FTC_Cache cache = manager->caches[node->cache_index];
490 
491 
492  if ( (FT_UInt)node->cache_index >= manager->num_caches )
493  FT_TRACE0(( "FTC_Manager_Check: invalid node (cache index = %ld\n",
494  node->cache_index ));
495  else
496  weight += cache->clazz.node_weight( node, cache );
497 
498  node = FTC_NODE_NEXT( node );
499 
500  } while ( node != first );
501 
502  if ( weight != manager->cur_weight )
503  FT_TRACE0(( "FTC_Manager_Check: invalid weight %ld instead of %ld\n",
504  manager->cur_weight, weight ));
505  }
506 
507  /* check circular list */
508  if ( first )
509  {
510  FT_UFast count = 0;
511 
512 
513  node = first;
514  do
515  {
516  count++;
517  node = FTC_NODE_NEXT( node );
518 
519  } while ( node != first );
520 
521  if ( count != manager->num_nodes )
522  FT_TRACE0(( "FTC_Manager_Check:"
523  " invalid cache node count %d instead of %d\n",
524  manager->num_nodes, count ));
525  }
526  }
527 
528 #endif /* FT_DEBUG_ERROR */
529 
530 
531  /* `Compress' the manager's data, i.e., get rid of old cache nodes */
532  /* that are not referenced anymore in order to limit the total */
533  /* memory used by the cache. */
534 
535  /* documentation is in ftcmanag.h */
536 
537  FT_LOCAL_DEF( void )
539  {
541 
542 
543  if ( !manager )
544  return;
545 
546  first = manager->nodes_list;
547 
548 #ifdef FT_DEBUG_ERROR
549  FTC_Manager_Check( manager );
550 
551  FT_TRACE0(( "compressing, weight = %ld, max = %ld, nodes = %d\n",
552  manager->cur_weight, manager->max_weight,
553  manager->num_nodes ));
554 #endif
555 
556  if ( manager->cur_weight < manager->max_weight || !first )
557  return;
558 
559  /* go to last node -- it's a circular list */
560  node = FTC_NODE_PREV( first );
561  do
562  {
563  FTC_Node prev;
564 
565 
566  prev = ( node == first ) ? NULL : FTC_NODE_PREV( node );
567 
568  if ( node->ref_count <= 0 )
569  ftc_node_destroy( node, manager );
570 
571  node = prev;
572 
573  } while ( node && manager->cur_weight > manager->max_weight );
574  }
575 
576 
577  /* documentation is in ftcmanag.h */
578 
581  FTC_CacheClass clazz,
582  FTC_Cache *acache )
583  {
584  FT_Error error = FT_ERR( Invalid_Argument );
585  FTC_Cache cache = NULL;
586 
587 
588  if ( manager && clazz && acache )
589  {
590  FT_Memory memory = manager->memory;
591 
592 
593  if ( manager->num_caches >= FTC_MAX_CACHES )
594  {
595  error = FT_THROW( Too_Many_Caches );
596  FT_ERROR(( "FTC_Manager_RegisterCache:"
597  " too many registered caches\n" ));
598  goto Exit;
599  }
600 
601  if ( !FT_ALLOC( cache, clazz->cache_size ) )
602  {
603  cache->manager = manager;
604  cache->memory = memory;
605  cache->clazz = clazz[0];
606  cache->org_class = clazz;
607 
608  /* THIS IS VERY IMPORTANT! IT WILL WRETCH THE MANAGER */
609  /* IF IT IS NOT SET CORRECTLY */
610  cache->index = manager->num_caches;
611 
612  error = clazz->cache_init( cache );
613  if ( error )
614  {
615  clazz->cache_done( cache );
616  FT_FREE( cache );
617  goto Exit;
618  }
619 
620  manager->caches[manager->num_caches++] = cache;
621  }
622  }
623 
624  Exit:
625  if ( acache )
626  *acache = cache;
627  return error;
628  }
629 
630 
633  FT_UInt count )
634  {
635  FTC_Node first = manager->nodes_list;
636  FTC_Node node;
637  FT_UInt result;
638 
639 
640  /* try to remove `count' nodes from the list */
641  if ( !first ) /* empty list! */
642  return 0;
643 
644  /* go to last node - it's a circular list */
646  for ( result = 0; result < count; )
647  {
648  FTC_Node prev = FTC_NODE_PREV( node );
649 
650 
651  /* don't touch locked nodes */
652  if ( node->ref_count <= 0 )
653  {
654  ftc_node_destroy( node, manager );
655  result++;
656  }
657 
658  if ( node == first )
659  break;
660 
661  node = prev;
662  }
663  return result;
664  }
665 
666 
667  /* documentation is in ftcache.h */
668 
669  FT_EXPORT_DEF( void )
671  FTC_FaceID face_id )
672  {
673  FT_UInt nn;
674 
675 
676  if ( !manager )
677  return;
678 
679  /* this will remove all FTC_SizeNode that correspond to
680  * the face_id as well
681  */
682  FTC_MruList_RemoveSelection( &manager->faces,
684  face_id );
685 
686  for ( nn = 0; nn < manager->num_caches; nn++ )
687  FTC_Cache_RemoveFaceID( manager->caches[nn], face_id );
688  }
689 
690 
691  /* documentation is in ftcache.h */
692 
693  FT_EXPORT_DEF( void )
695  FTC_Manager manager )
696  {
697  if ( node &&
698  manager &&
699  (FT_UInt)node->cache_index < manager->num_caches )
700  node->ref_count--;
701  }
702 
703 
704 /* END */
#define FT_ALLOC(ptr, size)
Definition: ftmemory.h:303
Definition: cache.c:46
int FT_Error
Definition: fttypes.h:300
struct FTC_ScalerRec_ * FTC_Scaler
Definition: ftcache.h:445
FT_UInt num_nodes
Definition: ftcmanag.h:99
#define FTC_FACE_NODE(x)
Definition: ftcmanag.c:231
unsigned long FT_ULong
Definition: fttypes.h:253
FT_Memory memory
Definition: ftobjs.h:918
FTC_MruListRec faces
Definition: ftcmanag.h:104
#define error(str)
Definition: mkdosfs.c:1605
#define FTC_SIZE_NODE(x)
Definition: ftcmanag.c:86
FTC_Manager_Compress(FTC_Manager manager)
Definition: ftcmanag.c:538
FTC_Manager_FlushN(FTC_Manager manager, FT_UInt count)
Definition: ftcmanag.c:632
GLuint GLuint GLsizei count
Definition: gl.h:1545
FTC_Manager_LookupSize(FTC_Manager manager, FTC_Scaler scaler, FT_Size *asize)
Definition: ftcmanag.c:183
const GLint * first
Definition: glext.h:5794
FT_Offset max_weight
Definition: ftcmanag.h:97
FT_UInt height
Definition: ftcache.h:429
FTC_MruNodeRec node
Definition: ftcmanag.c:225
typedefFT_BEGIN_HEADER struct FTC_MruNodeRec_ * FTC_MruNode
Definition: ftcmru.h:61
#define FTC_MAX_SIZES_DEFAULT
Definition: ftcmanag.h:84
WORD face[3]
Definition: mesh.c:4747
#define FTC_MAX_FACES_DEFAULT
Definition: ftcmanag.h:83
FT_Library library
Definition: cffdrivr.c:654
static char memory[1024 *256]
Definition: process.c:116
FT_Offset cur_weight
Definition: ftcmanag.h:98
GLuint GLuint GLfloat weight
Definition: glext.h:11719
FT_BEGIN_HEADER typedef FT_Pointer FTC_FaceID
Definition: ftcache.h:171
FTC_ScalerRec scaler
Definition: ftcmanag.c:82
FT_Size size
Definition: ftcmanag.c:81
FT_BEGIN_HEADER typedef unsigned char FT_Bool
Definition: fttypes.h:108
FT_Set_Pixel_Sizes(FT_Face face, FT_UInt pixel_width, FT_UInt pixel_height)
Definition: ftobjs.c:3309
struct node node
FTC_MruList_Init(FTC_MruList list, FTC_MruListClass clazz, FT_UInt max_nodes, FT_Pointer data, FT_Memory memory)
Definition: ftcmru.c:169
FT_Int pixel
Definition: ftcache.h:430
FTC_Manager_LookupFace(FTC_Manager manager, FTC_FaceID face_id, FT_Face *aface)
Definition: ftcmanag.c:310
#define FTC_MAX_BYTES_DEFAULT
Definition: ftcmanag.h:85
FT_Library library
Definition: ftcmanag.h:93
FT_Memory memory
Definition: ftcmanag.h:94
#define FT_ERROR(varformat)
Definition: ftdebug.h:181
FTC_MruList_RemoveSelection(FTC_MruList list, FTC_MruNode_CompareFunc selection, FT_Pointer key)
Definition: ftcmru.c:327
#define FT_THROW(e)
Definition: ftdebug.h:213
#define FTC_SCALER_COMPARE(a, b)
Definition: ftcmanag.h:154
static const FTC_MruListClassRec ftc_size_list_class
Definition: ftcmanag.c:156
FTC_MruNodeRec node
Definition: ftcmanag.c:80
unsigned int idx
Definition: utils.c:41
ftc_face_node_compare(FTC_MruNode ftcnode, FT_Pointer ftcface_id)
Definition: ftcmanag.c:284
smooth NULL
Definition: ftsmooth.c:416
#define FTC_MRULIST_LOOKUP_CMP(list, key, compare, node, error)
Definition: ftcmru.h:164
static FT_Bool ftc_size_node_compare_faceid(FTC_MruNode ftcnode, FT_Pointer ftcface_id)
Definition: ftcmanag.c:169
FT_Error(* FTC_Face_Requester)(FTC_FaceID face_id, FT_Library library, FT_Pointer req_data, FT_Face *aface)
Definition: ftcache.h:210
FT_UInt y_res
Definition: ftcache.h:432
#define FT_FREE(ptr)
Definition: ftmemory.h:329
struct FTC_SizeNodeRec_ * FTC_SizeNode
FTC_Manager_RegisterCache(FTC_Manager manager, FTC_CacheClass clazz, FTC_Cache *acache)
Definition: ftcmanag.c:580
#define FT_LOCAL_DEF(x)
Definition: ftconfig.h:388
FT_Set_Char_Size(FT_Face face, FT_F26Dot6 char_width, FT_F26Dot6 char_height, FT_UInt horz_resolution, FT_UInt vert_resolution)
Definition: ftobjs.c:3267
#define FT_ERR(e)
Definition: fttypes.h:586
FTC_Manager_Done(FTC_Manager manager)
Definition: ftcmanag.c:417
#define FT_TRACE0(varformat)
Definition: ftdebug.h:157
GLsizeiptr size
Definition: glext.h:5919
struct FTC_ManagerRec_ * FTC_Manager
Definition: ftcache.h:250
FT_UInt width
Definition: ftcache.h:428
#define FTC_NODE_PREV(x)
Definition: ftccache.h:73
FTC_MruList_Done(FTC_MruList list)
Definition: ftcmru.c:195
static void Exit(void)
Definition: sock.c:1331
FT_Activate_Size(FT_Size size)
Definition: ftobjs.c:4230
FTC_Manager_RemoveFaceID(FTC_Manager manager, FTC_FaceID face_id)
Definition: ftcmanag.c:670
FT_Done_Size(FT_Size size)
Definition: ftobjs.c:2827
FT_UInt x_res
Definition: ftcache.h:431
ftc_node_destroy(FTC_Node node, FTC_Manager manager)
Definition: ftccache.c:273
static FT_Error ftc_scaler_lookup_size(FTC_Manager manager, FTC_Scaler scaler, FT_Size *asize)
Definition: ftcmanag.c:39
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define FT_CALLBACK_DEF(x)
Definition: ftconfig.h:533
static IOleCache * cache
Definition: ole2.c:75
typedefFT_BEGIN_HEADER struct FT_MemoryRec_ * FT_Memory
Definition: ftsystem.h:66
#define FT_BOOL(x)
Definition: fttypes.h:578
ftc_face_node_init(FTC_MruNode ftcnode, FT_Pointer ftcface_id, FT_Pointer ftcmanager)
Definition: ftcmanag.c:235
ftc_size_node_reset(FTC_MruNode ftcnode, FT_Pointer ftcscaler, FT_Pointer ftcmanager)
Definition: ftcmanag.c:138
FTC_FaceID face_id
Definition: ftcmanag.c:226
static const FTC_MruListClassRec ftc_face_list_class
Definition: ftcmanag.c:296
struct FTC_SizeNodeRec_ FTC_SizeNodeRec
signed long FT_F26Dot6
Definition: fttypes.h:276
FTC_Cache_RemoveFaceID(FTC_Cache cache, FTC_FaceID face_id)
Definition: ftccache.c:564
ftc_size_node_done(FTC_MruNode ftcnode, FT_Pointer data)
Definition: ftcmanag.c:90
FTC_Manager_Reset(FTC_Manager manager)
Definition: ftcmanag.c:457
FT_Pointer request_data
Definition: ftcmanag.h:107
FTC_Node nodes_list
Definition: ftcmanag.h:96
FTC_MruListRec sizes
Definition: ftcmanag.h:105
ftc_size_node_compare(FTC_MruNode ftcnode, FT_Pointer ftcscaler)
Definition: ftcmanag.c:104
#define FT_EXPORT_DEF(x)
Definition: ftconfig.h:483
unsigned int FT_UInt
Definition: fttypes.h:231
FT_Face face
Definition: ftcmanag.c:227
#define FTC_MAX_CACHES
Definition: ftcmanag.h:88
ftc_face_node_done(FTC_MruNode ftcnode, FT_Pointer ftcmanager)
Definition: ftcmanag.c:263
FTC_Manager_New(FT_Library library, FT_UInt max_faces, FT_UInt max_sizes, FT_ULong max_bytes, FTC_Face_Requester requester, FT_Pointer req_data, FTC_Manager *amanager)
Definition: ftcmanag.c:355
FT_Done_Face(FT_Face face)
Definition: ftobjs.c:2721
#define FT_NEW(ptr)
Definition: ftmemory.h:331
struct FTC_FaceNodeRec_ FTC_FaceNodeRec
FTC_FaceID face_id
Definition: ftcache.h:427
ftc_size_node_init(FTC_MruNode ftcnode, FT_Pointer ftcscaler, FT_Pointer ftcmanager)
Definition: ftcmanag.c:122
GLuint64EXT * result
Definition: glext.h:11304
struct FTC_FaceNodeRec_ * FTC_FaceNode
#define FTC_NODE_NEXT(x)
Definition: ftccache.h:72
FT_UInt num_caches
Definition: ftcmanag.h:102
#define FT_UNUSED(arg)
Definition: ftconfig.h:101
FTC_MruList_Reset(FTC_MruList list)
Definition: ftcmru.c:185
GLenum GLuint GLint GLenum face
Definition: glext.h:7025
FT_BEGIN_HEADER FT_New_Size(FT_Face face, FT_Size *size)
Definition: ftobjs.c:2762
FTC_Cache caches[FTC_MAX_CACHES]
Definition: ftcmanag.h:101
size_t FT_Offset
Definition: fttypes.h:324
FTC_Face_Requester request_face
Definition: ftcmanag.h:108
FTC_Node_Unref(FTC_Node node, FTC_Manager manager)
Definition: ftcmanag.c:694
Definition: dlist.c:348