ftobjs.c revision ee451cb395940862dad63c85adfe8f2fd55e864c
1/***************************************************************************/ 2/* */ 3/* ftobjs.c */ 4/* */ 5/* The FreeType private base classes (body). */ 6/* */ 7/* Copyright 1996-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#include "../../include/ft2build.h" 20#include "../../include/freetype/ftlist.h" 21#include "../../include/freetype/ftoutln.h" 22#include "../../include/freetype/internal/ftvalid.h" 23#include "../../include/freetype/internal/ftobjs.h" 24#include "../../include/freetype/internal/ftdebug.h" 25#include "../../include/freetype/internal/ftrfork.h" 26#include "../../include/freetype/internal/ftstream.h" 27#include "../../include/freetype/internal/sfnt.h" /* for SFNT_Load_Table_Func */ 28#include "../../include/freetype/tttables.h" 29#include "../../include/freetype/tttags.h" 30#include "../../include/freetype/ttnameid.h" 31 32#include "../../include/freetype/internal/services/svprop.h" 33#include "../../include/freetype/internal/services/svsfnt.h" 34#include "../../include/freetype/internal/services/svpostnm.h" 35#include "../../include/freetype/internal/services/svgldict.h" 36#include "../../include/freetype/internal/services/svttcmap.h" 37#include "../../include/freetype/internal/services/svkern.h" 38#include "../../include/freetype/internal/services/svtteng.h" 39 40#ifdef FT_CONFIG_OPTION_MAC_FONTS 41#include "ftbase.h" 42#endif 43 44 45#ifdef FT_DEBUG_LEVEL_TRACE 46 47#include "../../include/freetype/ftbitmap.h" 48 49#if defined( _MSC_VER ) /* Visual C++ (and Intel C++) */ 50 /* We disable the warning `conversion from XXX to YYY, */ 51 /* possible loss of data' in order to compile cleanly with */ 52 /* the maximum level of warnings: `md5.c' is non-FreeType */ 53 /* code, and it gets used during development builds only. */ 54#pragma warning( push ) 55#pragma warning( disable : 4244 ) 56#endif /* _MSC_VER */ 57 58 /* it's easiest to include `md5.c' directly */ 59#define free md5_free /* suppress a shadow warning */ 60#include "md5.c" 61#undef free 62 63#if defined( _MSC_VER ) 64#pragma warning( pop ) 65#endif 66 67#endif /* FT_DEBUG_LEVEL_TRACE */ 68 69 70#define GRID_FIT_METRICS 71 72 73 FT_BASE_DEF( FT_Pointer ) 74 ft_service_list_lookup( FT_ServiceDesc service_descriptors, 75 const char* service_id ) 76 { 77 FT_Pointer result = NULL; 78 FT_ServiceDesc desc = service_descriptors; 79 80 81 if ( desc && service_id ) 82 { 83 for ( ; desc->serv_id != NULL; desc++ ) 84 { 85 if ( ft_strcmp( desc->serv_id, service_id ) == 0 ) 86 { 87 result = (FT_Pointer)desc->serv_data; 88 break; 89 } 90 } 91 } 92 93 return result; 94 } 95 96 97 FT_BASE_DEF( void ) 98 ft_validator_init( FT_Validator valid, 99 const FT_Byte* base, 100 const FT_Byte* limit, 101 FT_ValidationLevel level ) 102 { 103 valid->base = base; 104 valid->limit = limit; 105 valid->level = level; 106 valid->error = FT_Err_Ok; 107 } 108 109 110 FT_BASE_DEF( FT_Int ) 111 ft_validator_run( FT_Validator valid ) 112 { 113 /* This function doesn't work! None should call it. */ 114 FT_UNUSED( valid ); 115 116 return -1; 117 } 118 119 120 FT_BASE_DEF( void ) 121 ft_validator_error( FT_Validator valid, 122 FT_Error error ) 123 { 124 /* since the cast below also disables the compiler's */ 125 /* type check, we introduce a dummy variable, which */ 126 /* will be optimized away */ 127 volatile ft_jmp_buf* jump_buffer = &valid->jump_buffer; 128 129 130 valid->error = error; 131 132 /* throw away volatileness; use `jump_buffer' or the */ 133 /* compiler may warn about an unused local variable */ 134 ft_longjmp( *(ft_jmp_buf*) jump_buffer, 1 ); 135 } 136 137 138 /*************************************************************************/ 139 /*************************************************************************/ 140 /*************************************************************************/ 141 /**** ****/ 142 /**** ****/ 143 /**** S T R E A M ****/ 144 /**** ****/ 145 /**** ****/ 146 /*************************************************************************/ 147 /*************************************************************************/ 148 /*************************************************************************/ 149 150 151 /* create a new input stream from an FT_Open_Args structure */ 152 /* */ 153 FT_BASE_DEF( FT_Error ) 154 FT_Stream_New( FT_Library library, 155 const FT_Open_Args* args, 156 FT_Stream *astream ) 157 { 158 FT_Error error; 159 FT_Memory memory; 160 FT_Stream stream = NULL; 161 162 163 *astream = 0; 164 165 if ( !library ) 166 return FT_THROW( Invalid_Library_Handle ); 167 168 if ( !args ) 169 return FT_THROW( Invalid_Argument ); 170 171 memory = library->memory; 172 173 if ( FT_NEW( stream ) ) 174 goto Exit; 175 176 stream->memory = memory; 177 178 if ( args->flags & FT_OPEN_MEMORY ) 179 { 180 /* create a memory-based stream */ 181 FT_Stream_OpenMemory( stream, 182 (const FT_Byte*)args->memory_base, 183 args->memory_size ); 184 } 185 186#ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT 187 188 else if ( args->flags & FT_OPEN_PATHNAME ) 189 { 190 /* create a normal system stream */ 191 error = FT_Stream_Open( stream, args->pathname ); 192 stream->pathname.pointer = args->pathname; 193 } 194 else if ( ( args->flags & FT_OPEN_STREAM ) && args->stream ) 195 { 196 /* use an existing, user-provided stream */ 197 198 /* in this case, we do not need to allocate a new stream object */ 199 /* since the caller is responsible for closing it himself */ 200 FT_FREE( stream ); 201 stream = args->stream; 202 } 203 204#endif 205 206 else 207 error = FT_THROW( Invalid_Argument ); 208 209 if ( error ) 210 FT_FREE( stream ); 211 else 212 stream->memory = memory; /* just to be certain */ 213 214 *astream = stream; 215 216 Exit: 217 return error; 218 } 219 220 221 FT_BASE_DEF( void ) 222 FT_Stream_Free( FT_Stream stream, 223 FT_Int external ) 224 { 225 if ( stream ) 226 { 227 FT_Memory memory = stream->memory; 228 229 230 FT_Stream_Close( stream ); 231 232 if ( !external ) 233 FT_FREE( stream ); 234 } 235 } 236 237 238 /*************************************************************************/ 239 /* */ 240 /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ 241 /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ 242 /* messages during execution. */ 243 /* */ 244#undef FT_COMPONENT 245#define FT_COMPONENT trace_objs 246 247 248 /*************************************************************************/ 249 /*************************************************************************/ 250 /*************************************************************************/ 251 /**** ****/ 252 /**** ****/ 253 /**** FACE, SIZE & GLYPH SLOT OBJECTS ****/ 254 /**** ****/ 255 /**** ****/ 256 /*************************************************************************/ 257 /*************************************************************************/ 258 /*************************************************************************/ 259 260 261 static FT_Error 262 ft_glyphslot_init( FT_GlyphSlot slot ) 263 { 264 FT_Driver driver = slot->face->driver; 265 FT_Driver_Class clazz = driver->clazz; 266 FT_Memory memory = driver->root.memory; 267 FT_Error error = FT_Err_Ok; 268 FT_Slot_Internal internal = NULL; 269 270 271 slot->library = driver->root.library; 272 273 if ( FT_NEW( internal ) ) 274 goto Exit; 275 276 slot->internal = internal; 277 278 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 279 error = FT_GlyphLoader_New( memory, &internal->loader ); 280 281 if ( !error && clazz->init_slot ) 282 error = clazz->init_slot( slot ); 283 284 Exit: 285 return error; 286 } 287 288 289 FT_BASE_DEF( void ) 290 ft_glyphslot_free_bitmap( FT_GlyphSlot slot ) 291 { 292 if ( slot->internal && ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) ) 293 { 294 FT_Memory memory = FT_FACE_MEMORY( slot->face ); 295 296 297 FT_FREE( slot->bitmap.buffer ); 298 slot->internal->flags &= ~FT_GLYPH_OWN_BITMAP; 299 } 300 else 301 { 302 /* assume that the bitmap buffer was stolen or not */ 303 /* allocated from the heap */ 304 slot->bitmap.buffer = NULL; 305 } 306 } 307 308 309 FT_BASE_DEF( void ) 310 ft_glyphslot_set_bitmap( FT_GlyphSlot slot, 311 FT_Byte* buffer ) 312 { 313 ft_glyphslot_free_bitmap( slot ); 314 315 slot->bitmap.buffer = buffer; 316 317 FT_ASSERT( (slot->internal->flags & FT_GLYPH_OWN_BITMAP) == 0 ); 318 } 319 320 321 FT_BASE_DEF( FT_Error ) 322 ft_glyphslot_alloc_bitmap( FT_GlyphSlot slot, 323 FT_ULong size ) 324 { 325 FT_Memory memory = FT_FACE_MEMORY( slot->face ); 326 FT_Error error; 327 328 329 if ( slot->internal->flags & FT_GLYPH_OWN_BITMAP ) 330 FT_FREE( slot->bitmap.buffer ); 331 else 332 slot->internal->flags |= FT_GLYPH_OWN_BITMAP; 333 334 (void)FT_ALLOC( slot->bitmap.buffer, size ); 335 return error; 336 } 337 338 339 static void 340 ft_glyphslot_clear( FT_GlyphSlot slot ) 341 { 342 /* free bitmap if needed */ 343 ft_glyphslot_free_bitmap( slot ); 344 345 /* clear all public fields in the glyph slot */ 346 FT_ZERO( &slot->metrics ); 347 FT_ZERO( &slot->outline ); 348 349 slot->bitmap.width = 0; 350 slot->bitmap.rows = 0; 351 slot->bitmap.pitch = 0; 352 slot->bitmap.pixel_mode = 0; 353 /* `slot->bitmap.buffer' has been handled by ft_glyphslot_free_bitmap */ 354 355 slot->bitmap_left = 0; 356 slot->bitmap_top = 0; 357 slot->num_subglyphs = 0; 358 slot->subglyphs = 0; 359 slot->control_data = 0; 360 slot->control_len = 0; 361 slot->other = 0; 362 slot->format = FT_GLYPH_FORMAT_NONE; 363 364 slot->linearHoriAdvance = 0; 365 slot->linearVertAdvance = 0; 366 slot->lsb_delta = 0; 367 slot->rsb_delta = 0; 368 } 369 370 371 static void 372 ft_glyphslot_done( FT_GlyphSlot slot ) 373 { 374 FT_Driver driver = slot->face->driver; 375 FT_Driver_Class clazz = driver->clazz; 376 FT_Memory memory = driver->root.memory; 377 378 379 if ( clazz->done_slot ) 380 clazz->done_slot( slot ); 381 382 /* free bitmap buffer if needed */ 383 ft_glyphslot_free_bitmap( slot ); 384 385 /* slot->internal might be NULL in out-of-memory situations */ 386 if ( slot->internal ) 387 { 388 /* free glyph loader */ 389 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 390 { 391 FT_GlyphLoader_Done( slot->internal->loader ); 392 slot->internal->loader = 0; 393 } 394 395 FT_FREE( slot->internal ); 396 } 397 } 398 399 400 /* documentation is in ftobjs.h */ 401 402 FT_BASE_DEF( FT_Error ) 403 FT_New_GlyphSlot( FT_Face face, 404 FT_GlyphSlot *aslot ) 405 { 406 FT_Error error; 407 FT_Driver driver; 408 FT_Driver_Class clazz; 409 FT_Memory memory; 410 FT_GlyphSlot slot = NULL; 411 412 413 if ( !face || !face->driver ) 414 return FT_THROW( Invalid_Argument ); 415 416 driver = face->driver; 417 clazz = driver->clazz; 418 memory = driver->root.memory; 419 420 FT_TRACE4(( "FT_New_GlyphSlot: Creating new slot object\n" )); 421 if ( !FT_ALLOC( slot, clazz->slot_object_size ) ) 422 { 423 slot->face = face; 424 425 error = ft_glyphslot_init( slot ); 426 if ( error ) 427 { 428 ft_glyphslot_done( slot ); 429 FT_FREE( slot ); 430 goto Exit; 431 } 432 433 slot->next = face->glyph; 434 face->glyph = slot; 435 436 if ( aslot ) 437 *aslot = slot; 438 } 439 else if ( aslot ) 440 *aslot = 0; 441 442 443 Exit: 444 FT_TRACE4(( "FT_New_GlyphSlot: Return %d\n", error )); 445 return error; 446 } 447 448 449 /* documentation is in ftobjs.h */ 450 451 FT_BASE_DEF( void ) 452 FT_Done_GlyphSlot( FT_GlyphSlot slot ) 453 { 454 if ( slot ) 455 { 456 FT_Driver driver = slot->face->driver; 457 FT_Memory memory = driver->root.memory; 458 FT_GlyphSlot prev; 459 FT_GlyphSlot cur; 460 461 462 /* Remove slot from its parent face's list */ 463 prev = NULL; 464 cur = slot->face->glyph; 465 466 while ( cur ) 467 { 468 if ( cur == slot ) 469 { 470 if ( !prev ) 471 slot->face->glyph = cur->next; 472 else 473 prev->next = cur->next; 474 475 /* finalize client-specific data */ 476 if ( slot->generic.finalizer ) 477 slot->generic.finalizer( slot ); 478 479 ft_glyphslot_done( slot ); 480 FT_FREE( slot ); 481 break; 482 } 483 prev = cur; 484 cur = cur->next; 485 } 486 } 487 } 488 489 490 /* documentation is in freetype.h */ 491 492 FT_EXPORT_DEF( void ) 493 FT_Set_Transform( FT_Face face, 494 FT_Matrix* matrix, 495 FT_Vector* delta ) 496 { 497 FT_Face_Internal internal; 498 499 500 if ( !face ) 501 return; 502 503 internal = face->internal; 504 505 internal->transform_flags = 0; 506 507 if ( !matrix ) 508 { 509 internal->transform_matrix.xx = 0x10000L; 510 internal->transform_matrix.xy = 0; 511 internal->transform_matrix.yx = 0; 512 internal->transform_matrix.yy = 0x10000L; 513 matrix = &internal->transform_matrix; 514 } 515 else 516 internal->transform_matrix = *matrix; 517 518 /* set transform_flags bit flag 0 if `matrix' isn't the identity */ 519 if ( ( matrix->xy | matrix->yx ) || 520 matrix->xx != 0x10000L || 521 matrix->yy != 0x10000L ) 522 internal->transform_flags |= 1; 523 524 if ( !delta ) 525 { 526 internal->transform_delta.x = 0; 527 internal->transform_delta.y = 0; 528 delta = &internal->transform_delta; 529 } 530 else 531 internal->transform_delta = *delta; 532 533 /* set transform_flags bit flag 1 if `delta' isn't the null vector */ 534 if ( delta->x | delta->y ) 535 internal->transform_flags |= 2; 536 } 537 538 539 static FT_Renderer 540 ft_lookup_glyph_renderer( FT_GlyphSlot slot ); 541 542 543#ifdef GRID_FIT_METRICS 544 static void 545 ft_glyphslot_grid_fit_metrics( FT_GlyphSlot slot, 546 FT_Bool vertical ) 547 { 548 FT_Glyph_Metrics* metrics = &slot->metrics; 549 FT_Pos right, bottom; 550 551 552 if ( vertical ) 553 { 554 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX ); 555 metrics->horiBearingY = FT_PIX_CEIL ( metrics->horiBearingY ); 556 557 right = FT_PIX_CEIL( metrics->vertBearingX + metrics->width ); 558 bottom = FT_PIX_CEIL( metrics->vertBearingY + metrics->height ); 559 560 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX ); 561 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY ); 562 563 metrics->width = right - metrics->vertBearingX; 564 metrics->height = bottom - metrics->vertBearingY; 565 } 566 else 567 { 568 metrics->vertBearingX = FT_PIX_FLOOR( metrics->vertBearingX ); 569 metrics->vertBearingY = FT_PIX_FLOOR( metrics->vertBearingY ); 570 571 right = FT_PIX_CEIL ( metrics->horiBearingX + metrics->width ); 572 bottom = FT_PIX_FLOOR( metrics->horiBearingY - metrics->height ); 573 574 metrics->horiBearingX = FT_PIX_FLOOR( metrics->horiBearingX ); 575 metrics->horiBearingY = FT_PIX_CEIL ( metrics->horiBearingY ); 576 577 metrics->width = right - metrics->horiBearingX; 578 metrics->height = metrics->horiBearingY - bottom; 579 } 580 581 metrics->horiAdvance = FT_PIX_ROUND( metrics->horiAdvance ); 582 metrics->vertAdvance = FT_PIX_ROUND( metrics->vertAdvance ); 583 } 584#endif /* GRID_FIT_METRICS */ 585 586 587 /* documentation is in freetype.h */ 588 589 FT_EXPORT_DEF( FT_Error ) 590 FT_Load_Glyph( FT_Face face, 591 FT_UInt glyph_index, 592 FT_Int32 load_flags ) 593 { 594 FT_Error error; 595 FT_Driver driver; 596 FT_GlyphSlot slot; 597 FT_Library library; 598 FT_Bool autohint = FALSE; 599 FT_Module hinter; 600 TT_Face ttface = (TT_Face)face; 601 602 603 if ( !face || !face->size || !face->glyph ) 604 return FT_THROW( Invalid_Face_Handle ); 605 606 /* The validity test for `glyph_index' is performed by the */ 607 /* font drivers. */ 608 609 slot = face->glyph; 610 ft_glyphslot_clear( slot ); 611 612 driver = face->driver; 613 library = driver->root.library; 614 hinter = library->auto_hinter; 615 616 /* resolve load flags dependencies */ 617 618 if ( load_flags & FT_LOAD_NO_RECURSE ) 619 load_flags |= FT_LOAD_NO_SCALE | 620 FT_LOAD_IGNORE_TRANSFORM; 621 622 if ( load_flags & FT_LOAD_NO_SCALE ) 623 { 624 load_flags |= FT_LOAD_NO_HINTING | 625 FT_LOAD_NO_BITMAP; 626 627 load_flags &= ~FT_LOAD_RENDER; 628 } 629 630 /* 631 * Determine whether we need to auto-hint or not. 632 * The general rules are: 633 * 634 * - Do only auto-hinting if we have a hinter module, a scalable font 635 * format dealing with outlines, and no transforms except simple 636 * slants and/or rotations by integer multiples of 90 degrees. 637 * 638 * - Then, auto-hint if FT_LOAD_FORCE_AUTOHINT is set or if we don't 639 * have a native font hinter. 640 * 641 * - Otherwise, auto-hint for LIGHT hinting mode or if there isn't 642 * any hinting bytecode in the TrueType/OpenType font. 643 * 644 * - Exception: The font is `tricky' and requires the native hinter to 645 * load properly. 646 */ 647 648 if ( hinter && 649 !( load_flags & FT_LOAD_NO_HINTING ) && 650 !( load_flags & FT_LOAD_NO_AUTOHINT ) && 651 FT_DRIVER_IS_SCALABLE( driver ) && 652 FT_DRIVER_USES_OUTLINES( driver ) && 653 !FT_IS_TRICKY( face ) && 654 ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) || 655 ( face->internal->transform_matrix.yx == 0 && 656 face->internal->transform_matrix.xx != 0 ) || 657 ( face->internal->transform_matrix.xx == 0 && 658 face->internal->transform_matrix.yx != 0 ) ) ) 659 { 660 if ( ( load_flags & FT_LOAD_FORCE_AUTOHINT ) || 661 !FT_DRIVER_HAS_HINTER( driver ) ) 662 autohint = TRUE; 663 else 664 { 665 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags ); 666 667 668 /* the check for `num_locations' assures that we actually */ 669 /* test for instructions in a TTF and not in a CFF-based OTF */ 670 if ( mode == FT_RENDER_MODE_LIGHT || 671 face->internal->ignore_unpatented_hinter || 672 ( FT_IS_SFNT( face ) && 673 ttface->num_locations && 674 ttface->max_profile.maxSizeOfInstructions == 0 ) ) 675 autohint = TRUE; 676 } 677 } 678 679 if ( autohint ) 680 { 681 FT_AutoHinter_Interface hinting; 682 683 684 /* try to load embedded bitmaps first if available */ 685 /* */ 686 /* XXX: This is really a temporary hack that should disappear */ 687 /* promptly with FreeType 2.1! */ 688 /* */ 689 if ( FT_HAS_FIXED_SIZES( face ) && 690 ( load_flags & FT_LOAD_NO_BITMAP ) == 0 ) 691 { 692 error = driver->clazz->load_glyph( slot, face->size, 693 glyph_index, 694 load_flags | FT_LOAD_SBITS_ONLY ); 695 696 if ( !error && slot->format == FT_GLYPH_FORMAT_BITMAP ) 697 goto Load_Ok; 698 } 699 700 { 701 FT_Face_Internal internal = face->internal; 702 FT_Int transform_flags = internal->transform_flags; 703 704 705 /* since the auto-hinter calls FT_Load_Glyph by itself, */ 706 /* make sure that glyphs aren't transformed */ 707 internal->transform_flags = 0; 708 709 /* load auto-hinted outline */ 710 hinting = (FT_AutoHinter_Interface)hinter->clazz->module_interface; 711 712 error = hinting->load_glyph( (FT_AutoHinter)hinter, 713 slot, face->size, 714 glyph_index, load_flags ); 715 716 internal->transform_flags = transform_flags; 717 } 718 } 719 else 720 { 721 error = driver->clazz->load_glyph( slot, 722 face->size, 723 glyph_index, 724 load_flags ); 725 if ( error ) 726 goto Exit; 727 728 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) 729 { 730 /* check that the loaded outline is correct */ 731 error = FT_Outline_Check( &slot->outline ); 732 if ( error ) 733 goto Exit; 734 735#ifdef GRID_FIT_METRICS 736 if ( !( load_flags & FT_LOAD_NO_HINTING ) ) 737 ft_glyphslot_grid_fit_metrics( slot, 738 FT_BOOL( load_flags & FT_LOAD_VERTICAL_LAYOUT ) ); 739#endif 740 } 741 } 742 743 Load_Ok: 744 /* compute the advance */ 745 if ( load_flags & FT_LOAD_VERTICAL_LAYOUT ) 746 { 747 slot->advance.x = 0; 748 slot->advance.y = slot->metrics.vertAdvance; 749 } 750 else 751 { 752 slot->advance.x = slot->metrics.horiAdvance; 753 slot->advance.y = 0; 754 } 755 756 /* compute the linear advance in 16.16 pixels */ 757 if ( ( load_flags & FT_LOAD_LINEAR_DESIGN ) == 0 && 758 ( FT_IS_SCALABLE( face ) ) ) 759 { 760 FT_Size_Metrics* metrics = &face->size->metrics; 761 762 763 /* it's tricky! */ 764 slot->linearHoriAdvance = FT_MulDiv( slot->linearHoriAdvance, 765 metrics->x_scale, 64 ); 766 767 slot->linearVertAdvance = FT_MulDiv( slot->linearVertAdvance, 768 metrics->y_scale, 64 ); 769 } 770 771 if ( ( load_flags & FT_LOAD_IGNORE_TRANSFORM ) == 0 ) 772 { 773 FT_Face_Internal internal = face->internal; 774 775 776 /* now, transform the glyph image if needed */ 777 if ( internal->transform_flags ) 778 { 779 /* get renderer */ 780 FT_Renderer renderer = ft_lookup_glyph_renderer( slot ); 781 782 783 if ( renderer ) 784 error = renderer->clazz->transform_glyph( 785 renderer, slot, 786 &internal->transform_matrix, 787 &internal->transform_delta ); 788 else if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) 789 { 790 /* apply `standard' transformation if no renderer is available */ 791 if ( internal->transform_flags & 1 ) 792 FT_Outline_Transform( &slot->outline, 793 &internal->transform_matrix ); 794 795 if ( internal->transform_flags & 2 ) 796 FT_Outline_Translate( &slot->outline, 797 internal->transform_delta.x, 798 internal->transform_delta.y ); 799 } 800 801 /* transform advance */ 802 FT_Vector_Transform( &slot->advance, &internal->transform_matrix ); 803 } 804 } 805 806 FT_TRACE5(( " x advance: %d\n" , slot->advance.x )); 807 FT_TRACE5(( " y advance: %d\n" , slot->advance.y )); 808 809 FT_TRACE5(( " linear x advance: %d\n" , slot->linearHoriAdvance )); 810 FT_TRACE5(( " linear y advance: %d\n" , slot->linearVertAdvance )); 811 812 /* do we need to render the image now? */ 813 if ( !error && 814 slot->format != FT_GLYPH_FORMAT_BITMAP && 815 slot->format != FT_GLYPH_FORMAT_COMPOSITE && 816 load_flags & FT_LOAD_RENDER ) 817 { 818 FT_Render_Mode mode = FT_LOAD_TARGET_MODE( load_flags ); 819 820 821 if ( mode == FT_RENDER_MODE_NORMAL && 822 (load_flags & FT_LOAD_MONOCHROME ) ) 823 mode = FT_RENDER_MODE_MONO; 824 825 error = FT_Render_Glyph( slot, mode ); 826 } 827 828 Exit: 829 return error; 830 } 831 832 833 /* documentation is in freetype.h */ 834 835 FT_EXPORT_DEF( FT_Error ) 836 FT_Load_Char( FT_Face face, 837 FT_ULong char_code, 838 FT_Int32 load_flags ) 839 { 840 FT_UInt glyph_index; 841 842 843 if ( !face ) 844 return FT_THROW( Invalid_Face_Handle ); 845 846 glyph_index = (FT_UInt)char_code; 847 if ( face->charmap ) 848 glyph_index = FT_Get_Char_Index( face, char_code ); 849 850 return FT_Load_Glyph( face, glyph_index, load_flags ); 851 } 852 853 854 /* destructor for sizes list */ 855 static void 856 destroy_size( FT_Memory memory, 857 FT_Size size, 858 FT_Driver driver ) 859 { 860 /* finalize client-specific data */ 861 if ( size->generic.finalizer ) 862 size->generic.finalizer( size ); 863 864 /* finalize format-specific stuff */ 865 if ( driver->clazz->done_size ) 866 driver->clazz->done_size( size ); 867 868 FT_FREE( size->internal ); 869 FT_FREE( size ); 870 } 871 872 873 static void 874 ft_cmap_done_internal( FT_CMap cmap ); 875 876 877 static void 878 destroy_charmaps( FT_Face face, 879 FT_Memory memory ) 880 { 881 FT_Int n; 882 883 884 if ( !face ) 885 return; 886 887 for ( n = 0; n < face->num_charmaps; n++ ) 888 { 889 FT_CMap cmap = FT_CMAP( face->charmaps[n] ); 890 891 892 ft_cmap_done_internal( cmap ); 893 894 face->charmaps[n] = NULL; 895 } 896 897 FT_FREE( face->charmaps ); 898 face->num_charmaps = 0; 899 } 900 901 902 /* destructor for faces list */ 903 static void 904 destroy_face( FT_Memory memory, 905 FT_Face face, 906 FT_Driver driver ) 907 { 908 FT_Driver_Class clazz = driver->clazz; 909 910 911 /* discard auto-hinting data */ 912 if ( face->autohint.finalizer ) 913 face->autohint.finalizer( face->autohint.data ); 914 915 /* Discard glyph slots for this face. */ 916 /* Beware! FT_Done_GlyphSlot() changes the field `face->glyph' */ 917 while ( face->glyph ) 918 FT_Done_GlyphSlot( face->glyph ); 919 920 /* discard all sizes for this face */ 921 FT_List_Finalize( &face->sizes_list, 922 (FT_List_Destructor)destroy_size, 923 memory, 924 driver ); 925 face->size = 0; 926 927 /* now discard client data */ 928 if ( face->generic.finalizer ) 929 face->generic.finalizer( face ); 930 931 /* discard charmaps */ 932 destroy_charmaps( face, memory ); 933 934 /* finalize format-specific stuff */ 935 if ( clazz->done_face ) 936 clazz->done_face( face ); 937 938 /* close the stream for this face if needed */ 939 FT_Stream_Free( 940 face->stream, 941 ( face->face_flags & FT_FACE_FLAG_EXTERNAL_STREAM ) != 0 ); 942 943 face->stream = 0; 944 945 /* get rid of it */ 946 if ( face->internal ) 947 { 948 FT_FREE( face->internal ); 949 } 950 FT_FREE( face ); 951 } 952 953 954 static void 955 Destroy_Driver( FT_Driver driver ) 956 { 957 FT_List_Finalize( &driver->faces_list, 958 (FT_List_Destructor)destroy_face, 959 driver->root.memory, 960 driver ); 961 962 /* check whether we need to drop the driver's glyph loader */ 963 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 964 FT_GlyphLoader_Done( driver->glyph_loader ); 965 } 966 967 968 /*************************************************************************/ 969 /* */ 970 /* <Function> */ 971 /* find_unicode_charmap */ 972 /* */ 973 /* <Description> */ 974 /* This function finds a Unicode charmap, if there is one. */ 975 /* And if there is more than one, it tries to favour the more */ 976 /* extensive one, i.e., one that supports UCS-4 against those which */ 977 /* are limited to the BMP (said UCS-2 encoding.) */ 978 /* */ 979 /* This function is called from open_face() (just below), and also */ 980 /* from FT_Select_Charmap( ..., FT_ENCODING_UNICODE ). */ 981 /* */ 982 static FT_Error 983 find_unicode_charmap( FT_Face face ) 984 { 985 FT_CharMap* first; 986 FT_CharMap* cur; 987 988 989 /* caller should have already checked that `face' is valid */ 990 FT_ASSERT( face ); 991 992 first = face->charmaps; 993 994 if ( !first ) 995 return FT_THROW( Invalid_CharMap_Handle ); 996 997 /* 998 * The original TrueType specification(s) only specified charmap 999 * formats that are capable of mapping 8 or 16 bit character codes to 1000 * glyph indices. 1001 * 1002 * However, recent updates to the Apple and OpenType specifications 1003 * introduced new formats that are capable of mapping 32-bit character 1004 * codes as well. And these are already used on some fonts, mainly to 1005 * map non-BMP Asian ideographs as defined in Unicode. 1006 * 1007 * For compatibility purposes, these fonts generally come with 1008 * *several* Unicode charmaps: 1009 * 1010 * - One of them in the "old" 16-bit format, that cannot access 1011 * all glyphs in the font. 1012 * 1013 * - Another one in the "new" 32-bit format, that can access all 1014 * the glyphs. 1015 * 1016 * This function has been written to always favor a 32-bit charmap 1017 * when found. Otherwise, a 16-bit one is returned when found. 1018 */ 1019 1020 /* Since the `interesting' table, with IDs (3,10), is normally the */ 1021 /* last one, we loop backwards. This loses with type1 fonts with */ 1022 /* non-BMP characters (<.0001%), this wins with .ttf with non-BMP */ 1023 /* chars (.01% ?), and this is the same about 99.99% of the time! */ 1024 1025 cur = first + face->num_charmaps; /* points after the last one */ 1026 1027 for ( ; --cur >= first; ) 1028 { 1029 if ( cur[0]->encoding == FT_ENCODING_UNICODE ) 1030 { 1031 /* XXX If some new encodings to represent UCS-4 are added, */ 1032 /* they should be added here. */ 1033 if ( ( cur[0]->platform_id == TT_PLATFORM_MICROSOFT && 1034 cur[0]->encoding_id == TT_MS_ID_UCS_4 ) || 1035 ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE && 1036 cur[0]->encoding_id == TT_APPLE_ID_UNICODE_32 ) ) 1037 { 1038#ifdef FT_MAX_CHARMAP_CACHEABLE 1039 if ( cur - first > FT_MAX_CHARMAP_CACHEABLE ) 1040 { 1041 FT_ERROR(( "find_unicode_charmap: UCS-4 cmap is found " 1042 "at too late position (%d)\n", cur - first )); 1043 continue; 1044 } 1045#endif 1046 face->charmap = cur[0]; 1047 return FT_Err_Ok; 1048 } 1049 } 1050 } 1051 1052 /* We do not have any UCS-4 charmap. */ 1053 /* Do the loop again and search for UCS-2 charmaps. */ 1054 cur = first + face->num_charmaps; 1055 1056 for ( ; --cur >= first; ) 1057 { 1058 if ( cur[0]->encoding == FT_ENCODING_UNICODE ) 1059 { 1060#ifdef FT_MAX_CHARMAP_CACHEABLE 1061 if ( cur - first > FT_MAX_CHARMAP_CACHEABLE ) 1062 { 1063 FT_ERROR(( "find_unicode_charmap: UCS-2 cmap is found " 1064 "at too late position (%d)\n", cur - first )); 1065 continue; 1066 } 1067#endif 1068 face->charmap = cur[0]; 1069 return FT_Err_Ok; 1070 } 1071 } 1072 1073 return FT_THROW( Invalid_CharMap_Handle ); 1074 } 1075 1076 1077 /*************************************************************************/ 1078 /* */ 1079 /* <Function> */ 1080 /* find_variant_selector_charmap */ 1081 /* */ 1082 /* <Description> */ 1083 /* This function finds the variant selector charmap, if there is one. */ 1084 /* There can only be one (platform=0, specific=5, format=14). */ 1085 /* */ 1086 static FT_CharMap 1087 find_variant_selector_charmap( FT_Face face ) 1088 { 1089 FT_CharMap* first; 1090 FT_CharMap* end; 1091 FT_CharMap* cur; 1092 1093 1094 /* caller should have already checked that `face' is valid */ 1095 FT_ASSERT( face ); 1096 1097 first = face->charmaps; 1098 1099 if ( !first ) 1100 return NULL; 1101 1102 end = first + face->num_charmaps; /* points after the last one */ 1103 1104 for ( cur = first; cur < end; ++cur ) 1105 { 1106 if ( cur[0]->platform_id == TT_PLATFORM_APPLE_UNICODE && 1107 cur[0]->encoding_id == TT_APPLE_ID_VARIANT_SELECTOR && 1108 FT_Get_CMap_Format( cur[0] ) == 14 ) 1109 { 1110#ifdef FT_MAX_CHARMAP_CACHEABLE 1111 if ( cur - first > FT_MAX_CHARMAP_CACHEABLE ) 1112 { 1113 FT_ERROR(( "find_unicode_charmap: UVS cmap is found " 1114 "at too late position (%d)\n", cur - first )); 1115 continue; 1116 } 1117#endif 1118 return cur[0]; 1119 } 1120 } 1121 1122 return NULL; 1123 } 1124 1125 1126 /*************************************************************************/ 1127 /* */ 1128 /* <Function> */ 1129 /* open_face */ 1130 /* */ 1131 /* <Description> */ 1132 /* This function does some work for FT_Open_Face(). */ 1133 /* */ 1134 static FT_Error 1135 open_face( FT_Driver driver, 1136 FT_Stream stream, 1137 FT_Long face_index, 1138 FT_Int num_params, 1139 FT_Parameter* params, 1140 FT_Face *aface ) 1141 { 1142 FT_Memory memory; 1143 FT_Driver_Class clazz; 1144 FT_Face face = 0; 1145 FT_Error error, error2; 1146 FT_Face_Internal internal = NULL; 1147 1148 1149 clazz = driver->clazz; 1150 memory = driver->root.memory; 1151 1152 /* allocate the face object and perform basic initialization */ 1153 if ( FT_ALLOC( face, clazz->face_object_size ) ) 1154 goto Fail; 1155 1156 face->driver = driver; 1157 face->memory = memory; 1158 face->stream = stream; 1159 1160 if ( FT_NEW( internal ) ) 1161 goto Fail; 1162 1163 face->internal = internal; 1164 1165#ifdef FT_CONFIG_OPTION_INCREMENTAL 1166 { 1167 int i; 1168 1169 1170 face->internal->incremental_interface = 0; 1171 for ( i = 0; i < num_params && !face->internal->incremental_interface; 1172 i++ ) 1173 if ( params[i].tag == FT_PARAM_TAG_INCREMENTAL ) 1174 face->internal->incremental_interface = 1175 (FT_Incremental_Interface)params[i].data; 1176 } 1177#endif 1178 1179 if ( clazz->init_face ) 1180 error = clazz->init_face( stream, 1181 face, 1182 (FT_Int)face_index, 1183 num_params, 1184 params ); 1185 if ( error ) 1186 goto Fail; 1187 1188 /* select Unicode charmap by default */ 1189 error2 = find_unicode_charmap( face ); 1190 1191 /* if no Unicode charmap can be found, FT_Err_Invalid_CharMap_Handle */ 1192 /* is returned. */ 1193 1194 /* no error should happen, but we want to play safe */ 1195 if ( error2 && FT_ERR_NEQ( error2, Invalid_CharMap_Handle ) ) 1196 { 1197 error = error2; 1198 goto Fail; 1199 } 1200 1201 *aface = face; 1202 1203 Fail: 1204 if ( error ) 1205 { 1206 destroy_charmaps( face, memory ); 1207 if ( clazz->done_face ) 1208 clazz->done_face( face ); 1209 FT_FREE( internal ); 1210 FT_FREE( face ); 1211 *aface = 0; 1212 } 1213 1214 return error; 1215 } 1216 1217 1218 /* there's a Mac-specific extended implementation of FT_New_Face() */ 1219 /* in src/base/ftmac.c */ 1220 1221//#ifndef FT_MACINTOSH 1222 1223 /* documentation is in freetype.h */ 1224 1225 FT_EXPORT_DEF( FT_Error ) 1226 FT_New_Face( FT_Library library, 1227 const char* pathname, 1228 FT_Long face_index, 1229 FT_Face *aface ) 1230 { 1231 FT_Open_Args args; 1232 1233 1234 /* test for valid `library' and `aface' delayed to FT_Open_Face() */ 1235 if ( !pathname ) 1236 return FT_THROW( Invalid_Argument ); 1237 1238 args.flags = FT_OPEN_PATHNAME; 1239 args.pathname = (char*)pathname; 1240 args.stream = NULL; 1241 1242 return FT_Open_Face( library, &args, face_index, aface ); 1243 } 1244 1245//#endif 1246 1247 1248 /* documentation is in freetype.h */ 1249 1250 FT_EXPORT_DEF( FT_Error ) 1251 FT_New_Memory_Face( FT_Library library, 1252 const FT_Byte* file_base, 1253 FT_Long file_size, 1254 FT_Long face_index, 1255 FT_Face *aface ) 1256 { 1257 FT_Open_Args args; 1258 1259 1260 /* test for valid `library' and `face' delayed to FT_Open_Face() */ 1261 if ( !file_base ) 1262 return FT_THROW( Invalid_Argument ); 1263 1264 args.flags = FT_OPEN_MEMORY; 1265 args.memory_base = file_base; 1266 args.memory_size = file_size; 1267 args.stream = NULL; 1268 1269 return FT_Open_Face( library, &args, face_index, aface ); 1270 } 1271 1272 1273#ifdef FT_CONFIG_OPTION_MAC_FONTS 1274 1275 /* The behavior here is very similar to that in base/ftmac.c, but it */ 1276 /* is designed to work on non-mac systems, so no mac specific calls. */ 1277 /* */ 1278 /* We look at the file and determine if it is a mac dfont file or a mac */ 1279 /* resource file, or a macbinary file containing a mac resource file. */ 1280 /* */ 1281 /* Unlike ftmac I'm not going to look at a `FOND'. I don't really see */ 1282 /* the point, especially since there may be multiple `FOND' resources. */ 1283 /* Instead I'll just look for `sfnt' and `POST' resources, ordered as */ 1284 /* they occur in the file. */ 1285 /* */ 1286 /* Note that multiple `POST' resources do not mean multiple postscript */ 1287 /* fonts; they all get jammed together to make what is essentially a */ 1288 /* pfb file. */ 1289 /* */ 1290 /* We aren't interested in `NFNT' or `FONT' bitmap resources. */ 1291 /* */ 1292 /* As soon as we get an `sfnt' load it into memory and pass it off to */ 1293 /* FT_Open_Face. */ 1294 /* */ 1295 /* If we have a (set of) `POST' resources, massage them into a (memory) */ 1296 /* pfb file and pass that to FT_Open_Face. (As with ftmac.c I'm not */ 1297 /* going to try to save the kerning info. After all that lives in the */ 1298 /* `FOND' which isn't in the file containing the `POST' resources so */ 1299 /* we don't really have access to it. */ 1300 1301 1302 /* Finalizer for a memory stream; gets called by FT_Done_Face(). */ 1303 /* It frees the memory it uses. */ 1304 /* From ftmac.c. */ 1305 static void 1306 memory_stream_close( FT_Stream stream ) 1307 { 1308 FT_Memory memory = stream->memory; 1309 1310 1311 FT_FREE( stream->base ); 1312 1313 stream->size = 0; 1314 stream->base = 0; 1315 stream->close = 0; 1316 } 1317 1318 1319 /* Create a new memory stream from a buffer and a size. */ 1320 /* From ftmac.c. */ 1321 static FT_Error 1322 new_memory_stream( FT_Library library, 1323 FT_Byte* base, 1324 FT_ULong size, 1325 FT_Stream_CloseFunc close, 1326 FT_Stream *astream ) 1327 { 1328 FT_Error error; 1329 FT_Memory memory; 1330 FT_Stream stream = NULL; 1331 1332 1333 if ( !library ) 1334 return FT_THROW( Invalid_Library_Handle ); 1335 1336 if ( !base ) 1337 return FT_THROW( Invalid_Argument ); 1338 1339 *astream = 0; 1340 memory = library->memory; 1341 if ( FT_NEW( stream ) ) 1342 goto Exit; 1343 1344 FT_Stream_OpenMemory( stream, base, size ); 1345 1346 stream->close = close; 1347 1348 *astream = stream; 1349 1350 Exit: 1351 return error; 1352 } 1353 1354 1355 /* Create a new FT_Face given a buffer and a driver name. */ 1356 /* from ftmac.c */ 1357 FT_LOCAL_DEF( FT_Error ) 1358 open_face_from_buffer( FT_Library library, 1359 FT_Byte* base, 1360 FT_ULong size, 1361 FT_Long face_index, 1362 const char* driver_name, 1363 FT_Face *aface ) 1364 { 1365 FT_Open_Args args; 1366 FT_Error error; 1367 FT_Stream stream = NULL; 1368 FT_Memory memory = library->memory; 1369 1370 1371 error = new_memory_stream( library, 1372 base, 1373 size, 1374 memory_stream_close, 1375 &stream ); 1376 if ( error ) 1377 { 1378 FT_FREE( base ); 1379 return error; 1380 } 1381 1382 args.flags = FT_OPEN_STREAM; 1383 args.stream = stream; 1384 if ( driver_name ) 1385 { 1386 args.flags = args.flags | FT_OPEN_DRIVER; 1387 args.driver = FT_Get_Module( library, driver_name ); 1388 } 1389 1390#ifdef FT_MACINTOSH 1391 /* At this point, face_index has served its purpose; */ 1392 /* whoever calls this function has already used it to */ 1393 /* locate the correct font data. We should not propagate */ 1394 /* this index to FT_Open_Face() (unless it is negative). */ 1395 1396 if ( face_index > 0 ) 1397 face_index = 0; 1398#endif 1399 1400 error = FT_Open_Face( library, &args, face_index, aface ); 1401 1402 if ( error == FT_Err_Ok ) 1403 (*aface)->face_flags &= ~FT_FACE_FLAG_EXTERNAL_STREAM; 1404 else 1405#ifdef FT_MACINTOSH 1406 FT_Stream_Free( stream, 0 ); 1407#else 1408 { 1409 FT_Stream_Close( stream ); 1410 FT_FREE( stream ); 1411 } 1412#endif 1413 1414 return error; 1415 } 1416 1417 1418 /* Look up `TYP1' or `CID ' table from sfnt table directory. */ 1419 /* `offset' and `length' must exclude the binary header in tables. */ 1420 1421 /* Type 1 and CID-keyed font drivers should recognize sfnt-wrapped */ 1422 /* format too. Here, since we can't expect that the TrueType font */ 1423 /* driver is loaded unconditially, we must parse the font by */ 1424 /* ourselves. We are only interested in the name of the table and */ 1425 /* the offset. */ 1426 1427 static FT_Error 1428 ft_lookup_PS_in_sfnt_stream( FT_Stream stream, 1429 FT_Long face_index, 1430 FT_ULong* offset, 1431 FT_ULong* length, 1432 FT_Bool* is_sfnt_cid ) 1433 { 1434 FT_Error error; 1435 FT_UShort numTables; 1436 FT_Long pstable_index; 1437 FT_ULong tag; 1438 int i; 1439 1440 1441 *offset = 0; 1442 *length = 0; 1443 *is_sfnt_cid = FALSE; 1444 1445 /* TODO: support for sfnt-wrapped PS/CID in TTC format */ 1446 1447 /* version check for 'typ1' (should be ignored?) */ 1448 if ( FT_READ_ULONG( tag ) ) 1449 return error; 1450 if ( tag != TTAG_typ1 ) 1451 return FT_THROW( Unknown_File_Format ); 1452 1453 if ( FT_READ_USHORT( numTables ) ) 1454 return error; 1455 if ( FT_STREAM_SKIP( 2 * 3 ) ) /* skip binary search header */ 1456 return error; 1457 1458 pstable_index = -1; 1459 *is_sfnt_cid = FALSE; 1460 1461 for ( i = 0; i < numTables; i++ ) 1462 { 1463 if ( FT_READ_ULONG( tag ) || FT_STREAM_SKIP( 4 ) || 1464 FT_READ_ULONG( *offset ) || FT_READ_ULONG( *length ) ) 1465 return error; 1466 1467 if ( tag == TTAG_CID ) 1468 { 1469 pstable_index++; 1470 *offset += 22; 1471 *length -= 22; 1472 *is_sfnt_cid = TRUE; 1473 if ( face_index < 0 ) 1474 return FT_Err_Ok; 1475 } 1476 else if ( tag == TTAG_TYP1 ) 1477 { 1478 pstable_index++; 1479 *offset += 24; 1480 *length -= 24; 1481 *is_sfnt_cid = FALSE; 1482 if ( face_index < 0 ) 1483 return FT_Err_Ok; 1484 } 1485 if ( face_index >= 0 && pstable_index == face_index ) 1486 return FT_Err_Ok; 1487 } 1488 return FT_THROW( Table_Missing ); 1489 } 1490 1491 1492 FT_LOCAL_DEF( FT_Error ) 1493 open_face_PS_from_sfnt_stream( FT_Library library, 1494 FT_Stream stream, 1495 FT_Long face_index, 1496 FT_Int num_params, 1497 FT_Parameter *params, 1498 FT_Face *aface ) 1499 { 1500 FT_Error error; 1501 FT_Memory memory = library->memory; 1502 FT_ULong offset, length; 1503 FT_Long pos; 1504 FT_Bool is_sfnt_cid; 1505 FT_Byte* sfnt_ps = NULL; 1506 1507 FT_UNUSED( num_params ); 1508 FT_UNUSED( params ); 1509 1510 1511 pos = FT_Stream_Pos( stream ); 1512 1513 error = ft_lookup_PS_in_sfnt_stream( stream, 1514 face_index, 1515 &offset, 1516 &length, 1517 &is_sfnt_cid ); 1518 if ( error ) 1519 goto Exit; 1520 1521 if ( FT_Stream_Seek( stream, pos + offset ) ) 1522 goto Exit; 1523 1524 if ( FT_ALLOC( sfnt_ps, (FT_Long)length ) ) 1525 goto Exit; 1526 1527 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_ps, length ); 1528 if ( error ) 1529 goto Exit; 1530 1531 error = open_face_from_buffer( library, 1532 sfnt_ps, 1533 length, 1534 FT_MIN( face_index, 0 ), 1535 is_sfnt_cid ? "cid" : "type1", 1536 aface ); 1537 Exit: 1538 { 1539 FT_Error error1; 1540 1541 1542 if ( FT_ERR_EQ( error, Unknown_File_Format ) ) 1543 { 1544 error1 = FT_Stream_Seek( stream, pos ); 1545 if ( error1 ) 1546 return error1; 1547 } 1548 1549 return error; 1550 } 1551 } 1552 1553 1554#ifndef FT_MACINTOSH 1555 1556 /* The resource header says we've got resource_cnt `POST' (type1) */ 1557 /* resources in this file. They all need to be coalesced into */ 1558 /* one lump which gets passed on to the type1 driver. */ 1559 /* Here can be only one PostScript font in a file so face_index */ 1560 /* must be 0 (or -1). */ 1561 /* */ 1562 static FT_Error 1563 Mac_Read_POST_Resource( FT_Library library, 1564 FT_Stream stream, 1565 FT_Long *offsets, 1566 FT_Long resource_cnt, 1567 FT_Long face_index, 1568 FT_Face *aface ) 1569 { 1570 FT_Error error = FT_ERR( Cannot_Open_Resource ); 1571 FT_Memory memory = library->memory; 1572 FT_Byte* pfb_data = NULL; 1573 int i, type, flags; 1574 FT_Long len; 1575 FT_Long pfb_len, pfb_pos, pfb_lenpos; 1576 FT_Long rlen, temp; 1577 1578 1579 if ( face_index == -1 ) 1580 face_index = 0; 1581 if ( face_index != 0 ) 1582 return error; 1583 1584 /* Find the length of all the POST resources, concatenated. Assume */ 1585 /* worst case (each resource in its own section). */ 1586 pfb_len = 0; 1587 for ( i = 0; i < resource_cnt; ++i ) 1588 { 1589 error = FT_Stream_Seek( stream, offsets[i] ); 1590 if ( error ) 1591 goto Exit; 1592 if ( FT_READ_LONG( temp ) ) 1593 goto Exit; 1594 pfb_len += temp + 6; 1595 } 1596 1597 if ( FT_ALLOC( pfb_data, (FT_Long)pfb_len + 2 ) ) 1598 goto Exit; 1599 1600 pfb_data[0] = 0x80; 1601 pfb_data[1] = 1; /* Ascii section */ 1602 pfb_data[2] = 0; /* 4-byte length, fill in later */ 1603 pfb_data[3] = 0; 1604 pfb_data[4] = 0; 1605 pfb_data[5] = 0; 1606 pfb_pos = 6; 1607 pfb_lenpos = 2; 1608 1609 len = 0; 1610 type = 1; 1611 for ( i = 0; i < resource_cnt; ++i ) 1612 { 1613 error = FT_Stream_Seek( stream, offsets[i] ); 1614 if ( error ) 1615 goto Exit2; 1616 if ( FT_READ_LONG( rlen ) ) 1617 goto Exit; 1618 if ( FT_READ_USHORT( flags ) ) 1619 goto Exit; 1620 FT_TRACE3(( "POST fragment[%d]: offsets=0x%08x, rlen=0x%08x, flags=0x%04x\n", 1621 i, offsets[i], rlen, flags )); 1622 1623 /* postpone the check of rlen longer than buffer until FT_Stream_Read() */ 1624 if ( ( flags >> 8 ) == 0 ) /* Comment, should not be loaded */ 1625 continue; 1626 1627 /* the flags are part of the resource, so rlen >= 2. */ 1628 /* but some fonts declare rlen = 0 for empty fragment */ 1629 if ( rlen > 2 ) 1630 rlen -= 2; 1631 else 1632 rlen = 0; 1633 1634 if ( ( flags >> 8 ) == type ) 1635 len += rlen; 1636 else 1637 { 1638 if ( pfb_lenpos + 3 > pfb_len + 2 ) 1639 goto Exit2; 1640 pfb_data[pfb_lenpos ] = (FT_Byte)( len ); 1641 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 ); 1642 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 ); 1643 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 ); 1644 1645 if ( ( flags >> 8 ) == 5 ) /* End of font mark */ 1646 break; 1647 1648 if ( pfb_pos + 6 > pfb_len + 2 ) 1649 goto Exit2; 1650 pfb_data[pfb_pos++] = 0x80; 1651 1652 type = flags >> 8; 1653 len = rlen; 1654 1655 pfb_data[pfb_pos++] = (FT_Byte)type; 1656 pfb_lenpos = pfb_pos; 1657 pfb_data[pfb_pos++] = 0; /* 4-byte length, fill in later */ 1658 pfb_data[pfb_pos++] = 0; 1659 pfb_data[pfb_pos++] = 0; 1660 pfb_data[pfb_pos++] = 0; 1661 } 1662 1663 error = FT_ERR( Cannot_Open_Resource ); 1664 if ( pfb_pos > pfb_len || pfb_pos + rlen > pfb_len ) 1665 goto Exit2; 1666 1667 error = FT_Stream_Read( stream, (FT_Byte *)pfb_data + pfb_pos, rlen ); 1668 if ( error ) 1669 goto Exit2; 1670 pfb_pos += rlen; 1671 } 1672 1673 if ( pfb_pos + 2 > pfb_len + 2 ) 1674 goto Exit2; 1675 pfb_data[pfb_pos++] = 0x80; 1676 pfb_data[pfb_pos++] = 3; 1677 1678 if ( pfb_lenpos + 3 > pfb_len + 2 ) 1679 goto Exit2; 1680 pfb_data[pfb_lenpos ] = (FT_Byte)( len ); 1681 pfb_data[pfb_lenpos + 1] = (FT_Byte)( len >> 8 ); 1682 pfb_data[pfb_lenpos + 2] = (FT_Byte)( len >> 16 ); 1683 pfb_data[pfb_lenpos + 3] = (FT_Byte)( len >> 24 ); 1684 1685 return open_face_from_buffer( library, 1686 pfb_data, 1687 pfb_pos, 1688 face_index, 1689 "type1", 1690 aface ); 1691 1692 Exit2: 1693 FT_FREE( pfb_data ); 1694 1695 Exit: 1696 return error; 1697 } 1698 1699 1700 /* The resource header says we've got resource_cnt `sfnt' */ 1701 /* (TrueType/OpenType) resources in this file. Look through */ 1702 /* them for the one indicated by face_index, load it into mem, */ 1703 /* pass it on the the truetype driver and return it. */ 1704 /* */ 1705 static FT_Error 1706 Mac_Read_sfnt_Resource( FT_Library library, 1707 FT_Stream stream, 1708 FT_Long *offsets, 1709 FT_Long resource_cnt, 1710 FT_Long face_index, 1711 FT_Face *aface ) 1712 { 1713 FT_Memory memory = library->memory; 1714 FT_Byte* sfnt_data = NULL; 1715 FT_Error error; 1716 FT_Long flag_offset; 1717 FT_Long rlen; 1718 int is_cff; 1719 FT_Long face_index_in_resource = 0; 1720 1721 1722 if ( face_index == -1 ) 1723 face_index = 0; 1724 if ( face_index >= resource_cnt ) 1725 return FT_THROW( Cannot_Open_Resource ); 1726 1727 flag_offset = offsets[face_index]; 1728 error = FT_Stream_Seek( stream, flag_offset ); 1729 if ( error ) 1730 goto Exit; 1731 1732 if ( FT_READ_LONG( rlen ) ) 1733 goto Exit; 1734 if ( rlen == -1 ) 1735 return FT_THROW( Cannot_Open_Resource ); 1736 1737 error = open_face_PS_from_sfnt_stream( library, 1738 stream, 1739 face_index, 1740 0, NULL, 1741 aface ); 1742 if ( !error ) 1743 goto Exit; 1744 1745 /* rewind sfnt stream before open_face_PS_from_sfnt_stream() */ 1746 if ( FT_Stream_Seek( stream, flag_offset + 4 ) ) 1747 goto Exit; 1748 1749 if ( FT_ALLOC( sfnt_data, (FT_Long)rlen ) ) 1750 return error; 1751 error = FT_Stream_Read( stream, (FT_Byte *)sfnt_data, rlen ); 1752 if ( error ) 1753 goto Exit; 1754 1755 is_cff = rlen > 4 && !ft_memcmp( sfnt_data, "OTTO", 4 ); 1756 error = open_face_from_buffer( library, 1757 sfnt_data, 1758 rlen, 1759 face_index_in_resource, 1760 is_cff ? "cff" : "truetype", 1761 aface ); 1762 1763 Exit: 1764 return error; 1765 } 1766 1767 1768 /* Check for a valid resource fork header, or a valid dfont */ 1769 /* header. In a resource fork the first 16 bytes are repeated */ 1770 /* at the location specified by bytes 4-7. In a dfont bytes */ 1771 /* 4-7 point to 16 bytes of zeroes instead. */ 1772 /* */ 1773 static FT_Error 1774 IsMacResource( FT_Library library, 1775 FT_Stream stream, 1776 FT_Long resource_offset, 1777 FT_Long face_index, 1778 FT_Face *aface ) 1779 { 1780 FT_Memory memory = library->memory; 1781 FT_Error error; 1782 FT_Long map_offset, rdara_pos; 1783 FT_Long *data_offsets; 1784 FT_Long count; 1785 1786 1787 error = FT_Raccess_Get_HeaderInfo( library, stream, resource_offset, 1788 &map_offset, &rdara_pos ); 1789 if ( error ) 1790 return error; 1791 1792 error = FT_Raccess_Get_DataOffsets( library, stream, 1793 map_offset, rdara_pos, 1794 TTAG_POST, 1795 &data_offsets, &count ); 1796 if ( !error ) 1797 { 1798 error = Mac_Read_POST_Resource( library, stream, data_offsets, count, 1799 face_index, aface ); 1800 FT_FREE( data_offsets ); 1801 /* POST exists in an LWFN providing a single face */ 1802 if ( !error ) 1803 (*aface)->num_faces = 1; 1804 return error; 1805 } 1806 1807 error = FT_Raccess_Get_DataOffsets( library, stream, 1808 map_offset, rdara_pos, 1809 TTAG_sfnt, 1810 &data_offsets, &count ); 1811 if ( !error ) 1812 { 1813 FT_Long face_index_internal = face_index % count; 1814 1815 1816 error = Mac_Read_sfnt_Resource( library, stream, data_offsets, count, 1817 face_index_internal, aface ); 1818 FT_FREE( data_offsets ); 1819 if ( !error ) 1820 (*aface)->num_faces = count; 1821 } 1822 1823 return error; 1824 } 1825 1826 1827 /* Check for a valid macbinary header, and if we find one */ 1828 /* check that the (flattened) resource fork in it is valid. */ 1829 /* */ 1830 static FT_Error 1831 IsMacBinary( FT_Library library, 1832 FT_Stream stream, 1833 FT_Long face_index, 1834 FT_Face *aface ) 1835 { 1836 unsigned char header[128]; 1837 FT_Error error; 1838 FT_Long dlen, offset; 1839 1840 1841 if ( NULL == stream ) 1842 return FT_THROW( Invalid_Stream_Operation ); 1843 1844 error = FT_Stream_Seek( stream, 0 ); 1845 if ( error ) 1846 goto Exit; 1847 1848 error = FT_Stream_Read( stream, (FT_Byte*)header, 128 ); 1849 if ( error ) 1850 goto Exit; 1851 1852 if ( header[ 0] != 0 || 1853 header[74] != 0 || 1854 header[82] != 0 || 1855 header[ 1] == 0 || 1856 header[ 1] > 33 || 1857 header[63] != 0 || 1858 header[2 + header[1]] != 0 ) 1859 return FT_THROW( Unknown_File_Format ); 1860 1861 dlen = ( header[0x53] << 24 ) | 1862 ( header[0x54] << 16 ) | 1863 ( header[0x55] << 8 ) | 1864 header[0x56]; 1865#if 0 1866 rlen = ( header[0x57] << 24 ) | 1867 ( header[0x58] << 16 ) | 1868 ( header[0x59] << 8 ) | 1869 header[0x5a]; 1870#endif /* 0 */ 1871 offset = 128 + ( ( dlen + 127 ) & ~127 ); 1872 1873 return IsMacResource( library, stream, offset, face_index, aface ); 1874 1875 Exit: 1876 return error; 1877 } 1878 1879 1880 static FT_Error 1881 load_face_in_embedded_rfork( FT_Library library, 1882 FT_Stream stream, 1883 FT_Long face_index, 1884 FT_Face *aface, 1885 const FT_Open_Args *args ) 1886 { 1887 1888#undef FT_COMPONENT 1889#define FT_COMPONENT trace_raccess 1890 1891 FT_Memory memory = library->memory; 1892 FT_Error error = FT_ERR( Unknown_File_Format ); 1893 int i; 1894 1895 char * file_names[FT_RACCESS_N_RULES]; 1896 FT_Long offsets[FT_RACCESS_N_RULES]; 1897 FT_Error errors[FT_RACCESS_N_RULES]; 1898 FT_Bool is_darwin_vfs, vfs_rfork_has_no_font = FALSE; /* not tested */ 1899 1900 FT_Open_Args args2; 1901 FT_Stream stream2 = 0; 1902 1903 1904 FT_Raccess_Guess( library, stream, 1905 args->pathname, file_names, offsets, errors ); 1906 1907 for ( i = 0; i < FT_RACCESS_N_RULES; i++ ) 1908 { 1909 is_darwin_vfs = ft_raccess_rule_by_darwin_vfs( library, i ); 1910 if ( is_darwin_vfs && vfs_rfork_has_no_font ) 1911 { 1912 FT_TRACE3(( "Skip rule %d: darwin vfs resource fork" 1913 " is already checked and" 1914 " no font is found\n", i )); 1915 continue; 1916 } 1917 1918 if ( errors[i] ) 1919 { 1920 FT_TRACE3(( "Error[%d] has occurred in rule %d\n", errors[i], i )); 1921 continue; 1922 } 1923 1924 args2.flags = FT_OPEN_PATHNAME; 1925 args2.pathname = file_names[i] ? file_names[i] : args->pathname; 1926 1927 FT_TRACE3(( "Try rule %d: %s (offset=%d) ...", 1928 i, args2.pathname, offsets[i] )); 1929 1930 error = FT_Stream_New( library, &args2, &stream2 ); 1931 if ( is_darwin_vfs && FT_ERR_EQ( error, Cannot_Open_Stream ) ) 1932 vfs_rfork_has_no_font = TRUE; 1933 1934 if ( error ) 1935 { 1936 FT_TRACE3(( "failed\n" )); 1937 continue; 1938 } 1939 1940 error = IsMacResource( library, stream2, offsets[i], 1941 face_index, aface ); 1942 FT_Stream_Free( stream2, 0 ); 1943 1944 FT_TRACE3(( "%s\n", error ? "failed": "successful" )); 1945 1946 if ( !error ) 1947 break; 1948 else if ( is_darwin_vfs ) 1949 vfs_rfork_has_no_font = TRUE; 1950 } 1951 1952 for (i = 0; i < FT_RACCESS_N_RULES; i++) 1953 { 1954 if ( file_names[i] ) 1955 FT_FREE( file_names[i] ); 1956 } 1957 1958 /* Caller (load_mac_face) requires FT_Err_Unknown_File_Format. */ 1959 if ( error ) 1960 error = FT_ERR( Unknown_File_Format ); 1961 1962 return error; 1963 1964#undef FT_COMPONENT 1965#define FT_COMPONENT trace_objs 1966 1967 } 1968 1969 1970 /* Check for some macintosh formats without Carbon framework. */ 1971 /* Is this a macbinary file? If so look at the resource fork. */ 1972 /* Is this a mac dfont file? */ 1973 /* Is this an old style resource fork? (in data) */ 1974 /* Else call load_face_in_embedded_rfork to try extra rules */ 1975 /* (defined in `ftrfork.c'). */ 1976 /* */ 1977 static FT_Error 1978 load_mac_face( FT_Library library, 1979 FT_Stream stream, 1980 FT_Long face_index, 1981 FT_Face *aface, 1982 const FT_Open_Args *args ) 1983 { 1984 FT_Error error; 1985 FT_UNUSED( args ); 1986 1987 1988 error = IsMacBinary( library, stream, face_index, aface ); 1989 if ( FT_ERR_EQ( error, Unknown_File_Format ) ) 1990 { 1991 1992#undef FT_COMPONENT 1993#define FT_COMPONENT trace_raccess 1994 1995 FT_TRACE3(( "Try as dfont: %s ...", args->pathname )); 1996 1997 error = IsMacResource( library, stream, 0, face_index, aface ); 1998 1999 FT_TRACE3(( "%s\n", error ? "failed" : "successful" )); 2000 2001#undef FT_COMPONENT 2002#define FT_COMPONENT trace_objs 2003 2004 } 2005 2006 if ( ( FT_ERR_EQ( error, Unknown_File_Format ) || 2007 FT_ERR_EQ( error, Invalid_Stream_Operation ) ) && 2008 ( args->flags & FT_OPEN_PATHNAME ) ) 2009 error = load_face_in_embedded_rfork( library, stream, 2010 face_index, aface, args ); 2011 return error; 2012 } 2013#endif 2014 2015#endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */ 2016 2017 2018 /* documentation is in freetype.h */ 2019 2020 FT_EXPORT_DEF( FT_Error ) 2021 FT_Open_Face( FT_Library library, 2022 const FT_Open_Args* args, 2023 FT_Long face_index, 2024 FT_Face *aface ) 2025 { 2026 FT_Error error; 2027 FT_Driver driver = NULL; 2028 FT_Memory memory = NULL; 2029 FT_Stream stream = NULL; 2030 FT_Face face = NULL; 2031 FT_ListNode node = NULL; 2032 FT_Bool external_stream; 2033 FT_Module* cur; 2034 FT_Module* limit; 2035 2036 2037 /* test for valid `library' delayed to */ 2038 /* FT_Stream_New() */ 2039 2040 if ( ( !aface && face_index >= 0 ) || !args ) 2041 return FT_THROW( Invalid_Argument ); 2042 2043 external_stream = FT_BOOL( ( args->flags & FT_OPEN_STREAM ) && 2044 args->stream ); 2045 2046 /* create input stream */ 2047 error = FT_Stream_New( library, args, &stream ); 2048 if ( error ) 2049 goto Fail3; 2050 2051 memory = library->memory; 2052 2053 /* If the font driver is specified in the `args' structure, use */ 2054 /* it. Otherwise, we scan the list of registered drivers. */ 2055 if ( ( args->flags & FT_OPEN_DRIVER ) && args->driver ) 2056 { 2057 driver = FT_DRIVER( args->driver ); 2058 2059 /* not all modules are drivers, so check... */ 2060 if ( FT_MODULE_IS_DRIVER( driver ) ) 2061 { 2062 FT_Int num_params = 0; 2063 FT_Parameter* params = 0; 2064 2065 2066 if ( args->flags & FT_OPEN_PARAMS ) 2067 { 2068 num_params = args->num_params; 2069 params = args->params; 2070 } 2071 2072 error = open_face( driver, stream, face_index, 2073 num_params, params, &face ); 2074 if ( !error ) 2075 goto Success; 2076 } 2077 else 2078 error = FT_THROW( Invalid_Handle ); 2079 2080 FT_Stream_Free( stream, external_stream ); 2081 goto Fail; 2082 } 2083 else 2084 { 2085 error = FT_ERR( Missing_Module ); 2086 2087 /* check each font driver for an appropriate format */ 2088 cur = library->modules; 2089 limit = cur + library->num_modules; 2090 2091 for ( ; cur < limit; cur++ ) 2092 { 2093 /* not all modules are font drivers, so check... */ 2094 if ( FT_MODULE_IS_DRIVER( cur[0] ) ) 2095 { 2096 FT_Int num_params = 0; 2097 FT_Parameter* params = 0; 2098 2099 2100 driver = FT_DRIVER( cur[0] ); 2101 2102 if ( args->flags & FT_OPEN_PARAMS ) 2103 { 2104 num_params = args->num_params; 2105 params = args->params; 2106 } 2107 2108 error = open_face( driver, stream, face_index, 2109 num_params, params, &face ); 2110 if ( !error ) 2111 goto Success; 2112 2113#ifdef FT_CONFIG_OPTION_MAC_FONTS 2114 if ( ft_strcmp( cur[0]->clazz->module_name, "truetype" ) == 0 && 2115 FT_ERR_EQ( error, Table_Missing ) ) 2116 { 2117 /* TrueType but essential tables are missing */ 2118 if ( FT_Stream_Seek( stream, 0 ) ) 2119 break; 2120 2121 error = open_face_PS_from_sfnt_stream( library, 2122 stream, 2123 face_index, 2124 num_params, 2125 params, 2126 aface ); 2127 if ( !error ) 2128 { 2129 FT_Stream_Free( stream, external_stream ); 2130 return error; 2131 } 2132 } 2133#endif 2134 2135 if ( FT_ERR_NEQ( error, Unknown_File_Format ) ) 2136 goto Fail3; 2137 } 2138 } 2139 2140 Fail3: 2141 /* If we are on the mac, and we get an */ 2142 /* FT_Err_Invalid_Stream_Operation it may be because we have an */ 2143 /* empty data fork, so we need to check the resource fork. */ 2144 if ( FT_ERR_NEQ( error, Cannot_Open_Stream ) && 2145 FT_ERR_NEQ( error, Unknown_File_Format ) && 2146 FT_ERR_NEQ( error, Invalid_Stream_Operation ) ) 2147 goto Fail2; 2148 2149#if !defined( FT_MACINTOSH ) && defined( FT_CONFIG_OPTION_MAC_FONTS ) 2150 error = load_mac_face( library, stream, face_index, aface, args ); 2151 if ( !error ) 2152 { 2153 /* We don't want to go to Success here. We've already done that. */ 2154 /* On the other hand, if we succeeded we still need to close this */ 2155 /* stream (we opened a different stream which extracted the */ 2156 /* interesting information out of this stream here. That stream */ 2157 /* will still be open and the face will point to it). */ 2158 FT_Stream_Free( stream, external_stream ); 2159 return error; 2160 } 2161 2162 if ( FT_ERR_NEQ( error, Unknown_File_Format ) ) 2163 goto Fail2; 2164#endif /* !FT_MACINTOSH && FT_CONFIG_OPTION_MAC_FONTS */ 2165 2166 /* no driver is able to handle this format */ 2167 error = FT_THROW( Unknown_File_Format ); 2168 2169 Fail2: 2170 FT_Stream_Free( stream, external_stream ); 2171 goto Fail; 2172 } 2173 2174 Success: 2175 FT_TRACE4(( "FT_Open_Face: New face object, adding to list\n" )); 2176 2177 /* set the FT_FACE_FLAG_EXTERNAL_STREAM bit for FT_Done_Face */ 2178 if ( external_stream ) 2179 face->face_flags |= FT_FACE_FLAG_EXTERNAL_STREAM; 2180 2181 /* add the face object to its driver's list */ 2182 if ( FT_NEW( node ) ) 2183 goto Fail; 2184 2185 node->data = face; 2186 /* don't assume driver is the same as face->driver, so use */ 2187 /* face->driver instead. */ 2188 FT_List_Add( &face->driver->faces_list, node ); 2189 2190 /* now allocate a glyph slot object for the face */ 2191 FT_TRACE4(( "FT_Open_Face: Creating glyph slot\n" )); 2192 2193 if ( face_index >= 0 ) 2194 { 2195 error = FT_New_GlyphSlot( face, NULL ); 2196 if ( error ) 2197 goto Fail; 2198 2199 /* finally, allocate a size object for the face */ 2200 { 2201 FT_Size size; 2202 2203 2204 FT_TRACE4(( "FT_Open_Face: Creating size object\n" )); 2205 2206 error = FT_New_Size( face, &size ); 2207 if ( error ) 2208 goto Fail; 2209 2210 face->size = size; 2211 } 2212 } 2213 2214 /* some checks */ 2215 2216 if ( FT_IS_SCALABLE( face ) ) 2217 { 2218 if ( face->height < 0 ) 2219 face->height = (FT_Short)-face->height; 2220 2221 if ( !FT_HAS_VERTICAL( face ) ) 2222 face->max_advance_height = (FT_Short)face->height; 2223 } 2224 2225 if ( FT_HAS_FIXED_SIZES( face ) ) 2226 { 2227 FT_Int i; 2228 2229 2230 for ( i = 0; i < face->num_fixed_sizes; i++ ) 2231 { 2232 FT_Bitmap_Size* bsize = face->available_sizes + i; 2233 2234 2235 if ( bsize->height < 0 ) 2236 bsize->height = (FT_Short)-bsize->height; 2237 if ( bsize->x_ppem < 0 ) 2238 bsize->x_ppem = (FT_Short)-bsize->x_ppem; 2239 if ( bsize->y_ppem < 0 ) 2240 bsize->y_ppem = -bsize->y_ppem; 2241 } 2242 } 2243 2244 /* initialize internal face data */ 2245 { 2246 FT_Face_Internal internal = face->internal; 2247 2248 2249 internal->transform_matrix.xx = 0x10000L; 2250 internal->transform_matrix.xy = 0; 2251 internal->transform_matrix.yx = 0; 2252 internal->transform_matrix.yy = 0x10000L; 2253 2254 internal->transform_delta.x = 0; 2255 internal->transform_delta.y = 0; 2256 2257 internal->refcount = 1; 2258 } 2259 2260 if ( aface ) 2261 *aface = face; 2262 else 2263 FT_Done_Face( face ); 2264 2265 goto Exit; 2266 2267 Fail: 2268 if ( node ) 2269 FT_Done_Face( face ); /* face must be in the driver's list */ 2270 else if ( face ) 2271 destroy_face( memory, face, driver ); 2272 2273 Exit: 2274 FT_TRACE4(( "FT_Open_Face: Return %d\n", error )); 2275 2276 return error; 2277 } 2278 2279 2280 /* documentation is in freetype.h */ 2281 2282 FT_EXPORT_DEF( FT_Error ) 2283 FT_Attach_File( FT_Face face, 2284 const char* filepathname ) 2285 { 2286 FT_Open_Args open; 2287 2288 2289 /* test for valid `face' delayed to FT_Attach_Stream() */ 2290 2291 if ( !filepathname ) 2292 return FT_THROW( Invalid_Argument ); 2293 2294 open.stream = NULL; 2295 open.flags = FT_OPEN_PATHNAME; 2296 open.pathname = (char*)filepathname; 2297 2298 return FT_Attach_Stream( face, &open ); 2299 } 2300 2301 2302 /* documentation is in freetype.h */ 2303 2304 FT_EXPORT_DEF( FT_Error ) 2305 FT_Attach_Stream( FT_Face face, 2306 FT_Open_Args* parameters ) 2307 { 2308 FT_Stream stream; 2309 FT_Error error; 2310 FT_Driver driver; 2311 2312 FT_Driver_Class clazz; 2313 2314 2315 /* test for valid `parameters' delayed to FT_Stream_New() */ 2316 2317 if ( !face ) 2318 return FT_THROW( Invalid_Face_Handle ); 2319 2320 driver = face->driver; 2321 if ( !driver ) 2322 return FT_THROW( Invalid_Driver_Handle ); 2323 2324 error = FT_Stream_New( driver->root.library, parameters, &stream ); 2325 if ( error ) 2326 goto Exit; 2327 2328 /* we implement FT_Attach_Stream in each driver through the */ 2329 /* `attach_file' interface */ 2330 2331 error = FT_ERR( Unimplemented_Feature ); 2332 clazz = driver->clazz; 2333 if ( clazz->attach_file ) 2334 error = clazz->attach_file( face, stream ); 2335 2336 /* close the attached stream */ 2337 FT_Stream_Free( stream, 2338 (FT_Bool)( parameters->stream && 2339 ( parameters->flags & FT_OPEN_STREAM ) ) ); 2340 2341 Exit: 2342 return error; 2343 } 2344 2345 2346 /* documentation is in freetype.h */ 2347 2348 FT_EXPORT_DEF( FT_Error ) 2349 FT_Reference_Face( FT_Face face ) 2350 { 2351 face->internal->refcount++; 2352 2353 return FT_Err_Ok; 2354 } 2355 2356 2357 /* documentation is in freetype.h */ 2358 2359 FT_EXPORT_DEF( FT_Error ) 2360 FT_Done_Face( FT_Face face ) 2361 { 2362 FT_Error error; 2363 FT_Driver driver; 2364 FT_Memory memory; 2365 FT_ListNode node; 2366 2367 2368 error = FT_ERR( Invalid_Face_Handle ); 2369 if ( face && face->driver ) 2370 { 2371 face->internal->refcount--; 2372 if ( face->internal->refcount > 0 ) 2373 error = FT_Err_Ok; 2374 else 2375 { 2376 driver = face->driver; 2377 memory = driver->root.memory; 2378 2379 /* find face in driver's list */ 2380 node = FT_List_Find( &driver->faces_list, face ); 2381 if ( node ) 2382 { 2383 /* remove face object from the driver's list */ 2384 FT_List_Remove( &driver->faces_list, node ); 2385 FT_FREE( node ); 2386 2387 /* now destroy the object proper */ 2388 destroy_face( memory, face, driver ); 2389 error = FT_Err_Ok; 2390 } 2391 } 2392 } 2393 2394 return error; 2395 } 2396 2397 2398 /* documentation is in ftobjs.h */ 2399 2400 FT_EXPORT_DEF( FT_Error ) 2401 FT_New_Size( FT_Face face, 2402 FT_Size *asize ) 2403 { 2404 FT_Error error; 2405 FT_Memory memory; 2406 FT_Driver driver; 2407 FT_Driver_Class clazz; 2408 2409 FT_Size size = 0; 2410 FT_ListNode node = 0; 2411 2412 2413 if ( !face ) 2414 return FT_THROW( Invalid_Face_Handle ); 2415 2416 if ( !asize ) 2417 return FT_THROW( Invalid_Size_Handle ); 2418 2419 if ( !face->driver ) 2420 return FT_THROW( Invalid_Driver_Handle ); 2421 2422 *asize = 0; 2423 2424 driver = face->driver; 2425 clazz = driver->clazz; 2426 memory = face->memory; 2427 2428 /* Allocate new size object and perform basic initialisation */ 2429 if ( FT_ALLOC( size, clazz->size_object_size ) || FT_NEW( node ) ) 2430 goto Exit; 2431 2432 size->face = face; 2433 2434 /* for now, do not use any internal fields in size objects */ 2435 size->internal = 0; 2436 2437 if ( clazz->init_size ) 2438 error = clazz->init_size( size ); 2439 2440 /* in case of success, add to the face's list */ 2441 if ( !error ) 2442 { 2443 *asize = size; 2444 node->data = size; 2445 FT_List_Add( &face->sizes_list, node ); 2446 } 2447 2448 Exit: 2449 if ( error ) 2450 { 2451 FT_FREE( node ); 2452 FT_FREE( size ); 2453 } 2454 2455 return error; 2456 } 2457 2458 2459 /* documentation is in ftobjs.h */ 2460 2461 FT_EXPORT_DEF( FT_Error ) 2462 FT_Done_Size( FT_Size size ) 2463 { 2464 FT_Error error; 2465 FT_Driver driver; 2466 FT_Memory memory; 2467 FT_Face face; 2468 FT_ListNode node; 2469 2470 2471 if ( !size ) 2472 return FT_THROW( Invalid_Size_Handle ); 2473 2474 face = size->face; 2475 if ( !face ) 2476 return FT_THROW( Invalid_Face_Handle ); 2477 2478 driver = face->driver; 2479 if ( !driver ) 2480 return FT_THROW( Invalid_Driver_Handle ); 2481 2482 memory = driver->root.memory; 2483 2484 error = FT_Err_Ok; 2485 node = FT_List_Find( &face->sizes_list, size ); 2486 if ( node ) 2487 { 2488 FT_List_Remove( &face->sizes_list, node ); 2489 FT_FREE( node ); 2490 2491 if ( face->size == size ) 2492 { 2493 face->size = 0; 2494 if ( face->sizes_list.head ) 2495 face->size = (FT_Size)(face->sizes_list.head->data); 2496 } 2497 2498 destroy_size( memory, size, driver ); 2499 } 2500 else 2501 error = FT_THROW( Invalid_Size_Handle ); 2502 2503 return error; 2504 } 2505 2506 2507 /* documentation is in ftobjs.h */ 2508 2509 FT_BASE_DEF( FT_Error ) 2510 FT_Match_Size( FT_Face face, 2511 FT_Size_Request req, 2512 FT_Bool ignore_width, 2513 FT_ULong* size_index ) 2514 { 2515 FT_Int i; 2516 FT_Long w, h; 2517 2518 2519 if ( !FT_HAS_FIXED_SIZES( face ) ) 2520 return FT_THROW( Invalid_Face_Handle ); 2521 2522 /* FT_Bitmap_Size doesn't provide enough info... */ 2523 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL ) 2524 return FT_THROW( Unimplemented_Feature ); 2525 2526 w = FT_REQUEST_WIDTH ( req ); 2527 h = FT_REQUEST_HEIGHT( req ); 2528 2529 if ( req->width && !req->height ) 2530 h = w; 2531 else if ( !req->width && req->height ) 2532 w = h; 2533 2534 w = FT_PIX_ROUND( w ); 2535 h = FT_PIX_ROUND( h ); 2536 2537 for ( i = 0; i < face->num_fixed_sizes; i++ ) 2538 { 2539 FT_Bitmap_Size* bsize = face->available_sizes + i; 2540 2541 2542 if ( h != FT_PIX_ROUND( bsize->y_ppem ) ) 2543 continue; 2544 2545 if ( w == FT_PIX_ROUND( bsize->x_ppem ) || ignore_width ) 2546 { 2547 FT_TRACE3(( "FT_Match_Size: bitmap strike %d matches\n", i )); 2548 2549 if ( size_index ) 2550 *size_index = (FT_ULong)i; 2551 2552 return FT_Err_Ok; 2553 } 2554 } 2555 2556 return FT_THROW( Invalid_Pixel_Size ); 2557 } 2558 2559 2560 /* documentation is in ftobjs.h */ 2561 2562 FT_BASE_DEF( void ) 2563 ft_synthesize_vertical_metrics( FT_Glyph_Metrics* metrics, 2564 FT_Pos advance ) 2565 { 2566 FT_Pos height = metrics->height; 2567 2568 2569 /* compensate for glyph with bbox above/below the baseline */ 2570 if ( metrics->horiBearingY < 0 ) 2571 { 2572 if ( height < metrics->horiBearingY ) 2573 height = metrics->horiBearingY; 2574 } 2575 else if ( metrics->horiBearingY > 0 ) 2576 height -= metrics->horiBearingY; 2577 2578 /* the factor 1.2 is a heuristical value */ 2579 if ( !advance ) 2580 advance = height * 12 / 10; 2581 2582 metrics->vertBearingX = metrics->horiBearingX - metrics->horiAdvance / 2; 2583 metrics->vertBearingY = ( advance - height ) / 2; 2584 metrics->vertAdvance = advance; 2585 } 2586 2587 2588 static void 2589 ft_recompute_scaled_metrics( FT_Face face, 2590 FT_Size_Metrics* metrics ) 2591 { 2592 /* Compute root ascender, descender, test height, and max_advance */ 2593 2594#ifdef GRID_FIT_METRICS 2595 metrics->ascender = FT_PIX_CEIL( FT_MulFix( face->ascender, 2596 metrics->y_scale ) ); 2597 2598 metrics->descender = FT_PIX_FLOOR( FT_MulFix( face->descender, 2599 metrics->y_scale ) ); 2600 2601 metrics->height = FT_PIX_ROUND( FT_MulFix( face->height, 2602 metrics->y_scale ) ); 2603 2604 metrics->max_advance = FT_PIX_ROUND( FT_MulFix( face->max_advance_width, 2605 metrics->x_scale ) ); 2606#else /* !GRID_FIT_METRICS */ 2607 metrics->ascender = FT_MulFix( face->ascender, 2608 metrics->y_scale ); 2609 2610 metrics->descender = FT_MulFix( face->descender, 2611 metrics->y_scale ); 2612 2613 metrics->height = FT_MulFix( face->height, 2614 metrics->y_scale ); 2615 2616 metrics->max_advance = FT_MulFix( face->max_advance_width, 2617 metrics->x_scale ); 2618#endif /* !GRID_FIT_METRICS */ 2619 } 2620 2621 2622 FT_BASE_DEF( void ) 2623 FT_Select_Metrics( FT_Face face, 2624 FT_ULong strike_index ) 2625 { 2626 FT_Size_Metrics* metrics; 2627 FT_Bitmap_Size* bsize; 2628 2629 2630 metrics = &face->size->metrics; 2631 bsize = face->available_sizes + strike_index; 2632 2633 metrics->x_ppem = (FT_UShort)( ( bsize->x_ppem + 32 ) >> 6 ); 2634 metrics->y_ppem = (FT_UShort)( ( bsize->y_ppem + 32 ) >> 6 ); 2635 2636 if ( FT_IS_SCALABLE( face ) ) 2637 { 2638 metrics->x_scale = FT_DivFix( bsize->x_ppem, 2639 face->units_per_EM ); 2640 metrics->y_scale = FT_DivFix( bsize->y_ppem, 2641 face->units_per_EM ); 2642 2643 ft_recompute_scaled_metrics( face, metrics ); 2644 } 2645 else 2646 { 2647 metrics->x_scale = 1L << 16; 2648 metrics->y_scale = 1L << 16; 2649 metrics->ascender = bsize->y_ppem; 2650 metrics->descender = 0; 2651 metrics->height = bsize->height << 6; 2652 metrics->max_advance = bsize->x_ppem; 2653 } 2654 2655 FT_TRACE5(( "FT_Select_Metrics:\n" )); 2656 FT_TRACE5(( " x scale: %d (%f)\n", 2657 metrics->x_scale, metrics->x_scale / 65536.0 )); 2658 FT_TRACE5(( " y scale: %d (%f)\n", 2659 metrics->y_scale, metrics->y_scale / 65536.0 )); 2660 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 )); 2661 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 )); 2662 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 )); 2663 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 )); 2664 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem )); 2665 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem )); 2666 } 2667 2668 2669 FT_BASE_DEF( void ) 2670 FT_Request_Metrics( FT_Face face, 2671 FT_Size_Request req ) 2672 { 2673 FT_Size_Metrics* metrics; 2674 2675 2676 metrics = &face->size->metrics; 2677 2678 if ( FT_IS_SCALABLE( face ) ) 2679 { 2680 FT_Long w = 0, h = 0, scaled_w = 0, scaled_h = 0; 2681 2682 2683 switch ( req->type ) 2684 { 2685 case FT_SIZE_REQUEST_TYPE_NOMINAL: 2686 w = h = face->units_per_EM; 2687 break; 2688 2689 case FT_SIZE_REQUEST_TYPE_REAL_DIM: 2690 w = h = face->ascender - face->descender; 2691 break; 2692 2693 case FT_SIZE_REQUEST_TYPE_BBOX: 2694 w = face->bbox.xMax - face->bbox.xMin; 2695 h = face->bbox.yMax - face->bbox.yMin; 2696 break; 2697 2698 case FT_SIZE_REQUEST_TYPE_CELL: 2699 w = face->max_advance_width; 2700 h = face->ascender - face->descender; 2701 break; 2702 2703 case FT_SIZE_REQUEST_TYPE_SCALES: 2704 metrics->x_scale = (FT_Fixed)req->width; 2705 metrics->y_scale = (FT_Fixed)req->height; 2706 if ( !metrics->x_scale ) 2707 metrics->x_scale = metrics->y_scale; 2708 else if ( !metrics->y_scale ) 2709 metrics->y_scale = metrics->x_scale; 2710 goto Calculate_Ppem; 2711 2712 case FT_SIZE_REQUEST_TYPE_MAX: 2713 break; 2714 } 2715 2716 /* to be on the safe side */ 2717 if ( w < 0 ) 2718 w = -w; 2719 2720 if ( h < 0 ) 2721 h = -h; 2722 2723 scaled_w = FT_REQUEST_WIDTH ( req ); 2724 scaled_h = FT_REQUEST_HEIGHT( req ); 2725 2726 /* determine scales */ 2727 if ( req->width ) 2728 { 2729 metrics->x_scale = FT_DivFix( scaled_w, w ); 2730 2731 if ( req->height ) 2732 { 2733 metrics->y_scale = FT_DivFix( scaled_h, h ); 2734 2735 if ( req->type == FT_SIZE_REQUEST_TYPE_CELL ) 2736 { 2737 if ( metrics->y_scale > metrics->x_scale ) 2738 metrics->y_scale = metrics->x_scale; 2739 else 2740 metrics->x_scale = metrics->y_scale; 2741 } 2742 } 2743 else 2744 { 2745 metrics->y_scale = metrics->x_scale; 2746 scaled_h = FT_MulDiv( scaled_w, h, w ); 2747 } 2748 } 2749 else 2750 { 2751 metrics->x_scale = metrics->y_scale = FT_DivFix( scaled_h, h ); 2752 scaled_w = FT_MulDiv( scaled_h, w, h ); 2753 } 2754 2755 Calculate_Ppem: 2756 /* calculate the ppems */ 2757 if ( req->type != FT_SIZE_REQUEST_TYPE_NOMINAL ) 2758 { 2759 scaled_w = FT_MulFix( face->units_per_EM, metrics->x_scale ); 2760 scaled_h = FT_MulFix( face->units_per_EM, metrics->y_scale ); 2761 } 2762 2763 metrics->x_ppem = (FT_UShort)( ( scaled_w + 32 ) >> 6 ); 2764 metrics->y_ppem = (FT_UShort)( ( scaled_h + 32 ) >> 6 ); 2765 2766 ft_recompute_scaled_metrics( face, metrics ); 2767 } 2768 else 2769 { 2770 FT_ZERO( metrics ); 2771 metrics->x_scale = 1L << 16; 2772 metrics->y_scale = 1L << 16; 2773 } 2774 2775 FT_TRACE5(( "FT_Request_Metrics:\n" )); 2776 FT_TRACE5(( " x scale: %d (%f)\n", 2777 metrics->x_scale, metrics->x_scale / 65536.0 )); 2778 FT_TRACE5(( " y scale: %d (%f)\n", 2779 metrics->y_scale, metrics->y_scale / 65536.0 )); 2780 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 )); 2781 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 )); 2782 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 )); 2783 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 )); 2784 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem )); 2785 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem )); 2786 } 2787 2788 2789 /* documentation is in freetype.h */ 2790 2791 FT_EXPORT_DEF( FT_Error ) 2792 FT_Select_Size( FT_Face face, 2793 FT_Int strike_index ) 2794 { 2795 FT_Driver_Class clazz; 2796 2797 2798 if ( !face || !FT_HAS_FIXED_SIZES( face ) ) 2799 return FT_THROW( Invalid_Face_Handle ); 2800 2801 if ( strike_index < 0 || strike_index >= face->num_fixed_sizes ) 2802 return FT_THROW( Invalid_Argument ); 2803 2804 clazz = face->driver->clazz; 2805 2806 if ( clazz->select_size ) 2807 { 2808 FT_Error error; 2809 2810 2811 error = clazz->select_size( face->size, (FT_ULong)strike_index ); 2812 2813#ifdef FT_DEBUG_LEVEL_TRACE 2814 { 2815 FT_Size_Metrics* metrics = &face->size->metrics; 2816 2817 2818 FT_TRACE5(( "FT_Select_Size (font driver's `select_size'):\n" )); 2819 FT_TRACE5(( " x scale: %d (%f)\n", 2820 metrics->x_scale, metrics->x_scale / 65536.0 )); 2821 FT_TRACE5(( " y scale: %d (%f)\n", 2822 metrics->y_scale, metrics->y_scale / 65536.0 )); 2823 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 )); 2824 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 )); 2825 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 )); 2826 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 )); 2827 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem )); 2828 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem )); 2829 } 2830#endif 2831 2832 return error; 2833 } 2834 2835 FT_Select_Metrics( face, (FT_ULong)strike_index ); 2836 2837 return FT_Err_Ok; 2838 } 2839 2840 2841 /* documentation is in freetype.h */ 2842 2843 FT_EXPORT_DEF( FT_Error ) 2844 FT_Request_Size( FT_Face face, 2845 FT_Size_Request req ) 2846 { 2847 FT_Driver_Class clazz; 2848 FT_ULong strike_index; 2849 2850 2851 if ( !face ) 2852 return FT_THROW( Invalid_Face_Handle ); 2853 2854 if ( !req || req->width < 0 || req->height < 0 || 2855 req->type >= FT_SIZE_REQUEST_TYPE_MAX ) 2856 return FT_THROW( Invalid_Argument ); 2857 2858 clazz = face->driver->clazz; 2859 2860 if ( clazz->request_size ) 2861 { 2862 FT_Error error; 2863 2864 2865 error = clazz->request_size( face->size, req ); 2866 2867#ifdef FT_DEBUG_LEVEL_TRACE 2868 { 2869 FT_Size_Metrics* metrics = &face->size->metrics; 2870 2871 2872 FT_TRACE5(( "FT_Request_Size (font driver's `request_size'):\n" )); 2873 FT_TRACE5(( " x scale: %d (%f)\n", 2874 metrics->x_scale, metrics->x_scale / 65536.0 )); 2875 FT_TRACE5(( " y scale: %d (%f)\n", 2876 metrics->y_scale, metrics->y_scale / 65536.0 )); 2877 FT_TRACE5(( " ascender: %f\n", metrics->ascender / 64.0 )); 2878 FT_TRACE5(( " descender: %f\n", metrics->descender / 64.0 )); 2879 FT_TRACE5(( " height: %f\n", metrics->height / 64.0 )); 2880 FT_TRACE5(( " max advance: %f\n", metrics->max_advance / 64.0 )); 2881 FT_TRACE5(( " x ppem: %d\n", metrics->x_ppem )); 2882 FT_TRACE5(( " y ppem: %d\n", metrics->y_ppem )); 2883 } 2884#endif 2885 2886 return error; 2887 } 2888 2889 /* 2890 * The reason that a driver doesn't have `request_size' defined is 2891 * either that the scaling here suffices or that the supported formats 2892 * are bitmap-only and size matching is not implemented. 2893 * 2894 * In the latter case, a simple size matching is done. 2895 */ 2896 if ( !FT_IS_SCALABLE( face ) && FT_HAS_FIXED_SIZES( face ) ) 2897 { 2898 FT_Error error; 2899 2900 2901 error = FT_Match_Size( face, req, 0, &strike_index ); 2902 if ( error ) 2903 return error; 2904 2905 return FT_Select_Size( face, (FT_Int)strike_index ); 2906 } 2907 2908 FT_Request_Metrics( face, req ); 2909 2910 return FT_Err_Ok; 2911 } 2912 2913 2914 /* documentation is in freetype.h */ 2915 2916 FT_EXPORT_DEF( FT_Error ) 2917 FT_Set_Char_Size( FT_Face face, 2918 FT_F26Dot6 char_width, 2919 FT_F26Dot6 char_height, 2920 FT_UInt horz_resolution, 2921 FT_UInt vert_resolution ) 2922 { 2923 FT_Size_RequestRec req; 2924 2925 2926 if ( !char_width ) 2927 char_width = char_height; 2928 else if ( !char_height ) 2929 char_height = char_width; 2930 2931 if ( !horz_resolution ) 2932 horz_resolution = vert_resolution; 2933 else if ( !vert_resolution ) 2934 vert_resolution = horz_resolution; 2935 2936 if ( char_width < 1 * 64 ) 2937 char_width = 1 * 64; 2938 if ( char_height < 1 * 64 ) 2939 char_height = 1 * 64; 2940 2941 if ( !horz_resolution ) 2942 horz_resolution = vert_resolution = 72; 2943 2944 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL; 2945 req.width = char_width; 2946 req.height = char_height; 2947 req.horiResolution = horz_resolution; 2948 req.vertResolution = vert_resolution; 2949 2950 return FT_Request_Size( face, &req ); 2951 } 2952 2953 2954 /* documentation is in freetype.h */ 2955 2956 FT_EXPORT_DEF( FT_Error ) 2957 FT_Set_Pixel_Sizes( FT_Face face, 2958 FT_UInt pixel_width, 2959 FT_UInt pixel_height ) 2960 { 2961 FT_Size_RequestRec req; 2962 2963 2964 if ( pixel_width == 0 ) 2965 pixel_width = pixel_height; 2966 else if ( pixel_height == 0 ) 2967 pixel_height = pixel_width; 2968 2969 if ( pixel_width < 1 ) 2970 pixel_width = 1; 2971 if ( pixel_height < 1 ) 2972 pixel_height = 1; 2973 2974 /* use `>=' to avoid potential compiler warning on 16bit platforms */ 2975 if ( pixel_width >= 0xFFFFU ) 2976 pixel_width = 0xFFFFU; 2977 if ( pixel_height >= 0xFFFFU ) 2978 pixel_height = 0xFFFFU; 2979 2980 req.type = FT_SIZE_REQUEST_TYPE_NOMINAL; 2981 req.width = pixel_width << 6; 2982 req.height = pixel_height << 6; 2983 req.horiResolution = 0; 2984 req.vertResolution = 0; 2985 2986 return FT_Request_Size( face, &req ); 2987 } 2988 2989 2990 /* documentation is in freetype.h */ 2991 2992 FT_EXPORT_DEF( FT_Error ) 2993 FT_Get_Kerning( FT_Face face, 2994 FT_UInt left_glyph, 2995 FT_UInt right_glyph, 2996 FT_UInt kern_mode, 2997 FT_Vector *akerning ) 2998 { 2999 FT_Error error = FT_Err_Ok; 3000 FT_Driver driver; 3001 3002 3003 if ( !face ) 3004 return FT_THROW( Invalid_Face_Handle ); 3005 3006 if ( !akerning ) 3007 return FT_THROW( Invalid_Argument ); 3008 3009 driver = face->driver; 3010 3011 akerning->x = 0; 3012 akerning->y = 0; 3013 3014 if ( driver->clazz->get_kerning ) 3015 { 3016 error = driver->clazz->get_kerning( face, 3017 left_glyph, 3018 right_glyph, 3019 akerning ); 3020 if ( !error ) 3021 { 3022 if ( kern_mode != FT_KERNING_UNSCALED ) 3023 { 3024 akerning->x = FT_MulFix( akerning->x, face->size->metrics.x_scale ); 3025 akerning->y = FT_MulFix( akerning->y, face->size->metrics.y_scale ); 3026 3027 if ( kern_mode != FT_KERNING_UNFITTED ) 3028 { 3029 /* we scale down kerning values for small ppem values */ 3030 /* to avoid that rounding makes them too big. */ 3031 /* `25' has been determined heuristically. */ 3032 if ( face->size->metrics.x_ppem < 25 ) 3033 akerning->x = FT_MulDiv( akerning->x, 3034 face->size->metrics.x_ppem, 25 ); 3035 if ( face->size->metrics.y_ppem < 25 ) 3036 akerning->y = FT_MulDiv( akerning->y, 3037 face->size->metrics.y_ppem, 25 ); 3038 3039 akerning->x = FT_PIX_ROUND( akerning->x ); 3040 akerning->y = FT_PIX_ROUND( akerning->y ); 3041 } 3042 } 3043 } 3044 } 3045 3046 return error; 3047 } 3048 3049 3050 /* documentation is in freetype.h */ 3051 3052 FT_EXPORT_DEF( FT_Error ) 3053 FT_Get_Track_Kerning( FT_Face face, 3054 FT_Fixed point_size, 3055 FT_Int degree, 3056 FT_Fixed* akerning ) 3057 { 3058 FT_Service_Kerning service; 3059 FT_Error error = FT_Err_Ok; 3060 3061 3062 if ( !face ) 3063 return FT_THROW( Invalid_Face_Handle ); 3064 3065 if ( !akerning ) 3066 return FT_THROW( Invalid_Argument ); 3067 3068 FT_FACE_FIND_SERVICE( face, service, KERNING ); 3069 if ( !service ) 3070 return FT_THROW( Unimplemented_Feature ); 3071 3072 error = service->get_track( face, 3073 point_size, 3074 degree, 3075 akerning ); 3076 3077 return error; 3078 } 3079 3080 3081 /* documentation is in freetype.h */ 3082 3083 FT_EXPORT_DEF( FT_Error ) 3084 FT_Select_Charmap( FT_Face face, 3085 FT_Encoding encoding ) 3086 { 3087 FT_CharMap* cur; 3088 FT_CharMap* limit; 3089 3090 3091 if ( !face ) 3092 return FT_THROW( Invalid_Face_Handle ); 3093 3094 if ( encoding == FT_ENCODING_NONE ) 3095 return FT_THROW( Invalid_Argument ); 3096 3097 /* FT_ENCODING_UNICODE is special. We try to find the `best' Unicode */ 3098 /* charmap available, i.e., one with UCS-4 characters, if possible. */ 3099 /* */ 3100 /* This is done by find_unicode_charmap() above, to share code. */ 3101 if ( encoding == FT_ENCODING_UNICODE ) 3102 return find_unicode_charmap( face ); 3103 3104 cur = face->charmaps; 3105 if ( !cur ) 3106 return FT_THROW( Invalid_CharMap_Handle ); 3107 3108 limit = cur + face->num_charmaps; 3109 3110 for ( ; cur < limit; cur++ ) 3111 { 3112 if ( cur[0]->encoding == encoding ) 3113 { 3114#ifdef FT_MAX_CHARMAP_CACHEABLE 3115 if ( cur - face->charmaps > FT_MAX_CHARMAP_CACHEABLE ) 3116 { 3117 FT_ERROR(( "FT_Select_Charmap: requested charmap is found (%d), " 3118 "but in too late position to cache\n", 3119 cur - face->charmaps )); 3120 continue; 3121 } 3122#endif 3123 face->charmap = cur[0]; 3124 return 0; 3125 } 3126 } 3127 3128 return FT_THROW( Invalid_Argument ); 3129 } 3130 3131 3132 /* documentation is in freetype.h */ 3133 3134 FT_EXPORT_DEF( FT_Error ) 3135 FT_Set_Charmap( FT_Face face, 3136 FT_CharMap charmap ) 3137 { 3138 FT_CharMap* cur; 3139 FT_CharMap* limit; 3140 3141 3142 if ( !face ) 3143 return FT_THROW( Invalid_Face_Handle ); 3144 3145 cur = face->charmaps; 3146 if ( !cur ) 3147 return FT_THROW( Invalid_CharMap_Handle ); 3148 if ( FT_Get_CMap_Format( charmap ) == 14 ) 3149 return FT_THROW( Invalid_Argument ); 3150 3151 limit = cur + face->num_charmaps; 3152 3153 for ( ; cur < limit; cur++ ) 3154 { 3155 if ( cur[0] == charmap ) 3156 { 3157#ifdef FT_MAX_CHARMAP_CACHEABLE 3158 if ( cur - face->charmaps > FT_MAX_CHARMAP_CACHEABLE ) 3159 { 3160 FT_ERROR(( "FT_Set_Charmap: requested charmap is found (%d), " 3161 "but in too late position to cache\n", 3162 cur - face->charmaps )); 3163 continue; 3164 } 3165#endif 3166 face->charmap = cur[0]; 3167 return 0; 3168 } 3169 } 3170 return FT_THROW( Invalid_Argument ); 3171 } 3172 3173 3174 /* documentation is in freetype.h */ 3175 3176 FT_EXPORT_DEF( FT_Int ) 3177 FT_Get_Charmap_Index( FT_CharMap charmap ) 3178 { 3179 FT_Int i; 3180 3181 3182 if ( !charmap || !charmap->face ) 3183 return -1; 3184 3185 for ( i = 0; i < charmap->face->num_charmaps; i++ ) 3186 if ( charmap->face->charmaps[i] == charmap ) 3187 break; 3188 3189 FT_ASSERT( i < charmap->face->num_charmaps ); 3190 3191#ifdef FT_MAX_CHARMAP_CACHEABLE 3192 if ( i > FT_MAX_CHARMAP_CACHEABLE ) 3193 { 3194 FT_ERROR(( "FT_Get_Charmap_Index: requested charmap is found (%d), " 3195 "but in too late position to cache\n", 3196 i )); 3197 return -i; 3198 } 3199#endif 3200 return i; 3201 } 3202 3203 3204 static void 3205 ft_cmap_done_internal( FT_CMap cmap ) 3206 { 3207 FT_CMap_Class clazz = cmap->clazz; 3208 FT_Face face = cmap->charmap.face; 3209 FT_Memory memory = FT_FACE_MEMORY( face ); 3210 3211 3212 if ( clazz->done ) 3213 clazz->done( cmap ); 3214 3215 FT_FREE( cmap ); 3216 } 3217 3218 3219 FT_BASE_DEF( void ) 3220 FT_CMap_Done( FT_CMap cmap ) 3221 { 3222 if ( cmap ) 3223 { 3224 FT_Face face = cmap->charmap.face; 3225 FT_Memory memory = FT_FACE_MEMORY( face ); 3226 FT_Error error; 3227 FT_Int i, j; 3228 3229 3230 for ( i = 0; i < face->num_charmaps; i++ ) 3231 { 3232 if ( (FT_CMap)face->charmaps[i] == cmap ) 3233 { 3234 FT_CharMap last_charmap = face->charmaps[face->num_charmaps - 1]; 3235 3236 3237 if ( FT_RENEW_ARRAY( face->charmaps, 3238 face->num_charmaps, 3239 face->num_charmaps - 1 ) ) 3240 return; 3241 3242 /* remove it from our list of charmaps */ 3243 for ( j = i + 1; j < face->num_charmaps; j++ ) 3244 { 3245 if ( j == face->num_charmaps - 1 ) 3246 face->charmaps[j - 1] = last_charmap; 3247 else 3248 face->charmaps[j - 1] = face->charmaps[j]; 3249 } 3250 3251 face->num_charmaps--; 3252 3253 if ( (FT_CMap)face->charmap == cmap ) 3254 face->charmap = NULL; 3255 3256 ft_cmap_done_internal( cmap ); 3257 3258 break; 3259 } 3260 } 3261 } 3262 } 3263 3264 3265 FT_BASE_DEF( FT_Error ) 3266 FT_CMap_New( FT_CMap_Class clazz, 3267 FT_Pointer init_data, 3268 FT_CharMap charmap, 3269 FT_CMap *acmap ) 3270 { 3271 FT_Error error = FT_Err_Ok; 3272 FT_Face face; 3273 FT_Memory memory; 3274 FT_CMap cmap = NULL; 3275 3276 3277 if ( clazz == NULL || charmap == NULL || charmap->face == NULL ) 3278 return FT_THROW( Invalid_Argument ); 3279 3280 face = charmap->face; 3281 memory = FT_FACE_MEMORY( face ); 3282 3283 if ( !FT_ALLOC( cmap, clazz->size ) ) 3284 { 3285 cmap->charmap = *charmap; 3286 cmap->clazz = clazz; 3287 3288 if ( clazz->init ) 3289 { 3290 error = clazz->init( cmap, init_data ); 3291 if ( error ) 3292 goto Fail; 3293 } 3294 3295 /* add it to our list of charmaps */ 3296 if ( FT_RENEW_ARRAY( face->charmaps, 3297 face->num_charmaps, 3298 face->num_charmaps + 1 ) ) 3299 goto Fail; 3300 3301 face->charmaps[face->num_charmaps++] = (FT_CharMap)cmap; 3302 } 3303 3304 Exit: 3305 if ( acmap ) 3306 *acmap = cmap; 3307 3308 return error; 3309 3310 Fail: 3311 ft_cmap_done_internal( cmap ); 3312 cmap = NULL; 3313 goto Exit; 3314 } 3315 3316 3317 /* documentation is in freetype.h */ 3318 3319 FT_EXPORT_DEF( FT_UInt ) 3320 FT_Get_Char_Index( FT_Face face, 3321 FT_ULong charcode ) 3322 { 3323 FT_UInt result = 0; 3324 3325 3326 if ( face && face->charmap ) 3327 { 3328 FT_CMap cmap = FT_CMAP( face->charmap ); 3329 3330 3331 if ( charcode > 0xFFFFFFFFUL ) 3332 { 3333 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" )); 3334 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3335 } 3336 result = cmap->clazz->char_index( cmap, (FT_UInt32)charcode ); 3337 } 3338 return result; 3339 } 3340 3341 3342 /* documentation is in freetype.h */ 3343 3344 FT_EXPORT_DEF( FT_ULong ) 3345 FT_Get_First_Char( FT_Face face, 3346 FT_UInt *agindex ) 3347 { 3348 FT_ULong result = 0; 3349 FT_UInt gindex = 0; 3350 3351 3352 if ( face && face->charmap && face->num_glyphs ) 3353 { 3354 gindex = FT_Get_Char_Index( face, 0 ); 3355 if ( gindex == 0 || gindex >= (FT_UInt)face->num_glyphs ) 3356 result = FT_Get_Next_Char( face, 0, &gindex ); 3357 } 3358 3359 if ( agindex ) 3360 *agindex = gindex; 3361 3362 return result; 3363 } 3364 3365 3366 /* documentation is in freetype.h */ 3367 3368 FT_EXPORT_DEF( FT_ULong ) 3369 FT_Get_Next_Char( FT_Face face, 3370 FT_ULong charcode, 3371 FT_UInt *agindex ) 3372 { 3373 FT_ULong result = 0; 3374 FT_UInt gindex = 0; 3375 3376 3377 if ( face && face->charmap && face->num_glyphs ) 3378 { 3379 FT_UInt32 code = (FT_UInt32)charcode; 3380 FT_CMap cmap = FT_CMAP( face->charmap ); 3381 3382 3383 do { 3384 gindex = cmap->clazz->char_next( cmap, &code ); 3385 } while ( gindex >= (FT_UInt)face->num_glyphs ); 3386 3387 result = ( gindex == 0 ) ? 0 : code; 3388 } 3389 3390 if ( agindex ) 3391 *agindex = gindex; 3392 3393 return result; 3394 } 3395 3396 3397 /* documentation is in freetype.h */ 3398 3399 FT_EXPORT_DEF( FT_UInt ) 3400 FT_Face_GetCharVariantIndex( FT_Face face, 3401 FT_ULong charcode, 3402 FT_ULong variantSelector ) 3403 { 3404 FT_UInt result = 0; 3405 3406 3407 if ( face && face->charmap && 3408 face->charmap->encoding == FT_ENCODING_UNICODE ) 3409 { 3410 FT_CharMap charmap = find_variant_selector_charmap( face ); 3411 FT_CMap ucmap = FT_CMAP( face->charmap ); 3412 3413 3414 if ( charmap != NULL ) 3415 { 3416 FT_CMap vcmap = FT_CMAP( charmap ); 3417 3418 3419 if ( charcode > 0xFFFFFFFFUL ) 3420 { 3421 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" )); 3422 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3423 } 3424 if ( variantSelector > 0xFFFFFFFFUL ) 3425 { 3426 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" )); 3427 FT_TRACE1(( " 0x%x is truncated\n", variantSelector )); 3428 } 3429 3430 result = vcmap->clazz->char_var_index( vcmap, ucmap, 3431 (FT_UInt32)charcode, 3432 (FT_UInt32)variantSelector ); 3433 } 3434 } 3435 3436 return result; 3437 } 3438 3439 3440 /* documentation is in freetype.h */ 3441 3442 FT_EXPORT_DEF( FT_Int ) 3443 FT_Face_GetCharVariantIsDefault( FT_Face face, 3444 FT_ULong charcode, 3445 FT_ULong variantSelector ) 3446 { 3447 FT_Int result = -1; 3448 3449 3450 if ( face ) 3451 { 3452 FT_CharMap charmap = find_variant_selector_charmap( face ); 3453 3454 3455 if ( charmap != NULL ) 3456 { 3457 FT_CMap vcmap = FT_CMAP( charmap ); 3458 3459 3460 if ( charcode > 0xFFFFFFFFUL ) 3461 { 3462 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" )); 3463 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3464 } 3465 if ( variantSelector > 0xFFFFFFFFUL ) 3466 { 3467 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" )); 3468 FT_TRACE1(( " 0x%x is truncated\n", variantSelector )); 3469 } 3470 3471 result = vcmap->clazz->char_var_default( vcmap, 3472 (FT_UInt32)charcode, 3473 (FT_UInt32)variantSelector ); 3474 } 3475 } 3476 3477 return result; 3478 } 3479 3480 3481 /* documentation is in freetype.h */ 3482 3483 FT_EXPORT_DEF( FT_UInt32* ) 3484 FT_Face_GetVariantSelectors( FT_Face face ) 3485 { 3486 FT_UInt32 *result = NULL; 3487 3488 3489 if ( face ) 3490 { 3491 FT_CharMap charmap = find_variant_selector_charmap( face ); 3492 3493 3494 if ( charmap != NULL ) 3495 { 3496 FT_CMap vcmap = FT_CMAP( charmap ); 3497 FT_Memory memory = FT_FACE_MEMORY( face ); 3498 3499 3500 result = vcmap->clazz->variant_list( vcmap, memory ); 3501 } 3502 } 3503 3504 return result; 3505 } 3506 3507 3508 /* documentation is in freetype.h */ 3509 3510 FT_EXPORT_DEF( FT_UInt32* ) 3511 FT_Face_GetVariantsOfChar( FT_Face face, 3512 FT_ULong charcode ) 3513 { 3514 FT_UInt32 *result = NULL; 3515 3516 3517 if ( face ) 3518 { 3519 FT_CharMap charmap = find_variant_selector_charmap( face ); 3520 3521 3522 if ( charmap != NULL ) 3523 { 3524 FT_CMap vcmap = FT_CMAP( charmap ); 3525 FT_Memory memory = FT_FACE_MEMORY( face ); 3526 3527 3528 if ( charcode > 0xFFFFFFFFUL ) 3529 { 3530 FT_TRACE1(( "FT_Get_Char_Index: too large charcode" )); 3531 FT_TRACE1(( " 0x%x is truncated\n", charcode )); 3532 } 3533 3534 result = vcmap->clazz->charvariant_list( vcmap, memory, 3535 (FT_UInt32)charcode ); 3536 } 3537 } 3538 return result; 3539 } 3540 3541 3542 /* documentation is in freetype.h */ 3543 3544 FT_EXPORT_DEF( FT_UInt32* ) 3545 FT_Face_GetCharsOfVariant( FT_Face face, 3546 FT_ULong variantSelector ) 3547 { 3548 FT_UInt32 *result = NULL; 3549 3550 3551 if ( face ) 3552 { 3553 FT_CharMap charmap = find_variant_selector_charmap( face ); 3554 3555 3556 if ( charmap != NULL ) 3557 { 3558 FT_CMap vcmap = FT_CMAP( charmap ); 3559 FT_Memory memory = FT_FACE_MEMORY( face ); 3560 3561 3562 if ( variantSelector > 0xFFFFFFFFUL ) 3563 { 3564 FT_TRACE1(( "FT_Get_Char_Index: too large variantSelector" )); 3565 FT_TRACE1(( " 0x%x is truncated\n", variantSelector )); 3566 } 3567 3568 result = vcmap->clazz->variantchar_list( vcmap, memory, 3569 (FT_UInt32)variantSelector ); 3570 } 3571 } 3572 3573 return result; 3574 } 3575 3576 3577 /* documentation is in freetype.h */ 3578 3579 FT_EXPORT_DEF( FT_UInt ) 3580 FT_Get_Name_Index( FT_Face face, 3581 FT_String* glyph_name ) 3582 { 3583 FT_UInt result = 0; 3584 3585 3586 if ( face && FT_HAS_GLYPH_NAMES( face ) ) 3587 { 3588 FT_Service_GlyphDict service; 3589 3590 3591 FT_FACE_LOOKUP_SERVICE( face, 3592 service, 3593 GLYPH_DICT ); 3594 3595 if ( service && service->name_index ) 3596 result = service->name_index( face, glyph_name ); 3597 } 3598 3599 return result; 3600 } 3601 3602 3603 /* documentation is in freetype.h */ 3604 3605 FT_EXPORT_DEF( FT_Error ) 3606 FT_Get_Glyph_Name( FT_Face face, 3607 FT_UInt glyph_index, 3608 FT_Pointer buffer, 3609 FT_UInt buffer_max ) 3610 { 3611 FT_Error error = FT_ERR( Invalid_Argument ); 3612 3613 3614 /* clean up buffer */ 3615 if ( buffer && buffer_max > 0 ) 3616 ((FT_Byte*)buffer)[0] = 0; 3617 3618 if ( face && 3619 (FT_Long)glyph_index <= face->num_glyphs && 3620 FT_HAS_GLYPH_NAMES( face ) ) 3621 { 3622 FT_Service_GlyphDict service; 3623 3624 3625 FT_FACE_LOOKUP_SERVICE( face, 3626 service, 3627 GLYPH_DICT ); 3628 3629 if ( service && service->get_name ) 3630 error = service->get_name( face, glyph_index, buffer, buffer_max ); 3631 } 3632 3633 return error; 3634 } 3635 3636 3637 /* documentation is in freetype.h */ 3638 3639 FT_EXPORT_DEF( const char* ) 3640 FT_Get_Postscript_Name( FT_Face face ) 3641 { 3642 const char* result = NULL; 3643 3644 3645 if ( !face ) 3646 goto Exit; 3647 3648 if ( !result ) 3649 { 3650 FT_Service_PsFontName service; 3651 3652 3653 FT_FACE_LOOKUP_SERVICE( face, 3654 service, 3655 POSTSCRIPT_FONT_NAME ); 3656 3657 if ( service && service->get_ps_font_name ) 3658 result = service->get_ps_font_name( face ); 3659 } 3660 3661 Exit: 3662 return result; 3663 } 3664 3665 3666 /* documentation is in tttables.h */ 3667 3668 FT_EXPORT_DEF( void* ) 3669 FT_Get_Sfnt_Table( FT_Face face, 3670 FT_Sfnt_Tag tag ) 3671 { 3672 void* table = 0; 3673 FT_Service_SFNT_Table service; 3674 3675 3676 if ( face && FT_IS_SFNT( face ) ) 3677 { 3678 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE ); 3679 if ( service != NULL ) 3680 table = service->get_table( face, tag ); 3681 } 3682 3683 return table; 3684 } 3685 3686 3687 /* documentation is in tttables.h */ 3688 3689 FT_EXPORT_DEF( FT_Error ) 3690 FT_Load_Sfnt_Table( FT_Face face, 3691 FT_ULong tag, 3692 FT_Long offset, 3693 FT_Byte* buffer, 3694 FT_ULong* length ) 3695 { 3696 FT_Service_SFNT_Table service; 3697 3698 3699 if ( !face || !FT_IS_SFNT( face ) ) 3700 return FT_THROW( Invalid_Face_Handle ); 3701 3702 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE ); 3703 if ( service == NULL ) 3704 return FT_THROW( Unimplemented_Feature ); 3705 3706 return service->load_table( face, tag, offset, buffer, length ); 3707 } 3708 3709 3710 /* documentation is in tttables.h */ 3711 3712 FT_EXPORT_DEF( FT_Error ) 3713 FT_Sfnt_Table_Info( FT_Face face, 3714 FT_UInt table_index, 3715 FT_ULong *tag, 3716 FT_ULong *length ) 3717 { 3718 FT_Service_SFNT_Table service; 3719 FT_ULong offset; 3720 3721 3722 if ( !face || !FT_IS_SFNT( face ) ) 3723 return FT_THROW( Invalid_Face_Handle ); 3724 3725 FT_FACE_FIND_SERVICE( face, service, SFNT_TABLE ); 3726 if ( service == NULL ) 3727 return FT_THROW( Unimplemented_Feature ); 3728 3729 return service->table_info( face, table_index, tag, &offset, length ); 3730 } 3731 3732 3733 /* documentation is in tttables.h */ 3734 3735 FT_EXPORT_DEF( FT_ULong ) 3736 FT_Get_CMap_Language_ID( FT_CharMap charmap ) 3737 { 3738 FT_Service_TTCMaps service; 3739 FT_Face face; 3740 TT_CMapInfo cmap_info; 3741 3742 3743 if ( !charmap || !charmap->face ) 3744 return 0; 3745 3746 face = charmap->face; 3747 FT_FACE_FIND_SERVICE( face, service, TT_CMAP ); 3748 if ( service == NULL ) 3749 return 0; 3750 if ( service->get_cmap_info( charmap, &cmap_info )) 3751 return 0; 3752 3753 return cmap_info.language; 3754 } 3755 3756 3757 /* documentation is in tttables.h */ 3758 3759 FT_EXPORT_DEF( FT_Long ) 3760 FT_Get_CMap_Format( FT_CharMap charmap ) 3761 { 3762 FT_Service_TTCMaps service; 3763 FT_Face face; 3764 TT_CMapInfo cmap_info; 3765 3766 3767 if ( !charmap || !charmap->face ) 3768 return -1; 3769 3770 face = charmap->face; 3771 FT_FACE_FIND_SERVICE( face, service, TT_CMAP ); 3772 if ( service == NULL ) 3773 return -1; 3774 if ( service->get_cmap_info( charmap, &cmap_info )) 3775 return -1; 3776 3777 return cmap_info.format; 3778 } 3779 3780 3781 /* documentation is in ftsizes.h */ 3782 3783 FT_EXPORT_DEF( FT_Error ) 3784 FT_Activate_Size( FT_Size size ) 3785 { 3786 FT_Face face; 3787 3788 3789 if ( size == NULL ) 3790 return FT_THROW( Invalid_Argument ); 3791 3792 face = size->face; 3793 if ( face == NULL || face->driver == NULL ) 3794 return FT_THROW( Invalid_Argument ); 3795 3796 /* we don't need anything more complex than that; all size objects */ 3797 /* are already listed by the face */ 3798 face->size = size; 3799 3800 return FT_Err_Ok; 3801 } 3802 3803 3804 /*************************************************************************/ 3805 /*************************************************************************/ 3806 /*************************************************************************/ 3807 /**** ****/ 3808 /**** ****/ 3809 /**** R E N D E R E R S ****/ 3810 /**** ****/ 3811 /**** ****/ 3812 /*************************************************************************/ 3813 /*************************************************************************/ 3814 /*************************************************************************/ 3815 3816 /* lookup a renderer by glyph format in the library's list */ 3817 FT_BASE_DEF( FT_Renderer ) 3818 FT_Lookup_Renderer( FT_Library library, 3819 FT_Glyph_Format format, 3820 FT_ListNode* node ) 3821 { 3822 FT_ListNode cur; 3823 FT_Renderer result = 0; 3824 3825 3826 if ( !library ) 3827 goto Exit; 3828 3829 cur = library->renderers.head; 3830 3831 if ( node ) 3832 { 3833 if ( *node ) 3834 cur = (*node)->next; 3835 *node = 0; 3836 } 3837 3838 while ( cur ) 3839 { 3840 FT_Renderer renderer = FT_RENDERER( cur->data ); 3841 3842 3843 if ( renderer->glyph_format == format ) 3844 { 3845 if ( node ) 3846 *node = cur; 3847 3848 result = renderer; 3849 break; 3850 } 3851 cur = cur->next; 3852 } 3853 3854 Exit: 3855 return result; 3856 } 3857 3858 3859 static FT_Renderer 3860 ft_lookup_glyph_renderer( FT_GlyphSlot slot ) 3861 { 3862 FT_Face face = slot->face; 3863 FT_Library library = FT_FACE_LIBRARY( face ); 3864 FT_Renderer result = library->cur_renderer; 3865 3866 3867 if ( !result || result->glyph_format != slot->format ) 3868 result = FT_Lookup_Renderer( library, slot->format, 0 ); 3869 3870 return result; 3871 } 3872 3873 3874 static void 3875 ft_set_current_renderer( FT_Library library ) 3876 { 3877 FT_Renderer renderer; 3878 3879 3880 renderer = FT_Lookup_Renderer( library, FT_GLYPH_FORMAT_OUTLINE, 0 ); 3881 library->cur_renderer = renderer; 3882 } 3883 3884 3885 static FT_Error 3886 ft_add_renderer( FT_Module module ) 3887 { 3888 FT_Library library = module->library; 3889 FT_Memory memory = library->memory; 3890 FT_Error error; 3891 FT_ListNode node = NULL; 3892 3893 3894 if ( FT_NEW( node ) ) 3895 goto Exit; 3896 3897 { 3898 FT_Renderer render = FT_RENDERER( module ); 3899 FT_Renderer_Class* clazz = (FT_Renderer_Class*)module->clazz; 3900 3901 3902 render->clazz = clazz; 3903 render->glyph_format = clazz->glyph_format; 3904 3905 /* allocate raster object if needed */ 3906 if ( clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE && 3907 clazz->raster_class->raster_new ) 3908 { 3909 error = clazz->raster_class->raster_new( memory, &render->raster ); 3910 if ( error ) 3911 goto Fail; 3912 3913 render->raster_render = clazz->raster_class->raster_render; 3914 render->render = clazz->render_glyph; 3915 } 3916 3917 /* add to list */ 3918 node->data = module; 3919 FT_List_Add( &library->renderers, node ); 3920 3921 ft_set_current_renderer( library ); 3922 } 3923 3924 Fail: 3925 if ( error ) 3926 FT_FREE( node ); 3927 3928 Exit: 3929 return error; 3930 } 3931 3932 3933 static void 3934 ft_remove_renderer( FT_Module module ) 3935 { 3936 FT_Library library = module->library; 3937 FT_Memory memory = library->memory; 3938 FT_ListNode node; 3939 3940 3941 node = FT_List_Find( &library->renderers, module ); 3942 if ( node ) 3943 { 3944 FT_Renderer render = FT_RENDERER( module ); 3945 3946 3947 /* release raster object, if any */ 3948 if ( render->clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE && 3949 render->raster ) 3950 render->clazz->raster_class->raster_done( render->raster ); 3951 3952 /* remove from list */ 3953 FT_List_Remove( &library->renderers, node ); 3954 FT_FREE( node ); 3955 3956 ft_set_current_renderer( library ); 3957 } 3958 } 3959 3960 3961 /* documentation is in ftrender.h */ 3962 3963 FT_EXPORT_DEF( FT_Renderer ) 3964 FT_Get_Renderer( FT_Library library, 3965 FT_Glyph_Format format ) 3966 { 3967 /* test for valid `library' delayed to FT_Lookup_Renderer() */ 3968 3969 return FT_Lookup_Renderer( library, format, 0 ); 3970 } 3971 3972 3973 /* documentation is in ftrender.h */ 3974 3975 FT_EXPORT_DEF( FT_Error ) 3976 FT_Set_Renderer( FT_Library library, 3977 FT_Renderer renderer, 3978 FT_UInt num_params, 3979 FT_Parameter* parameters ) 3980 { 3981 FT_ListNode node; 3982 FT_Error error = FT_Err_Ok; 3983 3984 3985 if ( !library ) 3986 return FT_THROW( Invalid_Library_Handle ); 3987 3988 if ( !renderer ) 3989 return FT_THROW( Invalid_Argument ); 3990 3991 node = FT_List_Find( &library->renderers, renderer ); 3992 if ( !node ) 3993 { 3994 error = FT_THROW( Invalid_Argument ); 3995 goto Exit; 3996 } 3997 3998 FT_List_Up( &library->renderers, node ); 3999 4000 if ( renderer->glyph_format == FT_GLYPH_FORMAT_OUTLINE ) 4001 library->cur_renderer = renderer; 4002 4003 if ( num_params > 0 ) 4004 { 4005 FT_Renderer_SetModeFunc set_mode = renderer->clazz->set_mode; 4006 4007 4008 for ( ; num_params > 0; num_params-- ) 4009 { 4010 error = set_mode( renderer, parameters->tag, parameters->data ); 4011 if ( error ) 4012 break; 4013 parameters++; 4014 } 4015 } 4016 4017 Exit: 4018 return error; 4019 } 4020 4021 4022 FT_BASE_DEF( FT_Error ) 4023 FT_Render_Glyph_Internal( FT_Library library, 4024 FT_GlyphSlot slot, 4025 FT_Render_Mode render_mode ) 4026 { 4027 FT_Error error = FT_Err_Ok; 4028 FT_Renderer renderer; 4029 4030 4031 /* if it is already a bitmap, no need to do anything */ 4032 switch ( slot->format ) 4033 { 4034 case FT_GLYPH_FORMAT_BITMAP: /* already a bitmap, don't do anything */ 4035 break; 4036 4037 default: 4038 { 4039 FT_ListNode node = 0; 4040 FT_Bool update = 0; 4041 4042 4043 /* small shortcut for the very common case */ 4044 if ( slot->format == FT_GLYPH_FORMAT_OUTLINE ) 4045 { 4046 renderer = library->cur_renderer; 4047 node = library->renderers.head; 4048 } 4049 else 4050 renderer = FT_Lookup_Renderer( library, slot->format, &node ); 4051 4052 error = FT_ERR( Unimplemented_Feature ); 4053 while ( renderer ) 4054 { 4055 error = renderer->render( renderer, slot, render_mode, NULL ); 4056 if ( !error || 4057 FT_ERR_NEQ( error, Cannot_Render_Glyph ) ) 4058 break; 4059 4060 /* FT_Err_Cannot_Render_Glyph is returned if the render mode */ 4061 /* is unsupported by the current renderer for this glyph image */ 4062 /* format. */ 4063 4064 /* now, look for another renderer that supports the same */ 4065 /* format. */ 4066 renderer = FT_Lookup_Renderer( library, slot->format, &node ); 4067 update = 1; 4068 } 4069 4070 /* if we changed the current renderer for the glyph image format */ 4071 /* we need to select it as the next current one */ 4072 if ( !error && update && renderer ) 4073 FT_Set_Renderer( library, renderer, 0, 0 ); 4074 } 4075 } 4076 4077#ifdef FT_DEBUG_LEVEL_TRACE 4078 4079#undef FT_COMPONENT 4080#define FT_COMPONENT trace_bitmap 4081 4082 /* we convert to a single bitmap format for computing the checksum */ 4083 { 4084 FT_Bitmap bitmap; 4085 FT_Error err; 4086 4087 4088 FT_Bitmap_New( &bitmap ); 4089 4090 err = FT_Bitmap_Convert( library, &slot->bitmap, &bitmap, 1 ); 4091 if ( !err ) 4092 { 4093 MD5_CTX ctx; 4094 unsigned char md5[16]; 4095 int i; 4096 4097 4098 MD5_Init( &ctx); 4099 MD5_Update( &ctx, bitmap.buffer, bitmap.rows * bitmap.pitch ); 4100 MD5_Final( md5, &ctx ); 4101 4102 FT_TRACE3(( "MD5 checksum for %dx%d bitmap:\n" 4103 " ", 4104 bitmap.rows, bitmap.pitch )); 4105 for ( i = 0; i < 16; i++ ) 4106 FT_TRACE3(( "%02X", md5[i] )); 4107 FT_TRACE3(( "\n" )); 4108 } 4109 4110 FT_Bitmap_Done( library, &bitmap ); 4111 } 4112 4113#undef FT_COMPONENT 4114#define FT_COMPONENT trace_objs 4115 4116#endif /* FT_DEBUG_LEVEL_TRACE */ 4117 4118 return error; 4119 } 4120 4121 /* documentation is in freetype.h */ 4122 4123 FT_EXPORT_DEF( FT_Error ) 4124 FT_Render_Glyph( FT_GlyphSlot slot, 4125 FT_Render_Mode render_mode ) 4126 { 4127 FT_Library library; 4128 4129 if ( !slot || !slot->face ) 4130 return FT_THROW( Invalid_Argument ); 4131 4132 library = FT_FACE_LIBRARY( slot->face ); 4133 4134 return FT_Render_Glyph_Internal( library, slot, render_mode ); 4135 } 4136 4137 4138 /*************************************************************************/ 4139 /*************************************************************************/ 4140 /*************************************************************************/ 4141 /**** ****/ 4142 /**** ****/ 4143 /**** M O D U L E S ****/ 4144 /**** ****/ 4145 /**** ****/ 4146 /*************************************************************************/ 4147 /*************************************************************************/ 4148 /*************************************************************************/ 4149 4150 4151 /*************************************************************************/ 4152 /* */ 4153 /* <Function> */ 4154 /* Destroy_Module */ 4155 /* */ 4156 /* <Description> */ 4157 /* Destroys a given module object. For drivers, this also destroys */ 4158 /* all child faces. */ 4159 /* */ 4160 /* <InOut> */ 4161 /* module :: A handle to the target driver object. */ 4162 /* */ 4163 /* <Note> */ 4164 /* The driver _must_ be LOCKED! */ 4165 /* */ 4166 static void 4167 Destroy_Module( FT_Module module ) 4168 { 4169 FT_Memory memory = module->memory; 4170 FT_Module_Class* clazz = module->clazz; 4171 FT_Library library = module->library; 4172 4173 4174 if ( library && library->auto_hinter == module ) 4175 library->auto_hinter = 0; 4176 4177 /* if the module is a renderer */ 4178 if ( FT_MODULE_IS_RENDERER( module ) ) 4179 ft_remove_renderer( module ); 4180 4181 /* if the module is a font driver, add some steps */ 4182 if ( FT_MODULE_IS_DRIVER( module ) ) 4183 Destroy_Driver( FT_DRIVER( module ) ); 4184 4185 /* finalize the module object */ 4186 if ( clazz->module_done ) 4187 clazz->module_done( module ); 4188 4189 /* discard it */ 4190 FT_FREE( module ); 4191 } 4192 4193 4194 /* documentation is in ftmodapi.h */ 4195 4196 FT_EXPORT_DEF( FT_Error ) 4197 FT_Add_Module( FT_Library library, 4198 const FT_Module_Class* clazz ) 4199 { 4200 FT_Error error; 4201 FT_Memory memory; 4202 FT_Module module; 4203 FT_UInt nn; 4204 4205 4206#define FREETYPE_VER_FIXED ( ( (FT_Long)FREETYPE_MAJOR << 16 ) | \ 4207 FREETYPE_MINOR ) 4208 4209 if ( !library ) 4210 return FT_THROW( Invalid_Library_Handle ); 4211 4212 if ( !clazz ) 4213 return FT_THROW( Invalid_Argument ); 4214 4215 /* check freetype version */ 4216 if ( clazz->module_requires > FREETYPE_VER_FIXED ) 4217 return FT_THROW( Invalid_Version ); 4218 4219 /* look for a module with the same name in the library's table */ 4220 for ( nn = 0; nn < library->num_modules; nn++ ) 4221 { 4222 module = library->modules[nn]; 4223 if ( ft_strcmp( module->clazz->module_name, clazz->module_name ) == 0 ) 4224 { 4225 /* this installed module has the same name, compare their versions */ 4226 if ( clazz->module_version <= module->clazz->module_version ) 4227 return FT_THROW( Lower_Module_Version ); 4228 4229 /* remove the module from our list, then exit the loop to replace */ 4230 /* it by our new version.. */ 4231 FT_Remove_Module( library, module ); 4232 break; 4233 } 4234 } 4235 4236 memory = library->memory; 4237 error = FT_Err_Ok; 4238 4239 if ( library->num_modules >= FT_MAX_MODULES ) 4240 { 4241 error = FT_THROW( Too_Many_Drivers ); 4242 goto Exit; 4243 } 4244 4245 /* allocate module object */ 4246 if ( FT_ALLOC( module, clazz->module_size ) ) 4247 goto Exit; 4248 4249 /* base initialization */ 4250 module->library = library; 4251 module->memory = memory; 4252 module->clazz = (FT_Module_Class*)clazz; 4253 4254 /* check whether the module is a renderer - this must be performed */ 4255 /* before the normal module initialization */ 4256 if ( FT_MODULE_IS_RENDERER( module ) ) 4257 { 4258 /* add to the renderers list */ 4259 error = ft_add_renderer( module ); 4260 if ( error ) 4261 goto Fail; 4262 } 4263 4264 /* is the module a auto-hinter? */ 4265 if ( FT_MODULE_IS_HINTER( module ) ) 4266 library->auto_hinter = module; 4267 4268 /* if the module is a font driver */ 4269 if ( FT_MODULE_IS_DRIVER( module ) ) 4270 { 4271 /* allocate glyph loader if needed */ 4272 FT_Driver driver = FT_DRIVER( module ); 4273 4274 4275 driver->clazz = (FT_Driver_Class)module->clazz; 4276 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 4277 { 4278 error = FT_GlyphLoader_New( memory, &driver->glyph_loader ); 4279 if ( error ) 4280 goto Fail; 4281 } 4282 } 4283 4284 if ( clazz->module_init ) 4285 { 4286 error = clazz->module_init( module ); 4287 if ( error ) 4288 goto Fail; 4289 } 4290 4291 /* add module to the library's table */ 4292 library->modules[library->num_modules++] = module; 4293 4294 Exit: 4295 return error; 4296 4297 Fail: 4298 if ( FT_MODULE_IS_DRIVER( module ) ) 4299 { 4300 FT_Driver driver = FT_DRIVER( module ); 4301 4302 4303 if ( FT_DRIVER_USES_OUTLINES( driver ) ) 4304 FT_GlyphLoader_Done( driver->glyph_loader ); 4305 } 4306 4307 if ( FT_MODULE_IS_RENDERER( module ) ) 4308 { 4309 FT_Renderer renderer = FT_RENDERER( module ); 4310 4311 4312 if ( renderer->clazz && 4313 renderer->clazz->glyph_format == FT_GLYPH_FORMAT_OUTLINE && 4314 renderer->raster ) 4315 renderer->clazz->raster_class->raster_done( renderer->raster ); 4316 } 4317 4318 FT_FREE( module ); 4319 goto Exit; 4320 } 4321 4322 4323 /* documentation is in ftmodapi.h */ 4324 4325 FT_EXPORT_DEF( FT_Module ) 4326 FT_Get_Module( FT_Library library, 4327 const char* module_name ) 4328 { 4329 FT_Module result = 0; 4330 FT_Module* cur; 4331 FT_Module* limit; 4332 4333 4334 if ( !library || !module_name ) 4335 return result; 4336 4337 cur = library->modules; 4338 limit = cur + library->num_modules; 4339 4340 for ( ; cur < limit; cur++ ) 4341 if ( ft_strcmp( cur[0]->clazz->module_name, module_name ) == 0 ) 4342 { 4343 result = cur[0]; 4344 break; 4345 } 4346 4347 return result; 4348 } 4349 4350 4351 /* documentation is in ftobjs.h */ 4352 4353 FT_BASE_DEF( const void* ) 4354 FT_Get_Module_Interface( FT_Library library, 4355 const char* mod_name ) 4356 { 4357 FT_Module module; 4358 4359 4360 /* test for valid `library' delayed to FT_Get_Module() */ 4361 4362 module = FT_Get_Module( library, mod_name ); 4363 4364 return module ? module->clazz->module_interface : 0; 4365 } 4366 4367 4368 FT_BASE_DEF( FT_Pointer ) 4369 ft_module_get_service( FT_Module module, 4370 const char* service_id ) 4371 { 4372 FT_Pointer result = NULL; 4373 4374 4375 if ( module ) 4376 { 4377 FT_ASSERT( module->clazz && module->clazz->get_interface ); 4378 4379 /* first, look for the service in the module */ 4380 if ( module->clazz->get_interface ) 4381 result = module->clazz->get_interface( module, service_id ); 4382 4383 if ( result == NULL ) 4384 { 4385 /* we didn't find it, look in all other modules then */ 4386 FT_Library library = module->library; 4387 FT_Module* cur = library->modules; 4388 FT_Module* limit = cur + library->num_modules; 4389 4390 4391 for ( ; cur < limit; cur++ ) 4392 { 4393 if ( cur[0] != module ) 4394 { 4395 FT_ASSERT( cur[0]->clazz ); 4396 4397 if ( cur[0]->clazz->get_interface ) 4398 { 4399 result = cur[0]->clazz->get_interface( cur[0], service_id ); 4400 if ( result != NULL ) 4401 break; 4402 } 4403 } 4404 } 4405 } 4406 } 4407 4408 return result; 4409 } 4410 4411 4412 /* documentation is in ftmodapi.h */ 4413 4414 FT_EXPORT_DEF( FT_Error ) 4415 FT_Remove_Module( FT_Library library, 4416 FT_Module module ) 4417 { 4418 /* try to find the module from the table, then remove it from there */ 4419 4420 if ( !library ) 4421 return FT_THROW( Invalid_Library_Handle ); 4422 4423 if ( module ) 4424 { 4425 FT_Module* cur = library->modules; 4426 FT_Module* limit = cur + library->num_modules; 4427 4428 4429 for ( ; cur < limit; cur++ ) 4430 { 4431 if ( cur[0] == module ) 4432 { 4433 /* remove it from the table */ 4434 library->num_modules--; 4435 limit--; 4436 while ( cur < limit ) 4437 { 4438 cur[0] = cur[1]; 4439 cur++; 4440 } 4441 limit[0] = 0; 4442 4443 /* destroy the module */ 4444 Destroy_Module( module ); 4445 4446 return FT_Err_Ok; 4447 } 4448 } 4449 } 4450 return FT_THROW( Invalid_Driver_Handle ); 4451 } 4452 4453 4454 FT_Error 4455 ft_property_do( FT_Library library, 4456 const FT_String* module_name, 4457 const FT_String* property_name, 4458 void* value, 4459 FT_Bool set ) 4460 { 4461 FT_Module* cur; 4462 FT_Module* limit; 4463 FT_Module_Interface interface1; 4464 FT_Service_Properties service; 4465 4466#ifdef FT_DEBUG_LEVEL_ERROR 4467 const FT_String* set_name = "FT_Property_Set"; 4468 const FT_String* get_name = "FT_Property_Get"; 4469 const FT_String* func_name = set ? set_name : get_name; 4470#endif 4471 4472 FT_Bool missing_func; 4473 4474 4475 if ( !library ) 4476 return FT_THROW( Invalid_Library_Handle ); 4477 4478 if ( !module_name || !property_name || !value ) 4479 return FT_THROW( Invalid_Argument ); 4480 4481 cur = library->modules; 4482 limit = cur + library->num_modules; 4483 4484 /* search module */ 4485 for ( ; cur < limit; cur++ ) 4486 if ( !ft_strcmp( cur[0]->clazz->module_name, module_name ) ) 4487 break; 4488 4489 if ( cur == limit ) 4490 { 4491 FT_ERROR(( "%s: can't find module `%s'\n", 4492 func_name, module_name )); 4493 return FT_THROW( Missing_Module ); 4494 } 4495 4496 /* check whether we have a service interface */ 4497 if ( !cur[0]->clazz->get_interface ) 4498 { 4499 FT_ERROR(( "%s: module `%s' doesn't support properties\n", 4500 func_name, module_name )); 4501 return FT_THROW( Unimplemented_Feature ); 4502 } 4503 4504 /* search property service */ 4505 interface1 = cur[0]->clazz->get_interface( cur[0], 4506 FT_SERVICE_ID_PROPERTIES ); 4507 if ( !interface1 ) 4508 { 4509 FT_ERROR(( "%s: module `%s' doesn't support properties\n", 4510 func_name, module_name )); 4511 return FT_THROW( Unimplemented_Feature ); 4512 } 4513 4514 service = (FT_Service_Properties)interface1; 4515 4516 if ( set ) 4517 missing_func = (FT_Bool)( !service->set_property ); 4518 else 4519 missing_func = (FT_Bool)( !service->get_property ); 4520 4521 if ( missing_func ) 4522 { 4523 FT_ERROR(( "%s: property service of module `%s' is broken\n", 4524 func_name, module_name )); 4525 return FT_THROW( Unimplemented_Feature ); 4526 } 4527 4528 return set ? service->set_property( cur[0], property_name, value ) 4529 : service->get_property( cur[0], property_name, value ); 4530 } 4531 4532 4533 /* documentation is in ftmodapi.h */ 4534 4535 FT_EXPORT_DEF( FT_Error ) 4536 FT_Property_Set( FT_Library library, 4537 const FT_String* module_name, 4538 const FT_String* property_name, 4539 const void* value ) 4540 { 4541 return ft_property_do( library, 4542 module_name, 4543 property_name, 4544 (void*)value, 4545 TRUE ); 4546 } 4547 4548 4549 /* documentation is in ftmodapi.h */ 4550 4551 FT_EXPORT_DEF( FT_Error ) 4552 FT_Property_Get( FT_Library library, 4553 const FT_String* module_name, 4554 const FT_String* property_name, 4555 void* value ) 4556 { 4557 return ft_property_do( library, 4558 module_name, 4559 property_name, 4560 value, 4561 FALSE ); 4562 } 4563 4564 4565 /*************************************************************************/ 4566 /*************************************************************************/ 4567 /*************************************************************************/ 4568 /**** ****/ 4569 /**** ****/ 4570 /**** L I B R A R Y ****/ 4571 /**** ****/ 4572 /**** ****/ 4573 /*************************************************************************/ 4574 /*************************************************************************/ 4575 /*************************************************************************/ 4576 4577 4578 /* documentation is in ftmodapi.h */ 4579 4580 FT_EXPORT_DEF( FT_Error ) 4581 FT_Reference_Library( FT_Library library ) 4582 { 4583 library->refcount++; 4584 4585 return FT_Err_Ok; 4586 } 4587 4588 4589 /* documentation is in ftmodapi.h */ 4590 4591 FT_EXPORT_DEF( FT_Error ) 4592 FT_New_Library( FT_Memory memory, 4593 FT_Library *alibrary ) 4594 { 4595 FT_Library library = NULL; 4596 FT_Error error; 4597 4598 4599 if ( !memory ) 4600 return FT_THROW( Invalid_Argument ); 4601 4602#ifdef FT_DEBUG_LEVEL_ERROR 4603 /* init debugging support */ 4604 ft_debug_init(); 4605#endif 4606 4607 /* first of all, allocate the library object */ 4608 if ( FT_NEW( library ) ) 4609 return error; 4610 4611 library->memory = memory; 4612 4613#ifdef FT_CONFIG_OPTION_PIC 4614 /* initialize position independent code containers */ 4615 error = ft_pic_container_init( library ); 4616 if ( error ) 4617 goto Fail; 4618#endif 4619 4620 /* allocate the render pool */ 4621 library->raster_pool_size = FT_RENDER_POOL_SIZE; 4622#if FT_RENDER_POOL_SIZE > 0 4623 if ( FT_ALLOC( library->raster_pool, FT_RENDER_POOL_SIZE ) ) 4624 goto Fail; 4625#endif 4626 4627 library->version_major = FREETYPE_MAJOR; 4628 library->version_minor = FREETYPE_MINOR; 4629 library->version_patch = FREETYPE_PATCH; 4630 4631 library->refcount = 1; 4632 4633 /* That's ok now */ 4634 *alibrary = library; 4635 4636 return FT_Err_Ok; 4637 4638 Fail: 4639#ifdef FT_CONFIG_OPTION_PIC 4640 ft_pic_container_destroy( library ); 4641#endif 4642 FT_FREE( library ); 4643 return error; 4644 } 4645 4646 4647 /* documentation is in freetype.h */ 4648 4649 FT_EXPORT_DEF( void ) 4650 FT_Library_Version( FT_Library library, 4651 FT_Int *amajor, 4652 FT_Int *aminor, 4653 FT_Int *apatch ) 4654 { 4655 FT_Int major = 0; 4656 FT_Int minor = 0; 4657 FT_Int patch = 0; 4658 4659 4660 if ( library ) 4661 { 4662 major = library->version_major; 4663 minor = library->version_minor; 4664 patch = library->version_patch; 4665 } 4666 4667 if ( amajor ) 4668 *amajor = major; 4669 4670 if ( aminor ) 4671 *aminor = minor; 4672 4673 if ( apatch ) 4674 *apatch = patch; 4675 } 4676 4677 4678 /* documentation is in ftmodapi.h */ 4679 4680 FT_EXPORT_DEF( FT_Error ) 4681 FT_Done_Library( FT_Library library ) 4682 { 4683 FT_Memory memory; 4684 4685 4686 if ( !library ) 4687 return FT_THROW( Invalid_Library_Handle ); 4688 4689 library->refcount--; 4690 if ( library->refcount > 0 ) 4691 goto Exit; 4692 4693 memory = library->memory; 4694 4695 /* 4696 * Close all faces in the library. If we don't do this, we can have 4697 * some subtle memory leaks. 4698 * 4699 * Example: 4700 * 4701 * - the cff font driver uses the pshinter module in cff_size_done 4702 * - if the pshinter module is destroyed before the cff font driver, 4703 * opened FT_Face objects managed by the driver are not properly 4704 * destroyed, resulting in a memory leak 4705 * 4706 * Some faces are dependent on other faces, like Type42 faces that 4707 * depend on TrueType faces synthesized internally. 4708 * 4709 * The order of drivers should be specified in driver_name[]. 4710 */ 4711 { 4712 FT_UInt m, n; 4713 const char* driver_name[] = { "type42", NULL }; 4714 4715 4716 for ( m = 0; 4717 m < sizeof ( driver_name ) / sizeof ( driver_name[0] ); 4718 m++ ) 4719 { 4720 for ( n = 0; n < library->num_modules; n++ ) 4721 { 4722 FT_Module module = library->modules[n]; 4723 const char* module_name = module->clazz->module_name; 4724 FT_List faces; 4725 4726 4727 if ( driver_name[m] && 4728 ft_strcmp( module_name, driver_name[m] ) != 0 ) 4729 continue; 4730 4731 if ( ( module->clazz->module_flags & FT_MODULE_FONT_DRIVER ) == 0 ) 4732 continue; 4733 4734 FT_TRACE7(( "FT_Done_Library: close faces for %s\n", module_name )); 4735 4736 faces = &FT_DRIVER( module )->faces_list; 4737 while ( faces->head ) 4738 { 4739 FT_Done_Face( FT_FACE( faces->head->data ) ); 4740 if ( faces->head ) 4741 FT_TRACE0(( "FT_Done_Library: failed to free some faces\n" )); 4742 } 4743 } 4744 } 4745 } 4746 4747 /* Close all other modules in the library */ 4748#if 1 4749 /* XXX Modules are removed in the reversed order so that */ 4750 /* type42 module is removed before truetype module. This */ 4751 /* avoids double free in some occasions. It is a hack. */ 4752 while ( library->num_modules > 0 ) 4753 FT_Remove_Module( library, 4754 library->modules[library->num_modules - 1] ); 4755#else 4756 { 4757 FT_UInt n; 4758 4759 4760 for ( n = 0; n < library->num_modules; n++ ) 4761 { 4762 FT_Module module = library->modules[n]; 4763 4764 4765 if ( module ) 4766 { 4767 Destroy_Module( module ); 4768 library->modules[n] = 0; 4769 } 4770 } 4771 } 4772#endif 4773 4774 /* Destroy raster objects */ 4775 FT_FREE( library->raster_pool ); 4776 library->raster_pool_size = 0; 4777 4778#ifdef FT_CONFIG_OPTION_PIC 4779 /* Destroy pic container contents */ 4780 ft_pic_container_destroy( library ); 4781#endif 4782 4783 FT_FREE( library ); 4784 4785 Exit: 4786 return FT_Err_Ok; 4787 } 4788 4789 4790 /* documentation is in ftmodapi.h */ 4791 4792 FT_EXPORT_DEF( void ) 4793 FT_Set_Debug_Hook( FT_Library library, 4794 FT_UInt hook_index, 4795 FT_DebugHook_Func debug_hook ) 4796 { 4797 if ( library && debug_hook && 4798 hook_index < 4799 ( sizeof ( library->debug_hooks ) / sizeof ( void* ) ) ) 4800 library->debug_hooks[hook_index] = debug_hook; 4801 } 4802 4803 4804 /* documentation is in ftmodapi.h */ 4805 4806 FT_EXPORT_DEF( FT_TrueTypeEngineType ) 4807 FT_Get_TrueType_Engine_Type( FT_Library library ) 4808 { 4809 FT_TrueTypeEngineType result = FT_TRUETYPE_ENGINE_TYPE_NONE; 4810 4811 4812 if ( library ) 4813 { 4814 FT_Module module = FT_Get_Module( library, "truetype" ); 4815 4816 4817 if ( module ) 4818 { 4819 FT_Service_TrueTypeEngine service; 4820 4821 4822 service = (FT_Service_TrueTypeEngine) 4823 ft_module_get_service( module, 4824 FT_SERVICE_ID_TRUETYPE_ENGINE ); 4825 if ( service ) 4826 result = service->engine_type; 4827 } 4828 } 4829 4830 return result; 4831 } 4832 4833 4834 /* documentation is in freetype.h */ 4835 4836 FT_EXPORT_DEF( FT_Error ) 4837 FT_Get_SubGlyph_Info( FT_GlyphSlot glyph, 4838 FT_UInt sub_index, 4839 FT_Int *p_index, 4840 FT_UInt *p_flags, 4841 FT_Int *p_arg1, 4842 FT_Int *p_arg2, 4843 FT_Matrix *p_transform ) 4844 { 4845 FT_Error error = FT_ERR( Invalid_Argument ); 4846 4847 4848 if ( glyph && 4849 glyph->subglyphs && 4850 glyph->format == FT_GLYPH_FORMAT_COMPOSITE && 4851 sub_index < glyph->num_subglyphs ) 4852 { 4853 FT_SubGlyph subg = glyph->subglyphs + sub_index; 4854 4855 4856 *p_index = subg->index; 4857 *p_flags = subg->flags; 4858 *p_arg1 = subg->arg1; 4859 *p_arg2 = subg->arg2; 4860 *p_transform = subg->transform; 4861 } 4862 4863 return error; 4864 } 4865 4866 4867/* END */ 4868