| OLD | NEW |
| (Empty) |
| 1 /***************************************************************************/ | |
| 2 /* */ | |
| 3 /* ftlist.h */ | |
| 4 /* */ | |
| 5 /* Generic list support for FreeType (specification). */ | |
| 6 /* */ | |
| 7 /* Copyright 1996-2001, 2003, 2007, 2010, 2013, 2014 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 /* This file implements functions relative to list processing. Its */ | |
| 22 /* data structures are defined in `freetype.h'. */ | |
| 23 /* */ | |
| 24 /*************************************************************************/ | |
| 25 | |
| 26 | |
| 27 #ifndef __FTLIST_H__ | |
| 28 #define __FTLIST_H__ | |
| 29 | |
| 30 | |
| 31 #include <ft2build.h> | |
| 32 #include FT_FREETYPE_H | |
| 33 | |
| 34 #ifdef FREETYPE_H | |
| 35 #error "freetype.h of FreeType 1 has been loaded!" | |
| 36 #error "Please fix the directory search order for header files" | |
| 37 #error "so that freetype.h of FreeType 2 is found first." | |
| 38 #endif | |
| 39 | |
| 40 | |
| 41 FT_BEGIN_HEADER | |
| 42 | |
| 43 | |
| 44 /*************************************************************************/ | |
| 45 /* */ | |
| 46 /* <Section> */ | |
| 47 /* list_processing */ | |
| 48 /* */ | |
| 49 /* <Title> */ | |
| 50 /* List Processing */ | |
| 51 /* */ | |
| 52 /* <Abstract> */ | |
| 53 /* Simple management of lists. */ | |
| 54 /* */ | |
| 55 /* <Description> */ | |
| 56 /* This section contains various definitions related to list */ | |
| 57 /* processing using doubly-linked nodes. */ | |
| 58 /* */ | |
| 59 /* <Order> */ | |
| 60 /* FT_List */ | |
| 61 /* FT_ListNode */ | |
| 62 /* FT_ListRec */ | |
| 63 /* FT_ListNodeRec */ | |
| 64 /* */ | |
| 65 /* FT_List_Add */ | |
| 66 /* FT_List_Insert */ | |
| 67 /* FT_List_Find */ | |
| 68 /* FT_List_Remove */ | |
| 69 /* FT_List_Up */ | |
| 70 /* FT_List_Iterate */ | |
| 71 /* FT_List_Iterator */ | |
| 72 /* FT_List_Finalize */ | |
| 73 /* FT_List_Destructor */ | |
| 74 /* */ | |
| 75 /*************************************************************************/ | |
| 76 | |
| 77 | |
| 78 /*************************************************************************/ | |
| 79 /* */ | |
| 80 /* <Function> */ | |
| 81 /* FT_List_Find */ | |
| 82 /* */ | |
| 83 /* <Description> */ | |
| 84 /* Find the list node for a given listed object. */ | |
| 85 /* */ | |
| 86 /* <Input> */ | |
| 87 /* list :: A pointer to the parent list. */ | |
| 88 /* data :: The address of the listed object. */ | |
| 89 /* */ | |
| 90 /* <Return> */ | |
| 91 /* List node. NULL if it wasn't found. */ | |
| 92 /* */ | |
| 93 FT_EXPORT( FT_ListNode ) | |
| 94 FT_List_Find( FT_List list, | |
| 95 void* data ); | |
| 96 | |
| 97 | |
| 98 /*************************************************************************/ | |
| 99 /* */ | |
| 100 /* <Function> */ | |
| 101 /* FT_List_Add */ | |
| 102 /* */ | |
| 103 /* <Description> */ | |
| 104 /* Append an element to the end of a list. */ | |
| 105 /* */ | |
| 106 /* <InOut> */ | |
| 107 /* list :: A pointer to the parent list. */ | |
| 108 /* node :: The node to append. */ | |
| 109 /* */ | |
| 110 FT_EXPORT( void ) | |
| 111 FT_List_Add( FT_List list, | |
| 112 FT_ListNode node ); | |
| 113 | |
| 114 | |
| 115 /*************************************************************************/ | |
| 116 /* */ | |
| 117 /* <Function> */ | |
| 118 /* FT_List_Insert */ | |
| 119 /* */ | |
| 120 /* <Description> */ | |
| 121 /* Insert an element at the head of a list. */ | |
| 122 /* */ | |
| 123 /* <InOut> */ | |
| 124 /* list :: A pointer to parent list. */ | |
| 125 /* node :: The node to insert. */ | |
| 126 /* */ | |
| 127 FT_EXPORT( void ) | |
| 128 FT_List_Insert( FT_List list, | |
| 129 FT_ListNode node ); | |
| 130 | |
| 131 | |
| 132 /*************************************************************************/ | |
| 133 /* */ | |
| 134 /* <Function> */ | |
| 135 /* FT_List_Remove */ | |
| 136 /* */ | |
| 137 /* <Description> */ | |
| 138 /* Remove a node from a list. This function doesn't check whether */ | |
| 139 /* the node is in the list! */ | |
| 140 /* */ | |
| 141 /* <Input> */ | |
| 142 /* node :: The node to remove. */ | |
| 143 /* */ | |
| 144 /* <InOut> */ | |
| 145 /* list :: A pointer to the parent list. */ | |
| 146 /* */ | |
| 147 FT_EXPORT( void ) | |
| 148 FT_List_Remove( FT_List list, | |
| 149 FT_ListNode node ); | |
| 150 | |
| 151 | |
| 152 /*************************************************************************/ | |
| 153 /* */ | |
| 154 /* <Function> */ | |
| 155 /* FT_List_Up */ | |
| 156 /* */ | |
| 157 /* <Description> */ | |
| 158 /* Move a node to the head/top of a list. Used to maintain LRU */ | |
| 159 /* lists. */ | |
| 160 /* */ | |
| 161 /* <InOut> */ | |
| 162 /* list :: A pointer to the parent list. */ | |
| 163 /* node :: The node to move. */ | |
| 164 /* */ | |
| 165 FT_EXPORT( void ) | |
| 166 FT_List_Up( FT_List list, | |
| 167 FT_ListNode node ); | |
| 168 | |
| 169 | |
| 170 /*************************************************************************/ | |
| 171 /* */ | |
| 172 /* <FuncType> */ | |
| 173 /* FT_List_Iterator */ | |
| 174 /* */ | |
| 175 /* <Description> */ | |
| 176 /* An FT_List iterator function that is called during a list parse */ | |
| 177 /* by @FT_List_Iterate. */ | |
| 178 /* */ | |
| 179 /* <Input> */ | |
| 180 /* node :: The current iteration list node. */ | |
| 181 /* */ | |
| 182 /* user :: A typeless pointer passed to @FT_List_Iterate. */ | |
| 183 /* Can be used to point to the iteration's state. */ | |
| 184 /* */ | |
| 185 typedef FT_Error | |
| 186 (*FT_List_Iterator)( FT_ListNode node, | |
| 187 void* user ); | |
| 188 | |
| 189 | |
| 190 /*************************************************************************/ | |
| 191 /* */ | |
| 192 /* <Function> */ | |
| 193 /* FT_List_Iterate */ | |
| 194 /* */ | |
| 195 /* <Description> */ | |
| 196 /* Parse a list and calls a given iterator function on each element. */ | |
| 197 /* Note that parsing is stopped as soon as one of the iterator calls */ | |
| 198 /* returns a non-zero value. */ | |
| 199 /* */ | |
| 200 /* <Input> */ | |
| 201 /* list :: A handle to the list. */ | |
| 202 /* iterator :: An iterator function, called on each node of the list. */ | |
| 203 /* user :: A user-supplied field that is passed as the second */ | |
| 204 /* argument to the iterator. */ | |
| 205 /* */ | |
| 206 /* <Return> */ | |
| 207 /* The result (a FreeType error code) of the last iterator call. */ | |
| 208 /* */ | |
| 209 FT_EXPORT( FT_Error ) | |
| 210 FT_List_Iterate( FT_List list, | |
| 211 FT_List_Iterator iterator, | |
| 212 void* user ); | |
| 213 | |
| 214 | |
| 215 /*************************************************************************/ | |
| 216 /* */ | |
| 217 /* <FuncType> */ | |
| 218 /* FT_List_Destructor */ | |
| 219 /* */ | |
| 220 /* <Description> */ | |
| 221 /* An @FT_List iterator function that is called during a list */ | |
| 222 /* finalization by @FT_List_Finalize to destroy all elements in a */ | |
| 223 /* given list. */ | |
| 224 /* */ | |
| 225 /* <Input> */ | |
| 226 /* system :: The current system object. */ | |
| 227 /* */ | |
| 228 /* data :: The current object to destroy. */ | |
| 229 /* */ | |
| 230 /* user :: A typeless pointer passed to @FT_List_Iterate. It can */ | |
| 231 /* be used to point to the iteration's state. */ | |
| 232 /* */ | |
| 233 typedef void | |
| 234 (*FT_List_Destructor)( FT_Memory memory, | |
| 235 void* data, | |
| 236 void* user ); | |
| 237 | |
| 238 | |
| 239 /*************************************************************************/ | |
| 240 /* */ | |
| 241 /* <Function> */ | |
| 242 /* FT_List_Finalize */ | |
| 243 /* */ | |
| 244 /* <Description> */ | |
| 245 /* Destroy all elements in the list as well as the list itself. */ | |
| 246 /* */ | |
| 247 /* <Input> */ | |
| 248 /* list :: A handle to the list. */ | |
| 249 /* */ | |
| 250 /* destroy :: A list destructor that will be applied to each element */ | |
| 251 /* of the list. Set this to NULL if not needed. */ | |
| 252 /* */ | |
| 253 /* memory :: The current memory object that handles deallocation. */ | |
| 254 /* */ | |
| 255 /* user :: A user-supplied field that is passed as the last */ | |
| 256 /* argument to the destructor. */ | |
| 257 /* */ | |
| 258 /* <Note> */ | |
| 259 /* This function expects that all nodes added by @FT_List_Add or */ | |
| 260 /* @FT_List_Insert have been dynamically allocated. */ | |
| 261 /* */ | |
| 262 FT_EXPORT( void ) | |
| 263 FT_List_Finalize( FT_List list, | |
| 264 FT_List_Destructor destroy, | |
| 265 FT_Memory memory, | |
| 266 void* user ); | |
| 267 | |
| 268 /* */ | |
| 269 | |
| 270 | |
| 271 FT_END_HEADER | |
| 272 | |
| 273 #endif /* __FTLIST_H__ */ | |
| 274 | |
| 275 | |
| 276 /* END */ | |
| OLD | NEW |