bdfdrivr.c

a very goog book

        else
          root->available_sizes->width = root->available_sizes->height;
      }
      if ( root->available_sizes->height == 0 )
          root->available_sizes->height = root->available_sizes->width;

      /* encoding table */
      {
        bdf_glyph_t*   cur = font->glyphs;
        unsigned long  n;


        if ( FT_NEW_ARRAY( face->en_table, font->glyphs_size ) )
          goto Exit;

        for ( n = 0; n < font->glyphs_size; n++ )
        {
          (face->en_table[n]).enc = cur[n].encoding;
          FT_TRACE4(( "idx %d, val 0x%lX\n", n, cur[n].encoding ));
          (face->en_table[n]).glyph = (FT_Short)n;
        }
      }

      /* charmaps */
      {
        bdf_property_t  *charset_registry = 0, *charset_encoding = 0;
        FT_Bool          unicode_charmap  = 0;


        charset_registry =
          bdf_get_font_property( font, (char *)"CHARSET_REGISTRY" );
        charset_encoding =
          bdf_get_font_property( font, (char *)"CHARSET_ENCODING" );
        if ( ( charset_registry != NULL ) && ( charset_encoding != NULL ) )
        {
          if ( ( charset_registry->format == BDF_ATOM ) &&
               ( charset_encoding->format == BDF_ATOM ) &&
               ( charset_registry->value.atom != NULL ) &&
               ( charset_encoding->value.atom != NULL ) )
          {
            if ( FT_NEW_ARRAY( face->charset_encoding,
                               strlen( charset_encoding->value.atom ) + 1 ) )
              goto Exit;
            if ( FT_NEW_ARRAY( face->charset_registry,
                               strlen( charset_registry->value.atom ) + 1 ) )
              goto Exit;
            ft_strcpy( face->charset_registry, charset_registry->value.atom );
            ft_strcpy( face->charset_encoding, charset_encoding->value.atom );
            if ( !ft_strcmp( face->charset_registry, "ISO10646" )     ||
                 ( !ft_strcmp( face->charset_registry, "ISO8859" ) &&
                   !ft_strcmp( face->charset_encoding, "1" )       )  )
              unicode_charmap = 1;

#ifdef FT_CONFIG_OPTION_USE_CMAPS

            {
              FT_CharMapRec  charmap;


              charmap.face        = FT_FACE( face );
              charmap.encoding    = ft_encoding_none;
              charmap.platform_id = 0;
              charmap.encoding_id = 0;

              if ( unicode_charmap )
              {
                charmap.encoding    = ft_encoding_unicode;
                charmap.platform_id = 3;
                charmap.encoding_id = 1;
              }

              error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );

              /* Select default charmap */
              if (root->num_charmaps)
                root->charmap = root->charmaps[0];
            }

#else /* !FT_CONFIG_OPTION_USE_CMAPS */

            face->charmap.encoding    = ft_encoding_none;
            face->charmap.platform_id = 0;
            face->charmap.encoding_id = 0;
            if ( unicode_charmap )
            {
              face->charmap.encoding    = ft_encoding_unicode;
              face->charmap.platform_id = 3;
              face->charmap.encoding_id = 1;
            }
            face->charmap.face        = root;
            face->charmap_handle      = &face->charmap;

            root->charmap = face->charmap_handle;

#endif /* !FT_CONFIG_OPTION_USE_CMAPS */

            goto Exit;
          }
        }

        /* otherwise assume Adobe standard encoding */

#ifdef FT_CONFIG_OPTION_USE_CMAPS

        {
          FT_CharMapRec  charmap;


          charmap.face        = FT_FACE( face );
          charmap.encoding    = ft_encoding_adobe_standard;
          charmap.platform_id = 7;
          charmap.encoding_id = 0;

          error = FT_CMap_New( &bdf_cmap_class, NULL, &charmap, NULL );

          /* Select default charmap */
          if (root->num_charmaps)
            root->charmap = root->charmaps[0];
        }

#else /* !FT_CONFIG_OPTION_USE_CMAPS */

        face->charmap.encoding    = ft_encoding_adobe_standard;
        face->charmap.platform_id = 7; /* taken from t1objs.c */
        face->charmap.encoding_id = 0;
        face->charmap.face        = root;
        face->charmap_handle      = &face->charmap;

        root->charmap = face->charmap_handle;

#endif /* !FT_CONFIG_OPTION_USE_CMAPS */

      }
    }

  Exit:
    return error;

  Fail:
    BDF_Face_Done( face );
    return BDF_Err_Unknown_File_Format;
  }


  static FT_Error
  BDF_Set_Pixel_Size( FT_Size  size )
  {
    BDF_Face  face = (BDF_Face)FT_SIZE_FACE( size );
    FT_Face   root = FT_FACE( face );


    FT_TRACE4(( "rec %d - pres %d\n",
                size->metrics.y_ppem, root->available_sizes->height ));

    if ( size->metrics.y_ppem == root->available_sizes->height )
    {
      size->metrics.ascender  = face->bdffont->bbx.ascent << 6;
      size->metrics.descender = face->bdffont->bbx.descent * ( -64 );
      size->metrics.height    = face->bdffont->bbx.height << 6;

      return BDF_Err_Ok;
    }
    else
      return BDF_Err_Invalid_Pixel_Size;
  }


  static FT_Error
  BDF_Glyph_Load( FT_GlyphSlot  slot,
                  FT_Size       size,
                  FT_UInt       glyph_index,
                  FT_Int        load_flags )
  {
    BDF_Face        face   = (BDF_Face)FT_SIZE_FACE( size );
    FT_Error        error  = BDF_Err_Ok;
    FT_Bitmap*      bitmap = &slot->bitmap;
    bdf_glyph_t     glyph;
    int             bpp    = face->bdffont->bpp;
    int             i, j, count;
    unsigned char   *p, *pp;

    FT_Memory       memory = face->bdffont->memory;

    FT_UNUSED( load_flags );


    if ( !face )
    {
      error = BDF_Err_Invalid_Argument;
      goto Exit;
    }

    if ( glyph_index > 0 )
      glyph_index--;

    /* slot, bitmap => freetype, glyph => bdflib */
    glyph = face->bdffont->glyphs[glyph_index];

    bitmap->rows  = glyph.bbx.height;
    bitmap->width = glyph.bbx.width;

    if ( bpp == 1 )
    {
      bitmap->pixel_mode = ft_pixel_mode_mono;
      bitmap->pitch      = glyph.bpr;

      if ( FT_NEW_ARRAY( bitmap->buffer, glyph.bytes ) )
        goto Exit;
      FT_MEM_COPY( bitmap->buffer, glyph.bitmap, glyph.bytes );
    }
    else
    {
      /* blow up pixmap to have 8 bits per pixel */
      bitmap->pixel_mode = ft_pixel_mode_grays;
      bitmap->pitch      = bitmap->width;

      if ( FT_NEW_ARRAY( bitmap->buffer, bitmap->rows * bitmap->pitch ) )
        goto Exit;

      switch ( bpp )
      {
      case 2:
        bitmap->num_grays = 4;

        count = 0;
        p     = glyph.bitmap;

        for ( i = 0; i < bitmap->rows; i++ )
        {
          pp = p;

          /* get the full bytes */
          for ( j = 0; j < ( bitmap->width >> 2 ); j++ )
          {
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xC0 ) >> 6 );
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x30 ) >> 4 );
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x0C ) >> 2 );
            bitmap->buffer[count++] = (FT_Byte)(   *pp & 0x03 );

            pp++;
          }

          /* get remaining pixels (if any) */
          switch ( bitmap->width & 3 )
          {
          case 3:
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xC0 ) >> 6 );
            /* fall through */
          case 2:
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x30 ) >> 4 );
            /* fall through */
          case 1:
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0x0C ) >> 2 );
            /* fall through */
          case 0:
            break;
          }

          p += glyph.bpr;
        }
        break;

      case 4:
        bitmap->num_grays = 16;

        count = 0;
        p     = glyph.bitmap;

        for ( i = 0; i < bitmap->rows; i++ )
        {
          pp = p;

          /* get the full bytes */
          for ( j = 0; j < ( bitmap->width >> 1 ); j++ )
          {
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xF0 ) >> 4 );
            bitmap->buffer[count++] = (FT_Byte)(   *pp & 0x0F );

            pp++;
          }

          /* get remaining pixel (if any) */
          switch ( bitmap->width & 1 )
          {
          case 1:
            bitmap->buffer[count++] = (FT_Byte)( ( *pp & 0xF0 ) >> 4 );
            /* fall through */
          case 0:
            break;
          }

          p += glyph.bpr;
        }
        break;

      case 8:
        bitmap->num_grays = 256;

        FT_MEM_COPY( bitmap->buffer, glyph.bitmap,
                     bitmap->rows * bitmap->pitch );
        break;
      }
    }

    slot->bitmap_left = 0;
    slot->bitmap_top  = glyph.bbx.ascent;

    /* FZ XXX: TODO: vertical metrics */
    slot->metrics.horiAdvance  = glyph.dwidth << 6;
    slot->metrics.horiBearingX = glyph.bbx.x_offset << 6;
    slot->metrics.horiBearingY = glyph.bbx.y_offset << 6;
    slot->metrics.width        = bitmap->width << 6;
    slot->metrics.height       = bitmap->rows << 6;

    slot->linearHoriAdvance = (FT_Fixed)glyph.dwidth << 16;
    slot->format            = ft_glyph_format_bitmap;
    slot->flags             = FT_GLYPH_OWN_BITMAP;

  Exit:
    return error;
  }


  FT_CALLBACK_TABLE_DEF
  const FT_Driver_ClassRec  bdf_driver_class =
  {
    {
      ft_module_font_driver,
      sizeof ( FT_DriverRec ),

      "bdf",
      0x10000L,
      0x20000L,

      0,

      (FT_Module_Constructor)0,
      (FT_Module_Destructor) 0,
      (FT_Module_Requester)  0
    },

    sizeof ( BDF_FaceRec ),
    sizeof ( FT_SizeRec ),
    sizeof ( FT_GlyphSlotRec ),

    (FT_Face_InitFunc)        BDF_Face_Init,
    (FT_Face_DoneFunc)        BDF_Face_Done,
    (FT_Size_InitFunc)        0,
    (FT_Size_DoneFunc)        0,
    (FT_Slot_InitFunc)        0,
    (FT_Slot_DoneFunc)        0,

    (FT_Size_ResetPointsFunc) BDF_Set_Pixel_Size,
    (FT_Size_ResetPixelsFunc) BDF_Set_Pixel_Size,

    (FT_Slot_LoadFunc)        BDF_Glyph_Load,

#ifdef FT_CONFIG_OPTION_USE_CMAPS
    (FT_CharMap_CharIndexFunc)0,
#else
    (FT_CharMap_CharIndexFunc)BDF_Get_Char_Index,
#endif

    (FT_Face_GetKerningFunc)  0,
    (FT_Face_AttachFunc)      0,
    (FT_Face_GetAdvancesFunc) 0,

#ifdef FT_CONFIG_OPTION_USE_CMAPS
    (FT_CharMap_CharNextFunc) 0
#else
    (FT_CharMap_CharNextFunc) 0 /* BDF_Get_Next_Char */
#endif
  };


/* END */