pcfdrivr.c (21788B)
1 /* pcfdrivr.c 2 3 FreeType font driver for pcf files 4 5 Copyright (C) 2000-2004, 2006-2011, 2013, 2014 by 6 Francesco Zappa Nardelli 7 8 Permission is hereby granted, free of charge, to any person obtaining a copy 9 of this software and associated documentation files (the "Software"), to deal 10 in the Software without restriction, including without limitation the rights 11 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 copies of the Software, and to permit persons to whom the Software is 13 furnished to do so, subject to the following conditions: 14 15 The above copyright notice and this permission notice shall be included in 16 all copies or substantial portions of the Software. 17 18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 21 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 THE SOFTWARE. 25 */ 26 27 28 29 #include <freetype/internal/ftdebug.h> 30 #include <freetype/internal/ftstream.h> 31 #include <freetype/internal/ftobjs.h> 32 #include <freetype/ftgzip.h> 33 #include <freetype/ftlzw.h> 34 #include <freetype/ftbzip2.h> 35 #include <freetype/fterrors.h> 36 #include <freetype/ftbdf.h> 37 #include <freetype/ttnameid.h> 38 39 #include "pcf.h" 40 #include "pcfdrivr.h" 41 #include "pcfread.h" 42 43 #include "pcferror.h" 44 #include "pcfutil.h" 45 46 #undef FT_COMPONENT 47 #define FT_COMPONENT pcfread 48 49 #include <freetype/internal/services/svbdf.h> 50 #include <freetype/internal/services/svfntfmt.h> 51 #include <freetype/internal/services/svprop.h> 52 #include <freetype/ftdriver.h> 53 54 55 /************************************************************************** 56 * 57 * The macro FT_COMPONENT is used in trace mode. It is an implicit 58 * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log 59 * messages during execution. 60 */ 61 #undef FT_COMPONENT 62 #define FT_COMPONENT pcfdriver 63 64 65 /* 66 * This file uses X11 terminology for PCF data; an `encoding' in X11 speak 67 * is the same as a `character code' in FreeType speak. 68 */ 69 typedef struct PCF_CMapRec_ 70 { 71 FT_CMapRec root; 72 PCF_Enc enc; 73 74 } PCF_CMapRec, *PCF_CMap; 75 76 77 FT_CALLBACK_DEF( FT_Error ) 78 pcf_cmap_init( FT_CMap cmap, /* PCF_CMap */ 79 FT_Pointer init_data ) 80 { 81 PCF_CMap pcfcmap = (PCF_CMap)cmap; 82 PCF_Face face = (PCF_Face)FT_CMAP_FACE( cmap ); 83 84 FT_UNUSED( init_data ); 85 86 87 pcfcmap->enc = &face->enc; 88 89 return FT_Err_Ok; 90 } 91 92 93 FT_CALLBACK_DEF( void ) 94 pcf_cmap_done( FT_CMap cmap ) /* PCF_CMap */ 95 { 96 PCF_CMap pcfcmap = (PCF_CMap)cmap; 97 98 99 pcfcmap->enc = NULL; 100 } 101 102 103 FT_CALLBACK_DEF( FT_UInt ) 104 pcf_cmap_char_index( FT_CMap cmap, /* PCF_CMap */ 105 FT_UInt32 charcode ) 106 { 107 PCF_Enc enc = ( (PCF_CMap)cmap )->enc; 108 109 FT_UInt32 i = ( charcode >> 8 ) - enc->firstRow; 110 FT_UInt32 j = ( charcode & 0xFF ) - enc->firstCol; 111 FT_UInt32 h = enc->lastRow - enc->firstRow + 1; 112 FT_UInt32 w = enc->lastCol - enc->firstCol + 1; 113 114 115 /* wrapped around "negative" values are also rejected */ 116 if ( i >= h || j >= w ) 117 return 0; 118 119 return (FT_UInt)enc->offset[i * w + j]; 120 } 121 122 123 FT_CALLBACK_DEF( FT_UInt ) 124 pcf_cmap_char_next( FT_CMap cmap, /* PCF_CMap */ 125 FT_UInt32 *acharcode ) 126 { 127 PCF_Enc enc = ( (PCF_CMap)cmap )->enc; 128 FT_UInt32 charcode = *acharcode + 1; 129 130 FT_UInt32 i = ( charcode >> 8 ) - enc->firstRow; 131 FT_UInt32 j = ( charcode & 0xFF ) - enc->firstCol; 132 FT_UInt32 h = enc->lastRow - enc->firstRow + 1; 133 FT_UInt32 w = enc->lastCol - enc->firstCol + 1; 134 135 FT_UInt result = 0; 136 137 138 /* adjust wrapped around "negative" values */ 139 if ( (FT_Int32)i < 0 ) 140 i = 0; 141 if ( (FT_Int32)j < 0 ) 142 j = 0; 143 144 for ( ; i < h; i++, j = 0 ) 145 for ( ; j < w; j++ ) 146 { 147 result = (FT_UInt)enc->offset[i * w + j]; 148 if ( result != 0xFFFFU ) 149 goto Exit; 150 } 151 152 Exit: 153 *acharcode = ( ( i + enc->firstRow ) << 8 ) | ( j + enc->firstCol ); 154 155 return result; 156 } 157 158 159 static 160 const FT_CMap_ClassRec pcf_cmap_class = 161 { 162 sizeof ( PCF_CMapRec ), 163 pcf_cmap_init, 164 pcf_cmap_done, 165 pcf_cmap_char_index, 166 pcf_cmap_char_next, 167 168 NULL, NULL, NULL, NULL, NULL 169 }; 170 171 172 FT_CALLBACK_DEF( void ) 173 PCF_Face_Done( FT_Face face ) /* PCF_Face */ 174 { 175 PCF_Face pcfface = (PCF_Face)face; 176 FT_Memory memory; 177 178 179 if ( !face ) 180 return; 181 182 memory = FT_FACE_MEMORY( face ); 183 184 FT_FREE( pcfface->metrics ); 185 FT_FREE( pcfface->enc.offset ); 186 187 /* free properties */ 188 if ( pcfface->properties ) 189 { 190 FT_Int i; 191 192 193 for ( i = 0; i < pcfface->nprops; i++ ) 194 { 195 PCF_Property prop = &pcfface->properties[i]; 196 197 198 if ( prop ) 199 { 200 FT_FREE( prop->name ); 201 if ( prop->isString ) 202 FT_FREE( prop->value.atom ); 203 } 204 } 205 206 FT_FREE( pcfface->properties ); 207 } 208 209 FT_FREE( pcfface->toc.tables ); 210 FT_FREE( face->family_name ); 211 FT_FREE( face->style_name ); 212 FT_FREE( face->available_sizes ); 213 FT_FREE( pcfface->charset_encoding ); 214 FT_FREE( pcfface->charset_registry ); 215 216 /* close compressed stream if any */ 217 if ( face->stream == &pcfface->comp_stream ) 218 { 219 FT_Stream_Close( &pcfface->comp_stream ); 220 face->stream = pcfface->comp_source; 221 } 222 } 223 224 225 FT_CALLBACK_DEF( FT_Error ) 226 PCF_Face_Init( FT_Stream stream, 227 FT_Face face, /* PCF_Face */ 228 FT_Int face_index, 229 FT_Int num_params, 230 FT_Parameter* params ) 231 { 232 PCF_Face pcfface = (PCF_Face)face; 233 FT_Error error; 234 235 FT_UNUSED( num_params ); 236 FT_UNUSED( params ); 237 238 239 FT_TRACE2(( "PCF driver\n" )); 240 241 error = pcf_load_font( stream, pcfface, face_index ); 242 if ( error ) 243 { 244 PCF_Face_Done( face ); 245 246 #if defined( FT_CONFIG_OPTION_USE_ZLIB ) || \ 247 defined( FT_CONFIG_OPTION_USE_LZW ) || \ 248 defined( FT_CONFIG_OPTION_USE_BZIP2 ) 249 250 #ifdef FT_CONFIG_OPTION_USE_ZLIB 251 { 252 FT_Error error2; 253 254 255 /* this didn't work, try gzip support! */ 256 FT_TRACE2(( " ... try gzip stream\n" )); 257 error2 = FT_Stream_OpenGzip( &pcfface->comp_stream, stream ); 258 if ( FT_ERR_EQ( error2, Unimplemented_Feature ) ) 259 goto Fail; 260 261 error = error2; 262 } 263 #endif /* FT_CONFIG_OPTION_USE_ZLIB */ 264 265 #ifdef FT_CONFIG_OPTION_USE_LZW 266 if ( error ) 267 { 268 FT_Error error3; 269 270 271 /* this didn't work, try LZW support! */ 272 FT_TRACE2(( " ... try LZW stream\n" )); 273 error3 = FT_Stream_OpenLZW( &pcfface->comp_stream, stream ); 274 if ( FT_ERR_EQ( error3, Unimplemented_Feature ) ) 275 goto Fail; 276 277 error = error3; 278 } 279 #endif /* FT_CONFIG_OPTION_USE_LZW */ 280 281 #ifdef FT_CONFIG_OPTION_USE_BZIP2 282 if ( error ) 283 { 284 FT_Error error4; 285 286 287 /* this didn't work, try Bzip2 support! */ 288 FT_TRACE2(( " ... try Bzip2 stream\n" )); 289 error4 = FT_Stream_OpenBzip2( &pcfface->comp_stream, stream ); 290 if ( FT_ERR_EQ( error4, Unimplemented_Feature ) ) 291 goto Fail; 292 293 error = error4; 294 } 295 #endif /* FT_CONFIG_OPTION_USE_BZIP2 */ 296 297 if ( error ) 298 goto Fail; 299 300 pcfface->comp_source = stream; 301 face->stream = &pcfface->comp_stream; 302 303 stream = face->stream; 304 305 error = pcf_load_font( stream, pcfface, face_index ); 306 if ( error ) 307 goto Fail; 308 309 #else /* !(FT_CONFIG_OPTION_USE_ZLIB || 310 FT_CONFIG_OPTION_USE_LZW || 311 FT_CONFIG_OPTION_USE_BZIP2) */ 312 313 goto Fail; 314 315 #endif 316 } 317 318 /* PCF cannot have multiple faces in a single font file. 319 * XXX: A non-zero face_index is already an invalid argument, but 320 * Type1, Type42 drivers have a convention to return 321 * an invalid argument error when the font could be 322 * opened by the specified driver. 323 */ 324 if ( face_index < 0 ) 325 goto Exit; 326 else if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 ) 327 { 328 FT_ERROR(( "PCF_Face_Init: invalid face index\n" )); 329 PCF_Face_Done( face ); 330 return FT_THROW( Invalid_Argument ); 331 } 332 333 /* set up charmap */ 334 { 335 FT_String *charset_registry = pcfface->charset_registry; 336 FT_String *charset_encoding = pcfface->charset_encoding; 337 FT_Bool unicode_charmap = 0; 338 339 340 if ( charset_registry && charset_encoding ) 341 { 342 char* s = charset_registry; 343 344 345 /* Uh, oh, compare first letters manually to avoid dependency 346 on locales. */ 347 if ( ( s[0] == 'i' || s[0] == 'I' ) && 348 ( s[1] == 's' || s[1] == 'S' ) && 349 ( s[2] == 'o' || s[2] == 'O' ) ) 350 { 351 s += 3; 352 if ( !ft_strcmp( s, "10646" ) || 353 ( !ft_strcmp( s, "8859" ) && 354 !ft_strcmp( pcfface->charset_encoding, "1" ) ) ) 355 unicode_charmap = 1; 356 /* another name for ASCII */ 357 else if ( !ft_strcmp( s, "646.1991" ) && 358 !ft_strcmp( pcfface->charset_encoding, "IRV" ) ) 359 unicode_charmap = 1; 360 } 361 } 362 363 { 364 FT_CharMapRec charmap; 365 366 367 charmap.face = face; 368 charmap.encoding = FT_ENCODING_NONE; 369 /* initial platform/encoding should indicate unset status? */ 370 charmap.platform_id = TT_PLATFORM_APPLE_UNICODE; 371 charmap.encoding_id = TT_APPLE_ID_DEFAULT; 372 373 if ( unicode_charmap ) 374 { 375 charmap.encoding = FT_ENCODING_UNICODE; 376 charmap.platform_id = TT_PLATFORM_MICROSOFT; 377 charmap.encoding_id = TT_MS_ID_UNICODE_CS; 378 } 379 380 error = FT_CMap_New( &pcf_cmap_class, NULL, &charmap, NULL ); 381 } 382 } 383 384 Exit: 385 return error; 386 387 Fail: 388 FT_TRACE2(( " not a PCF file\n" )); 389 PCF_Face_Done( face ); 390 error = FT_THROW( Unknown_File_Format ); /* error */ 391 goto Exit; 392 } 393 394 395 FT_CALLBACK_DEF( FT_Error ) 396 PCF_Size_Select( FT_Size size, 397 FT_ULong strike_index ) 398 { 399 PCF_Accel accel = &( (PCF_Face)size->face )->accel; 400 401 402 FT_Select_Metrics( size->face, strike_index ); 403 404 size->metrics.ascender = accel->fontAscent * 64; 405 size->metrics.descender = -accel->fontDescent * 64; 406 size->metrics.max_advance = accel->maxbounds.characterWidth * 64; 407 408 return FT_Err_Ok; 409 } 410 411 412 FT_CALLBACK_DEF( FT_Error ) 413 PCF_Size_Request( FT_Size size, 414 FT_Size_Request req ) 415 { 416 PCF_Face face = (PCF_Face)size->face; 417 FT_Bitmap_Size* bsize = size->face->available_sizes; 418 FT_Error error = FT_ERR( Invalid_Pixel_Size ); 419 FT_Long height; 420 421 422 height = FT_REQUEST_HEIGHT( req ); 423 height = ( height + 32 ) >> 6; 424 425 switch ( req->type ) 426 { 427 case FT_SIZE_REQUEST_TYPE_NOMINAL: 428 if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) ) 429 error = FT_Err_Ok; 430 break; 431 432 case FT_SIZE_REQUEST_TYPE_REAL_DIM: 433 if ( height == ( face->accel.fontAscent + 434 face->accel.fontDescent ) ) 435 error = FT_Err_Ok; 436 break; 437 438 default: 439 error = FT_THROW( Unimplemented_Feature ); 440 break; 441 } 442 443 if ( error ) 444 return error; 445 else 446 return PCF_Size_Select( size, 0 ); 447 } 448 449 450 FT_CALLBACK_DEF( FT_Error ) 451 PCF_Glyph_Load( FT_GlyphSlot slot, 452 FT_Size size, 453 FT_UInt glyph_index, 454 FT_Int32 load_flags ) 455 { 456 PCF_Face face = (PCF_Face)size->face; 457 FT_Stream stream; 458 FT_Error error = FT_Err_Ok; 459 FT_Bitmap* bitmap = &slot->bitmap; 460 PCF_Metric metric; 461 FT_ULong bytes; 462 463 464 FT_TRACE1(( "PCF_Glyph_Load: glyph index %u\n", glyph_index )); 465 466 if ( !face ) 467 { 468 error = FT_THROW( Invalid_Face_Handle ); 469 goto Exit; 470 } 471 472 if ( glyph_index >= (FT_UInt)face->root.num_glyphs ) 473 { 474 error = FT_THROW( Invalid_Argument ); 475 goto Exit; 476 } 477 478 stream = face->root.stream; 479 480 metric = face->metrics + glyph_index; 481 482 bitmap->rows = (unsigned int)( metric->ascent + 483 metric->descent ); 484 bitmap->width = (unsigned int)( metric->rightSideBearing - 485 metric->leftSideBearing ); 486 bitmap->num_grays = 1; 487 bitmap->pixel_mode = FT_PIXEL_MODE_MONO; 488 489 switch ( PCF_GLYPH_PAD( face->bitmapsFormat ) ) 490 { 491 case 1: 492 bitmap->pitch = (int)( ( bitmap->width + 7 ) >> 3 ); 493 break; 494 495 case 2: 496 bitmap->pitch = (int)( ( ( bitmap->width + 15 ) >> 4 ) << 1 ); 497 break; 498 499 case 4: 500 bitmap->pitch = (int)( ( ( bitmap->width + 31 ) >> 5 ) << 2 ); 501 break; 502 503 case 8: 504 bitmap->pitch = (int)( ( ( bitmap->width + 63 ) >> 6 ) << 3 ); 505 break; 506 507 default: 508 return FT_THROW( Invalid_File_Format ); 509 } 510 511 slot->format = FT_GLYPH_FORMAT_BITMAP; 512 slot->bitmap_left = metric->leftSideBearing; 513 slot->bitmap_top = metric->ascent; 514 515 slot->metrics.horiAdvance = (FT_Pos)( metric->characterWidth * 64 ); 516 slot->metrics.horiBearingX = (FT_Pos)( metric->leftSideBearing * 64 ); 517 slot->metrics.horiBearingY = (FT_Pos)( metric->ascent * 64 ); 518 slot->metrics.width = (FT_Pos)( ( metric->rightSideBearing - 519 metric->leftSideBearing ) * 64 ); 520 slot->metrics.height = (FT_Pos)( bitmap->rows * 64 ); 521 522 ft_synthesize_vertical_metrics( &slot->metrics, 523 ( face->accel.fontAscent + 524 face->accel.fontDescent ) * 64 ); 525 526 if ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY ) 527 goto Exit; 528 529 /* XXX: to do: are there cases that need repadding the bitmap? */ 530 bytes = (FT_ULong)bitmap->pitch * bitmap->rows; 531 532 error = ft_glyphslot_alloc_bitmap( slot, (FT_ULong)bytes ); 533 if ( error ) 534 goto Exit; 535 536 if ( FT_STREAM_SEEK( metric->bits ) || 537 FT_STREAM_READ( bitmap->buffer, bytes ) ) 538 goto Exit; 539 540 if ( PCF_BIT_ORDER( face->bitmapsFormat ) != MSBFirst ) 541 BitOrderInvert( bitmap->buffer, bytes ); 542 543 if ( ( PCF_BYTE_ORDER( face->bitmapsFormat ) != 544 PCF_BIT_ORDER( face->bitmapsFormat ) ) ) 545 { 546 switch ( PCF_SCAN_UNIT( face->bitmapsFormat ) ) 547 { 548 case 1: 549 break; 550 551 case 2: 552 TwoByteSwap( bitmap->buffer, bytes ); 553 break; 554 555 case 4: 556 FourByteSwap( bitmap->buffer, bytes ); 557 break; 558 } 559 } 560 561 Exit: 562 return error; 563 } 564 565 566 /* 567 * 568 * BDF SERVICE 569 * 570 */ 571 572 FT_CALLBACK_DEF( FT_Error ) 573 pcf_get_bdf_property( FT_Face face, /* PCF_Face */ 574 const char* prop_name, 575 BDF_PropertyRec *aproperty ) 576 { 577 PCF_Face pcfface = (PCF_Face)face; 578 PCF_Property prop; 579 580 581 prop = pcf_find_property( pcfface, prop_name ); 582 if ( prop ) 583 { 584 if ( prop->isString ) 585 { 586 aproperty->type = BDF_PROPERTY_TYPE_ATOM; 587 aproperty->u.atom = prop->value.atom; 588 } 589 else 590 { 591 if ( prop->value.l > 0x7FFFFFFFL || 592 prop->value.l < ( -1 - 0x7FFFFFFFL ) ) 593 { 594 FT_TRACE2(( "pcf_get_bdf_property:" 595 " too large integer 0x%lx is truncated\n", 596 prop->value.l )); 597 } 598 599 /* 600 * The PCF driver loads all properties as signed integers. 601 * This really doesn't seem to be a problem, because this is 602 * sufficient for any meaningful values. 603 */ 604 aproperty->type = BDF_PROPERTY_TYPE_INTEGER; 605 aproperty->u.integer = (FT_Int32)prop->value.l; 606 } 607 608 return FT_Err_Ok; 609 } 610 611 return FT_THROW( Invalid_Argument ); 612 } 613 614 615 FT_CALLBACK_DEF( FT_Error ) 616 pcf_get_charset_id( FT_Face face, /* PCF_Face */ 617 const char* *acharset_encoding, 618 const char* *acharset_registry ) 619 { 620 PCF_Face pcfface = (PCF_Face)face; 621 622 623 *acharset_encoding = pcfface->charset_encoding; 624 *acharset_registry = pcfface->charset_registry; 625 626 return FT_Err_Ok; 627 } 628 629 630 static const FT_Service_BDFRec pcf_service_bdf = 631 { 632 (FT_BDF_GetCharsetIdFunc)pcf_get_charset_id, /* get_charset_id */ 633 (FT_BDF_GetPropertyFunc) pcf_get_bdf_property /* get_property */ 634 }; 635 636 637 /* 638 * PROPERTY SERVICE 639 * 640 */ 641 FT_CALLBACK_DEF( FT_Error ) 642 pcf_property_set( FT_Module module, /* PCF_Driver */ 643 const char* property_name, 644 const void* value, 645 FT_Bool value_is_string ) 646 { 647 #ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES 648 649 FT_Error error = FT_Err_Ok; 650 PCF_Driver driver = (PCF_Driver)module; 651 652 #ifndef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES 653 FT_UNUSED( value_is_string ); 654 #endif 655 656 657 if ( !ft_strcmp( property_name, "no-long-family-names" ) ) 658 { 659 #ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES 660 if ( value_is_string ) 661 { 662 const char* s = (const char*)value; 663 long lfn = ft_strtol( s, NULL, 10 ); 664 665 666 if ( lfn == 0 ) 667 driver->no_long_family_names = 0; 668 else if ( lfn == 1 ) 669 driver->no_long_family_names = 1; 670 else 671 return FT_THROW( Invalid_Argument ); 672 } 673 else 674 #endif 675 { 676 FT_Bool* no_long_family_names = (FT_Bool*)value; 677 678 679 driver->no_long_family_names = *no_long_family_names; 680 } 681 682 return error; 683 } 684 685 #else /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */ 686 687 FT_UNUSED( module ); 688 FT_UNUSED( value ); 689 FT_UNUSED( value_is_string ); 690 #ifndef FT_DEBUG_LEVEL_TRACE 691 FT_UNUSED( property_name ); 692 #endif 693 694 #endif /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */ 695 696 FT_TRACE2(( "pcf_property_set: missing property `%s'\n", 697 property_name )); 698 return FT_THROW( Missing_Property ); 699 } 700 701 702 FT_CALLBACK_DEF( FT_Error ) 703 pcf_property_get( FT_Module module, /* PCF_Driver */ 704 const char* property_name, 705 void* value ) 706 { 707 #ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES 708 709 FT_Error error = FT_Err_Ok; 710 PCF_Driver driver = (PCF_Driver)module; 711 712 713 if ( !ft_strcmp( property_name, "no-long-family-names" ) ) 714 { 715 FT_Bool no_long_family_names = driver->no_long_family_names; 716 FT_Bool* val = (FT_Bool*)value; 717 718 719 *val = no_long_family_names; 720 721 return error; 722 } 723 724 #else /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */ 725 726 FT_UNUSED( module ); 727 FT_UNUSED( value ); 728 #ifndef FT_DEBUG_LEVEL_TRACE 729 FT_UNUSED( property_name ); 730 #endif 731 732 #endif /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */ 733 734 FT_TRACE2(( "pcf_property_get: missing property `%s'\n", 735 property_name )); 736 return FT_THROW( Missing_Property ); 737 } 738 739 740 FT_DEFINE_SERVICE_PROPERTIESREC( 741 pcf_service_properties, 742 743 (FT_Properties_SetFunc)pcf_property_set, /* set_property */ 744 (FT_Properties_GetFunc)pcf_property_get ) /* get_property */ 745 746 747 /* 748 * 749 * SERVICE LIST 750 * 751 */ 752 753 static const FT_ServiceDescRec pcf_services[] = 754 { 755 { FT_SERVICE_ID_BDF, &pcf_service_bdf }, 756 { FT_SERVICE_ID_FONT_FORMAT, FT_FONT_FORMAT_PCF }, 757 { FT_SERVICE_ID_PROPERTIES, &pcf_service_properties }, 758 { NULL, NULL } 759 }; 760 761 762 FT_CALLBACK_DEF( FT_Module_Interface ) 763 pcf_driver_requester( FT_Module module, 764 const char* name ) 765 { 766 FT_UNUSED( module ); 767 768 return ft_service_list_lookup( pcf_services, name ); 769 } 770 771 772 FT_CALLBACK_DEF( FT_Error ) 773 pcf_driver_init( FT_Module module ) /* PCF_Driver */ 774 { 775 #ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES 776 PCF_Driver driver = (PCF_Driver)module; 777 778 779 driver->no_long_family_names = 0; 780 #else 781 FT_UNUSED( module ); 782 #endif 783 784 return FT_Err_Ok; 785 } 786 787 788 FT_CALLBACK_DEF( void ) 789 pcf_driver_done( FT_Module module ) /* PCF_Driver */ 790 { 791 FT_UNUSED( module ); 792 } 793 794 795 FT_CALLBACK_TABLE_DEF 796 const FT_Driver_ClassRec pcf_driver_class = 797 { 798 { 799 FT_MODULE_FONT_DRIVER | 800 FT_MODULE_DRIVER_NO_OUTLINES, 801 802 sizeof ( PCF_DriverRec ), 803 "pcf", 804 0x10000L, 805 0x20000L, 806 807 NULL, /* module-specific interface */ 808 809 pcf_driver_init, /* FT_Module_Constructor module_init */ 810 pcf_driver_done, /* FT_Module_Destructor module_done */ 811 pcf_driver_requester /* FT_Module_Requester get_interface */ 812 }, 813 814 sizeof ( PCF_FaceRec ), 815 sizeof ( FT_SizeRec ), 816 sizeof ( FT_GlyphSlotRec ), 817 818 PCF_Face_Init, /* FT_Face_InitFunc init_face */ 819 PCF_Face_Done, /* FT_Face_DoneFunc done_face */ 820 NULL, /* FT_Size_InitFunc init_size */ 821 NULL, /* FT_Size_DoneFunc done_size */ 822 NULL, /* FT_Slot_InitFunc init_slot */ 823 NULL, /* FT_Slot_DoneFunc done_slot */ 824 825 PCF_Glyph_Load, /* FT_Slot_LoadFunc load_glyph */ 826 827 NULL, /* FT_Face_GetKerningFunc get_kerning */ 828 NULL, /* FT_Face_AttachFunc attach_file */ 829 NULL, /* FT_Face_GetAdvancesFunc get_advances */ 830 831 PCF_Size_Request, /* FT_Size_RequestFunc request_size */ 832 PCF_Size_Select /* FT_Size_SelectFunc select_size */ 833 }; 834 835 836 /* END */