[692] | 1 | /***************************************************************************/
|
---|
| 2 | /* */
|
---|
| 3 | /* ftcache.h */
|
---|
| 4 | /* */
|
---|
| 5 | /* FreeType Cache subsystem (specification). */
|
---|
| 6 | /* */
|
---|
| 7 | /* Copyright 1996-2001, 2002, 2003, 2004, 2005 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 | /*************************************************************************/
|
---|
| 22 | /*************************************************************************/
|
---|
| 23 | /*************************************************************************/
|
---|
| 24 | /********* *********/
|
---|
| 25 | /********* WARNING, THIS IS BETA CODE. *********/
|
---|
| 26 | /********* *********/
|
---|
| 27 | /*************************************************************************/
|
---|
| 28 | /*************************************************************************/
|
---|
| 29 | /*************************************************************************/
|
---|
| 30 | /*************************************************************************/
|
---|
| 31 | /*************************************************************************/
|
---|
| 32 |
|
---|
| 33 |
|
---|
| 34 | #ifndef __FTCACHE_H__
|
---|
| 35 | #define __FTCACHE_H__
|
---|
| 36 |
|
---|
| 37 |
|
---|
| 38 | #include <ft2build.h>
|
---|
| 39 | #include FT_GLYPH_H
|
---|
| 40 |
|
---|
| 41 |
|
---|
| 42 | FT_BEGIN_HEADER
|
---|
| 43 |
|
---|
| 44 |
|
---|
| 45 | /*************************************************************************/
|
---|
| 46 | /* */
|
---|
| 47 | /* <Section> */
|
---|
| 48 | /* cache_subsystem */
|
---|
| 49 | /* */
|
---|
| 50 | /* <Title> */
|
---|
| 51 | /* Cache Sub-System */
|
---|
| 52 | /* */
|
---|
| 53 | /* <Abstract> */
|
---|
| 54 | /* How to cache face, size, and glyph data with FreeType 2. */
|
---|
| 55 | /* */
|
---|
| 56 | /* <Description> */
|
---|
| 57 | /* This section describes the FreeType 2 cache sub-system which is */
|
---|
| 58 | /* still in beta. */
|
---|
| 59 | /* */
|
---|
| 60 | /* <Order> */
|
---|
| 61 | /* FTC_Manager */
|
---|
| 62 | /* FTC_FaceID */
|
---|
| 63 | /* FTC_Face_Requester */
|
---|
| 64 | /* */
|
---|
| 65 | /* FTC_Manager_New */
|
---|
| 66 | /* FTC_Manager_Reset */
|
---|
| 67 | /* FTC_Manager_Done */
|
---|
| 68 | /* FTC_Manager_LookupFace */
|
---|
| 69 | /* FTC_Manager_LookupSize */
|
---|
| 70 | /* FTC_Manager_RemoveFaceID */
|
---|
| 71 | /* */
|
---|
| 72 | /* FTC_Node */
|
---|
| 73 | /* FTC_Node_Unref */
|
---|
| 74 | /* */
|
---|
| 75 | /* FTC_Font */
|
---|
| 76 | /* FTC_ImageCache */
|
---|
| 77 | /* FTC_ImageCache_New */
|
---|
| 78 | /* FTC_ImageCache_Lookup */
|
---|
| 79 | /* */
|
---|
| 80 | /* FTC_SBit */
|
---|
| 81 | /* FTC_SBitCache */
|
---|
| 82 | /* FTC_SBitCache_New */
|
---|
| 83 | /* FTC_SBitCache_Lookup */
|
---|
| 84 | /* */
|
---|
| 85 | /* FTC_CMapCache */
|
---|
| 86 | /* FTC_CMapCache_New */
|
---|
| 87 | /* FTC_CMapCache_Lookup */
|
---|
| 88 | /* */
|
---|
| 89 | /*************************************************************************/
|
---|
| 90 |
|
---|
| 91 |
|
---|
| 92 | /*************************************************************************/
|
---|
| 93 | /*************************************************************************/
|
---|
| 94 | /*************************************************************************/
|
---|
| 95 | /***** *****/
|
---|
| 96 | /***** BASIC TYPE DEFINITIONS *****/
|
---|
| 97 | /***** *****/
|
---|
| 98 | /*************************************************************************/
|
---|
| 99 | /*************************************************************************/
|
---|
| 100 | /*************************************************************************/
|
---|
| 101 |
|
---|
| 102 |
|
---|
| 103 | /*************************************************************************/
|
---|
| 104 | /* */
|
---|
| 105 | /* <Type> */
|
---|
| 106 | /* FTC_FaceID */
|
---|
| 107 | /* */
|
---|
| 108 | /* <Description> */
|
---|
| 109 | /* An opaque pointer type that is used to identity face objects. The */
|
---|
| 110 | /* contents of such objects is application-dependent. */
|
---|
| 111 | /* */
|
---|
| 112 | typedef struct FTC_FaceIDRec_* FTC_FaceID;
|
---|
| 113 |
|
---|
| 114 |
|
---|
| 115 | /*************************************************************************/
|
---|
| 116 | /* */
|
---|
| 117 | /* <FuncType> */
|
---|
| 118 | /* FTC_Face_Requester */
|
---|
| 119 | /* */
|
---|
| 120 | /* <Description> */
|
---|
| 121 | /* A callback function provided by client applications. It is used */
|
---|
| 122 | /* to translate a given @FTC_FaceID into a new valid @FT_Face object. */
|
---|
| 123 | /* */
|
---|
| 124 | /* <Input> */
|
---|
| 125 | /* face_id :: The face ID to resolve. */
|
---|
| 126 | /* */
|
---|
| 127 | /* library :: A handle to a FreeType library object. */
|
---|
| 128 | /* */
|
---|
| 129 | /* data :: Application-provided request data. */
|
---|
| 130 | /* */
|
---|
| 131 | /* <Output> */
|
---|
| 132 | /* aface :: A new @FT_Face handle. */
|
---|
| 133 | /* */
|
---|
| 134 | /* <Return> */
|
---|
| 135 | /* FreeType error code. 0 means success. */
|
---|
| 136 | /* */
|
---|
| 137 | /* <Note> */
|
---|
| 138 | /* The face requester should not perform funny things on the returned */
|
---|
| 139 | /* face object, like creating a new @FT_Size for it, or setting a */
|
---|
| 140 | /* transformation through @FT_Set_Transform! */
|
---|
| 141 | /* */
|
---|
| 142 | typedef FT_Error
|
---|
| 143 | (*FTC_Face_Requester)( FTC_FaceID face_id,
|
---|
| 144 | FT_Library library,
|
---|
| 145 | FT_Pointer request_data,
|
---|
| 146 | FT_Face* aface );
|
---|
| 147 |
|
---|
| 148 |
|
---|
| 149 | /*************************************************************************/
|
---|
| 150 | /* */
|
---|
| 151 | /* <Struct> */
|
---|
| 152 | /* FTC_FontRec */
|
---|
| 153 | /* */
|
---|
| 154 | /* <Description> */
|
---|
| 155 | /* A simple structure used to describe a given `font' to the cache */
|
---|
| 156 | /* manager. Note that a `font' is the combination of a given face */
|
---|
| 157 | /* with a given character size. */
|
---|
| 158 | /* */
|
---|
| 159 | /* <Fields> */
|
---|
| 160 | /* face_id :: The ID of the face to use. */
|
---|
| 161 | /* */
|
---|
| 162 | /* pix_width :: The character width in integer pixels. */
|
---|
| 163 | /* */
|
---|
| 164 | /* pix_height :: The character height in integer pixels. */
|
---|
| 165 | /* */
|
---|
| 166 | typedef struct FTC_FontRec_
|
---|
| 167 | {
|
---|
| 168 | FTC_FaceID face_id;
|
---|
| 169 | FT_UShort pix_width;
|
---|
| 170 | FT_UShort pix_height;
|
---|
| 171 |
|
---|
| 172 | } FTC_FontRec;
|
---|
| 173 |
|
---|
| 174 |
|
---|
| 175 | /* */
|
---|
| 176 |
|
---|
| 177 |
|
---|
| 178 | #define FTC_FONT_COMPARE( f1, f2 ) \
|
---|
| 179 | ( (f1)->face_id == (f2)->face_id && \
|
---|
| 180 | (f1)->pix_width == (f2)->pix_width && \
|
---|
| 181 | (f1)->pix_height == (f2)->pix_height )
|
---|
| 182 |
|
---|
| 183 | #define FT_POINTER_TO_ULONG( p ) ((FT_ULong)(FT_Pointer)(p))
|
---|
| 184 |
|
---|
| 185 | #define FTC_FACE_ID_HASH( i ) \
|
---|
| 186 | ((FT_UInt32)(( FT_POINTER_TO_ULONG( i ) >> 3 ) ^ \
|
---|
| 187 | ( FT_POINTER_TO_ULONG( i ) << 7 ) ) )
|
---|
| 188 |
|
---|
| 189 | #define FTC_FONT_HASH( f ) \
|
---|
| 190 | (FT_UInt32)( FTC_FACE_ID_HASH((f)->face_id) ^ \
|
---|
| 191 | ((f)->pix_width << 8) ^ \
|
---|
| 192 | ((f)->pix_height) )
|
---|
| 193 |
|
---|
| 194 |
|
---|
| 195 | /*************************************************************************/
|
---|
| 196 | /* */
|
---|
| 197 | /* <Type> */
|
---|
| 198 | /* FTC_Font */
|
---|
| 199 | /* */
|
---|
| 200 | /* <Description> */
|
---|
| 201 | /* A simple handle to an @FTC_FontRec structure. */
|
---|
| 202 | /* */
|
---|
| 203 | typedef FTC_FontRec* FTC_Font;
|
---|
| 204 |
|
---|
| 205 |
|
---|
| 206 | /*************************************************************************/
|
---|
| 207 | /*************************************************************************/
|
---|
| 208 | /*************************************************************************/
|
---|
| 209 | /***** *****/
|
---|
| 210 | /***** CACHE MANAGER OBJECT *****/
|
---|
| 211 | /***** *****/
|
---|
| 212 | /*************************************************************************/
|
---|
| 213 | /*************************************************************************/
|
---|
| 214 | /*************************************************************************/
|
---|
| 215 |
|
---|
| 216 |
|
---|
| 217 | /*************************************************************************/
|
---|
| 218 | /* */
|
---|
| 219 | /* <Type> */
|
---|
| 220 | /* FTC_Manager */
|
---|
| 221 | /* */
|
---|
| 222 | /* <Description> */
|
---|
| 223 | /* This object is used to cache one or more @FT_Face objects, along */
|
---|
| 224 | /* with corresponding @FT_Size objects. */
|
---|
| 225 | /* */
|
---|
| 226 | typedef struct FTC_ManagerRec_* FTC_Manager;
|
---|
| 227 |
|
---|
| 228 |
|
---|
| 229 | /*************************************************************************/
|
---|
| 230 | /* */
|
---|
| 231 | /* <Type> */
|
---|
| 232 | /* FTC_Node */
|
---|
| 233 | /* */
|
---|
| 234 | /* <Description> */
|
---|
| 235 | /* An opaque handle to a cache node object. Each cache node is */
|
---|
| 236 | /* reference-counted. A node with a count of 0 might be flushed */
|
---|
| 237 | /* out of a full cache whenever a lookup request is performed. */
|
---|
| 238 | /* */
|
---|
| 239 | /* If you lookup nodes, you have the ability to "acquire" them, i.e., */
|
---|
| 240 | /* to increment their reference count. This will prevent the node */
|
---|
| 241 | /* from being flushed out of the cache until you explicitly "release" */
|
---|
| 242 | /* it (see @FTC_Node_Unref). */
|
---|
| 243 | /* */
|
---|
| 244 | /* See also @FTC_SBitCache_Lookup and @FTC_ImageCache_Lookup. */
|
---|
| 245 | /* */
|
---|
| 246 | typedef struct FTC_NodeRec_* FTC_Node;
|
---|
| 247 |
|
---|
| 248 |
|
---|
| 249 | /*************************************************************************/
|
---|
| 250 | /* */
|
---|
| 251 | /* <Function> */
|
---|
| 252 | /* FTC_Manager_New */
|
---|
| 253 | /* */
|
---|
| 254 | /* <Description> */
|
---|
| 255 | /* Creates a new cache manager. */
|
---|
| 256 | /* */
|
---|
| 257 | /* <Input> */
|
---|
| 258 | /* library :: The parent FreeType library handle to use. */
|
---|
| 259 | /* */
|
---|
| 260 | /* max_bytes :: Maximum number of bytes to use for cached data */
|
---|
| 261 | /* nodes. Use 0 for defaults. Note that this value */
|
---|
| 262 | /* does not account for managed FT_Face and FT_Size */
|
---|
| 263 | /* objects. */
|
---|
| 264 | /* */
|
---|
| 265 | /* requester :: An application-provided callback used to translate */
|
---|
| 266 | /* face IDs into real @FT_Face objects. */
|
---|
| 267 | /* */
|
---|
| 268 | /* req_data :: A generic pointer that is passed to the requester */
|
---|
| 269 | /* each time it is called (see @FTC_Face_Requester). */
|
---|
| 270 | /* */
|
---|
| 271 | /* <Output> */
|
---|
| 272 | /* amanager :: A handle to a new manager object. 0 in case of */
|
---|
| 273 | /* failure. */
|
---|
| 274 | /* */
|
---|
| 275 | /* <Return> */
|
---|
| 276 | /* FreeType error code. 0 means success. */
|
---|
| 277 | /* */
|
---|
| 278 | /* <Note> */
|
---|
| 279 | /* When you perform a lookup, out-of-memory errors are detected */
|
---|
| 280 | /* _within_ the lookup and force incremental flushes of the cache */
|
---|
| 281 | /* until enough memory is released for the lookup to succeed. */
|
---|
| 282 | /* */
|
---|
| 283 | /* If a lookup fails with FT_Err_Out_Of_Memory the cache has already */
|
---|
| 284 | /* been completely flushed, and still no memory is available for the */
|
---|
| 285 | /* operation. */
|
---|
| 286 | /* */
|
---|
| 287 | FT_EXPORT( FT_Error )
|
---|
| 288 | FTC_Manager_New( FT_Library library,
|
---|
| 289 | FT_UInt max_faces,
|
---|
| 290 | FT_UInt max_sizes,
|
---|
| 291 | FT_ULong max_bytes,
|
---|
| 292 | FTC_Face_Requester requester,
|
---|
| 293 | FT_Pointer req_data,
|
---|
| 294 | FTC_Manager *amanager );
|
---|
| 295 |
|
---|
| 296 |
|
---|
| 297 | /*************************************************************************/
|
---|
| 298 | /* */
|
---|
| 299 | /* <Function> */
|
---|
| 300 | /* FTC_Manager_Reset */
|
---|
| 301 | /* */
|
---|
| 302 | /* <Description> */
|
---|
| 303 | /* Empties a given cache manager. This simply gets rid of all the */
|
---|
| 304 | /* currently cached @FT_Face and @FT_Size objects within the manager. */
|
---|
| 305 | /* */
|
---|
| 306 | /* <InOut> */
|
---|
| 307 | /* manager :: A handle to the manager. */
|
---|
| 308 | /* */
|
---|
| 309 | FT_EXPORT( void )
|
---|
| 310 | FTC_Manager_Reset( FTC_Manager manager );
|
---|
| 311 |
|
---|
| 312 |
|
---|
| 313 | /*************************************************************************/
|
---|
| 314 | /* */
|
---|
| 315 | /* <Function> */
|
---|
| 316 | /* FTC_Manager_Done */
|
---|
| 317 | /* */
|
---|
| 318 | /* <Description> */
|
---|
| 319 | /* Destroys a given manager after emptying it. */
|
---|
| 320 | /* */
|
---|
| 321 | /* <Input> */
|
---|
| 322 | /* manager :: A handle to the target cache manager object. */
|
---|
| 323 | /* */
|
---|
| 324 | FT_EXPORT( void )
|
---|
| 325 | FTC_Manager_Done( FTC_Manager manager );
|
---|
| 326 |
|
---|
| 327 |
|
---|
| 328 | /*************************************************************************/
|
---|
| 329 | /* */
|
---|
| 330 | /* <Function> */
|
---|
| 331 | /* FTC_Manager_LookupFace */
|
---|
| 332 | /* */
|
---|
| 333 | /* <Description> */
|
---|
| 334 | /* Retrieves the @FT_Face object that corresponds to a given face ID */
|
---|
| 335 | /* through a cache manager. */
|
---|
| 336 | /* */
|
---|
| 337 | /* <Input> */
|
---|
| 338 | /* manager :: A handle to the cache manager. */
|
---|
| 339 | /* */
|
---|
| 340 | /* face_id :: The ID of the face object. */
|
---|
| 341 | /* */
|
---|
| 342 | /* <Output> */
|
---|
| 343 | /* aface :: A handle to the face object. */
|
---|
| 344 | /* */
|
---|
| 345 | /* <Return> */
|
---|
| 346 | /* FreeType error code. 0 means success. */
|
---|
| 347 | /* */
|
---|
| 348 | /* <Note> */
|
---|
| 349 | /* The returned @FT_Face object is always owned by the manager. You */
|
---|
| 350 | /* should never try to discard it yourself. */
|
---|
| 351 | /* */
|
---|
| 352 | /* The @FT_Face object doesn't necessarily have a current size object */
|
---|
| 353 | /* (i.e., face->size can be 0). If you need a specific `font size', */
|
---|
| 354 | /* use @FTC_Manager_LookupSize instead. */
|
---|
| 355 | /* */
|
---|
| 356 | /* Never change the face's transformation matrix (i.e., never call */
|
---|
| 357 | /* the @FT_Set_Transform function) on a returned face! If you need */
|
---|
| 358 | /* to transform glyphs, do it yourself after glyph loading. */
|
---|
| 359 | /* */
|
---|
| 360 | FT_EXPORT( FT_Error )
|
---|
| 361 | FTC_Manager_LookupFace( FTC_Manager manager,
|
---|
| 362 | FTC_FaceID face_id,
|
---|
| 363 | FT_Face *aface );
|
---|
| 364 |
|
---|
| 365 |
|
---|
| 366 | /*************************************************************************/
|
---|
| 367 | /* */
|
---|
| 368 | /* <Struct> */
|
---|
| 369 | /* FTC_ScalerRec */
|
---|
| 370 | /* */
|
---|
| 371 | /* <Description> */
|
---|
| 372 | /* A structure used to describe a given character size in either */
|
---|
| 373 | /* pixels or points to the cache manager. See */
|
---|
| 374 | /* @FTC_Manager_LookupSize. */
|
---|
| 375 | /* */
|
---|
| 376 | /* <Fields> */
|
---|
| 377 | /* face_id :: The source face ID. */
|
---|
| 378 | /* */
|
---|
| 379 | /* width :: The character width. */
|
---|
| 380 | /* */
|
---|
| 381 | /* height :: The character height. */
|
---|
| 382 | /* */
|
---|
| 383 | /* pixel :: A Boolean. If TRUE, the `width' and `height' fields */
|
---|
| 384 | /* are interpreted as integer pixel character sizes. */
|
---|
| 385 | /* Otherwise, they are expressed as 1/64th of points. */
|
---|
| 386 | /* */
|
---|
| 387 | /* x_res :: Only used when `pixel' is FALSE to indicate the */
|
---|
| 388 | /* horizontal resolution in dpi. */
|
---|
| 389 | /* */
|
---|
| 390 | /* y_res :: Only used when `pixel' is FALSE to indicate the */
|
---|
| 391 | /* vertical resolution in dpi. */
|
---|
| 392 | /* */
|
---|
| 393 | /* <Note> */
|
---|
| 394 | /* This type is mainly used to retrieve @FT_Size objects through the */
|
---|
| 395 | /* cache manager. */
|
---|
| 396 | /* */
|
---|
| 397 | typedef struct FTC_ScalerRec_
|
---|
| 398 | {
|
---|
| 399 | FTC_FaceID face_id;
|
---|
| 400 | FT_UInt width;
|
---|
| 401 | FT_UInt height;
|
---|
| 402 | FT_Int pixel;
|
---|
| 403 | FT_UInt x_res;
|
---|
| 404 | FT_UInt y_res;
|
---|
| 405 |
|
---|
| 406 | } FTC_ScalerRec, *FTC_Scaler;
|
---|
| 407 |
|
---|
| 408 |
|
---|
| 409 | /*************************************************************************/
|
---|
| 410 | /* */
|
---|
| 411 | /* <Function> */
|
---|
| 412 | /* FTC_Manager_LookupSize */
|
---|
| 413 | /* */
|
---|
| 414 | /* <Description> */
|
---|
| 415 | /* Retrieve the @FT_Size object that corresponds to a given */
|
---|
| 416 | /* @FTC_Scaler through a cache manager. */
|
---|
| 417 | /* */
|
---|
| 418 | /* <Input> */
|
---|
| 419 | /* manager :: A handle to the cache manager. */
|
---|
| 420 | /* */
|
---|
| 421 | /* scaler :: A scaler handle. */
|
---|
| 422 | /* */
|
---|
| 423 | /* <Output> */
|
---|
| 424 | /* asize :: A handle to the size object. */
|
---|
| 425 | /* */
|
---|
| 426 | /* <Return> */
|
---|
| 427 | /* FreeType error code. 0 means success. */
|
---|
| 428 | /* */
|
---|
| 429 | /* <Note> */
|
---|
| 430 | /* The returned @FT_Size object is always owned by the manager. You */
|
---|
| 431 | /* should never try to discard it by yourself. */
|
---|
| 432 | /* */
|
---|
| 433 | /* You can access the parent @FT_Face object simply as `size->face' */
|
---|
| 434 | /* if you need it. Note that this object is also owned by the */
|
---|
| 435 | /* manager. */
|
---|
| 436 | /* */
|
---|
| 437 | FT_EXPORT( FT_Error )
|
---|
| 438 | FTC_Manager_LookupSize( FTC_Manager manager,
|
---|
| 439 | FTC_Scaler scaler,
|
---|
| 440 | FT_Size *asize );
|
---|
| 441 |
|
---|
| 442 |
|
---|
| 443 | /*************************************************************************/
|
---|
| 444 | /* */
|
---|
| 445 | /* <Function> */
|
---|
| 446 | /* FTC_Node_Unref */
|
---|
| 447 | /* */
|
---|
| 448 | /* <Description> */
|
---|
| 449 | /* Decrement a cache node's internal reference count. When the count */
|
---|
| 450 | /* reaches 0, it is not destroyed but becomes eligible for subsequent */
|
---|
| 451 | /* cache flushes. */
|
---|
| 452 | /* */
|
---|
| 453 | /* <Input> */
|
---|
| 454 | /* node :: The cache node handle. */
|
---|
| 455 | /* */
|
---|
| 456 | /* manager :: The cache manager handle. */
|
---|
| 457 | /* */
|
---|
| 458 | FT_EXPORT( void )
|
---|
| 459 | FTC_Node_Unref( FTC_Node node,
|
---|
| 460 | FTC_Manager manager );
|
---|
| 461 |
|
---|
| 462 |
|
---|
| 463 | /* remove all nodes belonging to a given face_id */
|
---|
| 464 | FT_EXPORT( void )
|
---|
| 465 | FTC_Manager_RemoveFaceID( FTC_Manager manager,
|
---|
| 466 | FTC_FaceID face_id );
|
---|
| 467 |
|
---|
| 468 |
|
---|
| 469 | /*************************************************************************/
|
---|
| 470 | /* */
|
---|
| 471 | /* <Section> */
|
---|
| 472 | /* cache_subsystem */
|
---|
| 473 | /* */
|
---|
| 474 | /*************************************************************************/
|
---|
| 475 |
|
---|
| 476 | /************************************************************************
|
---|
| 477 | *
|
---|
| 478 | * @type:
|
---|
| 479 | * FTC_CMapCache
|
---|
| 480 | *
|
---|
| 481 | * @description:
|
---|
| 482 | * An opaque handle used to manager a charmap cache. This cache is
|
---|
| 483 | * to hold character codes -> glyph indices mappings.
|
---|
| 484 | */
|
---|
| 485 | typedef struct FTC_CMapCacheRec_* FTC_CMapCache;
|
---|
| 486 |
|
---|
| 487 |
|
---|
| 488 | /*************************************************************************/
|
---|
| 489 | /* */
|
---|
| 490 | /* @function: */
|
---|
| 491 | /* FTC_CMapCache_New */
|
---|
| 492 | /* */
|
---|
| 493 | /* @description: */
|
---|
| 494 | /* Create a new charmap cache. */
|
---|
| 495 | /* */
|
---|
| 496 | /* @input: */
|
---|
| 497 | /* manager :: A handle to the cache manager. */
|
---|
| 498 | /* */
|
---|
| 499 | /* @output: */
|
---|
| 500 | /* acache :: A new cache handle. NULL in case of error. */
|
---|
| 501 | /* */
|
---|
| 502 | /* @return: */
|
---|
| 503 | /* FreeType error code. 0 means success. */
|
---|
| 504 | /* */
|
---|
| 505 | /* @note: */
|
---|
| 506 | /* Like all other caches, this one will be destroyed with the cache */
|
---|
| 507 | /* manager. */
|
---|
| 508 | /* */
|
---|
| 509 | FT_EXPORT( FT_Error )
|
---|
| 510 | FTC_CMapCache_New( FTC_Manager manager,
|
---|
| 511 | FTC_CMapCache *acache );
|
---|
| 512 |
|
---|
| 513 |
|
---|
| 514 | /*************************************************************************/
|
---|
| 515 | /* */
|
---|
| 516 | /* @function: */
|
---|
| 517 | /* FTC_CMapCache_Lookup */
|
---|
| 518 | /* */
|
---|
| 519 | /* @description: */
|
---|
| 520 | /* Translate a character code into a glyph index, using the charmap */
|
---|
| 521 | /* cache. */
|
---|
| 522 | /* */
|
---|
| 523 | /* @input: */
|
---|
| 524 | /* cache :: A charmap cache handle. */
|
---|
| 525 | /* */
|
---|
| 526 | /* face_id :: The source face ID. */
|
---|
| 527 | /* */
|
---|
| 528 | /* cmap_index :: The index of the charmap in the source face. */
|
---|
| 529 | /* */
|
---|
| 530 | /* char_code :: The character code (in the corresponding charmap). */
|
---|
| 531 | /* */
|
---|
| 532 | /* @return: */
|
---|
| 533 | /* Glyph index. 0 means `no glyph'. */
|
---|
| 534 | /* */
|
---|
| 535 | FT_EXPORT( FT_UInt )
|
---|
| 536 | FTC_CMapCache_Lookup( FTC_CMapCache cache,
|
---|
| 537 | FTC_FaceID face_id,
|
---|
| 538 | FT_Int cmap_index,
|
---|
| 539 | FT_UInt32 char_code );
|
---|
| 540 |
|
---|
| 541 |
|
---|
| 542 | /*************************************************************************/
|
---|
| 543 | /* */
|
---|
| 544 | /* <Section> */
|
---|
| 545 | /* cache_subsystem */
|
---|
| 546 | /* */
|
---|
| 547 | /*************************************************************************/
|
---|
| 548 |
|
---|
| 549 |
|
---|
| 550 | /*************************************************************************/
|
---|
| 551 | /*************************************************************************/
|
---|
| 552 | /*************************************************************************/
|
---|
| 553 | /***** *****/
|
---|
| 554 | /***** IMAGE CACHE OBJECT *****/
|
---|
| 555 | /***** *****/
|
---|
| 556 | /*************************************************************************/
|
---|
| 557 | /*************************************************************************/
|
---|
| 558 | /*************************************************************************/
|
---|
| 559 |
|
---|
| 560 | typedef struct FTC_ImageTypeRec_
|
---|
| 561 | {
|
---|
| 562 | FTC_FaceID face_id;
|
---|
| 563 | FT_Int width;
|
---|
| 564 | FT_Int height;
|
---|
| 565 | FT_Int32 flags;
|
---|
| 566 |
|
---|
| 567 | } FTC_ImageTypeRec;
|
---|
| 568 |
|
---|
| 569 | typedef struct FTC_ImageTypeRec_* FTC_ImageType;
|
---|
| 570 |
|
---|
| 571 | /* */
|
---|
| 572 |
|
---|
| 573 | #define FTC_IMAGE_TYPE_COMPARE( d1, d2 ) \
|
---|
| 574 | ( FTC_FONT_COMPARE( &(d1)->font, &(d2)->font ) && \
|
---|
| 575 | (d1)->flags == (d2)->flags )
|
---|
| 576 |
|
---|
| 577 | #define FTC_IMAGE_TYPE_HASH( d ) \
|
---|
| 578 | (FT_UFast)( FTC_FONT_HASH( &(d)->font ) ^ \
|
---|
| 579 | ( (d)->flags << 4 ) )
|
---|
| 580 |
|
---|
| 581 |
|
---|
| 582 | /*************************************************************************/
|
---|
| 583 | /* */
|
---|
| 584 | /* <Type> */
|
---|
| 585 | /* FTC_ImageCache */
|
---|
| 586 | /* */
|
---|
| 587 | /* <Description> */
|
---|
| 588 | /* A handle to an glyph image cache object. They are designed to */
|
---|
| 589 | /* hold many distinct glyph images while not exceeding a certain */
|
---|
| 590 | /* memory threshold. */
|
---|
| 591 | /* */
|
---|
| 592 | typedef struct FTC_ImageCacheRec_* FTC_ImageCache;
|
---|
| 593 |
|
---|
| 594 |
|
---|
| 595 | /*************************************************************************/
|
---|
| 596 | /* */
|
---|
| 597 | /* <Function> */
|
---|
| 598 | /* FTC_ImageCache_New */
|
---|
| 599 | /* */
|
---|
| 600 | /* <Description> */
|
---|
| 601 | /* Creates a new glyph image cache. */
|
---|
| 602 | /* */
|
---|
| 603 | /* <Input> */
|
---|
| 604 | /* manager :: The parent manager for the image cache. */
|
---|
| 605 | /* */
|
---|
| 606 | /* <Output> */
|
---|
| 607 | /* acache :: A handle to the new glyph image cache object. */
|
---|
| 608 | /* */
|
---|
| 609 | /* <Return> */
|
---|
| 610 | /* FreeType error code. 0 means success. */
|
---|
| 611 | /* */
|
---|
| 612 | FT_EXPORT( FT_Error )
|
---|
| 613 | FTC_ImageCache_New( FTC_Manager manager,
|
---|
| 614 | FTC_ImageCache *acache );
|
---|
| 615 |
|
---|
| 616 |
|
---|
| 617 | /*************************************************************************/
|
---|
| 618 | /* */
|
---|
| 619 | /* <Function> */
|
---|
| 620 | /* FTC_ImageCache_Lookup */
|
---|
| 621 | /* */
|
---|
| 622 | /* <Description> */
|
---|
| 623 | /* Retrieves a given glyph image from a glyph image cache. */
|
---|
| 624 | /* */
|
---|
| 625 | /* <Input> */
|
---|
| 626 | /* cache :: A handle to the source glyph image cache. */
|
---|
| 627 | /* */
|
---|
| 628 | /* type :: A pointer to a glyph image type descriptor. */
|
---|
| 629 | /* */
|
---|
| 630 | /* gindex :: The glyph index to retrieve. */
|
---|
| 631 | /* */
|
---|
| 632 | /* <Output> */
|
---|
| 633 | /* aglyph :: The corresponding @FT_Glyph object. 0 in case of */
|
---|
| 634 | /* failure. */
|
---|
| 635 | /* */
|
---|
| 636 | /* anode :: Used to return the address of of the corresponding cache */
|
---|
| 637 | /* node after incrementing its reference count (see note */
|
---|
| 638 | /* below). */
|
---|
| 639 | /* */
|
---|
| 640 | /* <Return> */
|
---|
| 641 | /* FreeType error code. 0 means success. */
|
---|
| 642 | /* */
|
---|
| 643 | /* <Note> */
|
---|
| 644 | /* The returned glyph is owned and managed by the glyph image cache. */
|
---|
| 645 | /* Never try to transform or discard it manually! You can however */
|
---|
| 646 | /* create a copy with @FT_Glyph_Copy and modify the new one. */
|
---|
| 647 | /* */
|
---|
| 648 | /* If `anode' is _not_ NULL, it receives the address of the cache */
|
---|
| 649 | /* node containing the glyph image, after increasing its reference */
|
---|
| 650 | /* count. This ensures that the node (as well as the FT_Glyph) will */
|
---|
| 651 | /* always be kept in the cache until you call @FTC_Node_Unref to */
|
---|
| 652 | /* `release' it. */
|
---|
| 653 | /* */
|
---|
| 654 | /* If `anode' is NULL, the cache node is left unchanged, which means */
|
---|
| 655 | /* that the FT_Glyph could be flushed out of the cache on the next */
|
---|
| 656 | /* call to one of the caching sub-system APIs. Don't assume that it */
|
---|
| 657 | /* is persistent! */
|
---|
| 658 | /* */
|
---|
| 659 | FT_EXPORT( FT_Error )
|
---|
| 660 | FTC_ImageCache_Lookup( FTC_ImageCache cache,
|
---|
| 661 | FTC_ImageType type,
|
---|
| 662 | FT_UInt gindex,
|
---|
| 663 | FT_Glyph *aglyph,
|
---|
| 664 | FTC_Node *anode );
|
---|
| 665 |
|
---|
| 666 |
|
---|
| 667 | /*************************************************************************/
|
---|
| 668 | /* */
|
---|
| 669 | /* <Type> */
|
---|
| 670 | /* FTC_SBit */
|
---|
| 671 | /* */
|
---|
| 672 | /* <Description> */
|
---|
| 673 | /* A handle to a small bitmap descriptor. See the @FTC_SBitRec */
|
---|
| 674 | /* structure for details. */
|
---|
| 675 | /* */
|
---|
| 676 | typedef struct FTC_SBitRec_* FTC_SBit;
|
---|
| 677 |
|
---|
| 678 |
|
---|
| 679 | /*************************************************************************/
|
---|
| 680 | /* */
|
---|
| 681 | /* <Struct> */
|
---|
| 682 | /* FTC_SBitRec */
|
---|
| 683 | /* */
|
---|
| 684 | /* <Description> */
|
---|
| 685 | /* A very compact structure used to describe a small glyph bitmap. */
|
---|
| 686 | /* */
|
---|
| 687 | /* <Fields> */
|
---|
| 688 | /* width :: The bitmap width in pixels. */
|
---|
| 689 | /* */
|
---|
| 690 | /* height :: The bitmap height in pixels. */
|
---|
| 691 | /* */
|
---|
| 692 | /* left :: The horizontal distance from the pen position to the */
|
---|
| 693 | /* left bitmap border (a.k.a. `left side bearing', or */
|
---|
| 694 | /* `lsb'). */
|
---|
| 695 | /* */
|
---|
| 696 | /* top :: The vertical distance from the pen position (on the */
|
---|
| 697 | /* baseline) to the upper bitmap border (a.k.a. `top */
|
---|
| 698 | /* side bearing'). The distance is positive for upwards */
|
---|
| 699 | /* Y coordinates. */
|
---|
| 700 | /* */
|
---|
| 701 | /* format :: The format of the glyph bitmap (monochrome or gray). */
|
---|
| 702 | /* */
|
---|
| 703 | /* max_grays :: Maximum gray level value (in the range 1 to 255). */
|
---|
| 704 | /* */
|
---|
| 705 | /* pitch :: The number of bytes per bitmap line. May be positive */
|
---|
| 706 | /* or negative. */
|
---|
| 707 | /* */
|
---|
| 708 | /* xadvance :: The horizontal advance width in pixels. */
|
---|
| 709 | /* */
|
---|
| 710 | /* yadvance :: The vertical advance height in pixels. */
|
---|
| 711 | /* */
|
---|
| 712 | /* buffer :: A pointer to the bitmap pixels. */
|
---|
| 713 | /* */
|
---|
| 714 | typedef struct FTC_SBitRec_
|
---|
| 715 | {
|
---|
| 716 | FT_Byte width;
|
---|
| 717 | FT_Byte height;
|
---|
| 718 | FT_Char left;
|
---|
| 719 | FT_Char top;
|
---|
| 720 |
|
---|
| 721 | FT_Byte format;
|
---|
| 722 | FT_Byte max_grays;
|
---|
| 723 | FT_Short pitch;
|
---|
| 724 | FT_Char xadvance;
|
---|
| 725 | FT_Char yadvance;
|
---|
| 726 |
|
---|
| 727 | FT_Byte* buffer;
|
---|
| 728 |
|
---|
| 729 | } FTC_SBitRec;
|
---|
| 730 |
|
---|
| 731 |
|
---|
| 732 | /*************************************************************************/
|
---|
| 733 | /* */
|
---|
| 734 | /* <Type> */
|
---|
| 735 | /* FTC_SBitCache */
|
---|
| 736 | /* */
|
---|
| 737 | /* <Description> */
|
---|
| 738 | /* A handle to a small bitmap cache. These are special cache objects */
|
---|
| 739 | /* used to store small glyph bitmaps (and anti-aliased pixmaps) in a */
|
---|
| 740 | /* much more efficient way than the traditional glyph image cache */
|
---|
| 741 | /* implemented by @FTC_ImageCache. */
|
---|
| 742 | /* */
|
---|
| 743 | typedef struct FTC_SBitCacheRec_* FTC_SBitCache;
|
---|
| 744 |
|
---|
| 745 |
|
---|
| 746 | /*************************************************************************/
|
---|
| 747 | /* */
|
---|
| 748 | /* <Function> */
|
---|
| 749 | /* FTC_SBitCache_New */
|
---|
| 750 | /* */
|
---|
| 751 | /* <Description> */
|
---|
| 752 | /* Creates a new cache to store small glyph bitmaps. */
|
---|
| 753 | /* */
|
---|
| 754 | /* <Input> */
|
---|
| 755 | /* manager :: A handle to the source cache manager. */
|
---|
| 756 | /* */
|
---|
| 757 | /* <Output> */
|
---|
| 758 | /* acache :: A handle to the new sbit cache. NULL in case of error. */
|
---|
| 759 | /* */
|
---|
| 760 | /* <Return> */
|
---|
| 761 | /* FreeType error code. 0 means success. */
|
---|
| 762 | /* */
|
---|
| 763 | FT_EXPORT( FT_Error )
|
---|
| 764 | FTC_SBitCache_New( FTC_Manager manager,
|
---|
| 765 | FTC_SBitCache *acache );
|
---|
| 766 |
|
---|
| 767 |
|
---|
| 768 | /*************************************************************************/
|
---|
| 769 | /* */
|
---|
| 770 | /* <Function> */
|
---|
| 771 | /* FTC_SBitCache_Lookup */
|
---|
| 772 | /* */
|
---|
| 773 | /* <Description> */
|
---|
| 774 | /* Looks up a given small glyph bitmap in a given sbit cache and */
|
---|
| 775 | /* `lock' it to prevent its flushing from the cache until needed. */
|
---|
| 776 | /* */
|
---|
| 777 | /* <Input> */
|
---|
| 778 | /* cache :: A handle to the source sbit cache. */
|
---|
| 779 | /* */
|
---|
| 780 | /* type :: A pointer to the glyph image type descriptor. */
|
---|
| 781 | /* */
|
---|
| 782 | /* gindex :: The glyph index. */
|
---|
| 783 | /* */
|
---|
| 784 | /* <Output> */
|
---|
| 785 | /* sbit :: A handle to a small bitmap descriptor. */
|
---|
| 786 | /* */
|
---|
| 787 | /* anode :: Used to return the address of of the corresponding cache */
|
---|
| 788 | /* node after incrementing its reference count (see note */
|
---|
| 789 | /* below). */
|
---|
| 790 | /* */
|
---|
| 791 | /* <Return> */
|
---|
| 792 | /* FreeType error code. 0 means success. */
|
---|
| 793 | /* */
|
---|
| 794 | /* <Note> */
|
---|
| 795 | /* The small bitmap descriptor and its bit buffer are owned by the */
|
---|
| 796 | /* cache and should never be freed by the application. They might */
|
---|
| 797 | /* as well disappear from memory on the next cache lookup, so don't */
|
---|
| 798 | /* treat them as persistent data. */
|
---|
| 799 | /* */
|
---|
| 800 | /* The descriptor's `buffer' field is set to 0 to indicate a missing */
|
---|
| 801 | /* glyph bitmap. */
|
---|
| 802 | /* */
|
---|
| 803 | /* If `anode' is _not_ NULL, it receives the address of the cache */
|
---|
| 804 | /* node containing the bitmap, after increasing its reference count. */
|
---|
| 805 | /* This ensures that the node (as well as the image) will always be */
|
---|
| 806 | /* kept in the cache until you call @FTC_Node_Unref to `release' it. */
|
---|
| 807 | /* */
|
---|
| 808 | /* If `anode' is NULL, the cache node is left unchanged, which means */
|
---|
| 809 | /* that the bitmap could be flushed out of the cache on the next */
|
---|
| 810 | /* call to one of the caching sub-system APIs. Don't assume that it */
|
---|
| 811 | /* is persistent! */
|
---|
| 812 | /* */
|
---|
| 813 | FT_EXPORT( FT_Error )
|
---|
| 814 | FTC_SBitCache_Lookup( FTC_SBitCache cache,
|
---|
| 815 | FTC_ImageType type,
|
---|
| 816 | FT_UInt gindex,
|
---|
| 817 | FTC_SBit *sbit,
|
---|
| 818 | FTC_Node *anode );
|
---|
| 819 |
|
---|
| 820 |
|
---|
| 821 | /* */
|
---|
| 822 |
|
---|
| 823 | FT_END_HEADER
|
---|
| 824 |
|
---|
| 825 | #endif /* __FTCACHE_H__ */
|
---|
| 826 |
|
---|
| 827 |
|
---|
| 828 | /* END */
|
---|