src/pcf/pcfdrivr.c

   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)FT_SIZE_FACE( size );
 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 %d\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 */