pcfdrivr.c File Reference

#include <ft2build.h>
#include "pcf.h"
#include "pcfdrivr.h"
#include "pcfread.h"
#include "pcferror.h"
#include "pcfutil.h"

Include dependency graph for pcfdrivr.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	PCF_CMapRec_

Macros
#define	FT_COMPONENT   pcfread
#define	FT_COMPONENT   pcfdriver

Typedefs
typedef struct PCF_CMapRec_	PCF_CMapRec
typedef struct PCF_CMapRec_ *	PCF_CMap

Functions
	pcf_cmap_init (FT_CMap pcfcmap, FT_Pointer init_data)
	pcf_cmap_done (FT_CMap pcfcmap)
	pcf_cmap_char_index (FT_CMap pcfcmap, FT_UInt32 charcode)
	pcf_cmap_char_next (FT_CMap pcfcmap, FT_UInt32 *acharcode)
	PCF_Face_Done (FT_Face pcfface)
	PCF_Face_Init (FT_Stream stream, FT_Face pcfface, FT_Int face_index, FT_Int num_params, FT_Parameter *params)
	PCF_Size_Select (FT_Size size, FT_ULong strike_index)
	PCF_Size_Request (FT_Size size, FT_Size_Request req)
	PCF_Glyph_Load (FT_GlyphSlot slot, FT_Size size, FT_UInt glyph_index, FT_Int32 load_flags)
static FT_Error	pcf_get_bdf_property (PCF_Face face, const char *prop_name, BDF_PropertyRec *aproperty)
static FT_Error	pcf_get_charset_id (PCF_Face face, const char **acharset_encoding, const char **acharset_registry)
static FT_Error	pcf_property_set (FT_Module module, const char *property_name, const void *value, FT_Bool value_is_string)
static FT_Error	pcf_property_get (FT_Module module, const char *property_name, const void *value)
	FT_DEFINE_SERVICE_PROPERTIESREC (pcf_service_properties,(FT_Properties_SetFunc) pcf_property_set,(FT_Properties_GetFunc) pcf_property_get) static const FT_ServiceDescRec pcf_services[]
	pcf_driver_requester (FT_Module module, const char *name)
	pcf_driver_init (FT_Module module)
	pcf_driver_done (FT_Module module)

Variables
static const FT_CMap_ClassRec	pcf_cmap_class
static const FT_Service_BDFRec	pcf_service_bdf
FT_CALLBACK_TABLE_DEF const FT_Driver_ClassRec	pcf_driver_class

Macro Definition Documentation

FT_COMPONENT [1/2]

#define FT_COMPONENT   pcfread

Definition at line 63 of file pcfdrivr.c.

FT_COMPONENT [2/2]

#define FT_COMPONENT   pcfdriver

Definition at line 63 of file pcfdrivr.c.

Typedef Documentation

PCF_CMap

typedef struct PCF_CMapRec_ * PCF_CMap

PCF_CMapRec

typedef struct PCF_CMapRec_ PCF_CMapRec

Function Documentation

FT_DEFINE_SERVICE_PROPERTIESREC()

FT_DEFINE_SERVICE_PROPERTIESREC	(	pcf_service_properties	,
		(FT_Properties_SetFunc)	pcf_property_set,
		(FT_Properties_GetFunc)	pcf_property_get
	)		const

pcf_cmap_char_index()

pcf_cmap_char_index	(	FT_CMap	pcfcmap,
		FT_UInt32	charcode
	)

Definition at line 105 of file pcfdrivr.c.

  {
    PCF_CMap   cmap = (PCF_CMap)pcfcmap;
    PCF_Enc    enc  = cmap->enc;
    FT_UShort  charcodeRow;
    FT_UShort  charcodeCol;
 
 
    if ( charcode > (FT_UInt32)( enc->lastRow  * 256 + enc->lastCol  ) ||
         charcode < (FT_UInt32)( enc->firstRow * 256 + enc->firstCol ) )
      return 0;
 
    charcodeRow = (FT_UShort)( charcode >> 8 );
    charcodeCol = (FT_UShort)( charcode & 0xFF );
 
    if ( charcodeCol < enc->firstCol ||
         charcodeCol > enc->lastCol  )
      return 0;
 
    return (FT_UInt)enc->offset[ ( charcodeRow - enc->firstRow ) *
                                 ( enc->lastCol - enc->firstCol + 1 ) +
                                   charcodeCol - enc->firstCol          ];
  }

pcf_cmap_char_next()

pcf_cmap_char_next	(	FT_CMap	pcfcmap,
		FT_UInt32 *	acharcode
	)

Definition at line 132 of file pcfdrivr.c.

  {
    PCF_CMap   cmap      = (PCF_CMap)pcfcmap;
    PCF_Enc    enc       = cmap->enc;
    FT_UInt32  charcode  = *acharcode;
    FT_UShort  charcodeRow;
    FT_UShort  charcodeCol;
    FT_Int     result = 0;
 
 
    while ( charcode < (FT_UInt32)( enc->lastRow * 256 + enc->lastCol ) )
    {
      charcode++;
 
      if ( charcode < (FT_UInt32)( enc->firstRow * 256 + enc->firstCol ) )
        charcode = (FT_UInt32)( enc->firstRow * 256 + enc->firstCol );
 
      charcodeRow = (FT_UShort)( charcode >> 8 );
      charcodeCol = (FT_UShort)( charcode & 0xFF );
 
      if ( charcodeCol < enc->firstCol )
        charcodeCol = enc->firstCol;
      else if ( charcodeCol > enc->lastCol )
      {
        charcodeRow++;
        charcodeCol = enc->firstCol;
      }
 
      charcode = (FT_UInt32)( charcodeRow * 256 + charcodeCol );
 
      result = (FT_UInt)enc->offset[ ( charcodeRow - enc->firstRow ) *
                                     ( enc->lastCol - enc->firstCol + 1 ) +
                                       charcodeCol - enc->firstCol          ];
      if ( result != 0xFFFFU )
        break;
    }
 
    *acharcode = charcode;
 
    return result;
  }

pcf_cmap_done()

pcf_cmap_done

(

FT_CMap

pcfcmap

)

Definition at line 95 of file pcfdrivr.c.

  {
    PCF_CMap  cmap = (PCF_CMap)pcfcmap;
 
 
    cmap->enc = NULL;
  }

pcf_cmap_init()

pcf_cmap_init	(	FT_CMap	pcfcmap,
		FT_Pointer	init_data
	)

Definition at line 79 of file pcfdrivr.c.

  {
    PCF_CMap  cmap = (PCF_CMap)pcfcmap;
    PCF_Face  face = (PCF_Face)FT_CMAP_FACE( pcfcmap );
 
    FT_UNUSED( init_data );
 
 
    cmap->enc = &face->enc;
 
    return FT_Err_Ok;
  }

pcf_driver_done()

pcf_driver_done

(

FT_Module

module

)

Definition at line 801 of file pcfdrivr.c.

  {
    FT_UNUSED( module );
  }

pcf_driver_init()

pcf_driver_init

(

FT_Module

module

)

Definition at line 785 of file pcfdrivr.c.

  {
#ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES
    PCF_Driver  driver = (PCF_Driver)module;
 
 
    driver->no_long_family_names = 0;
#else
    FT_UNUSED( module );
#endif
 
    return FT_Err_Ok;
  }

pcf_driver_requester()

pcf_driver_requester	(	FT_Module	module,
		const char *	name
	)

Definition at line 775 of file pcfdrivr.c.

  {
    FT_UNUSED( module );
 
    return ft_service_list_lookup( pcf_services, name );
  }

PCF_Face_Done()

PCF_Face_Done

(

FT_Face

pcfface

)

Definition at line 190 of file pcfdrivr.c.

  {
    PCF_Face   face = (PCF_Face)pcfface;
    FT_Memory  memory;
 
 
    if ( !face )
      return;
 
    memory = FT_FACE_MEMORY( face );
 
    FT_FREE( face->metrics );
    FT_FREE( face->enc.offset );
 
    /* free properties */
    if ( face->properties )
    {
      FT_Int  i;
 
 
      for ( i = 0; i < face->nprops; i++ )
      {
        PCF_Property  prop = &face->properties[i];
 
 
        if ( prop )
        {
          FT_FREE( prop->name );
          if ( prop->isString )
            FT_FREE( prop->value.atom );
        }
      }
 
      FT_FREE( face->properties );
    }
 
    FT_FREE( face->toc.tables );
    FT_FREE( pcfface->family_name );
    FT_FREE( pcfface->style_name );
    FT_FREE( pcfface->available_sizes );
    FT_FREE( face->charset_encoding );
    FT_FREE( face->charset_registry );
 
    /* close compressed stream if any */
    if ( pcfface->stream == &face->comp_stream )
    {
      FT_Stream_Close( &face->comp_stream );
      pcfface->stream = face->comp_source;
    }
  }

Referenced by PCF_Face_Init().

PCF_Face_Init()

PCF_Face_Init	(	FT_Stream	stream,
		FT_Face	pcfface,
		FT_Int	face_index,
		FT_Int	num_params,
		FT_Parameter *	params
	)

Definition at line 243 of file pcfdrivr.c.

  {
    PCF_Face  face  = (PCF_Face)pcfface;
    FT_Error  error;
 
    FT_UNUSED( num_params );
    FT_UNUSED( params );
 
 
    FT_TRACE2(( "PCF driver\n" ));
 
    error = pcf_load_font( stream, face, face_index );
    if ( error )
    {
      PCF_Face_Done( pcfface );
 
#if defined( FT_CONFIG_OPTION_USE_ZLIB )  || \
    defined( FT_CONFIG_OPTION_USE_LZW )   || \
    defined( FT_CONFIG_OPTION_USE_BZIP2 )
 
#ifdef FT_CONFIG_OPTION_USE_ZLIB
      {
        FT_Error  error2;
 
 
        /* this didn't work, try gzip support! */
        FT_TRACE2(( "  ... try gzip stream\n" ));
        error2 = FT_Stream_OpenGzip( &face->comp_stream, stream );
        if ( FT_ERR_EQ( error2, Unimplemented_Feature ) )
          goto Fail;
 
        error = error2;
      }
#endif /* FT_CONFIG_OPTION_USE_ZLIB */
 
#ifdef FT_CONFIG_OPTION_USE_LZW
      if ( error )
      {
        FT_Error  error3;
 
 
        /* this didn't work, try LZW support! */
        FT_TRACE2(( "  ... try LZW stream\n" ));
        error3 = FT_Stream_OpenLZW( &face->comp_stream, stream );
        if ( FT_ERR_EQ( error3, Unimplemented_Feature ) )
          goto Fail;
 
        error = error3;
      }
#endif /* FT_CONFIG_OPTION_USE_LZW */
 
#ifdef FT_CONFIG_OPTION_USE_BZIP2
      if ( error )
      {
        FT_Error  error4;
 
 
        /* this didn't work, try Bzip2 support! */
        FT_TRACE2(( "  ... try Bzip2 stream\n" ));
        error4 = FT_Stream_OpenBzip2( &face->comp_stream, stream );
        if ( FT_ERR_EQ( error4, Unimplemented_Feature ) )
          goto Fail;
 
        error = error4;
      }
#endif /* FT_CONFIG_OPTION_USE_BZIP2 */
 
      if ( error )
        goto Fail;
 
      face->comp_source = stream;
      pcfface->stream   = &face->comp_stream;
 
      stream = pcfface->stream;
 
      error = pcf_load_font( stream, face, face_index );
      if ( error )
        goto Fail;
 
#else /* !(FT_CONFIG_OPTION_USE_ZLIB ||
           FT_CONFIG_OPTION_USE_LZW ||
           FT_CONFIG_OPTION_USE_BZIP2) */
 
      goto Fail;
 
#endif
    }
 
    /* PCF cannot have multiple faces in a single font file.
     * XXX: A non-zero face_index is already an invalid argument, but
     *      Type1, Type42 drivers have a convention to return
     *      an invalid argument error when the font could be
     *      opened by the specified driver.
     */
    if ( face_index < 0 )
      goto Exit;
    else if ( face_index > 0 && ( face_index & 0xFFFF ) > 0 )
    {
      FT_ERROR(( "PCF_Face_Init: invalid face index\n" ));
      PCF_Face_Done( pcfface );
      return FT_THROW( Invalid_Argument );
    }
 
    /* set up charmap */
    {
      FT_String  *charset_registry = face->charset_registry;
      FT_String  *charset_encoding = face->charset_encoding;
      FT_Bool     unicode_charmap  = 0;
 
 
      if ( charset_registry && charset_encoding )
      {
        char*  s = charset_registry;
 
 
        /* Uh, oh, compare first letters manually to avoid dependency
           on locales. */
        if ( ( s[0] == 'i' || s[0] == 'I' ) &&
             ( s[1] == 's' || s[1] == 'S' ) &&
             ( s[2] == 'o' || s[2] == 'O' ) )
        {
          s += 3;
          if ( !ft_strcmp( s, "10646" )                      ||
               ( !ft_strcmp( s, "8859" ) &&
                 !ft_strcmp( face->charset_encoding, "1" ) ) )
            unicode_charmap = 1;
          /* another name for ASCII */
          else if ( !ft_strcmp( s, "646.1991" )                 &&
                    !ft_strcmp( face->charset_encoding, "IRV" ) )
            unicode_charmap = 1;
        }
      }
 
      {
        FT_CharMapRec  charmap;
 
 
        charmap.face        = FT_FACE( face );
        charmap.encoding    = FT_ENCODING_NONE;
        /* initial platform/encoding should indicate unset status? */
        charmap.platform_id = TT_PLATFORM_APPLE_UNICODE;
        charmap.encoding_id = TT_APPLE_ID_DEFAULT;
 
        if ( unicode_charmap )
        {
          charmap.encoding    = FT_ENCODING_UNICODE;
          charmap.platform_id = TT_PLATFORM_MICROSOFT;
          charmap.encoding_id = TT_MS_ID_UNICODE_CS;
        }
 
        error = FT_CMap_New( &pcf_cmap_class, NULL, &charmap, NULL );
      }
    }
 
  Exit:
    return error;
 
  Fail:
    FT_TRACE2(( "  not a PCF file\n" ));
    PCF_Face_Done( pcfface );
    error = FT_THROW( Unknown_File_Format );  /* error */
    goto Exit;
  }

pcf_get_bdf_property()

static FT_Error pcf_get_bdf_property ( PCF_Face  face, const char *  prop_name, BDF_PropertyRec *  aproperty  )

static

Definition at line 590 of file pcfdrivr.c.

  {
    PCF_Property  prop;
 
 
    prop = pcf_find_property( face, prop_name );
    if ( prop )
    {
      if ( prop->isString )
      {
        aproperty->type   = BDF_PROPERTY_TYPE_ATOM;
        aproperty->u.atom = prop->value.atom;
      }
      else
      {
        if ( prop->value.l > 0x7FFFFFFFL          ||
             prop->value.l < ( -1 - 0x7FFFFFFFL ) )
        {
          FT_TRACE1(( "pcf_get_bdf_property:" ));
          FT_TRACE1(( " too large integer 0x%x is truncated\n" ));
        }
 
        /*
         * The PCF driver loads all properties as signed integers.
         * This really doesn't seem to be a problem, because this is
         * sufficient for any meaningful values.
         */
        aproperty->type      = BDF_PROPERTY_TYPE_INTEGER;
        aproperty->u.integer = (FT_Int32)prop->value.l;
      }
 
      return FT_Err_Ok;
    }
 
    return FT_THROW( Invalid_Argument );
  }

pcf_get_charset_id()

static FT_Error pcf_get_charset_id ( PCF_Face  face, const char **  acharset_encoding, const char **  acharset_registry  )

static

Definition at line 631 of file pcfdrivr.c.

  {
    *acharset_encoding = face->charset_encoding;
    *acharset_registry = face->charset_registry;
 
    return FT_Err_Ok;
  }

PCF_Glyph_Load()

PCF_Glyph_Load	(	FT_GlyphSlot	slot,
		FT_Size	size,
		FT_UInt	glyph_index,
		FT_Int32	load_flags
	)

Definition at line 468 of file pcfdrivr.c.

  {
    PCF_Face    face   = (PCF_Face)FT_SIZE_FACE( size );
    FT_Stream   stream;
    FT_Error    error  = FT_Err_Ok;
    FT_Bitmap*  bitmap = &slot->bitmap;
    PCF_Metric  metric;
    FT_ULong    bytes;
 
 
    FT_TRACE1(( "PCF_Glyph_Load: glyph index %d\n", glyph_index ));
 
    if ( !face )
    {
      error = FT_THROW( Invalid_Face_Handle );
      goto Exit;
    }
 
    if ( glyph_index >= (FT_UInt)face->root.num_glyphs )
    {
      error = FT_THROW( Invalid_Argument );
      goto Exit;
    }
 
    stream = face->root.stream;
 
    metric = face->metrics + glyph_index;
 
    bitmap->rows       = (unsigned int)( metric->ascent +
                                         metric->descent );
    bitmap->width      = (unsigned int)( metric->rightSideBearing -
                                         metric->leftSideBearing );
    bitmap->num_grays  = 1;
    bitmap->pixel_mode = FT_PIXEL_MODE_MONO;
 
    switch ( PCF_GLYPH_PAD( face->bitmapsFormat ) )
    {
    case 1:
      bitmap->pitch = (int)( ( bitmap->width + 7 ) >> 3 );
      break;
 
    case 2:
      bitmap->pitch = (int)( ( ( bitmap->width + 15 ) >> 4 ) << 1 );
      break;
 
    case 4:
      bitmap->pitch = (int)( ( ( bitmap->width + 31 ) >> 5 ) << 2 );
      break;
 
    case 8:
      bitmap->pitch = (int)( ( ( bitmap->width + 63 ) >> 6 ) << 3 );
      break;
 
    default:
      return FT_THROW( Invalid_File_Format );
    }
 
    slot->format      = FT_GLYPH_FORMAT_BITMAP;
    slot->bitmap_left = metric->leftSideBearing;
    slot->bitmap_top  = metric->ascent;
 
    slot->metrics.horiAdvance  = (FT_Pos)( metric->characterWidth * 64 );
    slot->metrics.horiBearingX = (FT_Pos)( metric->leftSideBearing * 64 );
    slot->metrics.horiBearingY = (FT_Pos)( metric->ascent * 64 );
    slot->metrics.width        = (FT_Pos)( ( metric->rightSideBearing -
                                             metric->leftSideBearing ) * 64 );
    slot->metrics.height       = (FT_Pos)( bitmap->rows * 64 );
 
    ft_synthesize_vertical_metrics( &slot->metrics,
                                    ( face->accel.fontAscent +
                                      face->accel.fontDescent ) * 64 );
 
    if ( load_flags & FT_LOAD_BITMAP_METRICS_ONLY )
      goto Exit;
 
    /* XXX: to do: are there cases that need repadding the bitmap? */
    bytes = (FT_ULong)bitmap->pitch * bitmap->rows;
 
    error = ft_glyphslot_alloc_bitmap( slot, (FT_ULong)bytes );
    if ( error )
      goto Exit;
 
    if ( FT_STREAM_SEEK( metric->bits )          ||
         FT_STREAM_READ( bitmap->buffer, bytes ) )
      goto Exit;
 
    if ( PCF_BIT_ORDER( face->bitmapsFormat ) != MSBFirst )
      BitOrderInvert( bitmap->buffer, bytes );
 
    if ( ( PCF_BYTE_ORDER( face->bitmapsFormat ) !=
           PCF_BIT_ORDER( face->bitmapsFormat )  ) )
    {
      switch ( PCF_SCAN_UNIT( face->bitmapsFormat ) )
      {
      case 1:
        break;
 
      case 2:
        TwoByteSwap( bitmap->buffer, bytes );
        break;
 
      case 4:
        FourByteSwap( bitmap->buffer, bytes );
        break;
      }
    }
 
  Exit:
    return error;
  }

pcf_property_get()

static FT_Error pcf_property_get ( FT_Module  module, const char *  property_name, const void *  value  )

static

Definition at line 715 of file pcfdrivr.c.

  {
#ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES
 
    FT_Error    error  = FT_Err_Ok;
    PCF_Driver  driver = (PCF_Driver)module;
 
 
    if ( !ft_strcmp( property_name, "no-long-family-names" ) )
    {
      FT_Bool   no_long_family_names = driver->no_long_family_names;
      FT_Bool*  val                  = (FT_Bool*)value;
 
 
      *val = no_long_family_names;
 
      return error;
    }
 
#else /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */
 
    FT_UNUSED( module );
    FT_UNUSED( value );
#ifndef FT_DEBUG_LEVEL_TRACE
    FT_UNUSED( property_name );
#endif
 
#endif /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */
 
    FT_TRACE0(( "pcf_property_get: missing property `%s'\n",
                property_name ));
    return FT_THROW( Missing_Property );
  }

pcf_property_set()

static FT_Error pcf_property_set ( FT_Module  module, const char *  property_name, const void *  value, FT_Bool  value_is_string  )

static

Definition at line 654 of file pcfdrivr.c.

  {
#ifdef PCF_CONFIG_OPTION_LONG_FAMILY_NAMES
 
    FT_Error    error  = FT_Err_Ok;
    PCF_Driver  driver = (PCF_Driver)module;
 
#ifndef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
    FT_UNUSED( value_is_string );
#endif
 
 
    if ( !ft_strcmp( property_name, "no-long-family-names" ) )
    {
#ifdef FT_CONFIG_OPTION_ENVIRONMENT_PROPERTIES
      if ( value_is_string )
      {
        const char*  s   = (const char*)value;
        long         lfn = ft_strtol( s, NULL, 10 );
 
 
        if ( lfn == 0 )
          driver->no_long_family_names = 0;
        else if ( lfn == 1 )
          driver->no_long_family_names = 1;
        else
          return FT_THROW( Invalid_Argument );
      }
      else
#endif
      {
        FT_Bool*  no_long_family_names = (FT_Bool*)value;
 
 
        driver->no_long_family_names = *no_long_family_names;
      }
 
      return error;
    }
 
#else /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */
 
    FT_UNUSED( module );
    FT_UNUSED( value );
    FT_UNUSED( value_is_string );
#ifndef FT_DEBUG_LEVEL_TRACE
    FT_UNUSED( property_name );
#endif
 
#endif /* !PCF_CONFIG_OPTION_LONG_FAMILY_NAMES */
 
    FT_TRACE0(( "pcf_property_set: missing property `%s'\n",
                property_name ));
    return FT_THROW( Missing_Property );
  }

PCF_Size_Request()

PCF_Size_Request	(	FT_Size	size,
		FT_Size_Request	req
	)

Definition at line 430 of file pcfdrivr.c.

  {
    PCF_Face         face  = (PCF_Face)size->face;
    FT_Bitmap_Size*  bsize = size->face->available_sizes;
    FT_Error         error = FT_ERR( Invalid_Pixel_Size );
    FT_Long          height;
 
 
    height = FT_REQUEST_HEIGHT( req );
    height = ( height + 32 ) >> 6;
 
    switch ( req->type )
    {
    case FT_SIZE_REQUEST_TYPE_NOMINAL:
      if ( height == ( ( bsize->y_ppem + 32 ) >> 6 ) )
        error = FT_Err_Ok;
      break;
 
    case FT_SIZE_REQUEST_TYPE_REAL_DIM:
      if ( height == ( face->accel.fontAscent +
                       face->accel.fontDescent ) )
        error = FT_Err_Ok;
      break;
 
    default:
      error = FT_THROW( Unimplemented_Feature );
      break;
    }
 
    if ( error )
      return error;
    else
      return PCF_Size_Select( size, 0 );
  }

PCF_Size_Select()

PCF_Size_Select	(	FT_Size	size,
		FT_ULong	strike_index
	)

Definition at line 413 of file pcfdrivr.c.

  {
    PCF_Accel  accel = &( (PCF_Face)size->face )->accel;
 
 
    FT_Select_Metrics( size->face, strike_index );
 
    size->metrics.ascender    =  accel->fontAscent * 64;
    size->metrics.descender   = -accel->fontDescent * 64;
    size->metrics.max_advance =  accel->maxbounds.characterWidth * 64;
 
    return FT_Err_Ok;
  }

Referenced by PCF_Size_Request().

Variable Documentation

pcf_cmap_class

const FT_CMap_ClassRec pcf_cmap_class

static

Initial value:

=
  {
    sizeof ( PCF_CMapRec ),
    pcf_cmap_init,
    pcf_cmap_done,
    pcf_cmap_char_index,
    pcf_cmap_char_next,
 
    NULL, NULL, NULL, NULL, NULL
  }

Definition at line 177 of file pcfdrivr.c.

Referenced by PCF_Face_Init().

pcf_driver_class

FT_CALLBACK_TABLE_DEF const FT_Driver_ClassRec pcf_driver_class

Definition at line 808 of file pcfdrivr.c.

pcf_service_bdf

const FT_Service_BDFRec pcf_service_bdf

static

Initial value:

=
  {
    (FT_BDF_GetCharsetIdFunc)pcf_get_charset_id,     
    (FT_BDF_GetPropertyFunc) pcf_get_bdf_property    
  }

Definition at line 642 of file pcfdrivr.c.

Referenced by FT_DEFINE_SERVICE_PROPERTIESREC().