pdc_bool
pdf_get_metrics_afm(
PDF *p,
pdf_font *font,
const char *fontname,
pdc_encoding enc,
const char *filename,
pdc_bool requested)
{
static const char fn[] = "pdf_get_metrics_afm";
char fullname[PDC_FILENAMELEN];
pdc_file *afmfile;
/* open AFM file */
afmfile = pdc_fsearch_fopen(p->pdc, filename, fullname, "AFM ",
PDC_FILE_TEXT);
if (afmfile == NULL)
return pdc_check_fopen_errmsg(p->pdc, requested);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tLoading AFM metric fontfile \"%s\":\n", fullname);
/* parse AFM file */
if (pdf_parse_afm(p, afmfile, font, fontname, fullname) == pdc_false)
return pdc_false;
/* members not fount */
if (font->ft.m.type == fnt_unknownType)
font->ft.m.type = fnt_Type1;
if (font->ft.name == NULL)
{
font->ft.name = pdc_strdup(p->pdc, fontname);
font->ft.m.name = pdc_strdup(p->pdc, fontname);
}
/* save full filename */
font->metricfilename = pdc_strdup_ext(p->pdc, fullname, 0, fn);
/* process metric data */
font->ft.enc = enc;
if (pdf_process_metrics_data(p, font, fontname) == pdc_false)
return pdc_false;
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
}
pdc_bool
pdf_get_metrics_pfm(
PDF *p,
pdf_font *font,
const char *fontname,
pdc_encoding enc,
const char *filename,
pdc_bool requested)
{
static const char fn[] = "pdf_get_metrics_pfm";
char fullname[PDC_FILENAMELEN];
pdc_file *pfmfile;
(void) fontname;
/* open PFM file */
pfmfile = pdc_fsearch_fopen(p->pdc, filename, fullname, "PFM ",
PDC_FILE_BINARY);
if (pfmfile == NULL)
return pdc_check_fopen_errmsg(p->pdc, requested);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tLoading PFM metric fontfile \"%s\":\n", fullname);
/* Read PFM metrics */
if (!pdf_parse_pfm(p, pfmfile, font))
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_CORRUPT, "PFM", fullname, 0, 0);
return pdc_false;
}
/* save full filename */
font->metricfilename = pdc_strdup_ext(p->pdc, fullname, 0, fn);
/* Check encoding */
if (!pdf_check_pfm_encoding(p, font, enc))
return pdc_false;
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
}
pdc_bool
pdf_get_metrics_pfm(
PDF *p,
pdc_font *font,
const char *fontname,
pdc_encoding enc,
const char *filename)
{
pdc_file *pfmfile;
/* open PFM file */
pfmfile = pdf_fopen(p, filename, "PFM ", PDC_FILE_BINARY);
if (pfmfile == NULL)
{
if (font->verbose_open)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return pdc_false;
}
/* Read PFM metrics */
if (!pdf_parse_pfm(p, pfmfile, font))
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_CORRUPT, "PFM", filename, 0, 0);
if (font->verbose == pdc_true)
pdc_error(p->pdc, -1, 0, 0, 0, 0);
return pdc_false;
}
/* Check encoding */
if (!pdf_check_pfm_encoding(p, font, fontname, enc))
return pdc_false;
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
}
pdc_bool
pdf_get_metrics_tt(PDF *p, pdf_font *font, const char *fontname,
pdc_encoding enc, const char *filename)
{
pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_font);
pdc_bool logg2 = pdc_logg_is_enabled(p->pdc, 2, trc_font);
int filesize = 0;
double kbfilesize = 0;
int foundglyphs, flags = 0;
tt_file *ttf;
pdc_bool retval;
pdc_encoding enc_req;
pdc_encodingvector *ev = NULL;
pdc_bool isotf;
int errcode = 0;
(void) logg2;
/*
* Initialisation
*/
ttf = fnt_new_tt(p->pdc, &font->ft);
ttf->filename = filename;
ttf->fontname = fontname;
ttf->verbose = font->verbose;
ttf->incore = pdc_true;
ttf->monospace = font->opt.monospace;
filesize = font->ft.filelen;
kbfilesize = filesize / 1024.0;
/*
* Read font file
*/
retval = fnt_read_tt(ttf);
if (retval == pdc_false)
goto PDF_TRUETYPE_ERROR2;
/*
* Font type
*/
if (ttf->tab_CFF_)
{
isotf = pdc_true;
font->ft.m.type = fnt_Type1C;
font->cff_offset = (long) ttf->tab_CFF_->offset;
font->cff_length = ttf->tab_CFF_->length;
}
else
{
isotf = pdc_false;
font->ft.m.type = fnt_TrueType;
TT_IOCHECK(ttf, tt_tag2idx(ttf, fnt_str_glyf) != -1);
TT_IOCHECK(ttf, tt_tag2idx(ttf, fnt_str_loca) != -1);
}
/* Number of Glyphs */
if (ttf->numGlyphs <= 1)
{
errcode = FNT_E_TT_NOGLYFDESC;
goto PDF_TRUETYPE_ERROR1;
}
/*
* Encoding
*/
if (isotf)
{
/* OpenType font with CFF table */
if (ttf->charcoll != cc_none)
{
/* CID font */
if (font->ft.m.charcoll != cc_none)
{
if (!ttf->regisadobe)
{
errcode = PDF_E_CJK_UNSUPP_REGISTRY;
goto PDF_TRUETYPE_ERROR1;
}
if (font->ft.m.charcoll != ttf->charcoll)
{
errcode = PDF_E_CJK_UNSUPP_CHARCOLL;
goto PDF_TRUETYPE_ERROR1;
}
if (font->outcmapname != NULL)
enc = pdc_cid;
if (logg1)
pdc_logg(p->pdc, "\tCID font ordering: \"%s\"\n",
fnt_get_ordering_cid(ttf->charcoll));
}
else if (enc == pdc_unicode || enc == pdc_glyphid)
{
font->ft.m.charcoll = ttf->charcoll;
font->supplement = ttf->supplement;
}
else
{
errcode = PDF_E_FONT_ONLY_CMAP;
goto PDF_TRUETYPE_ERROR1;
}
}
else if (font->ft.m.charcoll != cc_none)
{
/* SID font */
errcode = PDF_E_FONT_UNSUPP_CMAP;
goto PDF_TRUETYPE_ERROR1;
}
}
else
{
if (font->ft.m.charcoll != cc_none)
{
int i;
pdc_bool iscjk = pdc_false;
for (i = 0; i < PDC_NUMCHARCOLL; i++)
{
if (ttf->tab_OS_2->charcolls[i])
iscjk = pdc_true;
if (ttf->tab_OS_2->charcolls[i] == font->ft.m.charcoll)
break;
}
if (i == PDC_NUMCHARCOLL)
{
if (iscjk)
{
/* CJK font */
errcode = PDF_E_CJK_UNSUPP_CHARCOLL;
goto PDF_TRUETYPE_ERROR1;
}
else
{
/* no CJK font */
errcode = PDF_E_FONT_UNSUPP_CMAP;
goto PDF_TRUETYPE_ERROR1;
}
}
else
{
if (font->outcmapname != NULL)
{
ttf->charcoll = font->ft.m.charcoll;
enc = pdc_cid;
}
}
}
}
/* encoding vector */
enc_req = fnt_get_tt_encoding_key(ttf, enc);
if (enc_req == pdc_invalidenc)
{
errcode = FNT_E_TT_BADCMAP;
goto PDF_TRUETYPE_ERROR1;
}
else if (enc_req != enc)
{
if (strcmp(font->encapiname, "auto"))
{
pdc_warning(p->pdc, PDF_E_FONT_FORCEENC,
pdf_get_encoding_name(p, enc_req, NULL),
0, 0, 0);
}
enc = enc_req;
}
if (enc >= 0)
ev = pdc_get_encoding_vector(p->pdc, enc);
font->ft.enc = enc;
font->ft.issymbfont = ttf->issymbol;
font->hasnomac = !ttf->tab_cmap || !ttf->tab_cmap->mac;
/* builtin encoding */
if (enc == pdc_builtin)
{
if (font->ft.issymbfont == pdc_false)
{
errcode = PDF_E_FONT_BADENC;
goto PDF_TRUETYPE_ERROR1;
}
else
{
/* encoding vector for builtin */
ev = pdf_create_font_encoding(p, enc, font, fontname, pdc_true);
font->symenc = font->ft.enc;
}
}
{
/* optimizing PDF output */
if (enc == pdc_ebcdic ||
enc == pdc_ebcdic_37 ||
enc == pdc_ebcdic_winansi)
font->towinansi = pdc_winansi;
}
/* /FontName in FontDescriptor */
font->ft.m.name = pdc_strdup(p->pdc, ttf->tab_name->englishname4);
/* /BaseFont name */
font->ft.name = pdc_strdup(p->pdc, ttf->tab_name->englishname6);
#define PDF_RESTRICTED_TT_EMBEDDING 0x02
/* check embedding flags */
if ((font->opt.embedding) && ttf->tab_OS_2 &&
ttf->tab_OS_2->fsType == PDF_RESTRICTED_TT_EMBEDDING)
{
errcode = FNT_E_TT_EMBED;
goto PDF_TRUETYPE_ERROR1;
}
if (logg1)
{
pdc_logg(p->pdc,
"\tFull font name: \"%s\"\n"
"\tPostScript font name: \"%s\"\n"
"\tFont embedding: %s\n"
"\tVertical font: %s\n",
font->ft.name, font->ft.m.name,
PDC_BOOLSTR(font->opt.embedding),
PDC_BOOLSTR(font->ft.vertical));
if (ttf->tab_name->producer != NULL)
pdc_logg(p->pdc, "\tFont producer: \"%s\"\n",
ttf->tab_name->producer);
pdc_logg(p->pdc, "\tNumber of Glyphs: %d\n", ttf->numGlyphs);
}
/* Save font values */
fnt_set_tt_fontvalues(ttf);
/* Flags for creating font arrays */
flags = TT_FONT_code2gid | TT_FONT_m_widths;
/* Create font mapping and width arrays */
foundglyphs = fnt_set_tt_fontarrays(ttf, flags);
/***********************************/
if (font->symenc != pdc_invalidenc)
font->ft.enc = pdc_builtin;
/***********************************/
if (!foundglyphs)
{
errcode = PDF_E_FONT_BADENC;
goto PDF_TRUETYPE_ERROR1;
}
fnt_delete_tt(ttf);
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
PDF_TRUETYPE_ERROR1:
pdc_set_errmsg(p->pdc, errcode, 0, 0, 0, 0);
PDF_TRUETYPE_ERROR2:
fnt_delete_tt(ttf);
return pdc_false;
}
pdc_bool
pdf_handle_t3font(PDF *p, const char *fontname, pdc_encoding enc,
pdf_font *font, int *slot)
{
static const char fn[] = "pdf_handle_t3font";
const char *encname;
char *fname;
size_t namlen;
pdf_font *deffont = &p->fonts[*slot];
pdc_encodingvector *ev = pdc_get_encoding_vector(p->pdc, enc);
fnt_font_metric *ftm = &font->ft.m;
size_t nalloc;
int code, gid;
pdc_bool newinst = pdc_false;
/* font name incl. encoding name */
encname = pdc_get_user_encoding(p->pdc, enc);
namlen = strlen(fontname) + strlen(encname) + 2;
fname = (char *) pdc_malloc(p->pdc, namlen, fn);
pdc_sprintf(p->pdc, pdc_false, fname, "%s.%s", fontname, encname);
/* we have to copy the available font.
* otherwise the original font will be changed
*/
newinst = deffont->ft.enc != pdc_invalidenc;
pdc_logg_cond(p->pdc, 1, trc_font,
"\n\tType3 font \"%s\" with %d glyphs found\n",
fontname, deffont->t3font->next_glyph);
if (newinst)
{
pdc_logg_cond(p->pdc, 1, trc_font,
"\tInstance with specified encoding will be created\n");
}
/* copy data from available font (see pdf__begin_font()) */
font->ft.m.type = fnt_Type3;
font->ft.matrix = deffont->ft.matrix;
font->ft.bbox = deffont->ft.bbox;
font->t3font = deffont->t3font;
font->ft.numglyphs = deffont->t3font->next_glyph;
nalloc = (size_t) font->ft.numglyphs;
ftm->name = fname;
font->ft.name = pdc_strdup(p->pdc, fname);
font->ft.enc = enc;
font->ft.issymbfont = pdc_false;
font->opt.embedding = pdc_true;
if (enc >= pdc_winansi)
{
font->codesize = 1;
font->ft.numcodes = 256;
font->lastcode = -1;
ftm->widths = (int *) pdc_calloc(p->pdc,
(size_t) font->ft.numcodes * sizeof(int), fn);
ftm->numwidths = font->ft.numcodes;
}
font->ft.code2gid = (pdc_ushort *) pdc_calloc(p->pdc,
(size_t) font->ft.numcodes * sizeof(pdc_ushort), fn);
font->ft.gid2code = (pdc_ushort *) pdc_calloc(p->pdc,
nalloc * sizeof (pdc_ushort), fn);
/* fill up font arrays */
for (gid = 0; gid < font->ft.numglyphs; gid++)
{
const char *str = NULL, *glyphname = font->t3font->glyphs[gid].name;
if (enc >= pdc_winansi)
{
/* search for code */
for (code = 0; code < font->ft.numcodes; code++)
{
if (ev->chars[code] != NULL)
str = ev->chars[code];
else if (ev->codes[code])
str = pdc_unicode2glyphname(p->pdc, ev->codes[code]);
if (str != NULL && !pdc_strcmp(glyphname, str))
break;
}
/* code found */
if (code < font->ft.numcodes)
{
font->ft.code2gid[code] = gid;
font->ft.gid2code[gid] = code;
if (!gid)
font->gid0code = code;
if (font->opt.monospace)
ftm->widths[code] = font->opt.monospace;
else
ftm->widths[code] =
(int) (font->t3font->glyphs[gid].width + 0.5);
}
}
}
pdf_type3_protocol(p, font, ev);
/* font flags */
if (!pdf_make_fontflag(p, font))
return pdc_false;
if (newinst)
{
*slot = -1;
}
else
{
if (deffont->apiname != NULL)
pdc_free(p->pdc, deffont->apiname);
*deffont = *font;
deffont->hasoriginal = pdc_true;
}
return pdc_true;
}
