1 /**************************************************************************** 2 * 3 * ftobjs.h 4 * 5 * The FreeType private base classes (specification). 6 * 7 * Copyright (C) 1996-2023 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 <freetype/ftrender.h> 30 #include <freetype/ftsizes.h> 31 #include <freetype/ftlcdfil.h> 32 #include <freetype/internal/ftmemory.h> 33 #include <freetype/internal/ftgloadr.h> 34 #include <freetype/internal/ftdrv.h> 35 #include <freetype/internal/autohint.h> 36 #include <freetype/internal/ftserv.h> 37 #include <freetype/internal/ftcalc.h> 38 39 #ifdef FT_CONFIG_OPTION_INCREMENTAL 40 #include <freetype/ftincrem.h> 41 #endif 42 43 #include "compiler-macros.h" 44 45 FT_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' algorithm. 77 * We use alpha = 1, beta = 3/8, giving us results with a largest error 78 * 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 /* we use FT_TYPEOF to suppress signedness compilation warnings */ 87 #define FT_PAD_FLOOR( x, n ) ( (x) & ~FT_TYPEOF( x )( (n) - 1 ) ) 88 #define FT_PAD_ROUND( x, n ) FT_PAD_FLOOR( (x) + (n) / 2, n ) 89 #define FT_PAD_CEIL( x, n ) FT_PAD_FLOOR( (x) + (n) - 1, n ) 90 91 #define FT_PIX_FLOOR( x ) ( (x) & ~FT_TYPEOF( x )63 ) 92 #define FT_PIX_ROUND( x ) FT_PIX_FLOOR( (x) + 32 ) 93 #define FT_PIX_CEIL( x ) FT_PIX_FLOOR( (x) + 63 ) 94 95 /* specialized versions (for signed values) */ 96 /* that don't produce run-time errors due to integer overflow */ 97 #define FT_PAD_ROUND_LONG( x, n ) FT_PAD_FLOOR( ADD_LONG( (x), (n) / 2 ), \ 98 n ) 99 #define FT_PAD_CEIL_LONG( x, n ) FT_PAD_FLOOR( ADD_LONG( (x), (n) - 1 ), \ 100 n ) 101 #define FT_PIX_ROUND_LONG( x ) FT_PIX_FLOOR( ADD_LONG( (x), 32 ) ) 102 #define FT_PIX_CEIL_LONG( x ) FT_PIX_FLOOR( ADD_LONG( (x), 63 ) ) 103 104 #define FT_PAD_ROUND_INT32( x, n ) FT_PAD_FLOOR( ADD_INT32( (x), (n) / 2 ), \ 105 n ) 106 #define FT_PAD_CEIL_INT32( x, n ) FT_PAD_FLOOR( ADD_INT32( (x), (n) - 1 ), \ 107 n ) 108 #define FT_PIX_ROUND_INT32( x ) FT_PIX_FLOOR( ADD_INT32( (x), 32 ) ) 109 #define FT_PIX_CEIL_INT32( x ) FT_PIX_FLOOR( ADD_INT32( (x), 63 ) ) 110 111 112 /* 113 * character classification functions -- since these are used to parse font 114 * files, we must not use those in <ctypes.h> which are locale-dependent 115 */ 116 #define ft_isdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U ) 117 118 #define ft_isxdigit( x ) ( ( (unsigned)(x) - '0' ) < 10U || \ 119 ( (unsigned)(x) - 'a' ) < 6U || \ 120 ( (unsigned)(x) - 'A' ) < 6U ) 121 122 /* the next two macros assume ASCII representation */ 123 #define ft_isupper( x ) ( ( (unsigned)(x) - 'A' ) < 26U ) 124 #define ft_islower( x ) ( ( (unsigned)(x) - 'a' ) < 26U ) 125 126 #define ft_isalpha( x ) ( ft_isupper( x ) || ft_islower( x ) ) 127 #define ft_isalnum( x ) ( ft_isdigit( x ) || ft_isalpha( x ) ) 128 129 130 /*************************************************************************/ 131 /*************************************************************************/ 132 /*************************************************************************/ 133 /**** ****/ 134 /**** ****/ 135 /**** C H A R M A P S ****/ 136 /**** ****/ 137 /**** ****/ 138 /*************************************************************************/ 139 /*************************************************************************/ 140 /*************************************************************************/ 141 142 /* handle to internal charmap object */ 143 typedef struct FT_CMapRec_* FT_CMap; 144 145 /* handle to charmap class structure */ 146 typedef const struct FT_CMap_ClassRec_* FT_CMap_Class; 147 148 /* internal charmap object structure */ 149 typedef struct FT_CMapRec_ 150 { 151 FT_CharMapRec charmap; 152 FT_CMap_Class clazz; 153 154 } FT_CMapRec; 155 156 /* typecast any pointer to a charmap handle */ 157 #define FT_CMAP( x ) ( (FT_CMap)( x ) ) 158 159 /* obvious macros */ 160 #define FT_CMAP_PLATFORM_ID( x ) FT_CMAP( x )->charmap.platform_id 161 #define FT_CMAP_ENCODING_ID( x ) FT_CMAP( x )->charmap.encoding_id 162 #define FT_CMAP_ENCODING( x ) FT_CMAP( x )->charmap.encoding 163 #define FT_CMAP_FACE( x ) FT_CMAP( x )->charmap.face 164 165 166 /* class method definitions */ 167 typedef FT_Error 168 (*FT_CMap_InitFunc)( FT_CMap cmap, 169 FT_Pointer init_data ); 170 171 typedef void 172 (*FT_CMap_DoneFunc)( FT_CMap cmap ); 173 174 typedef FT_UInt 175 (*FT_CMap_CharIndexFunc)( FT_CMap cmap, 176 FT_UInt32 char_code ); 177 178 typedef FT_UInt 179 (*FT_CMap_CharNextFunc)( FT_CMap cmap, 180 FT_UInt32 *achar_code ); 181 182 typedef FT_UInt 183 (*FT_CMap_CharVarIndexFunc)( FT_CMap cmap, 184 FT_CMap unicode_cmap, 185 FT_UInt32 char_code, 186 FT_UInt32 variant_selector ); 187 188 typedef FT_Int 189 (*FT_CMap_CharVarIsDefaultFunc)( FT_CMap cmap, 190 FT_UInt32 char_code, 191 FT_UInt32 variant_selector ); 192 193 typedef FT_UInt32 * 194 (*FT_CMap_VariantListFunc)( FT_CMap cmap, 195 FT_Memory mem ); 196 197 typedef FT_UInt32 * 198 (*FT_CMap_CharVariantListFunc)( FT_CMap cmap, 199 FT_Memory mem, 200 FT_UInt32 char_code ); 201 202 typedef FT_UInt32 * 203 (*FT_CMap_VariantCharListFunc)( FT_CMap cmap, 204 FT_Memory mem, 205 FT_UInt32 variant_selector ); 206 207 208 typedef struct FT_CMap_ClassRec_ 209 { 210 FT_ULong size; 211 212 FT_CMap_InitFunc init; 213 FT_CMap_DoneFunc done; 214 FT_CMap_CharIndexFunc char_index; 215 FT_CMap_CharNextFunc char_next; 216 217 /* Subsequent entries are special ones for format 14 -- the variant */ 218 /* selector subtable which behaves like no other */ 219 220 FT_CMap_CharVarIndexFunc char_var_index; 221 FT_CMap_CharVarIsDefaultFunc char_var_default; 222 FT_CMap_VariantListFunc variant_list; 223 FT_CMap_CharVariantListFunc charvariant_list; 224 FT_CMap_VariantCharListFunc variantchar_list; 225 226 } FT_CMap_ClassRec; 227 228 229 #define FT_DECLARE_CMAP_CLASS( class_ ) \ 230 FT_CALLBACK_TABLE const FT_CMap_ClassRec class_; 231 232 #define FT_DEFINE_CMAP_CLASS( \ 233 class_, \ 234 size_, \ 235 init_, \ 236 done_, \ 237 char_index_, \ 238 char_next_, \ 239 char_var_index_, \ 240 char_var_default_, \ 241 variant_list_, \ 242 charvariant_list_, \ 243 variantchar_list_ ) \ 244 FT_CALLBACK_TABLE_DEF \ 245 const FT_CMap_ClassRec class_ = \ 246 { \ 247 size_, \ 248 init_, \ 249 done_, \ 250 char_index_, \ 251 char_next_, \ 252 char_var_index_, \ 253 char_var_default_, \ 254 variant_list_, \ 255 charvariant_list_, \ 256 variantchar_list_ \ 257 }; 258 259 260 /* create a new charmap and add it to charmap->face */ 261 FT_BASE( FT_Error ) 262 FT_CMap_New( FT_CMap_Class clazz, 263 FT_Pointer init_data, 264 FT_CharMap charmap, 265 FT_CMap *acmap ); 266 267 /* destroy a charmap and remove it from face's list */ 268 FT_BASE( void ) 269 FT_CMap_Done( FT_CMap cmap ); 270 271 272 /* add LCD padding to CBox */ 273 FT_BASE( void ) 274 ft_lcd_padding( FT_BBox* cbox, 275 FT_GlyphSlot slot, 276 FT_Render_Mode mode ); 277 278 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 279 280 typedef void (*FT_Bitmap_LcdFilterFunc)( FT_Bitmap* bitmap, 281 FT_Byte* weights ); 282 283 284 /* This is the default LCD filter, an in-place, 5-tap FIR filter. */ 285 FT_BASE( void ) 286 ft_lcd_filter_fir( FT_Bitmap* bitmap, 287 FT_LcdFiveTapFilter weights ); 288 289 #endif /* FT_CONFIG_OPTION_SUBPIXEL_RENDERING */ 290 291 /************************************************************************** 292 * 293 * @struct: 294 * FT_Face_InternalRec 295 * 296 * @description: 297 * This structure contains the internal fields of each FT_Face object. 298 * These fields may change between different releases of FreeType. 299 * 300 * @fields: 301 * max_points :: 302 * The maximum number of points used to store the vectorial outline of 303 * any glyph in this face. If this value cannot be known in advance, 304 * or if the face isn't scalable, this should be set to 0. Only 305 * relevant for scalable formats. 306 * 307 * max_contours :: 308 * The maximum number of contours 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 * transform_matrix :: 314 * A 2x2 matrix of 16.16 coefficients used to transform glyph outlines 315 * after they are loaded from the font. Only used by the convenience 316 * functions. 317 * 318 * transform_delta :: 319 * A translation vector used to transform glyph outlines after they are 320 * loaded from the font. Only used by the convenience functions. 321 * 322 * transform_flags :: 323 * Some flags used to classify the transform. Only used by the 324 * convenience functions. 325 * 326 * services :: 327 * A cache for frequently used services. It should be only accessed 328 * with the macro `FT_FACE_LOOKUP_SERVICE`. 329 * 330 * incremental_interface :: 331 * If non-null, the interface through which glyph data and metrics are 332 * loaded incrementally for faces that do not provide all of this data 333 * when first opened. This field exists only if 334 * @FT_CONFIG_OPTION_INCREMENTAL is defined. 335 * 336 * no_stem_darkening :: 337 * Overrides the module-level default, see @stem-darkening[cff], for 338 * example. FALSE and TRUE toggle stem darkening on and off, 339 * respectively, value~-1 means to use the module/driver default. 340 * 341 * random_seed :: 342 * If positive, override the seed value for the CFF 'random' operator. 343 * Value~0 means to use the font's value. Value~-1 means to use the 344 * CFF driver's default. 345 * 346 * lcd_weights :: 347 * lcd_filter_func :: 348 * These fields specify the LCD filtering weights and callback function 349 * for ClearType-style subpixel rendering. 350 * 351 * refcount :: 352 * A counter initialized to~1 at the time an @FT_Face structure is 353 * created. @FT_Reference_Face increments this counter, and 354 * @FT_Done_Face only destroys a face if the counter is~1, otherwise it 355 * simply decrements it. 356 */ 357 typedef struct FT_Face_InternalRec_ 358 { 359 FT_Matrix transform_matrix; 360 FT_Vector transform_delta; 361 FT_Int transform_flags; 362 363 FT_ServiceCacheRec services; 364 365 #ifdef FT_CONFIG_OPTION_INCREMENTAL 366 FT_Incremental_InterfaceRec* incremental_interface; 367 #endif 368 369 FT_Char no_stem_darkening; 370 FT_Int32 random_seed; 371 372 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 373 FT_LcdFiveTapFilter lcd_weights; /* filter weights, if any */ 374 FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */ 375 #endif 376 377 FT_Int refcount; 378 379 } FT_Face_InternalRec; 380 381 382 /************************************************************************** 383 * 384 * @struct: 385 * FT_Slot_InternalRec 386 * 387 * @description: 388 * This structure contains the internal fields of each FT_GlyphSlot 389 * object. These fields may change between different releases of 390 * FreeType. 391 * 392 * @fields: 393 * loader :: 394 * The glyph loader object used to load outlines into the glyph slot. 395 * 396 * flags :: 397 * Possible values are zero or FT_GLYPH_OWN_BITMAP. The latter 398 * indicates that the FT_GlyphSlot structure owns the bitmap buffer. 399 * 400 * glyph_transformed :: 401 * Boolean. Set to TRUE when the loaded glyph must be transformed 402 * through a specific font transformation. This is _not_ the same as 403 * the face transform set through FT_Set_Transform(). 404 * 405 * glyph_matrix :: 406 * The 2x2 matrix corresponding to the glyph transformation, if 407 * necessary. 408 * 409 * glyph_delta :: 410 * The 2d translation vector corresponding to the glyph transformation, 411 * if necessary. 412 * 413 * glyph_hints :: 414 * Format-specific glyph hints management. 415 * 416 * load_flags :: 417 * The load flags passed as an argument to @FT_Load_Glyph while 418 * initializing the glyph slot. 419 */ 420 421 #define FT_GLYPH_OWN_BITMAP 0x1U 422 #define FT_GLYPH_OWN_GZIP_SVG 0x2U 423 424 typedef struct FT_Slot_InternalRec_ 425 { 426 FT_GlyphLoader loader; 427 FT_UInt flags; 428 FT_Bool glyph_transformed; 429 FT_Matrix glyph_matrix; 430 FT_Vector glyph_delta; 431 void* glyph_hints; 432 433 FT_Int32 load_flags; 434 435 } FT_GlyphSlot_InternalRec; 436 437 438 /************************************************************************** 439 * 440 * @struct: 441 * FT_Size_InternalRec 442 * 443 * @description: 444 * This structure contains the internal fields of each FT_Size object. 445 * 446 * @fields: 447 * module_data :: 448 * Data specific to a driver module. 449 * 450 * autohint_mode :: 451 * The used auto-hinting mode. 452 * 453 * autohint_metrics :: 454 * Metrics used by the auto-hinter. 455 * 456 */ 457 458 typedef struct FT_Size_InternalRec_ 459 { 460 void* module_data; 461 462 FT_Render_Mode autohint_mode; 463 FT_Size_Metrics autohint_metrics; 464 465 } FT_Size_InternalRec; 466 467 468 /*************************************************************************/ 469 /*************************************************************************/ 470 /*************************************************************************/ 471 /**** ****/ 472 /**** ****/ 473 /**** M O D U L E S ****/ 474 /**** ****/ 475 /**** ****/ 476 /*************************************************************************/ 477 /*************************************************************************/ 478 /*************************************************************************/ 479 480 481 /************************************************************************** 482 * 483 * @struct: 484 * FT_ModuleRec 485 * 486 * @description: 487 * A module object instance. 488 * 489 * @fields: 490 * clazz :: 491 * A pointer to the module's class. 492 * 493 * library :: 494 * A handle to the parent library object. 495 * 496 * memory :: 497 * A handle to the memory manager. 498 */ 499 typedef struct FT_ModuleRec_ 500 { 501 FT_Module_Class* clazz; 502 FT_Library library; 503 FT_Memory memory; 504 505 } FT_ModuleRec; 506 507 508 /* typecast an object to an FT_Module */ 509 #define FT_MODULE( x ) ( (FT_Module)(x) ) 510 511 #define FT_MODULE_CLASS( x ) FT_MODULE( x )->clazz 512 #define FT_MODULE_LIBRARY( x ) FT_MODULE( x )->library 513 #define FT_MODULE_MEMORY( x ) FT_MODULE( x )->memory 514 515 516 #define FT_MODULE_IS_DRIVER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 517 FT_MODULE_FONT_DRIVER ) 518 519 #define FT_MODULE_IS_RENDERER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 520 FT_MODULE_RENDERER ) 521 522 #define FT_MODULE_IS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 523 FT_MODULE_HINTER ) 524 525 #define FT_MODULE_IS_STYLER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 526 FT_MODULE_STYLER ) 527 528 #define FT_DRIVER_IS_SCALABLE( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 529 FT_MODULE_DRIVER_SCALABLE ) 530 531 #define FT_DRIVER_USES_OUTLINES( x ) !( FT_MODULE_CLASS( x )->module_flags & \ 532 FT_MODULE_DRIVER_NO_OUTLINES ) 533 534 #define FT_DRIVER_HAS_HINTER( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 535 FT_MODULE_DRIVER_HAS_HINTER ) 536 537 #define FT_DRIVER_HINTS_LIGHTLY( x ) ( FT_MODULE_CLASS( x )->module_flags & \ 538 FT_MODULE_DRIVER_HINTS_LIGHTLY ) 539 540 541 /************************************************************************** 542 * 543 * @function: 544 * FT_Get_Module_Interface 545 * 546 * @description: 547 * Finds a module and returns its specific interface as a typeless 548 * pointer. 549 * 550 * @input: 551 * library :: 552 * A handle to the library object. 553 * 554 * module_name :: 555 * The module's name (as an ASCII string). 556 * 557 * @return: 558 * A module-specific interface if available, 0 otherwise. 559 * 560 * @note: 561 * You should better be familiar with FreeType internals to know which 562 * module to look for, and what its interface is :-) 563 */ 564 FT_BASE( const void* ) 565 FT_Get_Module_Interface( FT_Library library, 566 const char* mod_name ); 567 568 FT_BASE( FT_Pointer ) 569 ft_module_get_service( FT_Module module, 570 const char* service_id, 571 FT_Bool global ); 572 573 #ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES 574 FT_BASE( FT_Error ) 575 ft_property_string_set( FT_Library library, 576 const FT_String* module_name, 577 const FT_String* property_name, 578 FT_String* value ); 579 #endif 580 581 /* */ 582 583 584 /*************************************************************************/ 585 /*************************************************************************/ 586 /*************************************************************************/ 587 /**** ****/ 588 /**** ****/ 589 /**** F A C E, S I Z E & G L Y P H S L O T O B J E C T S ****/ 590 /**** ****/ 591 /**** ****/ 592 /*************************************************************************/ 593 /*************************************************************************/ 594 /*************************************************************************/ 595 596 /* a few macros used to perform easy typecasts with minimal brain damage */ 597 598 #define FT_FACE( x ) ( (FT_Face)(x) ) 599 #define FT_SIZE( x ) ( (FT_Size)(x) ) 600 #define FT_SLOT( x ) ( (FT_GlyphSlot)(x) ) 601 602 #define FT_FACE_DRIVER( x ) FT_FACE( x )->driver 603 #define FT_FACE_LIBRARY( x ) FT_FACE_DRIVER( x )->root.library 604 #define FT_FACE_MEMORY( x ) FT_FACE( x )->memory 605 #define FT_FACE_STREAM( x ) FT_FACE( x )->stream 606 607 #define FT_SIZE_FACE( x ) FT_SIZE( x )->face 608 #define FT_SLOT_FACE( x ) FT_SLOT( x )->face 609 610 #define FT_FACE_SLOT( x ) FT_FACE( x )->glyph 611 #define FT_FACE_SIZE( x ) FT_FACE( x )->size 612 613 614 /************************************************************************** 615 * 616 * @function: 617 * FT_New_GlyphSlot 618 * 619 * @description: 620 * It is sometimes useful to have more than one glyph slot for a given 621 * face object. This function is used to create additional slots. All 622 * of them are automatically discarded when the face is destroyed. 623 * 624 * @input: 625 * face :: 626 * A handle to a parent face object. 627 * 628 * @output: 629 * aslot :: 630 * A handle to a new glyph slot object. 631 * 632 * @return: 633 * FreeType error code. 0 means success. 634 */ 635 FT_BASE( FT_Error ) 636 FT_New_GlyphSlot( FT_Face face, 637 FT_GlyphSlot *aslot ); 638 639 640 /************************************************************************** 641 * 642 * @function: 643 * FT_Done_GlyphSlot 644 * 645 * @description: 646 * Destroys a given glyph slot. Remember however that all slots are 647 * automatically destroyed with its parent. Using this function is not 648 * always mandatory. 649 * 650 * @input: 651 * slot :: 652 * A handle to a target glyph slot. 653 */ 654 FT_BASE( void ) 655 FT_Done_GlyphSlot( FT_GlyphSlot slot ); 656 657 /* */ 658 659 #define FT_REQUEST_WIDTH( req ) \ 660 ( (req)->horiResolution \ 661 ? ( (req)->width * (FT_Pos)(req)->horiResolution + 36 ) / 72 \ 662 : (req)->width ) 663 664 #define FT_REQUEST_HEIGHT( req ) \ 665 ( (req)->vertResolution \ 666 ? ( (req)->height * (FT_Pos)(req)->vertResolution + 36 ) / 72 \ 667 : (req)->height ) 668 669 670 /* Set the metrics according to a bitmap strike. */ 671 FT_BASE( void ) 672 FT_Select_Metrics( FT_Face face, 673 FT_ULong strike_index ); 674 675 676 /* Set the metrics according to a size request. */ 677 FT_BASE( FT_Error ) 678 FT_Request_Metrics( FT_Face face, 679 FT_Size_Request req ); 680 681 682 /* Match a size request against `available_sizes'. */ 683 FT_BASE( FT_Error ) 684 FT_Match_Size( FT_Face face, 685 FT_Size_Request req, 686 FT_Bool ignore_width, 687 FT_ULong* size_index ); 688 689 690 /* Use the horizontal metrics to synthesize the vertical metrics. */ 691 /* If `advance' is zero, it is also synthesized. */ 692 FT_BASE( void ) 693 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics, 694 FT_Pos advance ); 695 696 697 /* Free the bitmap of a given glyphslot when needed (i.e., only when it */ 698 /* was allocated with ft_glyphslot_alloc_bitmap). */ 699 FT_BASE( void ) 700 ft_glyphslot_free_bitmap( FT_GlyphSlot slot ); 701 702 703 /* Preset bitmap metrics of an outline glyphslot prior to rendering */ 704 /* and check whether the truncated bbox is too large for rendering. */ 705 FT_BASE( FT_Bool ) 706 ft_glyphslot_preset_bitmap( FT_GlyphSlot slot, 707 FT_Render_Mode mode, 708 const FT_Vector* origin ); 709 710 /* Allocate a new bitmap buffer in a glyph slot. */ 711 FT_BASE( FT_Error ) 712 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot, 713 FT_ULong size ); 714 715 716 /* Set the bitmap buffer in a glyph slot to a given pointer. The buffer */ 717 /* will not be freed by a later call to ft_glyphslot_free_bitmap. */ 718 FT_BASE( void ) 719 ft_glyphslot_set_bitmap( FT_GlyphSlot slot, 720 FT_Byte* buffer ); 721 722 723 /*************************************************************************/ 724 /*************************************************************************/ 725 /*************************************************************************/ 726 /**** ****/ 727 /**** ****/ 728 /**** R E N D E R E R S ****/ 729 /**** ****/ 730 /**** ****/ 731 /*************************************************************************/ 732 /*************************************************************************/ 733 /*************************************************************************/ 734 735 736 #define FT_RENDERER( x ) ( (FT_Renderer)(x) ) 737 #define FT_GLYPH( x ) ( (FT_Glyph)(x) ) 738 #define FT_BITMAP_GLYPH( x ) ( (FT_BitmapGlyph)(x) ) 739 #define FT_OUTLINE_GLYPH( x ) ( (FT_OutlineGlyph)(x) ) 740 741 742 typedef struct FT_RendererRec_ 743 { 744 FT_ModuleRec root; 745 FT_Renderer_Class* clazz; 746 FT_Glyph_Format glyph_format; 747 FT_Glyph_Class glyph_class; 748 749 FT_Raster raster; 750 FT_Raster_Render_Func raster_render; 751 FT_Renderer_RenderFunc render; 752 753 } FT_RendererRec; 754 755 756 /*************************************************************************/ 757 /*************************************************************************/ 758 /*************************************************************************/ 759 /**** ****/ 760 /**** ****/ 761 /**** F O N T D R I V E R S ****/ 762 /**** ****/ 763 /**** ****/ 764 /*************************************************************************/ 765 /*************************************************************************/ 766 /*************************************************************************/ 767 768 769 /* typecast a module into a driver easily */ 770 #define FT_DRIVER( x ) ( (FT_Driver)(x) ) 771 772 /* typecast a module as a driver, and get its driver class */ 773 #define FT_DRIVER_CLASS( x ) FT_DRIVER( x )->clazz 774 775 776 /************************************************************************** 777 * 778 * @struct: 779 * FT_DriverRec 780 * 781 * @description: 782 * The root font driver class. A font driver is responsible for managing 783 * and loading font files of a given format. 784 * 785 * @fields: 786 * root :: 787 * Contains the fields of the root module class. 788 * 789 * clazz :: 790 * A pointer to the font driver's class. Note that this is NOT 791 * root.clazz. 'class' wasn't used as it is a reserved word in C++. 792 * 793 * faces_list :: 794 * The list of faces currently opened by this driver. 795 * 796 * glyph_loader :: 797 * Unused. Used to be glyph loader for all faces managed by this 798 * driver. 799 */ 800 typedef struct FT_DriverRec_ 801 { 802 FT_ModuleRec root; 803 FT_Driver_Class clazz; 804 FT_ListRec faces_list; 805 FT_GlyphLoader glyph_loader; 806 807 } FT_DriverRec; 808 809 810 /*************************************************************************/ 811 /*************************************************************************/ 812 /*************************************************************************/ 813 /**** ****/ 814 /**** ****/ 815 /**** L I B R A R I E S ****/ 816 /**** ****/ 817 /**** ****/ 818 /*************************************************************************/ 819 /*************************************************************************/ 820 /*************************************************************************/ 821 822 823 /************************************************************************** 824 * 825 * @struct: 826 * FT_LibraryRec 827 * 828 * @description: 829 * The FreeType library class. This is the root of all FreeType data. 830 * Use FT_New_Library() to create a library object, and FT_Done_Library() 831 * to discard it and all child objects. 832 * 833 * @fields: 834 * memory :: 835 * The library's memory object. Manages memory allocation. 836 * 837 * version_major :: 838 * The major version number of the library. 839 * 840 * version_minor :: 841 * The minor version number of the library. 842 * 843 * version_patch :: 844 * The current patch level of the library. 845 * 846 * num_modules :: 847 * The number of modules currently registered within this library. 848 * This is set to 0 for new libraries. New modules are added through 849 * the FT_Add_Module() API function. 850 * 851 * modules :: 852 * A table used to store handles to the currently registered 853 * modules. Note that each font driver contains a list of its opened 854 * faces. 855 * 856 * renderers :: 857 * The list of renderers currently registered within the library. 858 * 859 * cur_renderer :: 860 * The current outline renderer. This is a shortcut used to avoid 861 * parsing the list on each call to FT_Outline_Render(). It is a 862 * handle to the current renderer for the FT_GLYPH_FORMAT_OUTLINE 863 * format. 864 * 865 * auto_hinter :: 866 * The auto-hinter module interface. 867 * 868 * debug_hooks :: 869 * An array of four function pointers that allow debuggers to hook into 870 * a font format's interpreter. Currently, only the TrueType bytecode 871 * debugger uses this. 872 * 873 * lcd_weights :: 874 * The LCD filter weights for ClearType-style subpixel rendering. 875 * 876 * lcd_filter_func :: 877 * The LCD filtering callback function for for ClearType-style subpixel 878 * rendering. 879 * 880 * lcd_geometry :: 881 * This array specifies LCD subpixel geometry and controls Harmony LCD 882 * rendering technique, alternative to ClearType. 883 * 884 * pic_container :: 885 * Contains global structs and tables, instead of defining them 886 * globally. 887 * 888 * refcount :: 889 * A counter initialized to~1 at the time an @FT_Library structure is 890 * created. @FT_Reference_Library increments this counter, and 891 * @FT_Done_Library only destroys a library if the counter is~1, 892 * otherwise it simply decrements it. 893 */ 894 typedef struct FT_LibraryRec_ 895 { 896 FT_Memory memory; /* library's memory manager */ 897 898 FT_Int version_major; 899 FT_Int version_minor; 900 FT_Int version_patch; 901 902 FT_UInt num_modules; 903 FT_Module modules[FT_MAX_MODULES]; /* module objects */ 904 905 FT_ListRec renderers; /* list of renderers */ 906 FT_Renderer cur_renderer; /* current outline renderer */ 907 FT_Module auto_hinter; 908 909 FT_DebugHook_Func debug_hooks[4]; 910 911 #ifdef FT_CONFIG_OPTION_SUBPIXEL_RENDERING 912 FT_LcdFiveTapFilter lcd_weights; /* filter weights, if any */ 913 FT_Bitmap_LcdFilterFunc lcd_filter_func; /* filtering callback */ 914 #else 915 FT_Vector lcd_geometry[3]; /* RGB subpixel positions */ 916 #endif 917 918 FT_Int refcount; 919 920 } FT_LibraryRec; 921 922 923 FT_BASE( FT_Renderer ) 924 FT_Lookup_Renderer( FT_Library library, 925 FT_Glyph_Format format, 926 FT_ListNode* node ); 927 928 FT_BASE( FT_Error ) 929 FT_Render_Glyph_Internal( FT_Library library, 930 FT_GlyphSlot slot, 931 FT_Render_Mode render_mode ); 932 933 typedef const char* 934 (*FT_Face_GetPostscriptNameFunc)( FT_Face face ); 935 936 typedef FT_Error 937 (*FT_Face_GetGlyphNameFunc)( FT_Face face, 938 FT_UInt glyph_index, 939 FT_Pointer buffer, 940 FT_UInt buffer_max ); 941 942 typedef FT_UInt 943 (*FT_Face_GetGlyphNameIndexFunc)( FT_Face face, 944 const FT_String* glyph_name ); 945 946 947 #ifndef FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM 948 949 /************************************************************************** 950 * 951 * @function: 952 * FT_New_Memory 953 * 954 * @description: 955 * Creates a new memory object. 956 * 957 * @return: 958 * A pointer to the new memory object. 0 in case of error. 959 */ 960 FT_BASE( FT_Memory ) 961 FT_New_Memory( void ); 962 963 964 /************************************************************************** 965 * 966 * @function: 967 * FT_Done_Memory 968 * 969 * @description: 970 * Discards memory manager. 971 * 972 * @input: 973 * memory :: 974 * A handle to the memory manager. 975 */ 976 FT_BASE( void ) 977 FT_Done_Memory( FT_Memory memory ); 978 979 #endif /* !FT_CONFIG_OPTION_NO_DEFAULT_SYSTEM */ 980 981 982 /* Define default raster's interface. The default raster is located in */ 983 /* `src/base/ftraster.c'. */ 984 /* */ 985 /* Client applications can register new rasters through the */ 986 /* FT_Set_Raster() API. */ 987 988 #ifndef FT_NO_DEFAULT_RASTER 989 FT_EXPORT_VAR( FT_Raster_Funcs ) ft_default_raster; 990 #endif 991 992 993 /************************************************************************** 994 * 995 * @macro: 996 * FT_DEFINE_OUTLINE_FUNCS 997 * 998 * @description: 999 * Used to initialize an instance of FT_Outline_Funcs struct. The struct 1000 * will be allocated in the global scope (or the scope where the macro is 1001 * used). 1002 */ 1003 #define FT_DEFINE_OUTLINE_FUNCS( \ 1004 class_, \ 1005 move_to_, \ 1006 line_to_, \ 1007 conic_to_, \ 1008 cubic_to_, \ 1009 shift_, \ 1010 delta_ ) \ 1011 static const FT_Outline_Funcs class_ = \ 1012 { \ 1013 move_to_, \ 1014 line_to_, \ 1015 conic_to_, \ 1016 cubic_to_, \ 1017 shift_, \ 1018 delta_ \ 1019 }; 1020 1021 1022 /************************************************************************** 1023 * 1024 * @macro: 1025 * FT_DEFINE_RASTER_FUNCS 1026 * 1027 * @description: 1028 * Used to initialize an instance of FT_Raster_Funcs struct. The struct 1029 * will be allocated in the global scope (or the scope where the macro is 1030 * used). 1031 */ 1032 #define FT_DEFINE_RASTER_FUNCS( \ 1033 class_, \ 1034 glyph_format_, \ 1035 raster_new_, \ 1036 raster_reset_, \ 1037 raster_set_mode_, \ 1038 raster_render_, \ 1039 raster_done_ ) \ 1040 const FT_Raster_Funcs class_ = \ 1041 { \ 1042 glyph_format_, \ 1043 raster_new_, \ 1044 raster_reset_, \ 1045 raster_set_mode_, \ 1046 raster_render_, \ 1047 raster_done_ \ 1048 }; 1049 1050 1051 1052 /************************************************************************** 1053 * 1054 * @macro: 1055 * FT_DEFINE_GLYPH 1056 * 1057 * @description: 1058 * The struct will be allocated in the global scope (or the scope where 1059 * the macro is used). 1060 */ 1061 #define FT_DECLARE_GLYPH( class_ ) \ 1062 FT_CALLBACK_TABLE const FT_Glyph_Class class_; 1063 1064 #define FT_DEFINE_GLYPH( \ 1065 class_, \ 1066 size_, \ 1067 format_, \ 1068 init_, \ 1069 done_, \ 1070 copy_, \ 1071 transform_, \ 1072 bbox_, \ 1073 prepare_ ) \ 1074 FT_CALLBACK_TABLE_DEF \ 1075 const FT_Glyph_Class class_ = \ 1076 { \ 1077 size_, \ 1078 format_, \ 1079 init_, \ 1080 done_, \ 1081 copy_, \ 1082 transform_, \ 1083 bbox_, \ 1084 prepare_ \ 1085 }; 1086 1087 1088 /************************************************************************** 1089 * 1090 * @macro: 1091 * FT_DECLARE_RENDERER 1092 * 1093 * @description: 1094 * Used to create a forward declaration of a FT_Renderer_Class struct 1095 * instance. 1096 * 1097 * @macro: 1098 * FT_DEFINE_RENDERER 1099 * 1100 * @description: 1101 * Used to initialize an instance of FT_Renderer_Class struct. 1102 * 1103 * The struct will be allocated in the global scope (or the scope where 1104 * the macro is used). 1105 */ 1106 #define FT_DECLARE_RENDERER( class_ ) \ 1107 FT_EXPORT_VAR( const FT_Renderer_Class ) class_; 1108 1109 #define FT_DEFINE_RENDERER( \ 1110 class_, \ 1111 flags_, \ 1112 size_, \ 1113 name_, \ 1114 version_, \ 1115 requires_, \ 1116 interface_, \ 1117 init_, \ 1118 done_, \ 1119 get_interface_, \ 1120 glyph_format_, \ 1121 render_glyph_, \ 1122 transform_glyph_, \ 1123 get_glyph_cbox_, \ 1124 set_mode_, \ 1125 raster_class_ ) \ 1126 FT_CALLBACK_TABLE_DEF \ 1127 const FT_Renderer_Class class_ = \ 1128 { \ 1129 FT_DEFINE_ROOT_MODULE( flags_, \ 1130 size_, \ 1131 name_, \ 1132 version_, \ 1133 requires_, \ 1134 interface_, \ 1135 init_, \ 1136 done_, \ 1137 get_interface_ ) \ 1138 glyph_format_, \ 1139 \ 1140 render_glyph_, \ 1141 transform_glyph_, \ 1142 get_glyph_cbox_, \ 1143 set_mode_, \ 1144 \ 1145 raster_class_ \ 1146 }; 1147 1148 1149 /************************************************************************** 1150 * 1151 * @macro: 1152 * FT_DECLARE_MODULE 1153 * 1154 * @description: 1155 * Used to create a forward declaration of a FT_Module_Class struct 1156 * instance. 1157 * 1158 * @macro: 1159 * FT_DEFINE_MODULE 1160 * 1161 * @description: 1162 * Used to initialize an instance of an FT_Module_Class struct. 1163 * 1164 * The struct will be allocated in the global scope (or the scope where 1165 * the macro is used). 1166 * 1167 * @macro: 1168 * FT_DEFINE_ROOT_MODULE 1169 * 1170 * @description: 1171 * Used to initialize an instance of an FT_Module_Class struct inside 1172 * another struct that contains it or in a function that initializes that 1173 * containing struct. 1174 */ 1175 #define FT_DECLARE_MODULE( class_ ) \ 1176 FT_CALLBACK_TABLE \ 1177 const FT_Module_Class class_; 1178 1179 #define FT_DEFINE_ROOT_MODULE( \ 1180 flags_, \ 1181 size_, \ 1182 name_, \ 1183 version_, \ 1184 requires_, \ 1185 interface_, \ 1186 init_, \ 1187 done_, \ 1188 get_interface_ ) \ 1189 { \ 1190 flags_, \ 1191 size_, \ 1192 \ 1193 name_, \ 1194 version_, \ 1195 requires_, \ 1196 \ 1197 interface_, \ 1198 \ 1199 init_, \ 1200 done_, \ 1201 get_interface_, \ 1202 }, 1203 1204 #define FT_DEFINE_MODULE( \ 1205 class_, \ 1206 flags_, \ 1207 size_, \ 1208 name_, \ 1209 version_, \ 1210 requires_, \ 1211 interface_, \ 1212 init_, \ 1213 done_, \ 1214 get_interface_ ) \ 1215 FT_CALLBACK_TABLE_DEF \ 1216 const FT_Module_Class class_ = \ 1217 { \ 1218 flags_, \ 1219 size_, \ 1220 \ 1221 name_, \ 1222 version_, \ 1223 requires_, \ 1224 \ 1225 interface_, \ 1226 \ 1227 init_, \ 1228 done_, \ 1229 get_interface_, \ 1230 }; 1231 1232 1233 FT_END_HEADER 1234 1235 #endif /* FTOBJS_H_ */ 1236 1237 1238 /* END */ 1239