FreeType-2.1.10 API Reference
List Processing
Synopsis
#FT_ListFT_List #FT_List_AddFT_List_Add #FT_List_IterateFT_List_Iterate #FT_ListNodeFT_ListNode #FT_List_InsertFT_List_Insert #FT_List_DestructorFT_List_Destructor #FT_ListRecFT_ListRec #FT_List_RemoveFT_List_Remove #FT_List_FinalizeFT_List_Finalize #FT_ListNodeRecFT_ListNodeRec #FT_List_UpFT_List_Up #FT_List_FindFT_List_Find #FT_List_IteratorFT_List_Iterator This section contains various definitions related to list processing using doubly-linked nodes.
FT_List 
  
typedef struct FT_ListRec_*  FT_List;
A handle to a list record (see FT_ListRec).
FT_ListNode 
  
typedef struct FT_ListNodeRec_*  FT_ListNode;
Many elements and objects in FreeType are listed through a FT_List record (see FT_ListRec). As its name suggests, a FT_ListNode is a handle to a single list element.
FT_ListRec 
  
typedef struct  FT_ListRec_
  {
    
ft2-list_processing.html#FT_ListNodeFT_ListNode   head;
    
ft2-list_processing.html#FT_ListNodeFT_ListNode   tail;
  } 
FT_ListRec;
A structure used to hold a simple doubly-linked list. These are used in many parts of FreeType.
fields head The head (first element) of doubly-linked list.
tail The tail (last element) of doubly-linked list.
FT_ListNodeRec 
  
typedef struct  FT_ListNodeRec_
  {
    
ft2-list_processing.html#FT_ListNodeFT_ListNode   prev;
    
ft2-list_processing.html#FT_ListNodeFT_ListNode   next;
    
void*        data;
  } 
FT_ListNodeRec;
A structure used to hold a single list element.
fields prev The previous element in the list. NULL if first.
next The next element in the list. NULL if last.
data A typeless pointer to the listed object.
FT_List_Find 
  FT_EXPORT( 
ft2-list_processing.html#FT_ListNodeFT_ListNode  )
  
FT_List_Find( ft2-list_processing.html#FT_ListFT_List   list,
                
void*    data );
Finds the list node for a given listed object.
input list A pointer to the parent list.
data The address of the listed object.
return List node. NULL if it wasn't found.
FT_List_Add 
  FT_EXPORT( 
void )
  
FT_List_Add( ft2-list_processing.html#FT_ListFT_List       list,
               
ft2-list_processing.html#FT_ListNodeFT_ListNode   node );
Appends an element to the end of a list.
inout list A pointer to the parent list.
node The node to append.
FT_List_Insert 
  FT_EXPORT( 
void )
  
FT_List_Insert( ft2-list_processing.html#FT_ListFT_List       list,
                  
ft2-list_processing.html#FT_ListNodeFT_ListNode   node );
Inserts an element at the head of a list.
inout list A pointer to parent list.
node The node to insert.
FT_List_Remove 
  FT_EXPORT( 
void )
  
FT_List_Remove( ft2-list_processing.html#FT_ListFT_List       list,
                  
ft2-list_processing.html#FT_ListNodeFT_ListNode   node );
Removes a node from a list. This function doesn't check whether the node is in the list!
input node The node to remove.
inout list A pointer to the parent list.
FT_List_Up 
  FT_EXPORT( 
void )
  
FT_List_Up( ft2-list_processing.html#FT_ListFT_List       list,
              
ft2-list_processing.html#FT_ListNodeFT_ListNode   node );
Moves a node to the head/top of a list. Used to maintain LRU lists.
inout list A pointer to the parent list.
node The node to move.
FT_List_Iterator 
  
typedef ft2-basic_types.html#FT_ErrorFT_Error   (*
FT_List_Iterator)( ft2-list_processing.html#FT_ListNodeFT_ListNode   node,
                       
void*        user );
An FT_List iterator function which is called during a list parse by FT_List_Iterate().
input node The current iteration list node.
user A typeless pointer passed to FT_List_Iterate(). Can be used to point to the iteration's state.
FT_List_Iterate 
  FT_EXPORT( 
ft2-basic_types.html#FT_ErrorFT_Error  )
  
FT_List_Iterate( ft2-list_processing.html#FT_ListFT_List            list,
                   
ft2-list_processing.html#FT_List_IteratorFT_List_Iterator   iterator,
                   
void*             user );
Parses a list and calls a given iterator function on each element. Note that parsing is stopped as soon as one of the iterator calls returns a non-zero value.
input list A handle to the list.
iterator An interator function, called on each node of the list.
user A user-supplied field which is passed as the second argument to the iterator.
return The result (a FreeType error code) of the last iterator call.
FT_List_Destructor 
  
typedef void  (*
FT_List_Destructor)( ft2-system_interface.html#FT_MemoryFT_Memory   memory,
                         
void*      data,
                         
void*      user );
An FT_List iterator function which is called during a list finalization by FT_List_Finalize() to destroy all elements in a given list.
input system The current system object.
data The current object to destroy.
user A typeless pointer passed to FT_List_Iterate(). It can be used to point to the iteration's state.
FT_List_Finalize 
  FT_EXPORT( 
void )
  
FT_List_Finalize( ft2-list_processing.html#FT_ListFT_List              list,
                    
ft2-list_processing.html#FT_List_DestructorFT_List_Destructor   destroy,
                    
ft2-system_interface.html#FT_MemoryFT_Memory            memory,
                    
void*               user );
Destroys all elements in the list as well as the list itself.
input list A handle to the list.
destroy A list destructor that will be applied to each element of the list.
memory The current memory object which handles deallocation.
user A user-supplied field which is passed as the last argument to the destructor.
