1/***************************************************************************/ 2/* */ 3/* ftobjs.h */ 4/* */ 5/* The FreeType private base classes (specification). */ 6/* */ 7/* Copyright 1996-2006, 2008, 2010, 2012-2013 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 contains the definition of all internal FreeType classes. */ 22 /* */ 23 /*************************************************************************/ 24 25 26#ifndef __FTOBJS_H__ 27#define __FTOBJS_H__ 28 29#include <ft2build.h> 30#include FT_RENDER_H 31#include FT_SIZES_H 32#include FT_LCD_FILTER_H 33#include FT_INTERNAL_MEMORY_H 34#include FT_INTERNAL_GLYPH_LOADER_H 35#include FT_INTERNAL_DRIVER_H 36#include FT_INTERNAL_AUTOHINT_H 37#include FT_INTERNAL_SERVICE_H 38#include FT_INTERNAL_PIC_H 39 40#ifdef FT_CONFIG_OPTION_INCREMENTAL 41#include FT_INCREMENTAL_H 42#endif 43 44 45FT_BEGIN_HEADER 46 47 48 /*************************************************************************/ 49 /* */ 50 /* Some generic definitions. */ 51 /* */ 52#ifndef TRUE 53#define TRUE 1 54#endif 55 56#ifndef FALSE 57#define FALSE 0 58#endif 59 60#ifndef NULL 61#define NULL (void*)0 62#endif 63 64 65 /*************************************************************************/ 66 /* */ 67 /* The min and max functions missing in C. As usual, be careful not to */ 68 /* write things like FT_MIN( a++, b++ ) to avoid side effects. */ 69 /* */ 70#define FT_MIN( a, b ) ( (a) < (b) ? (a) : (b) ) 71#define FT_MAX( a, b ) ( (a) > (b) ? (a) : (b) ) 72 73#define FT_ABS( a ) ( (a) < 0 ? -(a) : (a) ) 74 75 /* 76 * Approximate sqrt(x*x+y*y) using the `alpha max plus beta min' 77 * algorithm. We use alpha = 1, beta = 3/8, giving us results with a 78 * largest error less than 7% compared to the exact value. 79 */ 80#define FT_HYPOT( x, y ) \ 81 ( x = FT_ABS( x ), \ 82 y = FT_ABS( y ), \ 83 x > y ? x + ( 3 * y >> 3 ) \ 84 : y + ( 3 * x >> 3 ) ) 85 86#define FT_PAD_FLOOR( x, n ) ( (x) & ~((n)-1) ) 87#define FT_PAD_ROUND( x, n ) FT_PAD_FLOOR( (x) + ((n)/2), n ) 88#define FT_PAD_CEIL( x, n ) FT_PAD_FLOOR( (x) + ((n)-1), n ) 89 90#define FT_PIX_FLOOR( x ) ( (x) & ~63 ) 91#define FT_PIX_ROUND( x ) FT_PIX_FLOOR( (x) + 32 ) 92#define FT_PIX_CEIL( x ) FT_PIX_FLOOR( (x) + 63 ) 93 94 95 /* 96 * character classification functions -- since these are used to parse 97 * font files, we must not use those in <ctypes.h> which are 98 * locale-dependent 99 */ 100#define ft_isdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U ) 101 102#define ft_isxdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U || \ 103 ( (unsigned)(x) - 'a' ) < 6U || \ 104 ( (unsigned)(x) - 'A' ) < 6U ) 105 106 /* the next two macros assume ASCII representation */ 107#define ft_isupper( x ) ( ( (unsigned)(x) - 'A' ) < 26U ) 108#define ft_islower( x ) ( ( (unsigned)(x) - 'a' ) < 26U ) 109 110#define ft_isalpha( x ) ( ft_isupper( x ) || ft_islower( x ) ) 111#define ft_isalnum( x ) ( ft_isdigit( x ) || ft_isalpha( x ) ) 112 113 114 /*************************************************************************/ 115 /*************************************************************************/ 116 /*************************************************************************/ 117 /**** ****/ 118 /**** ****/ 119 /**** C H A R M A P S ****/ 120 /**** ****/ 121 /**** ****/ 122 /*************************************************************************/ 123 /*************************************************************************/ 124 /*************************************************************************/ 125 126 /* handle to internal charmap object */ 127 typedef struct FT_CMapRec_* FT_CMap; 128 129 /* handle to charmap class structure */ 130 typedef const struct FT_CMap_ClassRec_* FT_CMap_Class; 131 132 /* internal charmap object structure */ 133 typedef struct FT_CMapRec_ 134 { 135 FT_CharMapRec charmap; 136 FT_CMap_Class clazz; 137 138 } FT_CMapRec; 139 140 /* typecase any pointer to a charmap handle */ 141#define FT_CMAP( x ) ((FT_CMap)( x )) 142 143 /* obvious macros */ 144#define FT_CMAP_PLATFORM_ID( x ) FT_CMAP( x )->charmap.platform_id 145#define FT_CMAP_ENCODING_ID( x ) FT_CMAP( x )->charmap.encoding_id 146#define FT_CMAP_ENCODING( x ) FT_CMAP( x )->charmap.encoding 147#define FT_CMAP_FACE( x ) FT_CMAP( x )->charmap.face 148 149 150 /* class method definitions */ 151 typedef FT_Error 152 (*FT_CMap_InitFunc)( FT_CMap cmap, 153 FT_Pointer init_data ); 154 155 typedef void 156 (*FT_CMap_DoneFunc)( FT_CMap cmap ); 157 158 typedef FT_UInt 159 (*FT_CMap_CharIndexFunc)( FT_CMap cmap, 160 FT_UInt32 char_code ); 161 162 typedef FT_UInt 163 (*FT_CMap_CharNextFunc)( FT_CMap cmap, 164 FT_UInt32 *achar_code ); 165 166 typedef FT_UInt 167 (*FT_CMap_CharVarIndexFunc)( FT_CMap cmap, 168 FT_CMap unicode_cmap, 169 FT_UInt32 char_code, 170 FT_UInt32 variant_selector ); 171 172 typedef FT_Bool 173 (*FT_CMap_CharVarIsDefaultFunc)( FT_CMap cmap, 174 FT_UInt32 char_code, 175 FT_UInt32 variant_selector ); 176 177 typedef FT_UInt32 * 178 (*FT_CMap_VariantListFunc)( FT_CMap cmap, 179 FT_Memory mem ); 180 181 typedef FT_UInt32 * 182 (*FT_CMap_CharVariantListFunc)( FT_CMap cmap, 183 FT_Memory mem, 184 FT_UInt32 char_code ); 185 186 typedef FT_UInt32 * 187 (*FT_CMap_VariantCharListFunc)( FT_CMap cmap, 188 FT_Memory mem, 189 FT_UInt32 variant_selector ); 190 191 192 typedef struct FT_CMap_ClassRec_ 193 { 194 FT_ULong size; 195 FT_CMap_InitFunc init; 196 FT_CMap_DoneFunc done; 197 FT_CMap_CharIndexFunc char_index; 198 FT_CMap_CharNextFunc char_next; 199 200 /* Subsequent entries are special ones for format 14 -- the variant */ 201 /* selector subtable which behaves like no other */ 202 203 FT_CMap_CharVarIndexFunc char_var_index; 204 FT_CMap_CharVarIsDefaultFunc char_var_default; 205 FT_CMap_VariantListFunc variant_list; 206 FT_CMap_CharVariantListFunc charvariant_list; 207 FT_CMap_VariantCharListFunc variantchar_list; 208 209 } FT_CMap_ClassRec; 210 211 212#ifndef FT_CONFIG_OPTION_PIC 213 214#define FT_DECLARE_CMAP_CLASS( class_ ) \ 215 FT_CALLBACK_TABLE const FT_CMap_ClassRec class_; 216 217#define FT_DEFINE_CMAP_CLASS( \ 218 class_, \ 219 size_, \ 220 init_, \ 221 done_, \ 222 char_index_, \ 223 char_next_, \ 224 char_var_index_, \ 225 char_var_default_, \ 226 variant_list_, \ 227 charvariant_list_, \ 228 variantchar_list_ ) \ 229 FT_CALLBACK_TABLE_DEF \ 230 const FT_CMap_ClassRec class_ = \ 231 { \ 232 size_, \ 233 init_, \ 234 done_, \ 235 char_index_, \ 236 char_next_, \ 237 char_var_index_, \ 238 char_var_default_, \ 239 variant_list_, \ 240 charvariant_list_, \ 241 variantchar_list_ \ 242 }; 243 244#else /* FT_CONFIG_OPTION_PIC */ 245 246#define FT_DECLARE_CMAP_CLASS( class_ ) \ 247 void \ 248 FT_Init_Class_ ## class_( FT_Library library, \ 249 FT_CMap_ClassRec* clazz ); 250 251#define FT_DEFINE_CMAP_CLASS( \ 252 class_, \ 253 size_, \ 254 init_, \ 255 done_, \ 256 char_index_, \ 257 char_next_, \ 258 char_var_index_, \ 259 char_var_default_, \ 260 variant_list_, \ 261 charvariant_list_, \ 262 variantchar_list_ ) \ 263 void \ 264 FT_Init_Class_ ## class_( FT_Library library, \ 265 FT_CMap_ClassRec* clazz ) \ 266 { \ 267 FT_UNUSED( library ); \ 268 \ 269 clazz->size = size_; \ 270 clazz->init = init_; \ 271 clazz->done = done_; \ 272 clazz->char_index = char_index_; \ 273 clazz->char_next = char_next_; \ 274 clazz->char_var_index = char_var_index_; \ 275 clazz->char_var_default = char_var_default_; \ 276 clazz->variant_list = variant_list_; \ 277 clazz->charvariant_list = charvariant_list_; \ 278 clazz->variantchar_list = variantchar_list_; \ 279 } 280 281#endif /* FT_CONFIG_OPTION_PIC */ 282 283 284 /* create a new charmap and add it to charmap->face */ 285 FT_BASE( FT_Error ) 286 FT_CMap_New( FT_CMap_Class clazz, 287 FT_Pointer init_data, 288 FT_CharMap charmap, 289 FT_CMap *acmap ); 290 291 /* destroy a charmap and remove it from face's list */ 292 FT_BASE( void ) 293 FT_CMap_Done( FT_CMap cmap ); 294 295 296 /*************************************************************************/ 297 /* */ 298 /* <Struct> */ 299 /* FT_Face_InternalRec */ 300 /* */ 301 /* <Description> */ 302 /* This structure contains the internal fields of each FT_Face */ 303 /* object. These fields may change between different releases of */ 304 /* FreeType. */ 305 /* */ 306 /* <Fields> */ 307 /* max_points :: */ 308 /* The maximum number of points used to store the vectorial outline */ 309 /* of any glyph in this face. If this value cannot be known in */ 310 /* advance, or if the face isn't scalable, this should be set to 0. */ 311 /* Only relevant for scalable formats. */ 312 /* */ 313 /* max_contours :: */ 314 /* The maximum number of contours used to store the vectorial */ 315 /* outline of any glyph in this face. If this value cannot be */ 316 /* known in advance, or if the face isn't scalable, this should be */ 317 /* set to 0. Only relevant for scalable formats. */ 318 /* */ 319 /* transform_matrix :: */ 320 /* A 2x2 matrix of 16.16 coefficients used to transform glyph */ 321 /* outlines after they are loaded from the font. Only used by the */ 322 /* convenience functions. */ 323 /* */ 324 /* transform_delta :: */ 325 /* A translation vector used to transform glyph outlines after they */ 326 /* are loaded from the font. Only used by the convenience */ 327 /* functions. */ 328 /* */ 329 /* transform_flags :: */ 330 /* Some flags used to classify the transform. Only used by the */ 331 /* convenience functions. */ 332 /* */ 333 /* services :: */ 334 /* A cache for frequently used services. It should be only */ 335 /* accessed with the macro `FT_FACE_LOOKUP_SERVICE'. */ 336 /* */ 337 /* incremental_interface :: */ 338 /* If non-null, the interface through which glyph data and metrics */ 339 /* are loaded incrementally for faces that do not provide all of */ 340 /* this data when first opened. This field exists only if */ 341 /* @FT_CONFIG_OPTION_INCREMENTAL is defined. */ 342 /* */ 343 /* ignore_unpatented_hinter :: */ 344 /* This boolean flag instructs the glyph loader to ignore the */ 345 /* native font hinter, if one is found. This is exclusively used */ 346 /* in the case when the unpatented hinter is compiled within the */ 347 /* library. */ 348 /* */ 349 /* refcount :: */ 350 /* A counter initialized to~1 at the time an @FT_Face structure is */ 351 /* created. @FT_Reference_Face increments this counter, and */ 352 /* @FT_Done_Face only destroys a face if the counter is~1, */ 353 /* otherwise it simply decrements it. */ 354 /* */ 355 typedef struct FT_Face_InternalRec_ 356 { 357 FT_Matrix transform_matrix; 358 FT_Vector transform_delta; 359 FT_Int transform_flags; 360 361 FT_ServiceCacheRec services; 362 363#ifdef FT_CONFIG_OPTION_INCREMENTAL 364 FT_Incremental_InterfaceRec* incremental_interface; 365#endif 366 367 FT_Bool ignore_unpatented_hinter; 368 FT_Int refcount; 369 370 } FT_Face_InternalRec; 371 372 373 /*************************************************************************/ 374 /* */ 375 /* <Struct> */ 376 /* FT_Slot_InternalRec */ 377 /* */ 378 /* <Description> */ 379 /* This structure contains the internal fields of each FT_GlyphSlot */ 380 /* object. These fields may change between different releases of */ 381 /* FreeType. */ 382 /* */ 383 /* <Fields> */ 384 /* loader :: The glyph loader object used to load outlines */ 385 /* into the glyph slot. */ 386 /* */ 387 /* flags :: Possible values are zero or */ 388 /* FT_GLYPH_OWN_BITMAP. The latter indicates */ 389 /* that the FT_GlyphSlot structure owns the */ 390 /* bitmap buffer. */ 391 /* */ 392 /* glyph_transformed :: Boolean. Set to TRUE when the loaded glyph */ 393 /* must be transformed through a specific */ 394 /* font transformation. This is _not_ the same */ 395 /* as the face transform set through */ 396 /* FT_Set_Transform(). */ 397 /* */ 398 /* glyph_matrix :: The 2x2 matrix corresponding to the glyph */ 399 /* transformation, if necessary. */ 400 /* */ 401 /* glyph_delta :: The 2d translation vector corresponding to */ 402 /* the glyph transformation, if necessary. */ 403 /* */ 404 /* glyph_hints :: Format-specific glyph hints management. */ 405 /* */ 406 407#define FT_GLYPH_OWN_BITMAP 0x1 408 409 typedef struct FT_Slot_InternalRec_ 410 { 411 FT_GlyphLoader loader; 412 FT_UInt flags; 413 FT_Bool glyph_transformed; 414 FT_Matrix glyph_matrix; 415 FT_Vector glyph_delta; 416 void* glyph_hints; 417 418 } FT_GlyphSlot_InternalRec; 419 420 421#if 0 422 423 /*************************************************************************/ 424 /* */ 425 /* <Struct> */ 426 /* FT_Size_InternalRec */ 427 /* */ 428 /* <Description> */ 429 /* This structure contains the internal fields of each FT_Size */ 430 /* object. Currently, it's empty. */ 431 /* */ 432 /*************************************************************************/ 433 434 typedef struct FT_Size_InternalRec_ 435 { 436 /* empty */ 437 438 } FT_Size_InternalRec; 439 440#endif 441 442 443 /*************************************************************************/ 444 /*************************************************************************/ 445 /*************************************************************************/ 446 /**** ****/ 447 /**** ****/ 448 /**** M O D U L E S ****/ 449 /**** ****/ 450 /**** ****/ 451 /*************************************************************************/ 452 /*************************************************************************/ 453 /*************************************************************************/ 454 455 456 /*************************************************************************/ 457 /* */ 458 /* <Struct> */ 459 /* FT_ModuleRec */ 460 /* */ 461 /* <Description> */ 462 /* A module object instance. */ 463 /* */ 464 /* <Fields> */ 465 /* clazz :: A pointer to the module's class. */ 466 /* */ 467 /* library :: A handle to the parent library object. */ 468 /* */ 469 /* memory :: A handle to the memory manager. */ 470 /* */ 471 typedef struct FT_ModuleRec_ 472 { 473 FT_Module_Class* clazz; 474 FT_Library library; 475 FT_Memory memory; 476 477 } FT_ModuleRec; 478 479 480 /* typecast an object to an FT_Module */ 481#define FT_MODULE( x ) ((FT_Module)( x )) 482#define FT_MODULE_CLASS( x ) FT_MODULE( x )->clazz 483#define FT_MODULE_LIBRARY( x ) FT_MODULE( x )->library 484#define FT_MODULE_MEMORY( x ) FT_MODULE( x )->memory 485 486 487#define FT_MODULE_IS_DRIVER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 488 FT_MODULE_FONT_DRIVER ) 489 490#define FT_MODULE_IS_RENDERER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 491 FT_MODULE_RENDERER ) 492 493#define FT_MODULE_IS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 494 FT_MODULE_HINTER ) 495 496#define FT_MODULE_IS_STYLER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 497 FT_MODULE_STYLER ) 498 499#define FT_DRIVER_IS_SCALABLE( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 500 FT_MODULE_DRIVER_SCALABLE ) 501 502#define FT_DRIVER_USES_OUTLINES( x ) !( FT_MODULE_CLASS( x )->module_flags & \ 503 FT_MODULE_DRIVER_NO_OUTLINES ) 504 505#define FT_DRIVER_HAS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 506 FT_MODULE_DRIVER_HAS_HINTER ) 507 508 509 /*************************************************************************/ 510 /* */ 511 /* <Function> */ 512 /* FT_Get_Module_Interface */ 513 /* */ 514 /* <Description> */ 515 /* Finds a module and returns its specific interface as a typeless */ 516 /* pointer. */ 517 /* */ 518 /* <Input> */ 519 /* library :: A handle to the library object. */ 520 /* */ 521 /* module_name :: The module's name (as an ASCII string). */ 522 /* */ 523 /* <Return> */ 524 /* A module-specific interface if available, 0 otherwise. */ 525 /* */ 526 /* <Note> */ 527 /* You should better be familiar with FreeType internals to know */ 528 /* which module to look for, and what its interface is :-) */ 529 /* */ 530 FT_BASE( const void* ) 531 FT_Get_Module_Interface( FT_Library library, 532 const char* mod_name ); 533 534 FT_BASE( FT_Pointer ) 535 ft_module_get_service( FT_Module module, 536 const char* service_id ); 537 538 /* */ 539 540 541 /*************************************************************************/ 542 /*************************************************************************/ 543 /*************************************************************************/ 544 /**** ****/ 545 /**** ****/ 546 /**** F A C E, S I Z E & G L Y P H S L O T O B J E C T S ****/ 547 /**** ****/ 548 /**** ****/ 549 /*************************************************************************/ 550 /*************************************************************************/ 551 /*************************************************************************/ 552 553 /* a few macros used to perform easy typecasts with minimal brain damage */ 554 555#define FT_FACE( x ) ((FT_Face)(x)) 556#define FT_SIZE( x ) ((FT_Size)(x)) 557#define FT_SLOT( x ) ((FT_GlyphSlot)(x)) 558 559#define FT_FACE_DRIVER( x ) FT_FACE( x )->driver 560#define FT_FACE_LIBRARY( x ) FT_FACE_DRIVER( x )->root.library 561#define FT_FACE_MEMORY( x ) FT_FACE( x )->memory 562#define FT_FACE_STREAM( x ) FT_FACE( x )->stream 563 564#define FT_SIZE_FACE( x ) FT_SIZE( x )->face 565#define FT_SLOT_FACE( x ) FT_SLOT( x )->face 566 567#define FT_FACE_SLOT( x ) FT_FACE( x )->glyph 568#define FT_FACE_SIZE( x ) FT_FACE( x )->size 569 570 571 /*************************************************************************/ 572 /* */ 573 /* <Function> */ 574 /* FT_New_GlyphSlot */ 575 /* */ 576 /* <Description> */ 577 /* It is sometimes useful to have more than one glyph slot for a */ 578 /* given face object. This function is used to create additional */ 579 /* slots. All of them are automatically discarded when the face is */ 580 /* destroyed. */ 581 /* */ 582 /* <Input> */ 583 /* face :: A handle to a parent face object. */ 584 /* */ 585 /* <Output> */ 586 /* aslot :: A handle to a new glyph slot object. */ 587 /* */ 588 /* <Return> */ 589 /* FreeType error code. 0 means success. */ 590 /* */ 591 FT_BASE( FT_Error ) 592 FT_New_GlyphSlot( FT_Face face, 593 FT_GlyphSlot *aslot ); 594 595 596 /*************************************************************************/ 597 /* */ 598 /* <Function> */ 599 /* FT_Done_GlyphSlot */ 600 /* */ 601 /* <Description> */ 602 /* Destroys a given glyph slot. Remember however that all slots are */ 603 /* automatically destroyed with its parent. Using this function is */ 604 /* not always mandatory. */ 605 /* */ 606 /* <Input> */ 607 /* slot :: A handle to a target glyph slot. */ 608 /* */ 609 FT_BASE( void ) 610 FT_Done_GlyphSlot( FT_GlyphSlot slot ); 611 612 /* */ 613 614#define FT_REQUEST_WIDTH( req ) \ 615 ( (req)->horiResolution \ 616 ? (FT_Pos)( (req)->width * (req)->horiResolution + 36 ) / 72 \ 617 : (req)->width ) 618 619#define FT_REQUEST_HEIGHT( req ) \ 620 ( (req)->vertResolution \ 621 ? (FT_Pos)( (req)->height * (req)->vertResolution + 36 ) / 72 \ 622 : (req)->height ) 623 624 625 /* Set the metrics according to a bitmap strike. */ 626 FT_BASE( void ) 627 FT_Select_Metrics( FT_Face face, 628 FT_ULong strike_index ); 629 630 631 /* Set the metrics according to a size request. */ 632 FT_BASE( void ) 633 FT_Request_Metrics( FT_Face face, 634 FT_Size_Request req ); 635 636 637 /* Match a size request against `available_sizes'. */ 638 FT_BASE( FT_Error ) 639 FT_Match_Size( FT_Face face, 640 FT_Size_Request req, 641 FT_Bool ignore_width, 642 FT_ULong* size_index ); 643 644 645 /* Use the horizontal metrics to synthesize the vertical metrics. */ 646 /* If `advance' is zero, it is also synthesized. */ 647 FT_BASE( void ) 648 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics, 649 FT_Pos advance ); 650 651 652 /* Free the bitmap of a given glyphslot when needed (i.e., only when it */ 653 /* was allocated with ft_glyphslot_alloc_bitmap). */ 654 FT_BASE( void ) 655 ft_glyphslot_free_bitmap( FT_GlyphSlot slot ); 656 657 658 /* Allocate a new bitmap buffer in a glyph slot. */ 659 FT_BASE( FT_Error ) 660 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot, 661 FT_ULong size ); 662 663 664 /* Set the bitmap buffer in a glyph slot to a given pointer. The buffer */ 665 /* will not be freed by a later call to ft_glyphslot_free_bitmap. */ 666 FT_BASE( void ) 667 ft_glyphslot_set_bitmap( FT_GlyphSlot slot, 668 FT_Byte* buffer ); 669 670 671 /*************************************************************************/ 672 /*************************************************************************/ 673 /*************************************************************************/ 674 /**** ****/ 675 /**** ****/ 676 /**** R E N D E R E R S ****/ 677 /**** ****/ 678 /**** ****/ 679 /*************************************************************************/ 680 /*************************************************************************/ 681 /*************************************************************************/ 682 683 684#define FT_RENDERER( x ) ((FT_Renderer)( x )) 685#define FT_GLYPH( x ) ((FT_Glyph)( x )) 686#define FT_BITMAP_GLYPH( x ) ((FT_BitmapGlyph)( x )) 687#define FT_OUTLINE_GLYPH( x ) ((FT_OutlineGlyph)( x )) 688 689 690 typedef struct FT_RendererRec_ 691 { 692 FT_ModuleRec root; 693 FT_Renderer_Class* clazz; 694 FT_Glyph_Format glyph_format; 695 FT_Glyph_Class glyph_class; 696 697 FT_Raster raster; 698 FT_Raster_Render_Func raster_render; 699 FT_Renderer_RenderFunc render; 700 701 } FT_RendererRec; 702 703 704 /*************************************************************************/ 705 /*************************************************************************/ 706 /*************************************************************************/ 707 /**** ****/ 708 /**** ****/ 709 /**** F O N T D R I V E R S ****/ 710 /**** ****/ 711 /**** ****/ 712 /*************************************************************************/ 713 /*************************************************************************/ 714 /*************************************************************************/ 715 716 717 /* typecast a module into a driver easily */ 718#define FT_DRIVER( x ) ((FT_Driver)(x)) 719 720 /* typecast a module as a driver, and get its driver class */ 721#define FT_DRIVER_CLASS( x ) FT_DRIVER( x )->clazz 722 723 724 /*************************************************************************/ 725 /* */ 726 /* <Struct> */ 727 /* FT_DriverRec */ 728 /* */ 729 /* <Description> */ 730 /* The root font driver class. A font driver is responsible for */ 731 /* managing and loading font files of a given format. */ 732 /* */ 733 /* <Fields> */ 734 /* root :: Contains the fields of the root module class. */ 735 /* */ 736 /* clazz :: A pointer to the font driver's class. Note that */ 737 /* this is NOT root.clazz. `class' wasn't used */ 738 /* as it is a reserved word in C++. */ 739 /* */ 740 /* faces_list :: The list of faces currently opened by this */ 741 /* driver. */ 742 /* */ 743 /* glyph_loader :: The glyph loader for all faces managed by this */ 744 /* driver. This object isn't defined for unscalable */ 745 /* formats. */ 746 /* */ 747 typedef struct FT_DriverRec_ 748 { 749 FT_ModuleRec root; 750 FT_Driver_Class clazz; 751 FT_ListRec faces_list; 752 FT_GlyphLoader glyph_loader; 753 754 } FT_DriverRec; 755 756 757 /*************************************************************************/ 758 /*************************************************************************/ 759 /*************************************************************************/ 760 /**** ****/ 761 /**** ****/ 762 /**** L I B R A R I E S ****/ 763 /**** ****/ 764 /**** ****/ 765 /*************************************************************************/ 766 /*************************************************************************/ 767 /*************************************************************************/ 768 769 770 /* This hook is used by the TrueType debugger. It must be set to an */ 771 /* alternate truetype bytecode interpreter function. */ 772#define FT_DEBUG_HOOK_TRUETYPE 0 773 774 775 /* Set this debug hook to a non-null pointer to force unpatented hinting */ 776 /* for all faces when both TT_USE_BYTECODE_INTERPRETER and */ 777 /* TT_CONFIG_OPTION_UNPATENTED_HINTING are defined. This is only used */ 778 /* during debugging. */ 779#define FT_DEBUG_HOOK_UNPATENTED_HINTING 1 780 781 782 typedef void (*FT_Bitmap_LcdFilterFunc)( FT_Bitmap* bitmap, 783 FT_Render_Mode render_mode, 784 FT_Library library ); 785 786 787 /*************************************************************************/ 788 /* */ 789 /* <Struct> */ 790 /* FT_LibraryRec */ 791 /* */ 792 /* <Description> */ 793 /* The FreeType library class. This is the root of all FreeType */ 794 /* data. Use FT_New_Library() to create a library object, and */ 795 /* FT_Done_Library() to discard it and all child objects. */ 796 /* */ 797 /* <Fields> */ 798 /* memory :: The library's memory object. Manages memory */ 799 /* allocation. */ 800 /* */ 801 /* version_major :: The major version number of the library. */ 802 /* */ 803 /* version_minor :: The minor version number of the library. */ 804 /* */ 805 /* version_patch :: The current patch level of the library. */ 806 /* */ 807 /* num_modules :: The number of modules currently registered */ 808 /* within this library. This is set to 0 for new */ 809 /* libraries. New modules are added through the */ 810 /* FT_Add_Module() API function. */ 811 /* */ 812 /* modules :: A table used to store handles to the currently */ 813 /* registered modules. Note that each font driver */ 814 /* contains a list of its opened faces. */ 815 /* */ 816 /* renderers :: The list of renderers currently registered */ 817 /* within the library. */ 818 /* */ 819 /* cur_renderer :: The current outline renderer. This is a */ 820 /* shortcut used to avoid parsing the list on */ 821 /* each call to FT_Outline_Render(). It is a */ 822 /* handle to the current renderer for the */ 823 /* FT_GLYPH_FORMAT_OUTLINE format. */ 824 /* */ 825 /* auto_hinter :: XXX */ 826 /* */ 827 /* raster_pool :: The raster object's render pool. This can */ 828 /* ideally be changed dynamically at run-time. */ 829 /* */ 830 /* raster_pool_size :: The size of the render pool in bytes. */ 831 /* */ 832 /* debug_hooks :: XXX */ 833 /* */ 834 /* lcd_filter :: If subpixel rendering is activated, the */ 835 /* selected LCD filter mode. */ 836 /* */ 837 /* lcd_extra :: If subpixel rendering is activated, the number */ 838 /* of extra pixels needed for the LCD filter. */ 839 /* */ 840 /* lcd_weights :: If subpixel rendering is activated, the LCD */ 841 /* filter weights, if any. */ 842 /* */ 843 /* lcd_filter_func :: If subpixel rendering is activated, the LCD */ 844 /* filtering callback function. */ 845 /* */ 846 /* pic_container :: Contains global structs and tables, instead */ 847 /* of defining them globallly. */ 848 /* */ 849 /* refcount :: A counter initialized to~1 at the time an */ 850 /* @FT_Library structure is created. */ 851 /* @FT_Reference_Library increments this counter, */ 852 /* and @FT_Done_Library only destroys a library */ 853 /* if the counter is~1, otherwise it simply */ 854 /* decrements it. */ 855 /* */ 856 typedef struct FT_LibraryRec_ 857 { 858 FT_Memory memory; /* library's memory manager */ 859 860 FT_Int version_major; 861 FT_Int version_minor; 862 FT_Int version_patch; 863 864 FT_UInt num_modules; 865 FT_Module modules[FT_MAX_MODULES]; /* module objects */ 866 867 FT_ListRec renderers; /* list of renderers */ 868 FT_Renderer cur_renderer; /* current outline renderer */ 869 FT_Module auto_hinter; 870 871 FT_Byte* raster_pool; /* scan-line conversion */ 872 /* render pool */ 873 FT_ULong raster_pool_size; /* size of render pool in bytes */ 874 875 FT_DebugHook_Func debug_hooks[4]; 876 877#ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 878 FT_LcdFilter lcd_filter; 879 FT_Int lcd_extra; /* number of extra pixels */ 880 FT_Byte lcd_weights[7]; /* filter weights, if any */ 881 FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */ 882#endif 883 884#ifdef FT_CONFIG_OPTION_PIC 885 FT_PIC_Container pic_container; 886#endif 887 888 FT_Int refcount; 889 890 } FT_LibraryRec; 891 892 893 FT_BASE( FT_Renderer ) 894 FT_Lookup_Renderer( FT_Library library, 895 FT_Glyph_Format format, 896 FT_ListNode* node ); 897 898 FT_BASE( FT_Error ) 899 FT_Render_Glyph_Internal( FT_Library library, 900 FT_GlyphSlot slot, 901 FT_Render_Mode render_mode ); 902 903 typedef const char* 904 (*FT_Face_GetPostscriptNameFunc)( FT_Face face ); 905 906 typedef FT_Error 907 (*FT_Face_GetGlyphNameFunc)( FT_Face face, 908 FT_UInt glyph_index, 909 FT_Pointer buffer, 910 FT_UInt buffer_max ); 911 912 typedef FT_UInt 913 (*FT_Face_GetGlyphNameIndexFunc)( FT_Face face, 914 FT_String* glyph_name ); 915 916 917#ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM 918 919 /*************************************************************************/ 920 /* */ 921 /* <Function> */ 922 /* FT_New_Memory */ 923 /* */ 924 /* <Description> */ 925 /* Creates a new memory object. */ 926 /* */ 927 /* <Return> */ 928 /* A pointer to the new memory object. 0 in case of error. */ 929 /* */ 930 FT_BASE( FT_Memory ) 931 FT_New_Memory( void ); 932 933 934 /*************************************************************************/ 935 /* */ 936 /* <Function> */ 937 /* FT_Done_Memory */ 938 /* */ 939 /* <Description> */ 940 /* Discards memory manager. */ 941 /* */ 942 /* <Input> */ 943 /* memory :: A handle to the memory manager. */ 944 /* */ 945 FT_BASE( void ) 946 FT_Done_Memory( FT_Memory memory ); 947 948#endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */ 949 950 951 /* Define default raster's interface. The default raster is located in */ 952 /* `src/base/ftraster.c'. */ 953 /* */ 954 /* Client applications can register new rasters through the */ 955 /* FT_Set_Raster() API. */ 956 957#ifndef FT_NO_DEFAULT_RASTER 958 FT_EXPORT_VAR( FT_Raster_Funcs ) ft_default_raster; 959#endif 960 961 962 /*************************************************************************/ 963 /*************************************************************************/ 964 /*************************************************************************/ 965 /**** ****/ 966 /**** ****/ 967 /**** P I C S U P P O R T ****/ 968 /**** ****/ 969 /**** ****/ 970 /*************************************************************************/ 971 /*************************************************************************/ 972 /*************************************************************************/ 973 974 975 /* PIC support macros for ftimage.h */ 976 977 978 /*************************************************************************/ 979 /* */ 980 /* <Macro> */ 981 /* FT_DEFINE_OUTLINE_FUNCS */ 982 /* */ 983 /* <Description> */ 984 /* Used to initialize an instance of FT_Outline_Funcs struct. */ 985 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */ 986 /* be called with a pre-allocated structure to be filled. */ 987 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ 988 /* allocated in the global scope (or the scope where the macro */ 989 /* is used). */ 990 /* */ 991#ifndef FT_CONFIG_OPTION_PIC 992 993#define FT_DEFINE_OUTLINE_FUNCS( \ 994 class_, \ 995 move_to_, \ 996 line_to_, \ 997 conic_to_, \ 998 cubic_to_, \ 999 shift_, \ 1000 delta_ ) \ 1001 static const FT_Outline_Funcs class_ = \ 1002 { \ 1003 move_to_, \ 1004 line_to_, \ 1005 conic_to_, \ 1006 cubic_to_, \ 1007 shift_, \ 1008 delta_ \ 1009 }; 1010 1011#else /* FT_CONFIG_OPTION_PIC */ 1012 1013#define FT_DEFINE_OUTLINE_FUNCS( \ 1014 class_, \ 1015 move_to_, \ 1016 line_to_, \ 1017 conic_to_, \ 1018 cubic_to_, \ 1019 shift_, \ 1020 delta_ ) \ 1021 static FT_Error \ 1022 Init_Class_ ## class_( FT_Outline_Funcs* clazz ) \ 1023 { \ 1024 clazz->move_to = move_to_; \ 1025 clazz->line_to = line_to_; \ 1026 clazz->conic_to = conic_to_; \ 1027 clazz->cubic_to = cubic_to_; \ 1028 clazz->shift = shift_; \ 1029 clazz->delta = delta_; \ 1030 \ 1031 return FT_Err_Ok; \ 1032 } 1033 1034#endif /* FT_CONFIG_OPTION_PIC */ 1035 1036 1037 /*************************************************************************/ 1038 /* */ 1039 /* <Macro> */ 1040 /* FT_DEFINE_RASTER_FUNCS */ 1041 /* */ 1042 /* <Description> */ 1043 /* Used to initialize an instance of FT_Raster_Funcs struct. */ 1044 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */ 1045 /* be called with a pre-allocated structure to be filled. */ 1046 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ 1047 /* allocated in the global scope (or the scope where the macro */ 1048 /* is used). */ 1049 /* */ 1050#ifndef FT_CONFIG_OPTION_PIC 1051 1052#define FT_DEFINE_RASTER_FUNCS( \ 1053 class_, \ 1054 glyph_format_, \ 1055 raster_new_, \ 1056 raster_reset_, \ 1057 raster_set_mode_, \ 1058 raster_render_, \ 1059 raster_done_ ) \ 1060 const FT_Raster_Funcs class_ = \ 1061 { \ 1062 glyph_format_, \ 1063 raster_new_, \ 1064 raster_reset_, \ 1065 raster_set_mode_, \ 1066 raster_render_, \ 1067 raster_done_ \ 1068 }; 1069 1070#else /* FT_CONFIG_OPTION_PIC */ 1071 1072#define FT_DEFINE_RASTER_FUNCS( \ 1073 class_, \ 1074 glyph_format_, \ 1075 raster_new_, \ 1076 raster_reset_, \ 1077 raster_set_mode_, \ 1078 raster_render_, \ 1079 raster_done_ ) \ 1080 void \ 1081 FT_Init_Class_ ## class_( FT_Raster_Funcs* clazz ) \ 1082 { \ 1083 clazz->glyph_format = glyph_format_; \ 1084 clazz->raster_new = raster_new_; \ 1085 clazz->raster_reset = raster_reset_; \ 1086 clazz->raster_set_mode = raster_set_mode_; \ 1087 clazz->raster_render = raster_render_; \ 1088 clazz->raster_done = raster_done_; \ 1089 } 1090 1091#endif /* FT_CONFIG_OPTION_PIC */ 1092 1093 1094 /* PIC support macros for ftrender.h */ 1095 1096 1097 /*************************************************************************/ 1098 /* */ 1099 /* <Macro> */ 1100 /* FT_DEFINE_GLYPH */ 1101 /* */ 1102 /* <Description> */ 1103 /* Used to initialize an instance of FT_Glyph_Class struct. */ 1104 /* When FT_CONFIG_OPTION_PIC is defined an init funtion will need to */ 1105 /* be called with a pre-allocated stcture to be filled. */ 1106 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ 1107 /* allocated in the global scope (or the scope where the macro */ 1108 /* is used). */ 1109 /* */ 1110#ifndef FT_CONFIG_OPTION_PIC 1111 1112#define FT_DEFINE_GLYPH( \ 1113 class_, \ 1114 size_, \ 1115 format_, \ 1116 init_, \ 1117 done_, \ 1118 copy_, \ 1119 transform_, \ 1120 bbox_, \ 1121 prepare_ ) \ 1122 FT_CALLBACK_TABLE_DEF \ 1123 const FT_Glyph_Class class_ = \ 1124 { \ 1125 size_, \ 1126 format_, \ 1127 init_, \ 1128 done_, \ 1129 copy_, \ 1130 transform_, \ 1131 bbox_, \ 1132 prepare_ \ 1133 }; 1134 1135#else /* FT_CONFIG_OPTION_PIC */ 1136 1137#define FT_DEFINE_GLYPH( \ 1138 class_, \ 1139 size_, \ 1140 format_, \ 1141 init_, \ 1142 done_, \ 1143 copy_, \ 1144 transform_, \ 1145 bbox_, \ 1146 prepare_ ) \ 1147 void \ 1148 FT_Init_Class_ ## class_( FT_Glyph_Class* clazz ) \ 1149 { \ 1150 clazz->glyph_size = size_; \ 1151 clazz->glyph_format = format_; \ 1152 clazz->glyph_init = init_; \ 1153 clazz->glyph_done = done_; \ 1154 clazz->glyph_copy = copy_; \ 1155 clazz->glyph_transform = transform_; \ 1156 clazz->glyph_bbox = bbox_; \ 1157 clazz->glyph_prepare = prepare_; \ 1158 } 1159 1160#endif /* FT_CONFIG_OPTION_PIC */ 1161 1162 1163 /*************************************************************************/ 1164 /* */ 1165 /* <Macro> */ 1166 /* FT_DECLARE_RENDERER */ 1167 /* */ 1168 /* <Description> */ 1169 /* Used to create a forward declaration of a */ 1170 /* FT_Renderer_Class struct instance. */ 1171 /* */ 1172 /* <Macro> */ 1173 /* FT_DEFINE_RENDERER */ 1174 /* */ 1175 /* <Description> */ 1176 /* Used to initialize an instance of FT_Renderer_Class struct. */ 1177 /* */ 1178 /* When FT_CONFIG_OPTION_PIC is defined a `create' funtion will need */ 1179 /* to be called with a pointer where the allocated structure is */ 1180 /* returned. And when it is no longer needed a `destroy' function */ 1181 /* needs to be called to release that allocation. */ 1182 /* `fcinit.c' (ft_create_default_module_classes) already contains */ 1183 /* a mechanism to call these functions for the default modules */ 1184 /* described in `ftmodule.h'. */ 1185 /* */ 1186 /* Notice that the created `create' and `destroy' functions call */ 1187 /* `pic_init' and `pic_free' to allow you to manually allocate and */ 1188 /* initialize any additional global data, like a module specific */ 1189 /* interface, and put them in the global pic container defined in */ 1190 /* `ftpic.h'. If you don't need them just implement the functions as */ 1191 /* empty to resolve the link error. Also the `pic_init' and */ 1192 /* `pic_free' functions should be declared in `pic.h', to be referred */ 1193 /* by the renderer definition calling `FT_DEFINE_RENDERER' in the */ 1194 /* following. */ 1195 /* */ 1196 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ 1197 /* allocated in the global scope (or the scope where the macro */ 1198 /* is used). */ 1199 /* */ 1200#ifndef FT_CONFIG_OPTION_PIC 1201 1202#define FT_DECLARE_RENDERER( class_ ) \ 1203 FT_EXPORT_VAR( const FT_Renderer_Class ) class_; 1204 1205#define FT_DEFINE_RENDERER( \ 1206 class_, \ 1207 flags_, \ 1208 size_, \ 1209 name_, \ 1210 version_, \ 1211 requires_, \ 1212 interface_, \ 1213 init_, \ 1214 done_, \ 1215 get_interface_, \ 1216 glyph_format_, \ 1217 render_glyph_, \ 1218 transform_glyph_, \ 1219 get_glyph_cbox_, \ 1220 set_mode_, \ 1221 raster_class_ ) \ 1222 FT_CALLBACK_TABLE_DEF \ 1223 const FT_Renderer_Class class_ = \ 1224 { \ 1225 FT_DEFINE_ROOT_MODULE( flags_, \ 1226 size_, \ 1227 name_, \ 1228 version_, \ 1229 requires_, \ 1230 interface_, \ 1231 init_, \ 1232 done_, \ 1233 get_interface_ ) \ 1234 glyph_format_, \ 1235 \ 1236 render_glyph_, \ 1237 transform_glyph_, \ 1238 get_glyph_cbox_, \ 1239 set_mode_, \ 1240 \ 1241 raster_class_ \ 1242 }; 1243 1244#else /* FT_CONFIG_OPTION_PIC */ 1245 1246#define FT_DECLARE_RENDERER( class_ ) FT_DECLARE_MODULE( class_ ) 1247 1248#define FT_DEFINE_RENDERER( \ 1249 class_, \ 1250 flags_, \ 1251 size_, \ 1252 name_, \ 1253 version_, \ 1254 requires_, \ 1255 interface_, \ 1256 init_, \ 1257 done_, \ 1258 get_interface_, \ 1259 glyph_format_, \ 1260 render_glyph_, \ 1261 transform_glyph_, \ 1262 get_glyph_cbox_, \ 1263 set_mode_, \ 1264 raster_class_ ) \ 1265 void \ 1266 FT_Destroy_Class_ ## class_( FT_Library library, \ 1267 FT_Module_Class* clazz ) \ 1268 { \ 1269 FT_Renderer_Class* rclazz = (FT_Renderer_Class*)clazz; \ 1270 FT_Memory memory = library->memory; \ 1271 \ 1272 \ 1273 class_ ## _pic_free( library ); \ 1274 if ( rclazz ) \ 1275 FT_FREE( rclazz ); \ 1276 } \ 1277 \ 1278 \ 1279 FT_Error \ 1280 FT_Create_Class_ ## class_( FT_Library library, \ 1281 FT_Module_Class** output_class ) \ 1282 { \ 1283 FT_Renderer_Class* clazz = NULL; \ 1284 FT_Error error; \ 1285 FT_Memory memory = library->memory; \ 1286 \ 1287 \ 1288 if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \ 1289 return error; \ 1290 \ 1291 error = class_ ## _pic_init( library ); \ 1292 if ( error ) \ 1293 { \ 1294 FT_FREE( clazz ); \ 1295 return error; \ 1296 } \ 1297 \ 1298 FT_DEFINE_ROOT_MODULE( flags_, \ 1299 size_, \ 1300 name_, \ 1301 version_, \ 1302 requires_, \ 1303 interface_, \ 1304 init_, \ 1305 done_, \ 1306 get_interface_ ) \ 1307 \ 1308 clazz->glyph_format = glyph_format_; \ 1309 \ 1310 clazz->render_glyph = render_glyph_; \ 1311 clazz->transform_glyph = transform_glyph_; \ 1312 clazz->get_glyph_cbox = get_glyph_cbox_; \ 1313 clazz->set_mode = set_mode_; \ 1314 \ 1315 clazz->raster_class = raster_class_; \ 1316 \ 1317 *output_class = (FT_Module_Class*)clazz; \ 1318 \ 1319 return FT_Err_Ok; \ 1320 } 1321 1322#endif /* FT_CONFIG_OPTION_PIC */ 1323 1324 1325 /* PIC support macros for ftmodapi.h **/ 1326 1327 1328#ifdef FT_CONFIG_OPTION_PIC 1329 1330 /*************************************************************************/ 1331 /* */ 1332 /* <FuncType> */ 1333 /* FT_Module_Creator */ 1334 /* */ 1335 /* <Description> */ 1336 /* A function used to create (allocate) a new module class object. */ 1337 /* The object's members are initialized, but the module itself is */ 1338 /* not. */ 1339 /* */ 1340 /* <Input> */ 1341 /* memory :: A handle to the memory manager. */ 1342 /* output_class :: Initialized with the newly allocated class. */ 1343 /* */ 1344 typedef FT_Error 1345 (*FT_Module_Creator)( FT_Memory memory, 1346 FT_Module_Class** output_class ); 1347 1348 /*************************************************************************/ 1349 /* */ 1350 /* <FuncType> */ 1351 /* FT_Module_Destroyer */ 1352 /* */ 1353 /* <Description> */ 1354 /* A function used to destroy (deallocate) a module class object. */ 1355 /* */ 1356 /* <Input> */ 1357 /* memory :: A handle to the memory manager. */ 1358 /* clazz :: Module class to destroy. */ 1359 /* */ 1360 typedef void 1361 (*FT_Module_Destroyer)( FT_Memory memory, 1362 FT_Module_Class* clazz ); 1363 1364#endif 1365 1366 1367 /*************************************************************************/ 1368 /* */ 1369 /* <Macro> */ 1370 /* FT_DECLARE_MODULE */ 1371 /* */ 1372 /* <Description> */ 1373 /* Used to create a forward declaration of a */ 1374 /* FT_Module_Class struct instance. */ 1375 /* */ 1376 /* <Macro> */ 1377 /* FT_DEFINE_MODULE */ 1378 /* */ 1379 /* <Description> */ 1380 /* Used to initialize an instance of an FT_Module_Class struct. */ 1381 /* */ 1382 /* When FT_CONFIG_OPTION_PIC is defined a `create' funtion needs to */ 1383 /* be called with a pointer where the allocated structure is */ 1384 /* returned. And when it is no longer needed a `destroy' function */ 1385 /* needs to be called to release that allocation. */ 1386 /* `fcinit.c' (ft_create_default_module_classes) already contains */ 1387 /* a mechanism to call these functions for the default modules */ 1388 /* described in `ftmodule.h'. */ 1389 /* */ 1390 /* Notice that the created `create' and `destroy' functions call */ 1391 /* `pic_init' and `pic_free' to allow you to manually allocate and */ 1392 /* initialize any additional global data, like a module specific */ 1393 /* interface, and put them in the global pic container defined in */ 1394 /* `ftpic.h'. If you don't need them just implement the functions as */ 1395 /* empty to resolve the link error. Also the `pic_init' and */ 1396 /* `pic_free' functions should be declared in `pic.h', to be referred */ 1397 /* by the module definition calling `FT_DEFINE_MODULE' in the */ 1398 /* following. */ 1399 /* */ 1400 /* When FT_CONFIG_OPTION_PIC is not defined the struct will be */ 1401 /* allocated in the global scope (or the scope where the macro */ 1402 /* is used). */ 1403 /* */ 1404 /* <Macro> */ 1405 /* FT_DEFINE_ROOT_MODULE */ 1406 /* */ 1407 /* <Description> */ 1408 /* Used to initialize an instance of an FT_Module_Class struct inside */ 1409 /* another struct that contains it or in a function that initializes */ 1410 /* that containing struct. */ 1411 /* */ 1412#ifndef FT_CONFIG_OPTION_PIC 1413 1414#define FT_DECLARE_MODULE( class_ ) \ 1415 FT_CALLBACK_TABLE \ 1416 const FT_Module_Class class_; 1417 1418#define FT_DEFINE_ROOT_MODULE( \ 1419 flags_, \ 1420 size_, \ 1421 name_, \ 1422 version_, \ 1423 requires_, \ 1424 interface_, \ 1425 init_, \ 1426 done_, \ 1427 get_interface_ ) \ 1428 { \ 1429 flags_, \ 1430 size_, \ 1431 \ 1432 name_, \ 1433 version_, \ 1434 requires_, \ 1435 \ 1436 interface_, \ 1437 \ 1438 init_, \ 1439 done_, \ 1440 get_interface_, \ 1441 }, 1442 1443#define FT_DEFINE_MODULE( \ 1444 class_, \ 1445 flags_, \ 1446 size_, \ 1447 name_, \ 1448 version_, \ 1449 requires_, \ 1450 interface_, \ 1451 init_, \ 1452 done_, \ 1453 get_interface_ ) \ 1454 FT_CALLBACK_TABLE_DEF \ 1455 const FT_Module_Class class_ = \ 1456 { \ 1457 flags_, \ 1458 size_, \ 1459 \ 1460 name_, \ 1461 version_, \ 1462 requires_, \ 1463 \ 1464 interface_, \ 1465 \ 1466 init_, \ 1467 done_, \ 1468 get_interface_, \ 1469 }; 1470 1471 1472#else /* FT_CONFIG_OPTION_PIC */ 1473 1474#define FT_DECLARE_MODULE( class_ ) \ 1475 FT_Error \ 1476 FT_Create_Class_ ## class_( FT_Library library, \ 1477 FT_Module_Class** output_class ); \ 1478 void \ 1479 FT_Destroy_Class_ ## class_( FT_Library library, \ 1480 FT_Module_Class* clazz ); 1481 1482#define FT_DEFINE_ROOT_MODULE( \ 1483 flags_, \ 1484 size_, \ 1485 name_, \ 1486 version_, \ 1487 requires_, \ 1488 interface_, \ 1489 init_, \ 1490 done_, \ 1491 get_interface_ ) \ 1492 clazz->root.module_flags = flags_; \ 1493 clazz->root.module_size = size_; \ 1494 clazz->root.module_name = name_; \ 1495 clazz->root.module_version = version_; \ 1496 clazz->root.module_requires = requires_; \ 1497 \ 1498 clazz->root.module_interface = interface_; \ 1499 \ 1500 clazz->root.module_init = init_; \ 1501 clazz->root.module_done = done_; \ 1502 clazz->root.get_interface = get_interface_; 1503 1504#define FT_DEFINE_MODULE( \ 1505 class_, \ 1506 flags_, \ 1507 size_, \ 1508 name_, \ 1509 version_, \ 1510 requires_, \ 1511 interface_, \ 1512 init_, \ 1513 done_, \ 1514 get_interface_ ) \ 1515 void \ 1516 FT_Destroy_Class_ ## class_( FT_Library library, \ 1517 FT_Module_Class* clazz ) \ 1518 { \ 1519 FT_Memory memory = library->memory; \ 1520 \ 1521 \ 1522 class_ ## _pic_free( library ); \ 1523 if ( clazz ) \ 1524 FT_FREE( clazz ); \ 1525 } \ 1526 \ 1527 \ 1528 FT_Error \ 1529 FT_Create_Class_ ## class_( FT_Library library, \ 1530 FT_Module_Class** output_class ) \ 1531 { \ 1532 FT_Memory memory = library->memory; \ 1533 FT_Module_Class* clazz = NULL; \ 1534 FT_Error error; \ 1535 \ 1536 \ 1537 if ( FT_ALLOC( clazz, sizeof ( *clazz ) ) ) \ 1538 return error; \ 1539 error = class_ ## _pic_init( library ); \ 1540 if ( error ) \ 1541 { \ 1542 FT_FREE( clazz ); \ 1543 return error; \ 1544 } \ 1545 \ 1546 clazz->module_flags = flags_; \ 1547 clazz->module_size = size_; \ 1548 clazz->module_name = name_; \ 1549 clazz->module_version = version_; \ 1550 clazz->module_requires = requires_; \ 1551 \ 1552 clazz->module_interface = interface_; \ 1553 \ 1554 clazz->module_init = init_; \ 1555 clazz->module_done = done_; \ 1556 clazz->get_interface = get_interface_; \ 1557 \ 1558 *output_class = clazz; \ 1559 \ 1560 return FT_Err_Ok; \ 1561 } 1562 1563#endif /* FT_CONFIG_OPTION_PIC */ 1564 1565 1566FT_END_HEADER 1567 1568#endif /* __FTOBJS_H__ */ 1569 1570 1571/* END */ 1572