void
pdf_concat_raw(PDF *p, pdc_matrix *m)
{
if (!pdc_is_identity_matrix(m))
{
char sa[32], sb[32], sc[32], sd[32];
pdc_sprintf(p->pdc, pdc_true, sa, "%f", m->a);
pdc_sprintf(p->pdc, pdc_true, sb, "%f", m->b);
pdc_sprintf(p->pdc, pdc_true, sc, "%f", m->c);
pdc_sprintf(p->pdc, pdc_true, sd, "%f", m->d);
if ((!strcmp(sa, "0") || !strcmp(sd, "0")) &&
(!strcmp(sb, "0") || !strcmp(sc, "0")))
{
pdc_error(p->pdc, PDC_E_ILLARG_MATRIX,
pdc_errprintf(p->pdc, "%f %f %f %f %f %f",
m->a, m->b, m->c, m->d, m->e, m->f),
0, 0, 0);
}
pdf_end_text(p);
pdc_printf(p->out, "%s %s %s %s %f %f cm\n",
sa, sb, sc, sd, m->e, m->f);
pdc_multiply_matrix(m, &p->curr_ppt->gstate[p->curr_ppt->sl].ctm);
}
}
int
pdf__add_bookmark(PDF *p, const char *text, int len, int parent, int open)
{
static const char *fn = "pdf__add_bookmark";
pdf_outline self;
pdf_dest *dest = (pdf_dest *) p->bookmark_dest;
char *hypertext = NULL;
int acthdl;
int retval = 0;
len = pdc_check_text_length(p->pdc, &text, len, PDF_MAXSTRINGSIZE);
if (!len)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "text", 0, 0, 0);
pdf_init_outline(p, &self);
if (parent != 0)
pdf_check_handle(p, parent, pdc_bookmarkhandle);
self.parent = parent;
self.open = open;
/* creating a Launch action - defined via bookmarkdest */
if (dest->filename)
{
char *actoptlist;
actoptlist = (char *)
pdc_malloc(p->pdc, strlen(dest->filename) + 80, fn);
pdc_sprintf(p->pdc, pdc_false, actoptlist, "filename {%s} ",
dest->filename);
acthdl = pdf__create_action(p, "Launch", actoptlist);
if (acthdl != -1)
{
if (p->pdc->hastobepos) acthdl++;
pdc_sprintf(p->pdc, pdc_false, actoptlist, "activate %d", acthdl);
self.action = pdc_strdup(p->pdc, actoptlist);
}
pdc_free(p->pdc, actoptlist);
}
else
{
self.dest = pdf_init_destination(p);
*self.dest = *dest;
if (dest->name)
self.dest->name = pdc_strdup(p->pdc, dest->name);
}
memcpy(self.textcolor, dest->color, 3 * sizeof(pdc_scalar));
self.fontstyle = dest->fontstyle;
hypertext = pdf_convert_hypertext_depr(p, text, len);
if (hypertext)
retval = pdf_insert_bookmark(p, hypertext, &self, -1);
return retval;
}
pdc_encodingvector *
fnt_create_font_ev(pdc_core *pdc, fnt_font *font)
{
pdc_encodingvector *ev = NULL;
char encname[PDC_GEN_BUFSIZE];
pdc->uniqueno++;
pdc_sprintf(pdc, pdc_false, encname, "encoding_%s_%d",
font->name, pdc->uniqueno);
ev = pdc_new_encoding(pdc, encname);
pdc_insert_encoding_vector(pdc, ev);
font->enc = pdc_find_encoding(pdc, encname);
ev->flags |= PDC_ENC_FONT;
return ev;
}
pdc_id
pdf_write_info(PDF *p, pdc_bool moddate)
{
pdc_bool logg3 = pdc_logg_is_enabled(p->pdc, 3, trc_xmp);
char time_str[PDC_TIME_SBUF_SIZE];
char producer[PDC_GEN_BUFSIZE];
pdf_info *info;
pdc_id info_id;
const char *product = "PDFlib Lite";
const char *security = "";
(void) logg3;
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api,
"[Full product name: \"%s\"]\n", product);
info_id = pdc_begin_obj(p->out, PDC_NEW_ID); /* Info object */
pdc_begin_dict(p->out);
/*
* Although it would be syntactically correct, we must not remove
* the space characters after the dictionary keys since this
* would break the PDF properties feature in Windows Explorer.
*/
if (p->userinfo)
{
for (info = p->userinfo; info != NULL; info = info->next)
{
pdf_put_pdfname(p, info->key);
pdc_puts(p->out, " ");
if (strcmp(info->key, "Trapped"))
pdf_put_hypertext(p, info->value);
else
pdf_put_pdfname(p, info->value);
pdc_puts(p->out, "\n");
}
}
pdc_get_timestr(time_str, pdc_false);
/* creation date and time */
pdc_puts(p->out, "/CreationDate ");
pdf_put_hypertext(p, time_str);
pdc_puts(p->out, "\n");
/* modification date and time */
if (moddate)
{
pdc_puts(p->out, "/ModDate ");
pdf_put_hypertext(p, time_str);
pdc_puts(p->out, "\n");
}
/*
* If you change the /Producer entry your license to use
* PDFlib will be void!
*/
if (p->pdc->binding)
pdc_sprintf(p->pdc, pdc_false, producer, "%s %s%s (%s/%s)", product,
PDFLIB_VERSIONSTRING, security, p->pdc->binding, PDF_PLATFORM);
else
pdc_sprintf(p->pdc, pdc_false, producer, "%s %s%s (%s)", product,
PDFLIB_VERSIONSTRING, security, PDF_PLATFORM);
pdc_puts(p->out, "/Producer ");
pdf_put_hypertext(p, producer);
pdc_puts(p->out, "\n");
pdc_end_dict(p->out);
pdc_end_obj(p->out); /* Info object */
return info_id;
}
void
pdf__set_parameter(PDF *p, const char *key, const char *value)
{
pdc_pagebox usebox = pdc_pbox_none;
pdc_text_format textformat = pdc_auto;
char optlist[PDC_GEN_BUFSIZE];
pdf_ppt *ppt;
int i, k;
i = pdf_get_index(p, key, pdc_true);
if (value == NULL) value = "";
ppt = p->curr_ppt;
switch (i)
{
case PDF_PARAMETER_PDIUSEBOX:
case PDF_PARAMETER_VIEWAREA:
case PDF_PARAMETER_VIEWCLIP:
case PDF_PARAMETER_PRINTAREA:
case PDF_PARAMETER_PRINTCLIP:
k = pdc_get_keycode_ci(value, pdf_usebox_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
usebox = (pdc_pagebox) k;
pdc_sprintf(p->pdc, pdc_false, optlist, "%s %s", key, value);
break;
case PDF_PARAMETER_TEXTFORMAT:
case PDF_PARAMETER_HYPERTEXTFORMAT:
k = pdc_get_keycode_ci(value, pdf_textformat_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
textformat = (pdc_text_format) k;
break;
}
switch (i)
{
case PDF_PARAMETER_SEARCHPATH:
case PDF_PARAMETER_FONTAFM:
case PDF_PARAMETER_FONTPFM:
case PDF_PARAMETER_FONTOUTLINE:
case PDF_PARAMETER_HOSTFONT:
case PDF_PARAMETER_ENCODING:
case PDF_PARAMETER_ICCPROFILE:
case PDF_PARAMETER_STANDARDOUTPUTINTENT:
{
pdf_add_pdflib_resource(p, key, value);
break;
}
case PDF_PARAMETER_DEBUG:
{
const unsigned char *c;
for (c = (const unsigned char *) value; *c; c++)
p->debug[(int) *c] = 1;
break;
}
case PDF_PARAMETER_NODEBUG:
{
const unsigned char *c;
for (c = (const unsigned char *) value; *c; c++)
p->debug[(int) *c] = 0;
break;
}
case PDF_PARAMETER_BINDING:
if (!p->pdc->binding)
p->pdc->binding = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_OBJORIENT:
p->pdc->objorient = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_HASTOBEPOS:
p->pdc->hastobepos = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_PTFRUN:
p->pdc->ptfrun = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_SMOKERUN:
p->pdc->smokerun = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_UNICAPLANG:
p->pdc->unicaplang = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_ERRORPOLICY:
k = pdc_get_keycode_ci(value, pdf_errpol_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
p->errorpolicy = (pdf_errpol) k;
break;
case PDF_PARAMETER_UNDERLINE:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_underline);
break;
case PDF_PARAMETER_OVERLINE:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_overline);
break;
case PDF_PARAMETER_STRIKEOUT:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_strikeout);
break;
case PDF_PARAMETER_KERNING:
pdc_warning(p->pdc, PDF_E_UNSUPP_KERNING, 0, 0, 0, 0);
break;
case PDF_PARAMETER_FAKEBOLD:
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_fakebold);
break;
case PDF_PARAMETER_RESOURCEFILE:
pdc_set_resourcefile(p->pdc, value);
break;
case PDF_PARAMETER_RENDERINGINTENT:
k = pdc_get_keycode_ci(value, pdf_renderingintent_pdfkeylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
p->rendintent = (pdf_renderingintent) k;
break;
case PDF_PARAMETER_PRESERVEOLDPANTONENAMES:
p->preserveoldpantonenames = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_SPOTCOLORLOOKUP:
p->spotcolorlookup = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_PDISTRICT:
p->pdi_strict = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_TOPDOWN:
if (pdf_bool_value(p, key, value))
p->ydirection = -1.0;
else
p->ydirection = 1.0;
break;
case PDF_PARAMETER_USERCOORDINATES:
p->usercoordinates = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_USEHYPERTEXTENCODING:
p->usehyptxtenc = pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_TEXTFORMAT:
pdf_check_textformat(p, textformat);
p->textformat = textformat;
if (p->curr_ppt)
pdf_set_tstate(p, (double) textformat, to_textformat);
break;
case PDF_PARAMETER_HYPERTEXTFORMAT:
pdf_check_hypertextformat(p, textformat);
p->hypertextformat = textformat;
break;
case PDF_PARAMETER_HYPERTEXTENCODING:
{
p->hypertextencoding =
pdf_get_hypertextencoding(p, value, &p->hypertextcodepage,
pdc_true);
pdf_check_hypertextencoding(p, p->hypertextencoding);
break;
}
case PDF_PARAMETER_CHARREF:
pdc_warning(p->pdc, PDF_E_UNSUPP_CHARREF, 0, 0, 0, 0);
break;
case PDF_PARAMETER_ESCAPESEQUENCE:
pdc_warning(p->pdc, PDF_E_UNSUPP_ESCAPESEQU, 0, 0, 0, 0);
break;
case PDF_PARAMETER_HONORLANG:
pdc_warning(p->pdc, PDF_E_UNSUPP_HONORLANG, 0, 0, 0, 0);
break;
case PDF_PARAMETER_GLYPHCHECK:
pdc_warning(p->pdc, PDF_E_UNSUPP_GLYPHCHECK, 0, 0, 0, 0);
break;
case PDF_PARAMETER_FILLRULE:
k = pdc_get_keycode_ci(value, pdf_fillrule_keylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
ppt->fillrule = (pdf_fillrule) k;
break;
case PDF_PARAMETER_LOGGING:
pdc_set_logg_options(p->pdc, value);
break;
case PDF_PARAMETER_LOGMSG:
pdc_logg_cond(p->pdc, 1, trc_user, value);
break;
case PDF_PARAMETER_TRACEMSG:
/* do nothing -- client-supplied string will show up
* in the log file
*/
break;
case PDF_PARAMETER_NODEMOSTAMP:
break;
case PDF_PARAMETER_SERIAL:
case PDF_PARAMETER_LICENCE:
case PDF_PARAMETER_LICENSE:
break;
case PDF_PARAMETER_LICENCEFILE:
case PDF_PARAMETER_LICENSEFILE:
break;
case PDF_PARAMETER_AUTOSPACE:
pdc_warning(p->pdc, PDF_E_UNSUPP_TAGGED, 0, 0, 0, 0);
break;
/*****************************************************************************/
/** deprecated historical parameters **/
/*****************************************************************************/
case PDF_PARAMETER_OPENWARNING:
p->debug[(int) 'o'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_FONTWARNING:
p->debug[(int) 'F'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_ICCWARNING:
p->debug[(int) 'I'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_IMAGEWARNING:
p->debug[(int) 'i'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_PDIWARNING:
p->debug[(int) 'p'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_HONORICCPROFILE:
p->debug[(int) 'e'] = (char) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_GLYPHWARNING:
p->debug[(int) 'g'] = (char) pdf_bool_value(p, key, value);
if (p->curr_ppt)
pdf_set_tstate(p, (double) pdf_bool_value(p, key, value),
to_glyphwarning);
break;
case PDF_PARAMETER_TRACE:
{
pdc_bool bv = pdf_bool_value(p, key, value);
if (bv)
pdc_set_logg_options(p->pdc, "");
else
pdc_set_logg_options(p->pdc, "disable");
break;
}
case PDF_PARAMETER_TRACEFILE:
pdc_sprintf(p->pdc, pdc_false, optlist, "filename %s", value);
pdc_set_logg_options(p->pdc, optlist);
break;
case PDF_PARAMETER_WARNING:
break;
case PDF_PARAMETER_MASTERPASSWORD:
pdc_warning(p->pdc, PDF_E_UNSUPP_CRYPT, 0, 0, 0, 0);
break;
case PDF_PARAMETER_USERPASSWORD:
pdc_warning(p->pdc, PDF_E_UNSUPP_CRYPT, 0, 0, 0, 0);
break;
case PDF_PARAMETER_PERMISSIONS:
pdc_warning(p->pdc, PDF_E_UNSUPP_CRYPT, 0, 0, 0, 0);
break;
case PDF_PARAMETER_COMPATIBILITY:
pdf_set_compatibility(p, value);
break;
case PDF_PARAMETER_FLUSH:
pdf_set_flush(p, value);
break;
case PDF_PARAMETER_PDFX:
pdc_warning(p->pdc, PDF_E_UNSUPP_PDFX, 0, 0, 0, 0);
break;
case PDF_PARAMETER_HIDETOOLBAR:
case PDF_PARAMETER_HIDEMENUBAR:
case PDF_PARAMETER_HIDEWINDOWUI:
case PDF_PARAMETER_FITWINDOW:
case PDF_PARAMETER_CENTERWINDOW:
case PDF_PARAMETER_DISPLAYDOCTITLE:
if (pdf_bool_value(p, key, value))
pdf_set_viewerpreference(p, key);
break;
case PDF_PARAMETER_NONFULLSCREENPAGEMODE:
if (!pdc_stricmp(value, "useoutlines"))
pdf_set_viewerpreference(p, "nonfullscreenpagemode bookmarks");
else if (!pdc_stricmp(value, "usethumbs"))
pdf_set_viewerpreference(p, "nonfullscreenpagemode thumbnails");
else if (!pdc_stricmp(value, "usenone"))
pdf_set_viewerpreference(p, "nonfullscreenpagemode none");
else
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
break;
case PDF_PARAMETER_DIRECTION:
if (!pdc_stricmp(value, "r2l"))
pdf_set_viewerpreference(p, "direction r2l");
else if (!pdc_stricmp(value, "l2r"))
pdf_set_viewerpreference(p, "direction l2r");
else
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM, value, key, 0, 0);
break;
case PDF_PARAMETER_VIEWAREA:
case PDF_PARAMETER_VIEWCLIP:
case PDF_PARAMETER_PRINTAREA:
case PDF_PARAMETER_PRINTCLIP:
pdf_set_viewerpreference(p, optlist);
break;
case PDF_PARAMETER_OPENACTION:
pdf_set_openaction(p, value);
break;
case PDF_PARAMETER_OPENMODE:
pdf_set_openmode(p, value);
break;
case PDF_PARAMETER_BOOKMARKDEST:
pdf_cleanup_destination(p, p->bookmark_dest);
p->bookmark_dest =
pdf_parse_destination_optlist(p, value, 0, pdf_bookmark);
break;
case PDF_PARAMETER_INHERITGSTATE:
(void) pdf_bool_value(p, key, value);
break;
case PDF_PARAMETER_TRANSITION:
pdf_set_transition(p, value);
break;
case PDF_PARAMETER_BASE:
pdf_set_uri(p, value);
break;
case PDF_PARAMETER_LAUNCHLINK_PARAMETERS:
if (p->launchlink_parameters) {
pdc_free(p->pdc, p->launchlink_parameters);
p->launchlink_parameters = NULL;
}
p->launchlink_parameters = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_LAUNCHLINK_OPERATION:
if (p->launchlink_operation) {
pdc_free(p->pdc, p->launchlink_operation);
p->launchlink_operation = NULL;
}
p->launchlink_operation = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_LAUNCHLINK_DEFAULTDIR:
if (p->launchlink_defaultdir) {
pdc_free(p->pdc, p->launchlink_defaultdir);
p->launchlink_defaultdir = NULL;
}
p->launchlink_defaultdir = pdc_strdup(p->pdc, value);
break;
case PDF_PARAMETER_PDIUSEBOX:
p->pdi_usebox = usebox;
break;
case PDF_PARAMETER_AUTOSUBSETTING:
case PDF_PARAMETER_AUTOCIDFONT:
case PDF_PARAMETER_UNICODEMAP:
pdc_warning(p->pdc, PDF_E_UNSUPP_UNICODE, 0, 0, 0, 0);
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
break;
} /* switch */
} /* pdf__set_parameter */
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;
}
