void
pdf_check_hypertextencoding(PDF *p, pdc_encoding hypertextencoding)
{
if (!p->pdc->ptfrun && p->pdc->unicaplang &&
hypertextencoding != pdc_unicode)
pdc_error(p->pdc, PDF_E_ENC_UNSUPPENCFORMAT, "hypertextencoding",
0, 0, 0);
pdc_logg_cond(p->pdc, 1, trc_encoding, "\tHypertextencoding: \"%s\"\n",
pdc_get_user_encoding(p->pdc, hypertextencoding));
}
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;
}
char *
pdf_get_opt_filename(PDF *p, const char *keyword, pdc_resopt *resopts,
pdc_encoding enc, int codepage)
{
pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_optlist);
pdc_bool logg3 = pdc_logg_is_enabled(p->pdc, 3, trc_text);
pdc_byte *filename = NULL;
char **strlist;
if (pdc_get_optvalues(keyword, resopts, NULL, &strlist))
{
pdc_encodingvector *inev = NULL, *outev = NULL;
pdc_text_format intextformat = pdc_bytes;
pdc_text_format outtextformat = pdc_utf16; /* sic! */
int convflags = PDC_CONV_NOBOM | PDC_CONV_TRYBYTES | PDC_CONV_NEWALLOC;
pdc_bool isutf8;
int ic, outlen;
/* whole option list or string list is in UTF-8 */
isutf8 = pdc_is_lastopt_utf8(resopts);
if (!isutf8)
{
if (enc < 0 && enc != pdc_unicode && enc != pdc_cid)
enc = pdf_get_hypertextencoding(p, "auto", &codepage,
pdc_true);
if (enc >= 0)
inev = pdc_get_encoding_vector(p->pdc, enc);
}
else
{
intextformat = PDC_UTF8;
}
if (logg1)
{
if (isutf8)
{
pdc_logg(p->pdc, "\tOption \"%s\" is "PDC_UTF8_STRG" encoded\n",
keyword);
}
else
{
pdc_logg(p->pdc, "\tOption \"%s\" is %s encoded\n",
keyword, pdc_get_user_encoding(p->pdc, enc));
}
}
outev = pdc_get_encoding_vector(p->pdc, pdc_winansi);
if (logg3)
convflags |= PDC_CONV_LOGGING;
pdf_set_convertflags(p, &convflags);
pdc_convert_string(p->pdc, intextformat, codepage, inev,
(pdc_byte *) strlist[0], (int) strlen(strlist[0]),
&outtextformat, outev, &filename, &outlen,
convflags, pdc_true);
if (outtextformat == pdc_utf16)
{
pdc_ushort uv, *unifilename = (pdc_ushort *) filename;
int code;
if (p->compatibility < PDC_1_7)
pdc_error(p->pdc, PDC_E_IO_UNSUPP_PDFUNINAME, 0, 0, 0, 0);
/* we must replace non-WinAnsi characters by period
* and omit the BOM to get a WinAnsi string.
*/
outlen /= 2;
for (ic = 0; ic < outlen; ic++)
{
uv = unifilename[ic];
code = pdc_get_encoding_bytecode(p->pdc, outev, uv);
if (code <= 0)
uv = PDC_UNICODE_PERIOD;
filename[ic] = (char) uv;
}
filename[ic] = 0;
}
if (logg3)
pdc_logg_hexdump(p->pdc, "output filename", "\t\t",
(char *) filename, strlen((char *) filename));
}
return (char *) filename;
}
int
pdf_get_opt_textlist(PDF *p, const char *keyword, pdc_resopt *resopts,
pdc_encoding enc, int codepage, pdc_bool ishypertext,
const char *fieldname, char **text, char ***textlist)
{
pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_optlist);
int ns;
char **strlist;
ns = pdc_get_optvalues(keyword, resopts, NULL, &strlist);
if (ns)
{
pdc_byte *string = NULL;
pdc_encodingvector *inev = NULL, *outev = NULL;
pdc_text_format intextformat = pdc_bytes;
pdc_text_format outtextformat = pdc_utf16be;
pdc_text_format textformat;
int convflags = PDC_CONV_WITHBOM;
pdc_bool isutf8;
int i, outlen;
/* whole option list or string list is in UTF-8 */
isutf8 = pdc_is_lastopt_utf8(resopts);
/* Encoding */
if (ishypertext)
{
/* Initialize */
if (!isutf8)
{
if (enc < 0 && enc != pdc_unicode && enc != pdc_cid)
enc = pdf_get_hypertextencoding(p, "auto", &codepage,
pdc_true);
if (enc >= 0)
inev = pdc_get_encoding_vector(p->pdc, enc);
}
outev = pdc_get_encoding_vector(p->pdc, pdc_pdfdoc);
/* conversion to PDFDocEncoding if possible */
convflags |= PDC_CONV_TRYBYTES;
}
else
{
if (enc == pdc_invalidenc)
{
if (fieldname)
{
pdc_cleanup_optionlist(p->pdc, resopts);
pdc_error(p->pdc, PDF_E_FF_FONTMISSING, fieldname, 0, 0, 0);
}
return 0;
}
else if (enc >= 0 && !isutf8)
{
/* bug #2069: always conversion to UTF-16BE */
inev = pdc_get_encoding_vector(p->pdc, enc);
}
}
if (logg1)
{
if (isutf8)
{
pdc_logg(p->pdc, "\tOption \"%s\" is "PDC_UTF8_STRG" encoded\n",
keyword);
}
else
{
pdc_logg(p->pdc, "\tOption \"%s\" is %s encoded\n",
keyword, pdc_get_user_encoding(p->pdc, enc));
}
}
for (i = 0; i < ns; i++)
{
string = (pdc_byte *) strlist[i];
{
if (ishypertext || isutf8 || inev != NULL)
{
intextformat = isutf8 ? PDC_UTF8 : pdc_bytes;
if (pdc_logg_is_enabled(p->pdc, 3, trc_text))
convflags |= PDC_CONV_LOGGING;
pdf_set_convertflags(p, &convflags);
textformat = outtextformat;
pdc_convert_string(p->pdc, intextformat, codepage, inev,
string, (int) strlen((char *) string),
&textformat, outev, &string, &outlen,
convflags, pdc_true);
pdc_free(p->pdc, strlist[i]);
strlist[i] = (char *) string;
}
}
}
if (text)
*text = strlist[0];
else
*textlist = strlist;
if (fieldname)
{
strlist = (char **) pdc_save_lastopt(resopts, PDC_OPT_SAVEALL);
pdf_insert_stringlist(p, strlist, ns);
}
}
return ns;
}
