rgraves
/
freetype2
forked from minhngoc25a/freetype2
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

* src/type42/t42drivr.c, src/type42/t42drivr.h, src/type42/t42parse.c, 

src/type42/t42parse.h, src/type42/t42objs.h, src/type42/t42objs.c,
          src/type42/type42.c:

            updated the Type42 driver by splitting it into several files since
            it makes the code easier to read and maintain. Also fixed the bug
            that prevented the correct display of fonts with "ftview"
This commit is contained in:
David Turner 2002-06-07 07:23:06 +00:00
parent 5a1fae15a9
commit 9f95babf3e
11 changed files with 2250 additions and 1962 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ChangeLog
View File

@ -1,3 +1,13 @@
2002-06-07 David Turner <david@freetype.org>
* src/type42/t42drivr.c, src/type42/t42drivr.h, src/type42/t42parse.c,
src/type42/t42parse.h, src/type42/t42objs.h, src/type42/t42objs.c,
src/type42/type42.c:
updated the Type42 driver by splitting it into several files since
it makes the code easier to read and maintain. Also fixed the bug
that prevented the correct display of fonts with "ftview"
2002-06-03 Werner Lemberg <wl@gnu.org>
Add 8bpp support.

4
src/type42/Jamfile
View File

@ -10,11 +10,11 @@ SubDirHdrs [ FT2_SubDir src type42 ] ;
if $(FT2_MULTI)
{
_sources = t42drivr ;
_sources = t42objs t42parse t42drivr ;
}
else
{
_sources = t42drivr ;
_sources = type42 ;
}
Library $(FT2_LIB) : $(_sources).c ;

2
src/type42/descrip.mms
View File

@ -15,7 +15,7 @@
CFLAGS=$(COMP_FLAGS)$(DEBUG)/include=([--.include],[--.src.type42])
OBJS=t42drivr.obj
OBJS=type42.obj
all : $(OBJS)
library [--.lib]freetype.olb $(OBJS)

8
src/type42/rules.mk
View File

@ -26,11 +26,13 @@ T42_COMPILE := $(FT_COMPILE) $I$(T42_DIR)
# Type42 driver source
#
T42_DRV_SRC := $(T42_DIR_)t42drivr.c
T42_DRV_SRC := $(T42_DIR_)t42objs.c \
$(T42_DIR_)t42parse.c \
$(T42_DIR_)t42drivr.c
# Type42 driver headers
#
T42_DRV_H :=
T42_DRV_H := $(T42_DRV_SRC:%.c=%.h)
# Type42 driver object(s)
@ -39,7 +41,7 @@ T42_DRV_H :=
# T42_DRV_OBJ_S is used during `single' builds
#
T42_DRV_OBJ_M := $(T42_DRV_SRC:$(T42_DIR_)%.c=$(OBJ_)%.$O)
T42_DRV_OBJ_S := $(OBJ_)t42drivr.$O
T42_DRV_OBJ_S := $(OBJ_)type42.$O
# Type42 driver source file for single build
#

1973
src/type42/t42drivr.c
View File

File diff suppressed because it is too large Load Diff

38
src/type42/t42drivr.h Normal file
View File

@ -0,0 +1,38 @@
/***************************************************************************/
/* */
/* t42drivr.h */
/* */
/* High-level Type 42 driver interface (specification). */
/* */
/* Copyright 1996-2001, 2002 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#ifndef __T42DRIVER_H__
#define __T42DRIVER_H__
#include <ft2build.h>
#include FT_INTERNAL_DRIVER_H
FT_BEGIN_HEADER
FT_EXPORT_VAR( const FT_Driver_ClassRec ) t42_driver_class;
FT_END_HEADER
#endif /* __T42DRIVER_H__ */
/* END */

881
src/type42/t42objs.c Normal file
View File

@ -0,0 +1,881 @@
#include "t42objs.h"
#include "t42parse.h"
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_LIST_H
#undef FT_COMPONENT
#define FT_COMPONENT trace_t42
static FT_Error
T42_Open_Face( T42_Face face )
{
T42_LoaderRec loader;
T42_Parser parser;
T1_Font type1 = &face->type1;
FT_Memory memory = face->root.memory;
FT_Error error;
PSAux_Service psaux = (PSAux_Service)face->psaux;
t42_loader_init( &loader, face );
parser = &loader.parser;
if ( FT_ALLOC( face->ttf_data, 12 ) )
goto Exit;
error = t42_parser_init( parser,
face->root.stream,
memory,
psaux);
if ( error )
goto Exit;
error = t42_parse_dict( face, &loader, parser->base_dict, parser->base_len );
if ( type1->font_type != 42 )
{
error = FT_Err_Unknown_File_Format;
goto Exit;
}
/* now, propagate the charstrings and glyphnames tables */
/* to the Type1 data */
type1->num_glyphs = loader.num_glyphs;
if ( !loader.charstrings.init ) {
FT_ERROR(( "T42_Open_Face: no charstrings array in face!\n" ));
error = FT_Err_Invalid_File_Format;
}
loader.charstrings.init = 0;
type1->charstrings_block = loader.charstrings.block;
type1->charstrings = loader.charstrings.elements;
type1->charstrings_len = loader.charstrings.lengths;
/* we copy the glyph names `block' and `elements' fields; */
/* the `lengths' field must be released later */
type1->glyph_names_block = loader.glyph_names.block;
type1->glyph_names = (FT_String**)loader.glyph_names.elements;
loader.glyph_names.block = 0;
loader.glyph_names.elements = 0;
/* we must now build type1.encoding when we have a custom array */
if ( type1->encoding_type == T1_ENCODING_TYPE_ARRAY )
{
FT_Int charcode, idx, min_char, max_char;
FT_Byte* char_name;
FT_Byte* glyph_name;
/* OK, we do the following: for each element in the encoding */
/* table, look up the index of the glyph having the same name */
/* as defined in the CharStrings array. */
/* The index is then stored in type1.encoding.char_index, and */
/* the name in type1.encoding.char_name */
min_char = +32000;
max_char = -32000;
charcode = 0;
for ( ; charcode < loader.encoding_table.max_elems; charcode++ )
{
type1->encoding.char_index[charcode] = 0;
type1->encoding.char_name [charcode] = (char *)".notdef";
char_name = loader.encoding_table.elements[charcode];
if ( char_name )
for ( idx = 0; idx < type1->num_glyphs; idx++ )
{
glyph_name = (FT_Byte*)type1->glyph_names[idx];
if ( ft_strcmp( (const char*)char_name,
(const char*)glyph_name ) == 0 )
{
type1->encoding.char_index[charcode] = (FT_UShort)idx;
type1->encoding.char_name [charcode] = (char*)glyph_name;
/* Change min/max encoded char only if glyph name is */
/* not /.notdef */
if ( ft_strcmp( (const char*)".notdef",
(const char*)glyph_name ) != 0 )
{
if ( charcode < min_char ) min_char = charcode;
if ( charcode > max_char ) max_char = charcode;
}
break;
}
}
}
type1->encoding.code_first = min_char;
type1->encoding.code_last = max_char;
type1->encoding.num_chars = loader.num_chars;
}
Exit:
t42_loader_done( &loader );
return error;
}
/***************** Driver Functions *************/
FT_LOCAL_DEF( FT_Error )
T42_Face_Init( FT_Stream stream,
T42_Face face,
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params)
{
FT_Error error;
PSNames_Service psnames;
PSAux_Service psaux;
FT_Face root = (FT_Face)&face->root;
FT_UNUSED( num_params );
FT_UNUSED( params );
FT_UNUSED( face_index );
FT_UNUSED( stream );
face->ttf_face = NULL;
face->root.num_faces = 1;
face->psnames = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
"psnames" );
psnames = (PSNames_Service)face->psnames;
face->psaux = FT_Get_Module_Interface( FT_FACE_LIBRARY( face ),
"psaux" );
psaux = (PSAux_Service)face->psaux;
/* open the tokenizer, this will also check the font format */
error = T42_Open_Face( face );
if ( error )
goto Exit;
/* if we just wanted to check the format, leave successfully now */
if ( face_index < 0 )
goto Exit;
/* check the face index */
if ( face_index != 0 )
{
FT_ERROR(( "T42_Face_Init: invalid face index\n" ));
error = FT_Err_Invalid_Argument;
goto Exit;
}
/* Now, load the font program into the face object */
/* Init the face object fields */
/* Now set up root face fields */
root->num_glyphs = face->type1.num_glyphs;
root->num_charmaps = 0;
root->face_index = face_index;
root->face_flags = FT_FACE_FLAG_SCALABLE;
root->face_flags |= FT_FACE_FLAG_HORIZONTAL;
root->face_flags |= FT_FACE_FLAG_GLYPH_NAMES;
if ( face->type1.font_info.is_fixed_pitch )
root->face_flags |= FT_FACE_FLAG_FIXED_WIDTH;
/* XXX: TODO -- add kerning with .afm support */
/* get style name -- be careful, some broken fonts only */
/* have a `/FontName' dictionary entry! */
root->family_name = face->type1.font_info.family_name;
if ( root->family_name )
{
char* full = face->type1.font_info.full_name;
char* family = root->family_name;
if ( full )
{
while ( *family && *full == *family )
{
family++;
full++;
}
root->style_name = ( *full == ' ' ? full + 1
: (char *)"Regular" );
}
else
root->style_name = (char *)"Regular";
}
else
{
/* do we have a `/FontName'? */
if ( face->type1.font_name )
{
root->family_name = face->type1.font_name;
root->style_name = (char *)"Regular";
}
}
/* no embedded bitmap support */
root->num_fixed_sizes = 0;
root->available_sizes = 0;
/* Load the TTF font embedded in the T42 font */
error = FT_New_Memory_Face( FT_FACE_LIBRARY( face ),
face->ttf_data,
face->ttf_size,
0,
&face->ttf_face );
if ( error )
goto Exit;
/* Ignore info in FontInfo dictionary and use the info from the */
/* loaded TTF font. The PostScript interpreter also ignores it. */
root->bbox = face->ttf_face->bbox;
root->units_per_EM = face->ttf_face->units_per_EM;
root->ascender = face->ttf_face->ascender;
root->descender = face->ttf_face->descender;
root->height = face->ttf_face->height;
root->max_advance_width = face->ttf_face->max_advance_width;
root->max_advance_height = face->ttf_face->max_advance_height;
root->underline_position = face->type1.font_info.underline_position;
root->underline_thickness = face->type1.font_info.underline_thickness;
root->internal->max_points = 0;
root->internal->max_contours = 0;
/* compute style flags */
root->style_flags = 0;
if ( face->type1.font_info.italic_angle )
root->style_flags |= FT_STYLE_FLAG_ITALIC;
if ( face->ttf_face->style_flags & FT_STYLE_FLAG_BOLD )
root->style_flags |= FT_STYLE_FLAG_BOLD;
if ( face->ttf_face->face_flags & FT_FACE_FLAG_VERTICAL )
root->face_flags |= FT_FACE_FLAG_VERTICAL;
#ifdef FT_CONFIG_OPTION_USE_CMAPS
{
if ( psnames && psaux )
{
FT_CharMapRec charmap;
T1_CMap_Classes cmap_classes = psaux->t1_cmap_classes;
FT_CMap_Class clazz;
charmap.face = root;
/* first of all, try to synthetize a Unicode charmap */
charmap.platform_id = 3;
charmap.encoding_id = 1;
charmap.encoding = ft_encoding_unicode;
FT_CMap_New( cmap_classes->unicode, NULL, &charmap, NULL );
/* now, generate an Adobe Standard encoding when appropriate */
charmap.platform_id = 7;
clazz = NULL;
switch ( face->type1.encoding_type )
{
case T1_ENCODING_TYPE_STANDARD:
charmap.encoding = ft_encoding_adobe_standard;
charmap.encoding_id = 0;
clazz = cmap_classes->standard;
break;
case T1_ENCODING_TYPE_EXPERT:
charmap.encoding = ft_encoding_adobe_expert;
charmap.encoding_id = 1;
clazz = cmap_classes->expert;
break;
case T1_ENCODING_TYPE_ARRAY:
charmap.encoding = ft_encoding_adobe_custom;
charmap.encoding_id = 2;
clazz = cmap_classes->custom;
break;
case T1_ENCODING_TYPE_ISOLATIN1:
charmap.encoding = ft_encoding_latin_1;
charmap.encoding_id = 3;
clazz = cmap_classes->unicode;
break;
default:
;
}
if ( clazz )
FT_CMap_New( clazz, NULL, &charmap, NULL );
/* Select default charmap */
if (root->num_charmaps)
root->charmap = root->charmaps[0];
}
}
#else /* !FT_CONFIG_OPTION_USE_CMAPS */
/* charmap support -- synthetize unicode charmap if possible */
{
FT_CharMap charmap = face->charmaprecs;
/* synthesize a Unicode charmap if there is support in the `PSNames' */
/* module */
if ( psnames && psnames->unicode_value )
{
error = psnames->build_unicodes( root->memory,
face->type1.num_glyphs,
(const char**)face->type1.glyph_names,
&face->unicode_map );
if ( !error )
{
root->charmap = charmap;
charmap->face = (FT_Face)face;
charmap->encoding = ft_encoding_unicode;
charmap->platform_id = 3;
charmap->encoding_id = 1;
charmap++;
}
/* XXX: Is the following code correct? It is used in t1objs.c */
/* simply clear the error in case of failure (which really) */
/* means that out of memory or no unicode glyph names */
error = FT_Err_Ok;
}
/* now, support either the standard, expert, or custom encoding */
charmap->face = (FT_Face)face;
charmap->platform_id = 7; /* a new platform id for Adobe fonts? */
switch ( face->type1.encoding_type )
{
case T1_ENCODING_TYPE_STANDARD:
charmap->encoding = ft_encoding_adobe_standard;
charmap->encoding_id = 0;
break;
case T1_ENCODING_TYPE_EXPERT:
charmap->encoding = ft_encoding_adobe_expert;
charmap->encoding_id = 1;
break;
case T1_ENCODING_TYPE_ARRAY:
charmap->encoding = ft_encoding_adobe_custom;
charmap->encoding_id = 2;
break;
case T1_ENCODING_TYPE_ISOLATIN1:
charmap->encoding = ft_encoding_latin_1;
charmap->encoding_id = 3;
break;
default:
FT_ERROR(( "T42_Face_Init: invalid encoding\n" ));
error = FT_Err_Invalid_File_Format;
goto Exit;
}
root->charmaps = face->charmaps;
root->num_charmaps = charmap - face->charmaprecs + 1;
face->charmaps[0] = &face->charmaprecs[0];
face->charmaps[1] = &face->charmaprecs[1];
}
#endif /* !FT_CONFIG_OPTION_USE_CMAPS */
Exit:
return error;
}
FT_LOCAL_DEF( void )
T42_Face_Done( T42_Face face )
{
T1_Font type1;
PS_FontInfo info;
FT_Memory memory;
if ( face )
{
type1 = &face->type1;
info = &type1->font_info;
memory = face->root.memory;
/* delete internal ttf face prior to freeing face->ttf_data */
if ( face->ttf_face )
FT_Done_Face( face->ttf_face );
/* release font info strings */
FT_FREE( info->version );
FT_FREE( info->notice );
FT_FREE( info->full_name );
FT_FREE( info->family_name );
FT_FREE( info->weight );
/* release top dictionary */
FT_FREE( type1->charstrings_len );
FT_FREE( type1->charstrings );
FT_FREE( type1->glyph_names );
FT_FREE( type1->charstrings_block );
FT_FREE( type1->glyph_names_block );
FT_FREE( type1->encoding.char_index );
FT_FREE( type1->encoding.char_name );
FT_FREE( type1->font_name );
FT_FREE( face->ttf_data );
#if 0
/* release afm data if present */
if ( face->afm_data )
T1_Done_AFM( memory, (T1_AFM*)face->afm_data );
#endif
/* release unicode map, if any */
FT_FREE( face->unicode_map.maps );
face->unicode_map.num_maps = 0;
face->root.family_name = 0;
face->root.style_name = 0;
}
}
/*************************************************************************/
/* */
/* <Function> */
/* T42_Driver_Init */
/* */
/* <Description> */
/* Initializes a given Type 42 driver object. */
/* */
/* <Input> */
/* driver :: A handle to the target driver object. */
/* */
/* <Return> */
/* FreeType error code. 0 means success. */
/* */
FT_LOCAL_DEF( FT_Error )
T42_Driver_Init( T42_Driver driver )
{
FT_Module ttmodule;
ttmodule = FT_Get_Module( FT_MODULE(driver)->library, "truetype" );
driver->ttclazz = (FT_Driver_Class)ttmodule->clazz;
return FT_Err_Ok;
}
FT_LOCAL_DEF( void )
T42_Driver_Done( T42_Driver driver )
{
FT_UNUSED( driver );
}
FT_LOCAL_DEF( FT_UInt )
T42_CMap_CharIndex( FT_CharMap charmap,
FT_Long charcode )
{
T42_Face face;
FT_UInt result = 0;
PSNames_Service psnames;
face = (T42_Face)charmap->face;
psnames = (PSNames_Service)face->psnames;
if (!psnames )
goto Exit;
switch ( charmap->encoding )
{
/*******************************************************************/
/* */
/* Unicode encoding support */
/* */
case ft_encoding_unicode:
/* if this charmap is used, we ignore the encoding of the font and */
/* use the `PSNames' module to synthetize the Unicode charmap */
result = psnames->lookup_unicode( &face->unicode_map,
(FT_ULong)charcode );
/* the function returns 0xFFFF if the Unicode charcode has */
/* no corresponding glyph */
if ( result == 0xFFFFU )
result = 0;
/* The result returned is the index (position)in the CharStrings */
/* array. This must be used now to get the value associated to */
/* that glyph_name, which is the real index within the truetype */
/* structure. */
result = ft_atoi( (const char*)face->type1.charstrings[result] );
goto Exit;
/*******************************************************************/
/* */
/* ISOLatin1 encoding support */
/* */
case ft_encoding_latin_1:
/* ISOLatin1 is the first page of Unicode */
if ( charcode < 256 && psnames->unicode_value )
{
result = psnames->lookup_unicode( &face->unicode_map,
(FT_ULong)charcode );
/* the function returns 0xFFFF if the Unicode charcode has */
/* no corresponding glyph */
if ( result == 0xFFFFU )
result = 0;
}
goto Exit;
/*******************************************************************/
/* */
/* Custom Type 1 encoding */
/* */
case ft_encoding_adobe_custom:
{
T1_Encoding encoding = &face->type1.encoding;
if ( charcode >= encoding->code_first &&
charcode <= encoding->code_last )
{
FT_UInt idx = encoding->char_index[charcode];
result = ft_atoi( (const char *)face->type1.charstrings[idx] );
}
goto Exit;
}
/*******************************************************************/
/* */
/* Adobe Standard & Expert encoding support */
/* */
default:
if ( charcode < 256 )
{
FT_UInt code;
FT_Int n;
const char* glyph_name;
code = psnames->adobe_std_encoding[charcode];
if ( charmap->encoding == ft_encoding_adobe_expert )
code = psnames->adobe_expert_encoding[charcode];
glyph_name = psnames->adobe_std_strings( code );
if ( !glyph_name )
break;
for ( n = 0; n < face->type1.num_glyphs; n++ )
{
const char* gname = face->type1.glyph_names[n];
if ( gname && ( ft_strcmp( gname, glyph_name ) == 0 ) )
{
result = ft_atoi( (const char *)face->type1.charstrings[n] );
break;
}
}
}
}
Exit:
return result;
}
FT_LOCAL_DEF( FT_Error )
T42_Size_Init( T42_Size size )
{
FT_Face face = size->root.face;
T42_Face t42face = (T42_Face)face;
FT_Size ttsize;
FT_Error error = FT_Err_Ok;
error = FT_New_Size( t42face->ttf_face, &ttsize );
size->ttsize = ttsize;
return error;
}
FT_LOCAL_DEF( void )
T42_Size_Done( T42_Size size )
{
FT_Face face = size->root.face;
T42_Face t42face = (T42_Face)face;
FT_ListNode node;
node = FT_List_Find( &t42face->ttf_face->sizes_list, size->ttsize );
if ( node )
{
FT_Done_Size( size->ttsize );
size->ttsize = NULL;
}
}
FT_LOCAL_DEF( FT_Error )
T42_GlyphSlot_Init( T42_GlyphSlot slot )
{
FT_Face face = slot->root.face;
T42_Face t42face = (T42_Face)face;
FT_GlyphSlot ttslot;
FT_Error error = FT_Err_Ok;
if ( face->glyph == NULL )
{
/* First glyph slot for this face */
slot->ttslot = t42face->ttf_face->glyph;
}
else
{
error = FT_New_GlyphSlot( t42face->ttf_face, &ttslot );
slot->ttslot = ttslot;
}
return error;
}
FT_LOCAL_DEF( void )
T42_GlyphSlot_Done( T42_GlyphSlot slot )
{
FT_Face face = slot->root.face;
T42_Face t42face = (T42_Face)face;
FT_GlyphSlot cur = t42face->ttf_face->glyph;
while ( cur )
{
if ( cur == slot->ttslot )
{
FT_Done_GlyphSlot( slot->ttslot );
break;
}
cur = cur->next;
}
}
FT_LOCAL_DEF( FT_Error )
T42_Size_SetChars( T42_Size size,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution )
{
FT_Face face = size->root.face;
T42_Face t42face = (T42_Face)face;
return FT_Set_Char_Size( t42face->ttf_face,
char_width,
char_height,
horz_resolution,
vert_resolution );
}
FT_LOCAL_DEF( FT_Error )
T42_Size_SetPixels( T42_Size size,
FT_UInt pixel_width,
FT_UInt pixel_height )
{
FT_Face face = size->root.face;
T42_Face t42face = (T42_Face)face;
return FT_Set_Pixel_Sizes( t42face->ttf_face,
pixel_width,
pixel_height );
}
static void
ft_glyphslot_clear( FT_GlyphSlot slot )
{
/* free bitmap if needed */
if ( slot->flags & FT_GLYPH_OWN_BITMAP )
{
FT_Memory memory = FT_FACE_MEMORY( slot->face );
FT_FREE( slot->bitmap.buffer );
slot->flags &= ~FT_GLYPH_OWN_BITMAP;
}
/* clear all public fields in the glyph slot */
FT_MEM_SET( &slot->metrics, 0, sizeof ( slot->metrics ) );
FT_MEM_SET( &slot->outline, 0, sizeof ( slot->outline ) );
FT_MEM_SET( &slot->bitmap, 0, sizeof ( slot->bitmap ) );
slot->bitmap_left = 0;
slot->bitmap_top = 0;
slot->num_subglyphs = 0;
slot->subglyphs = 0;
slot->control_data = 0;
slot->control_len = 0;
slot->other = 0;
slot->format = ft_glyph_format_none;
slot->linearHoriAdvance = 0;
slot->linearVertAdvance = 0;
}
FT_LOCAL_DEF( FT_Error )
T42_GlyphSlot_Load( FT_GlyphSlot glyph,
FT_Size size,
FT_Int glyph_index,
FT_Int load_flags )
{
FT_Error error;
T42_GlyphSlot t42slot = (T42_GlyphSlot)glyph;
T42_Size t42size = (T42_Size)size;
FT_Driver_Class ttclazz = ((T42_Driver)glyph->face->driver)->ttclazz;
ft_glyphslot_clear( t42slot->ttslot );
error = ttclazz->load_glyph( t42slot->ttslot,
t42size->ttsize,
glyph_index,
load_flags | FT_LOAD_NO_BITMAP );
if ( !error )
{
glyph->metrics = t42slot->ttslot->metrics;
glyph->linearHoriAdvance = t42slot->ttslot->linearHoriAdvance;
glyph->linearVertAdvance = t42slot->ttslot->linearVertAdvance;
glyph->format = t42slot->ttslot->format;
glyph->outline = t42slot->ttslot->outline;
glyph->bitmap = t42slot->ttslot->bitmap;
glyph->bitmap_left = t42slot->ttslot->bitmap_left;
glyph->bitmap_top = t42slot->ttslot->bitmap_top;
}
return error;
}
FT_LOCAL_DEF( FT_Long )
T42_CMap_CharNext( FT_CharMap charmap,
FT_Long charcode )
{
T42_Face face;
PSNames_Service psnames;
face = (T42_Face)charmap->face;
psnames = (PSNames_Service)face->psnames;
if ( psnames )
switch ( charmap->encoding )
{
/*******************************************************************/
/* */
/* Unicode encoding support */
/* */
case ft_encoding_unicode:
/* use the `PSNames' module to synthetize the Unicode charmap */
return psnames->next_unicode( &face->unicode_map,
(FT_ULong)charcode );
/*******************************************************************/
/* */
/* ISOLatin1 encoding support */
/* */
case ft_encoding_latin_1:
{
FT_ULong code;
/* use the `PSNames' module to synthetize the Unicode charmap */
code = psnames->next_unicode( &face->unicode_map,
(FT_ULong)charcode );
if ( code < 256 )
return code;
break;
}
/*******************************************************************/
/* */
/* Custom Type 1 encoding */
/* */
case ft_encoding_adobe_custom:
{
T1_Encoding encoding = &face->type1.encoding;
charcode++;
if ( charcode < encoding->code_first )
charcode = encoding->code_first;
while ( charcode <= encoding->code_last ) {
if ( encoding->char_index[charcode] )
return charcode;
charcode++;
}
}
/*******************************************************************/
/* */
/* Adobe Standard & Expert encoding support */
/* */
default:
while ( ++charcode < 256 )
{
FT_UInt code;
FT_Int n;
const char* glyph_name;
code = psnames->adobe_std_encoding[charcode];
if ( charmap->encoding == ft_encoding_adobe_expert )
code = psnames->adobe_expert_encoding[charcode];
glyph_name = psnames->adobe_std_strings( code );
if ( !glyph_name )
continue;
for ( n = 0; n < face->type1.num_glyphs; n++ )
{
const char* gname = face->type1.glyph_names[n];
if ( gname && gname[0] == glyph_name[0] &&
ft_strcmp( gname, glyph_name ) == 0 )
return charcode;
}
}
}
return 0;
}

130
src/type42/t42objs.h Normal file
View File

@ -0,0 +1,130 @@
#ifndef __TYPE42_OBJS_H__
#define __TYPE42_OBJS_H__
#include <ft2build.h>
#include FT_FREETYPE_H
#include FT_TYPE1_TABLES_H
#include FT_INTERNAL_TYPE1_TYPES_H
#include FT_INTERNAL_OBJECTS_H
#include FT_INTERNAL_DRIVER_H
#include FT_INTERNAL_POSTSCRIPT_NAMES_H
#include FT_INTERNAL_POSTSCRIPT_HINTS_H
FT_BEGIN_HEADER
/* Type42 face */
typedef struct T42_FaceRec_
{
FT_FaceRec root;
T1_FontRec type1;
const void* psnames;
const void* psaux;
const void* afm_data;
FT_CharMapRec charmaprecs[2];
FT_CharMap charmaps[2];
PS_Unicodes unicode_map;
FT_Byte* ttf_data;
FT_ULong ttf_size;
FT_Face ttf_face;
} T42_FaceRec, *T42_Face;
/* Type42 size */
typedef struct T42_SizeRec_
{
FT_SizeRec root;
FT_Size ttsize;
} T42_SizeRec, *T42_Size;
/* Type42 slot */
typedef struct T42_GlyphSlotRec_
{
FT_GlyphSlotRec root;
FT_GlyphSlot ttslot;
} T42_GlyphSlotRec, *T42_GlyphSlot;
/* Type 42 driver */
typedef struct T42_DriverRec_
{
FT_DriverRec root;
FT_Driver_Class ttclazz;
void* extension_component;
} T42_DriverRec, *T42_Driver;
/* */
FT_LOCAL( FT_Error )
T42_Face_Init( FT_Stream stream,
T42_Face face,
FT_Int face_index,
FT_Int num_params,
FT_Parameter* params );
FT_LOCAL( void )
T42_Face_Done( T42_Face face );
FT_LOCAL( FT_Error )
T42_Size_Init( T42_Size size );
FT_LOCAL( FT_Error )
T42_Size_SetChars( T42_Size size,
FT_F26Dot6 char_width,
FT_F26Dot6 char_height,
FT_UInt horz_resolution,
FT_UInt vert_resolution );
FT_LOCAL( FT_Error )
T42_Size_SetPixels( T42_Size size,
FT_UInt pixel_width,
FT_UInt pixel_height );
FT_LOCAL( void )
T42_Size_Done( T42_Size size );
FT_LOCAL( FT_Error )
T42_GlyphSlot_Init( T42_GlyphSlot slot );
FT_LOCAL( FT_Error )
T42_GlyphSlot_Load( FT_GlyphSlot glyph,
FT_Size size,
FT_Int glyph_index,
FT_Int load_flags );
FT_LOCAL( void )
T42_GlyphSlot_Done( T42_GlyphSlot slot );
FT_LOCAL( FT_UInt )
T42_CMap_CharIndex( FT_CharMap charmap,
FT_Long charcode );
FT_LOCAL( FT_Long )
T42_CMap_CharNext( FT_CharMap charmap,
FT_Long charcode );
FT_LOCAL( FT_Error )
T42_Driver_Init( T42_Driver driver );
FT_LOCAL( void )
T42_Driver_Done( T42_Driver driver );
/* */
FT_END_HEADER
#endif /* __TYPE42_OBJS_H__ */

1083
src/type42/t42parse.c Normal file
View File

File diff suppressed because it is too large Load Diff

66
src/type42/t42parse.h Normal file
View File

@ -0,0 +1,66 @@
#ifndef __TYPE42_PARSE_H__
#define __TYPE42_PARSE_H__
#include "t42objs.h"
#include FT_INTERNAL_POSTSCRIPT_AUX_H
FT_BEGIN_HEADER
typedef struct T42_ParserRec_
{
PS_ParserRec root;
FT_Stream stream;
FT_Byte* base_dict;
FT_Int base_len;
FT_Byte in_memory;
} T42_ParserRec, *T42_Parser;
typedef struct T42_Loader_
{
T42_ParserRec parser; /* parser used to read the stream */
FT_Int num_chars; /* number of characters in encoding */
PS_TableRec encoding_table; /* PS_Table used to store the */
/* encoding character names */
FT_Int num_glyphs;
PS_TableRec glyph_names;
PS_TableRec charstrings;
} T42_LoaderRec, *T42_Loader;
FT_LOCAL( FT_Error )
t42_parser_init( T42_Parser parser,
FT_Stream stream,
FT_Memory memory,
PSAux_Service psaux );
FT_LOCAL( void )
t42_parser_done( T42_Parser parser );
FT_LOCAL( FT_Error )
t42_parse_dict( T42_Face face,
T42_Loader loader,
FT_Byte* base,
FT_Long size );
FT_LOCAL( void )
t42_loader_init( T42_Loader loader,
T42_Face face );
FT_LOCAL( void )
t42_loader_done( T42_Loader loader );
/* */
FT_END_HEADER
#endif /* __TYPE42_PARSE_H__ */

17
src/type42/type42.c Normal file
View File

@ -0,0 +1,17 @@
/***************************************************************************/
/* */
/* type42c */
/* */
/* FreeType Type 42 driver component */
/* */
/***************************************************************************/
#define FT_MAKE_OPTION_SINGLE_OBJECT
#include <ft2build.h>
#include "t42objs.c"
#include "t42parse.c"
#include "t42drivr.c"
/* END */