void
pdf_check_textformat(PDF *p, pdc_text_format textformat)
{
if (!p->pdc->ptfrun && p->pdc->unicaplang && textformat != pdc_auto2)
pdc_error(p->pdc, PDF_E_ENC_UNSUPPENCFORMAT, "textformat", 0, 0, 0);
pdc_logg_cond(p->pdc, 1, trc_encoding, "\tTextformat: \"%s\"\n",
pdc_get_keyword(textformat, pdf_textformat_keylist));
}
const char *
pdf_current_scope(PDF *p)
{
const char *scopename =
pdc_get_keyword(PDF_GET_STATE(p), pdf_scope_keylist);
if (!scopename)
pdc_error(p->pdc, PDF_E_INT_BADSCOPE,
pdc_errprintf(p->pdc, " (0x%08X)", PDF_GET_STATE(p)), 0, 0, 0);
return (char *) scopename; /* be happy, compiler! */
}
static int
pdf_opt_effectless(PDF *p, const char *keyword, pdf_actiontype curratype,
pdf_actiontype intendatypes)
{
if ((pdf_actiontype) !(intendatypes & curratype))
{
const char *type = pdc_get_keyword(curratype, pdf_action_pdfkeylist);
pdc_warning(p->pdc, PDF_E_ACT_OPTIGNORE_FORTYPE, keyword,type, 0, 0);
return 1;
}
return 0;
}
void
pdf_logg_coloropt(PDF *p, pdf_coloropt *c, pdc_bool newline)
{
const char *keyword =
pdc_get_keyword((int) c->type, pdf_colortype_keylist);
pdc_logg(p->pdc, "{%s ", keyword);
switch (c->type)
{
case color_gray:
case color_iccbasedgray:
case color_pattern:
case color_spot:
pdc_logg(p->pdc, "%g}", c->value[0]);
break;
case color_rgb:
case color_iccbasedrgb:
case color_lab:
pdc_logg(p->pdc, "%g %g %g}", c->value[0], c->value[1], c->value[2]);
break;
case color_cmyk:
case color_iccbasedcmyk:
pdc_logg(p->pdc, "%g %g %g %g}", c->value[0], c->value[1],
c->value[2], c->value[3]);
break;
case color_spotname:
pdc_logg(p->pdc, "{%s} %g}", c->name, c->value[0]);
break;
default:
pdc_logg(p->pdc, "}");
break;
}
if (newline)
pdc_logg(p->pdc, "\n");
}
const char *
fnt_weight2weightname(int weight)
{
return pdc_get_keyword(weight, fnt_fontweight_keylist);
}
const char *
fnt_get_pdf_fonttype_desc(int typecode)
{
const char *name = pdc_get_keyword(typecode, pdf_fonttype_descrkeylist);
return name ? name : "";
}
pdf_dest *
pdf_parse_destination_optlist(
PDF *p,
const char *optlist,
int page,
pdf_destuse destuse)
{
int minpage;
pdc_resopt *resopts;
pdc_encoding hypertextencoding;
int hypertextcodepage;
const char *keyword;
const char *type_name;
char **strlist = NULL;
int inum;
pdc_bool boolval;
/* Defaults */
pdf_dest *dest = pdf_init_destination(p);
/* parse option list */
resopts = pdc_parse_optionlist(p->pdc, optlist, pdf_destination_options,
NULL, pdc_true);
if (pdc_get_optvalues("fitbbox", resopts, &boolval, NULL) &&
boolval == pdc_true)
dest->type = fitvisible;
if (pdc_get_optvalues("fitheight", resopts, &boolval, NULL) &&
boolval == pdc_true)
dest->type = fitheight;
if (pdc_get_optvalues("fitpage", resopts, &boolval, NULL) &&
boolval == pdc_true)
dest->type = fitwindow;
if (pdc_get_optvalues("fitwidth", resopts, &boolval, NULL) &&
boolval == pdc_true)
dest->type = fitwidth;
if (pdc_get_optvalues("retain", resopts, &boolval, NULL) &&
boolval == pdc_true)
dest->type = fixed;
if (pdc_get_optvalues("type", resopts, &inum, NULL))
dest->type = (pdf_desttype) inum;
type_name = pdc_get_keyword(dest->type, pdf_type_keylist);
hypertextencoding =
pdf_get_hypertextencoding_opt(p, resopts, &hypertextcodepage, pdc_true);
keyword = "name";
if (pdf_get_opt_textlist(p, keyword, resopts, hypertextencoding,
hypertextcodepage, pdc_true, NULL, &dest->name, NULL))
{
if (dest->type != nameddest)
{
dest->name = NULL;
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword,
type_name, 0, 0);
}
else
pdc_save_lastopt(resopts, PDC_OPT_SAVE1ELEM);
}
keyword = "page";
if (pdc_get_optvalues(keyword, resopts, &page, NULL) &&
dest->type == filedest)
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword, type_name,
0, 0);
keyword = "group";
if (pdc_get_optvalues(keyword, resopts, NULL, &strlist))
{
page = pdf_xlat_pageno(p, page, strlist[0]);
}
keyword = "zoom";
if (pdc_get_optvalues(keyword, resopts, &dest->zoom, NULL) &&
dest->type != fixed)
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword, type_name,
0, 0);
keyword = "left";
if (pdc_get_optvalues(keyword, resopts, &dest->left, NULL) &&
(dest->type == fitwindow || dest->type == fitwidth ||
dest->type == fitvisible || dest->type == fitvisiblewidth ||
dest->type == nameddest || dest->type == filedest))
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword, type_name,
0, 0);
keyword = "right";
if (pdc_get_optvalues(keyword, resopts, &dest->right, NULL) &&
dest->type != fitrect)
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword, type_name,
0, 0);
keyword = "bottom";
if (pdc_get_optvalues(keyword, resopts, &dest->bottom, NULL) &&
dest->type != fitrect)
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword, type_name,
0, 0);
keyword = "top";
if (pdc_get_optvalues(keyword, resopts, &dest->top, NULL) &&
(dest->type == fitwindow || dest->type == fitheight ||
dest->type == fitvisible || dest->type == fitvisibleheight ||
dest->type == nameddest || dest->type == filedest))
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword, type_name,
0, 0);
keyword = "color";
if (pdc_get_optvalues(keyword, resopts, &dest->color, NULL) &&
destuse != pdf_bookmark)
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORELEM, keyword, 0, 0, 0);
keyword = "fontstyle";
if (pdc_get_optvalues(keyword, resopts, &inum, NULL))
{
dest->fontstyle = (fnt_fontstyle) inum;
if (destuse != pdf_bookmark)
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORELEM, keyword, 0, 0, 0);
}
keyword = "filename";
if (pdc_get_optvalues(keyword, resopts, NULL, NULL))
{
if (dest->type != filedest)
{
pdc_warning(p->pdc, PDF_E_HYP_OPTIGNORE_FORTYPE, keyword,
type_name, 0, 0);
}
else
dest->filename =
(char *) pdc_save_lastopt(resopts, PDC_OPT_SAVE1ELEM);
}
pdc_cleanup_optionlist(p->pdc, resopts);
switch (dest->type)
{
case fitwidth:
/* Trick: we don't know the height of a future page yet,
* so we use a "large" value for top which will do for
* most pages. If it doesn't work, not much harm is done.
*/
if (dest->top == -1)
dest->top = 10000;
break;
case fitrect:
case fitheight:
case fitvisiblewidth:
case fitvisibleheight:
if (dest->left == -1)
dest->left = 0;
if (dest->bottom == -1)
dest->bottom = 0;
if (dest->right == -1)
dest->right = 1000;
if (dest->top == -1)
dest->top = 1000;
break;
case nameddest:
if (destuse == pdf_nameddest)
{
pdf_cleanup_destination(p, dest);
pdc_error(p->pdc, PDC_E_OPT_ILLKEYWORD, "type", type_name, 0, 0);
}
if (dest->name == NULL)
{
pdf_cleanup_destination(p, dest);
pdc_error(p->pdc, PDC_E_OPT_NOTFOUND, "name", 0, 0, 0);
}
break;
case filedest:
if (destuse != pdf_bookmark)
{
pdf_cleanup_destination(p, dest);
pdc_error(p->pdc, PDC_E_OPT_ILLKEYWORD, "type", type_name, 0, 0);
}
if (dest->filename == NULL)
{
pdf_cleanup_destination(p, dest);
pdc_error(p->pdc, PDC_E_OPT_NOTFOUND, "filename", 0, 0, 0);
}
break;
default:
break;
}
/* check for minpage */
minpage = (destuse == pdf_bookmark) ? 0 : 1;
switch (destuse)
{
case pdf_nameddest:
case pdf_locallink:
if (page == 0)
{
page = pdf_current_page(p);
}
case pdf_openaction:
case pdf_bookmark:
case pdf_remotelink:
if (page < minpage)
{
const char *stemp = pdc_errprintf(p->pdc, "%d", page);
pdf_cleanup_destination(p, dest);
pdc_error(p->pdc, PDC_E_ILLARG_HANDLE, "page", stemp, 0, 0);
}
break;
}
dest->pgnum = page;
if (destuse != pdf_remotelink && destuse != pdf_openaction && page != 0)
{
dest->page = pdf_get_page_id(p, page);
}
/* remote page number */
if (destuse == pdf_remotelink)
dest->remote_page = page;
return dest;
}
static pdc_id
pdf_write_action(PDF *p, pdf_action *action, pdc_id next_id)
{
pdc_id ret_id = PDC_BAD_ID;
int i, flags = 0;
ret_id = pdc_begin_obj(p->out, PDC_NEW_ID); /* Action object */
pdc_begin_dict(p->out); /* Action dict */
pdc_puts(p->out, "/Type/Action\n");
pdc_printf(p->out, "/S/%s\n",
pdc_get_keyword(action->atype, pdf_action_pdfkeylist));
/* next action */
if (next_id != PDC_BAD_ID)
pdc_objref(p->out, "/Next", next_id);
else
action->obj_id = ret_id;
/* destination */
switch (action->atype)
{
case pdf_goto:
case pdf_gotor:
pdc_puts(p->out, "/D");
pdf_write_destination(p, action->dest);
default:
break;
}
/* file specification */
switch (action->atype)
{
case pdf_gotor:
case pdf_launch:
if (action->newwindow != pdc_undef)
pdc_printf(p->out, "/NewWindow %s\n",
PDC_BOOLSTR(action->newwindow));
case pdf_importdata:
if (action->parameters || action->operation || action->defaultdir)
{
/* Windows-specific launch parameters */
pdc_puts(p->out, "/Win");
pdc_begin_dict(p->out); /* Win dict */
pdc_puts(p->out, "/F");
pdf_put_pdffilename(p, action->nativefilename);
pdc_puts(p->out, "\n");
if (p->compatibility >= PDC_1_7)
{
pdc_puts(p->out, "/UF");
pdf_put_pdfunifilename(p, action->filename);
pdc_puts(p->out, "\n");
}
if (action->parameters)
{
pdc_puts(p->out, "/P");
pdf_put_hypertext(p, action->parameters);
pdc_puts(p->out, "\n");
pdc_free(p->pdc, action->parameters);
action->parameters = NULL;
}
if (action->operation)
{
pdc_puts(p->out, "/O");
pdf_put_hypertext(p, action->operation);
pdc_puts(p->out, "\n");
action->operation = NULL;
}
if (action->defaultdir)
{
pdc_puts(p->out, "/D");
pdf_put_hypertext(p, action->defaultdir);
pdc_puts(p->out, "\n");
pdc_free(p->pdc, action->defaultdir);
action->defaultdir = NULL;
}
pdc_end_dict(p->out); /* Win dict */
}
else
{
pdc_puts(p->out, "/F");
pdc_begin_dict(p->out); /* F dict */
pdc_puts(p->out, "/Type/Filespec\n");
pdc_puts(p->out, "/F");
pdf_put_pdffilename(p, action->nativefilename);
pdc_puts(p->out, "\n");
if (p->compatibility >= PDC_1_7)
{
pdc_puts(p->out, "/UF");
pdf_put_pdfunifilename(p, action->filename);
pdc_puts(p->out, "\n");
}
pdc_end_dict(p->out); /* F dict */
}
default:
break;
}
/* URI */
switch (action->atype)
{
case pdf_uri:
pdc_puts(p->out, "/URI");
pdf_put_hypertext(p, action->filename);
pdc_puts(p->out, "\n");
/* IsMap */
if (action->ismap == pdc_true)
pdc_puts(p->out, "/IsMap true\n");
default:
break;
}
/* Named */
switch (action->atype)
{
case pdf_named:
pdc_puts(p->out, "/N");
pdf_put_pdfname(p, action->menuname);
pdc_puts(p->out, "\n");
default:
break;
}
/* name list */
switch (action->atype)
{
case pdf_hide:
if (action->hide == pdc_false)
pdc_puts(p->out, "/H false\n");
case pdf_submitform:
case pdf_resetform:
if (action->nsnames)
{
pdc_printf(p->out, "/%s",
(action->atype == pdf_hide) ? "T" : "Fields");
pdc_begin_array(p->out);
for (i = 0; i < action->nsnames; i++)
{
pdf_put_hypertext(p, action->namelist[i]);
if (i < action->nsnames - 1)
pdc_puts(p->out, "\n");
else
pdc_end_array(p->out);
}
}
default:
break;
}
/* URL */
switch (action->atype)
{
case pdf_submitform:
pdc_puts(p->out, "/F");
pdc_begin_dict(p->out); /* F dict */
pdc_puts(p->out, "/FS/URL\n");
pdc_printf(p->out, "/F");
pdf_put_hypertext(p, action->filename);
pdc_puts(p->out, "\n");
pdc_end_dict(p->out); /* F dict */
default:
break;
}
/* Trans */
switch (action->atype)
{
case pdf_trans:
pdc_puts(p->out, "/Trans");
pdc_begin_dict(p->out); /* Trans dict */
pdc_puts(p->out, "/Type/Trans\n");
if (action->transition != trans_replace)
pdc_printf(p->out, "/S/%s",
pdc_get_keyword(action->transition, pdf_transition_pdfkeylist));
if (action->duration > 0)
pdc_printf(p->out, "/D %f\n", action->duration);
pdc_end_dict(p->out); /* Trans dict */
default:
break;
}
/* Flags */
switch (action->atype)
{
case pdf_submitform:
flags = (int) action->exportmethod;
if (action->submitemptyfields)
flags |= (1<<1);
if (action->canonicaldate)
flags |= (1<<9);
case pdf_resetform:
if (action->exclude)
flags |= (1<<0);
if (flags)
pdc_printf(p->out, "/Flags %d\n", flags);
default:
break;
}
/* Movie */
pdc_end_dict(p->out); /* Action dict */
pdc_end_obj(p->out); /* Action object */
return ret_id;
}
const char *
pdc_get_handletype(pdc_opttype type)
{
return pdc_get_keyword(type, pdc_handletypes);
}
const char *
pdf__get_parameter(PDF *p, const char *key, double mod)
{
int i = -1;
int imod = (int) mod;
const char *result = "";
pdf_ppt *ppt;
i = pdf_get_index(p, key, pdc_false);
if (parms[i].mod_zero && mod != 0)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM,
pdc_errprintf(p->pdc, "%f", mod), key, 0, 0);
ppt = p->curr_ppt;
switch (i)
{
case PDF_PARAMETER_CAPHEIGHTFAKED:
case PDF_PARAMETER_ASCENDERFAKED:
case PDF_PARAMETER_DESCENDERFAKED:
case PDF_PARAMETER_XHEIGHTFAKED:
if (p->pdc->hastobepos) imod -= 1;
pdf_check_handle(p, imod, pdc_fonthandle);
break;
}
switch (i)
{
case PDF_PARAMETER_BINDING:
result = p->pdc->binding;
break;
case PDF_PARAMETER_OBJORIENT:
result = PDC_BOOLSTR(p->pdc->objorient);
break;
case PDF_PARAMETER_HASTOBEPOS:
result = PDC_BOOLSTR(p->pdc->hastobepos);
break;
case PDF_PARAMETER_PTFRUN:
result = PDC_BOOLSTR(p->pdc->ptfrun);
break;
case PDF_PARAMETER_SMOKERUN:
result = PDC_BOOLSTR(p->pdc->smokerun);
break;
case PDF_PARAMETER_UNICAPLANG:
result = PDC_BOOLSTR(p->pdc->unicaplang);
break;
case PDF_PARAMETER_CONFIGURATION:
result = "lite";
break;
case PDF_PARAMETER_PRODUCT:
result = "PDFlib Lite";
break;
case PDF_PARAMETER_ERRORPOLICY:
result = pdc_get_keyword(p->errorpolicy, pdf_errpol_keylist);
break;
case PDF_PARAMETER_PDIUSEBOX:
result = pdc_get_keyword(p->pdi_usebox, pdf_usebox_keylist);
break;
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:
result = pdc_find_resource_nr(p->pdc, key, imod);
break;
case PDF_PARAMETER_FONTNAME:
result = pdf_get_font_char_option(p, fo_fontname);
break;
case PDF_PARAMETER_FONTENCODING:
result = pdf_get_font_char_option(p, fo_encoding);
break;
case PDF_PARAMETER_FONTSTYLE:
result = pdf_get_font_char_option(p, fo_fontstyle);
break;
case PDF_PARAMETER_ASCENDERFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_ascender));
break;
case PDF_PARAMETER_DESCENDERFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_descender));
break;
case PDF_PARAMETER_CAPHEIGHTFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_capheight));
break;
case PDF_PARAMETER_XHEIGHTFAKED:
result = PDC_BOOLSTR(pdf_font_get_is_faked(&p->fonts[imod],
font_xheight));
break;
case PDF_PARAMETER_UNDERLINE:
result = PDC_BOOLSTR((int) pdf_get_tstate(p, to_underline));
break;
case PDF_PARAMETER_OVERLINE:
result = PDC_BOOLSTR((int) pdf_get_tstate(p, to_overline));
break;
case PDF_PARAMETER_STRIKEOUT:
result = PDC_BOOLSTR((int) pdf_get_tstate(p, to_strikeout));
break;
/* deprecated */
case PDF_PARAMETER_INHERITGSTATE:
result = PDC_BOOLSTR(pdc_false);
break;
case PDF_PARAMETER_SCOPE:
result = pdf_current_scope(p);
break;
case PDF_PARAMETER_TEXTFORMAT:
result = pdc_get_keyword(p->textformat, pdf_textformat_keylist);
break;
case PDF_PARAMETER_HYPERTEXTFORMAT:
result = pdc_get_keyword(p->hypertextformat,pdf_textformat_keylist);
break;
case PDF_PARAMETER_HYPERTEXTENCODING:
result = pdf_get_encoding_name(p, p->hypertextencoding, NULL);
break;
case PDF_PARAMETER_RESOURCEFILE:
result = pdc_get_resourcefile(p->pdc);
break;
/* deprecated */
case PDF_PARAMETER_WARNING:
result = PDC_BOOLSTR(0);
break;
case PDF_PARAMETER_OPENWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'o']);
break;
case PDF_PARAMETER_FONTWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'F']);
break;
case PDF_PARAMETER_ICCWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'I']);
break;
case PDF_PARAMETER_IMAGEWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'i']);
break;
case PDF_PARAMETER_PDIWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'p']);
break;
case PDF_PARAMETER_HONORICCPROFILE:
result = PDC_BOOLSTR((int) p->debug[(int) 'e']);
break;
case PDF_PARAMETER_GLYPHWARNING:
result = PDC_BOOLSTR((int) p->debug[(int) 'g']);
break;
case PDF_PARAMETER_RENDERINGINTENT:
result = pdc_get_keyword(p->rendintent,
pdf_renderingintent_pdfkeylist);
break;
case PDF_PARAMETER_PRESERVEOLDPANTONENAMES:
result = PDC_BOOLSTR(p->preserveoldpantonenames);
break;
case PDF_PARAMETER_SPOTCOLORLOOKUP:
result = PDC_BOOLSTR(p->spotcolorlookup);
break;
case PDF_PARAMETER_PDISTRICT:
result = PDC_BOOLSTR(p->pdi_strict);
break;
case PDF_PARAMETER_TOPDOWN:
result = PDC_BOOLSTR((p->ydirection == -1.0));
break;
case PDF_PARAMETER_USERCOORDINATES:
result = PDC_BOOLSTR(p->usercoordinates);
break;
case PDF_PARAMETER_USEHYPERTEXTENCODING:
result = PDC_BOOLSTR(p->usehyptxtenc);
break;
case PDF_PARAMETER_FILLRULE:
result = pdc_get_keyword(ppt->fillrule, pdf_fillrule_keylist);
break;
case PDF_PARAMETER_COMPATIBILITY:
result = pdc_get_keyword(p->compatibility,
pdf_compatibility_keylist);
break;
case PDF_PARAMETER_STRING:
pdf_check_handle(p, imod, pdc_stringhandle);
result = pdf_get_utilstring(p, imod);
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNSUPPKEY, key, 0, 0, 0);
break;
} /* switch */
return result ? result : "";
} /* pdf__get_parameter */
const char *
fnt_get_ordering_cid(int charcoll)
{
return pdc_get_keyword(charcoll, fnt_charcoll_keylist);
}
PDFLIB_API const char * PDFLIB_CALL
PDF_get_parameter(PDF *p, const char *key, float mod)
{
static const char fn[] = "PDF_get_parameter";
int i = -1;
const char *result = "";
/* some parameters can be retrieved with p == 0.
*/
if (key != NULL && (i = get_index(key)) != -1)
{
switch (i)
{
case PDF_PARAMETER_VERSION:
result = PDFLIB_VERSIONSTRING;
return result;
case PDF_PARAMETER_PDI:
result = "false";
return result;
} /* switch */
}
if (!pdf_enter_api(p, fn, (pdf_state) pdf_state_all,
"(p[%p], \"%s\", %g);", (void *) p, key, mod))
return "";
if (key == NULL || !*key)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "key", 0, 0, 0);
if (i == -1)
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
if ((p->state_stack[p->state_sp] & parms[i].get_scope) == 0)
pdc_error(p->pdc, PDF_E_DOC_SCOPE_GET, key, pdf_current_scope(p), 0, 0);
if (parms[i].mod_zero && mod != (float) 0)
pdc_error(p->pdc, PDC_E_PAR_ILLPARAM,
pdc_errprintf(p->pdc, "%f", mod), key, 0, 0);
switch (i)
{
case PDF_PARAMETER_FONTNAME:
result = pdf_get_fontname(p);
break;
case PDF_PARAMETER_FONTSTYLE:
result = pdf_get_fontstyle(p);
break;
case PDF_PARAMETER_FONTENCODING:
result = pdf_get_fontencoding(p);
break;
case PDF_PARAMETER_UNDERLINE:
result = PDC_BOOLSTR(p->underline);
break;
case PDF_PARAMETER_OVERLINE:
result = PDC_BOOLSTR(p->overline);
break;
case PDF_PARAMETER_STRIKEOUT:
result = PDC_BOOLSTR(p->strikeout);
break;
case PDF_PARAMETER_INHERITGSTATE:
result = PDC_BOOLSTR(p->inheritgs);
break;
case PDF_PARAMETER_SCOPE:
switch (p->state_stack[p->state_sp]) {
case pdf_state_object: result = "object"; break;
case pdf_state_document:result = "document"; break;
case pdf_state_page: result = "page"; break;
case pdf_state_pattern: result = "pattern"; break;
case pdf_state_template:result = "template"; break;
case pdf_state_path: result = "path"; break;
default: result = "(unknown)"; break;
}
break;
case PDF_PARAMETER_TEXTFORMAT:
result = pdc_get_keyword(p->textformat, pdf_textformat_keylist);
break;
case PDF_PARAMETER_HYPERTEXTFORMAT:
result = pdc_get_keyword(p->hypertextformat,pdf_textformat_keylist);
break;
case PDF_PARAMETER_HYPERTEXTENCODING:
result = pdf_get_encoding_name(p, p->hypertextencoding);
break;
default:
pdc_error(p->pdc, PDC_E_PAR_UNKNOWNKEY, key, 0, 0, 0);
break;
} /* switch */
pdc_trace(p->pdc, "[%s]\n", result);
return result;
} /* PDF_get_parameter */
void
pdf_write_doc_extgstates(PDF *p)
{
int i, j;
pdf_extgstateresource *gs;
for (i = 0; i < p->extgstates_number; i++)
{
gs = &p->extgstates[i];
pdc_begin_obj(p->out, gs->obj_id); /* ExtGState resource */
pdc_begin_dict(p->out);
pdc_puts(p->out, "/Type/ExtGState\n");
if (gs->font_obj != PDC_NEW_ID)
{
pdc_puts(p->out, "/Font");
pdc_begin_array(p->out);
pdc_objref(p->out, "", gs->font_obj);
pdc_printf(p->out, "%f", gs->font_size);
pdc_end_array(p->out);
}
if (gs->line_width != pdc_undef)
pdc_printf(p->out, "/LW %f\n", gs->line_width);
if (gs->line_cap != pdc_undef)
pdc_printf(p->out, "/LC %d\n", gs->line_cap);
if (gs->line_join != pdc_undef)
pdc_printf(p->out, "/LJ %d\n", gs->line_join);
if (gs->miter_limit != pdc_undef)
pdc_printf(p->out, "/ML %f\n", gs->miter_limit);
if (gs->dash_count > 0)
{
pdc_printf(p->out, "/D");
pdc_begin_array(p->out);
pdc_begin_array(p->out);
for (j = 0; j < gs->dash_count; ++j)
pdc_printf(p->out, "%f ", gs->dash_array[j]);
pdc_end_array_c(p->out);
pdc_printf(p->out, "%f", gs->dash_phase);
pdc_end_array(p->out);
/* but see page 157 of PDF Reference: integer */
}
if (gs->ri != AutoIntent)
pdc_printf(p->out, "/RI/%s\n",
pdc_get_keyword((long) gs->ri, pdf_renderingintent_pdfkeylist));
if (gs->stroke_adjust != pdc_undef)
pdc_printf(p->out, "/SA %s\n", PDC_BOOLSTR(gs->stroke_adjust));
if (gs->overprint_stroke != pdc_undef)
pdc_printf(p->out, "/OP %s\n", PDC_BOOLSTR(gs->overprint_stroke));
if (gs->overprint_fill != pdc_undef)
pdc_printf(p->out, "/op %s\n", PDC_BOOLSTR(gs->overprint_fill));
else if (gs->overprint_stroke == pdc_true)
pdc_puts(p->out, "/op false\n");
if (gs->overprint_mode != pdc_undef)
pdc_printf(p->out, "/OPM %d\n", gs->overprint_mode);
if (gs->flatness != pdc_undef)
pdc_printf(p->out, "/FL %f\n", gs->flatness);
if (gs->smoothness != pdc_undef)
pdc_printf(p->out, "/SM %f\n", gs->smoothness);
if (gs->opacity_fill != pdc_undef)
pdc_printf(p->out, "/ca %f\n", gs->opacity_fill);
if (gs->blendmode != BM_None) {
const char *modename;
int modecount=0;
for (j = 0; ; j++) {
if (!pdf_blendmode_pdfkeylist[j].word)
break;
if (gs->blendmode & pdf_blendmode_pdfkeylist[j].code)
modecount++;
}
pdc_printf(p->out, "/BM");
/*
* ACROBUG: Acrobat 7 doesn't like Blend mode arrays with a
* singly entry under some circumstances (many entries? images
* involved?) so we avoid the array if we have only one entry.
*/
if (modecount > 1)
pdc_begin_array(p->out);
for (j = 0; ; j++) {
modename = pdf_blendmode_pdfkeylist[j].word;
if (!modename) break;
if (gs->blendmode & pdf_blendmode_pdfkeylist[j].code)
pdc_printf(p->out, "/%s", modename);
}
if (modecount > 1)
pdc_end_array(p->out);
}
if (gs->opacity_stroke != pdc_undef)
pdc_printf(p->out, "/CA %f\n", gs->opacity_stroke);
if (gs->alpha_is_shape != pdc_undef)
pdc_printf(p->out, "/AIS %s\n", PDC_BOOLSTR(gs->alpha_is_shape));
if (gs->text_knockout != pdc_undef)
pdc_printf(p->out, "/TK %s\n", PDC_BOOLSTR(gs->text_knockout));
pdc_end_dict(p->out);
pdc_end_obj(p->out); /* ExtGState resource */
}
}
static int
PFA_data_fill(PDF *p, PDF_data_source *src)
{
static const char *fn = "PFA_data_fill";
pdc_bool logg6 = pdc_logg_is_enabled(p->pdc, 6, trc_font);
#ifndef PDFLIB_EBCDIC
static const char HexToBin['F' - '0' + 1] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
0, 10, 11, 12, 13, 14, 15
};
#else
#endif
char *s, *c;
int i;
int len;
t1_private_data *t1;
pdf_t1portion t1portion;
t1 = (t1_private_data *) src->private_data;
if (t1->portion == t1_eof)
return pdc_false;
if (src->buffer_start == NULL)
{
src->buffer_start = (pdc_byte *)
pdc_malloc(p->pdc, PDC_BUFSIZE + 1, fn);
src->buffer_length = PDC_BUFSIZE;
}
if (logg6)
pdc_logg(p->pdc, "\t\t\tdata fill: portion=%s\n",
pdc_get_keyword(t1->portion, pdf_t1portion_keylist));
s = pdc_fgetline((char *) src->buffer_start, PDC_BUFSIZE, t1->fontfile);
if (s == NULL)
return pdc_false;
/* set unix line end */
len = (int) strlen(s);
s[len] = '\n';
len++;
s[len] = 0;
/* check for line of zeros: set t1_zero flag if found */
if (*s == '0')
{
for (i = 0; s[i] == '0'; i++)
{
/* */ ;
}
if (s[i] == '\n')
{
t1->portion = t1_zeros;
if (logg6)
pdc_logg(p->pdc, "\t\t\tlinefeed detected: set portion %s\n",
pdc_get_keyword(t1->portion,
pdf_t1portion_keylist));
}
}
/* check whether font data portion follows: set t1_encrypted flag later */
t1portion = t1->portion;
if (t1->portion != t1_encrypted &&
!strncmp((const char *)s, PDF_CURRENTFILE, strlen(PDF_CURRENTFILE)))
{
t1portion = t1_encrypted;
if (logg6)
pdc_logg(p->pdc, "\t\t\t\"%s\" detected\n", PDF_CURRENTFILE);
}
src->next_byte = src->buffer_start;
switch (t1->portion)
{
case t1_ascii:
{
t1->length[1] += (size_t) len;
src->bytes_available = (size_t) len;
}
break;
case t1_encrypted:
{
src->bytes_available = 0;
/* Convert to upper case for safe binary conversion */
for (c = s; *c != '\n'; c++)
{
*c = (char) pdc_toupper(*c);
}
/* convert ASCII to binary in-place */
for (i = 0; s[i] != '\n'; i += 2)
{
if ((!pdc_isxdigit(s[i]) && !pdc_isspace(s[i])) ||
(!pdc_isxdigit(s[i+1]) && !pdc_isspace(s[i+1])))
{
pdc_fclose(t1->fontfile);
pdc_error(p->pdc, PDF_E_FONT_CORRUPT_PFA, 0, 0, 0, 0);
}
s[i/2] = (char) (16*HexToBin[s[i]-'0'] + HexToBin[s[i+1]-'0']);
src->bytes_available++;
}
t1->length[2] += src->bytes_available;
}
break;
case t1_zeros:
{
t1->length[3] += (size_t) len;
src->bytes_available = (size_t) len;
}
break;
default:
break;
}
t1->portion = t1portion;
if (logg6)
pdc_logg(p->pdc, "\t\t\tset portion %s\n",
pdc_get_keyword(t1->portion, pdf_t1portion_keylist));
return pdc_true;
}
pdc_bool
pdf_parse_and_write_actionlist(PDF *p, pdf_event_object eventobj,
pdc_id *act_idlist, const char *optlist)
{
const pdc_defopt *defopttable = NULL;
const pdc_keyconn *keyconntable = NULL;
pdc_resopt *resopts = NULL;
pdc_clientdata data;
pdc_id ret_id = PDC_BAD_ID;
pdf_action *action = NULL;
pdc_bool calcevent = pdc_false;
const char *keyword, *type;
char **strlist;
int *actlist;
int i, code, nsact, beginjava = 0;
switch(eventobj)
{
case event_annotation:
defopttable = pdf_annotevent_options;
keyconntable = pdf_annotevent_keylist;
beginjava = pdf_annotevent_beginjava;
break;
case event_bookmark:
defopttable = pdf_bookmarkevent_options;
keyconntable = pdf_bookmarkevent_keylist;
beginjava = pdf_bookmarkevent_beginjava;
break;
case event_document:
defopttable = pdf_documentevent_options;
keyconntable = pdf_documentevent_keylist;
beginjava = pdf_documentevent_beginjava;
break;
case event_page:
defopttable = pdf_pageevent_options;
keyconntable = pdf_pageevent_keylist;
beginjava = pdf_pageevent_beginjava;
break;
default:
break;
}
/* parsing option list */
pdf_set_clientdata(p, &data);
resopts = pdc_parse_optionlist(p->pdc, optlist, defopttable,
&data, pdc_true);
/* write actions and saving action ids */
for (code = 0; ; code++)
{
keyword = pdc_get_keyword(code, keyconntable);
if (keyword)
{
nsact = pdc_get_optvalues(keyword, resopts, NULL, &strlist);
actlist = (int *) strlist;
/* Not activate event */
if (code && nsact)
{
/* additional action type check */
for (i = 0; i < nsact; i++)
{
action = (pdf_action *) &pdc_vtr_at(p->actions, actlist[i],
pdf_action);
if (code >= beginjava && action->atype != pdf_javascript)
{
type = pdc_get_keyword(action->atype,
pdf_action_pdfkeylist);
pdc_error(p->pdc, PDF_E_ACT_BADACTTYPE,
type, keyword, 0, 0);
}
}
/* saving calculation event */
if (!strcmp(keyword, "calculate"))
calcevent = pdc_true;
}
/* write action objects */
if (act_idlist != NULL)
{
ret_id = PDC_BAD_ID;
if (nsact == 1)
{
action = (pdf_action *) &pdc_vtr_at(p->actions, actlist[0],
pdf_action);
if (action->obj_id == PDC_BAD_ID)
ret_id = pdf_write_action(p, action, ret_id);
else
ret_id = action->obj_id;
}
else if (nsact > 1)
{
for (i = nsact-1; i >= 0; i--)
{
action = (pdf_action *) &pdc_vtr_at(p->actions,
actlist[i], pdf_action);
ret_id = pdf_write_action(p, action, ret_id);
}
}
act_idlist[code] = ret_id;
}
}
else
break;
}
return calcevent;
}
pdc_bool
pdf_write_action_entries(PDF *p, pdf_event_object eventobj, pdc_id *act_idlist)
{
const pdc_keyconn *keyconntable = NULL;
const char *keyword;
pdc_id act_id = PDC_BAD_ID;
pdc_bool adict = pdc_false;
pdc_bool aadict = pdc_false;
int code;
switch(eventobj)
{
case event_annotation:
keyconntable = pdf_annotevent_pdfkeylist;
break;
case event_bookmark:
keyconntable = pdf_bookmarkevent_pdfkeylist;
break;
case event_document:
keyconntable = pdf_documentevent_pdfkeylist;
break;
case event_page:
keyconntable = pdf_pageevent_pdfkeylist;
break;
default:
break;
}
for (code = 0; ; code++)
{
keyword = pdc_get_keyword(code, keyconntable);
if (keyword)
{
act_id = act_idlist[code];
if (act_id != PDC_BAD_ID)
{
if (code && !aadict)
{
pdc_puts(p->out, "/AA");
pdc_begin_dict(p->out); /* AA dict */
aadict = pdc_true;
}
else if (!code)
adict = pdc_true;
pdc_printf(p->out, "/%s", keyword);
pdc_objref_c(p->out, act_id);
}
}
else
break;
}
if (aadict)
pdc_end_dict(p->out); /* AA dict */
else if (adict)
pdc_puts(p->out, "\n");
return adict;
}
pdc_resopt *
pdc_parse_optionlist(pdc_core *pdc, const char *optlist,
const pdc_defopt *defopt,
const pdc_clientdata *clientdata, pdc_bool verbose)
{
static const char *fn = "pdc_parse_optionlist";
pdc_bool logg5 = pdc_logg_is_enabled(pdc, 5, trc_optlist);
const char *stemp1 = NULL, *stemp2 = NULL, *stemp3 = NULL, *s1, *s2;
char **items = NULL, *keyword = NULL;
char **values = NULL, *value = NULL, **strings = NULL;
int i, j, k, nd, is, iss, it, iv, icoord;
int numdef, nitems = 0, nvalues, ncoords = 0, errcode = 0;
void *resval;
double dz, maxval;
int retval, iz;
pdc_sint32 lz = 0;
pdc_uint32 ulz = 0;
size_t len;
const pdc_defopt *dopt = NULL;
pdc_resopt *resopt = NULL;
pdc_bool ignore = pdc_false;
pdc_bool boolval = pdc_false;
pdc_bool tocheck = pdc_false;
pdc_bool issorted = pdc_true;
pdc_bool ishandle = pdc_true;
pdc_bool isutf8 = pdc_false;
pdc_logg_cond(pdc, 1, trc_optlist, "\n\tOption list: \"%T\"\n",
optlist ? optlist : "", 0);
/* split option list */
if (optlist != NULL)
{
nitems = pdc_split_stringlist(pdc, optlist, PDC_OPT_LISTSEPS,
PDC_SPLIT_ISOPTLIST, &items);
isutf8 = pdc_is_utf8_bytecode(optlist);
}
if (nitems < 0)
{
keyword = (char *) optlist;
errcode = PDC_E_OPT_NOTBAL;
goto PDC_OPT_SYNTAXERROR;
}
/* initialize result list */
for (numdef = 0; defopt[numdef].name != NULL; numdef++)
{
/* */ ;
}
/* allocate temporary memory for option parser result struct */
resopt = (pdc_resopt *) pdc_calloc_tmp(pdc, numdef * sizeof(pdc_resopt),
fn, pdc, pdc_cleanup_optionlist_tmp);
for (i = 0; i < numdef; i++)
{
resopt[i].numdef = numdef;
resopt[i].defopt = &defopt[i];
if (defopt[i].flags & PDC_OPT_IGNOREIF1 ||
defopt[i].flags & PDC_OPT_IGNOREIF2 ||
defopt[i].flags & PDC_OPT_REQUIRIF1 ||
defopt[i].flags & PDC_OPT_REQUIRIF2 ||
defopt[i].flags & PDC_OPT_REQUIRED)
tocheck = pdc_true;
if (i && issorted)
issorted = (strcmp(defopt[i-1].name, defopt[i].name) <= 0) ?
pdc_true : pdc_false;
}
/* loop over all option list elements */
for (is = 0; is < nitems; is++)
{
pdc_bool isequal = pdc_false;
/* search keyword */
boolval = pdc_undef;
keyword = items[is];
for (it = 0; it < numdef; it++)
{
s1 = keyword;
s2 = defopt[it].name;
/* if (!pdc_stricmp(keyword, defopt[it].name))
* isequal = pdc_true;
*/
for (; *s1; ++s1, ++s2)
{
if (pdc_tolower(*s1) != pdc_tolower(*s2))
break;
}
if (pdc_tolower(*s1) == pdc_tolower(*s2))
isequal = pdc_true;
/* special handling for booleans */
if (defopt[it].type == pdc_booleanlist)
{
if (isequal ||
(keyword[1] != 0 &&
!pdc_stricmp(&keyword[2], defopt[it].name)))
{
iss = is + 1;
if (iss == nitems ||
(pdc_stricmp(items[iss], "true") &&
pdc_stricmp(items[iss], "false")))
{
i = pdc_strincmp(defopt[it].name, "no", 2) ? 0 : 2;
if (!pdc_strincmp(&keyword[i], "no", 2))
{
boolval = pdc_false;
break;
}
else if (isequal)
{
boolval = pdc_true;
break;
}
}
}
}
if (isequal)
break;
}
if (logg5)
pdc_logg(pdc, "\t\t\toption \"%s\" specified: ", keyword);
if (it == numdef)
{
errcode = PDC_E_OPT_UNKNOWNKEY;
goto PDC_OPT_SYNTAXERROR;
}
/* initialize */
dopt = &defopt[it];
ignore = pdc_false;
nvalues = 1;
values = NULL;
ishandle = pdc_true;
/* compatibility */
if (clientdata && clientdata->compatibility)
{
int compatibility = clientdata->compatibility;
for (iv = PDC_1_3; iv <= PDC_X_X_LAST; iv++)
{
if (logg5 && (dopt->flags & (1L<<iv)))
pdc_logg(pdc, "(compatibility >= %s) ",
pdc_get_pdfversion(pdc, iv));
if ((dopt->flags & (1L<<iv)) && compatibility < iv)
{
if (logg5)
pdc_logg(pdc, "\n");
stemp2 = pdc_get_pdfversion(pdc, compatibility);
errcode = PDC_E_OPT_VERSION;
goto PDC_OPT_SYNTAXERROR;
}
}
}
/* not supported */
if (dopt->flags & PDC_OPT_UNSUPP)
{
if (logg5)
pdc_logg(pdc, "(unsupported)\n");
keyword = (char *) dopt->name;
errcode = PDC_E_OPT_UNSUPP;
goto PDC_OPT_SYNTAXERROR;
}
/* parse values */
if (boolval == pdc_undef)
{
is++;
if (is == nitems)
{
errcode = PDC_E_OPT_NOVALUES;
goto PDC_OPT_SYNTAXERROR;
}
if (!ignore)
{
if (dopt->type == pdc_stringlist &&
pdc_is_utf8_bytecode(items[is]))
resopt[it].flags |= PDC_OPT_ISUTF8;
if (dopt->type != pdc_stringlist || dopt->maxnum > 1)
nvalues = pdc_split_stringlist(pdc, items[is],
(dopt->flags & PDC_OPT_SUBOPTLIST) ?
PDC_OPT_LISTSEPS : NULL,
PDC_SPLIT_ISOPTLIST, &values);
if (dopt->flags & PDC_OPT_DUPORIGVAL)
resopt[it].origval = pdc_strdup(pdc, items[is]);
}
}
/* ignore */
if (ignore) continue;
/* number of values check */
if (nvalues < dopt->minnum)
{
stemp2 = pdc_errprintf(pdc, "%d", dopt->minnum);
errcode = PDC_E_OPT_TOOFEWVALUES;
goto PDC_OPT_SYNTAXERROR;
}
else if (nvalues > dopt->maxnum)
{
stemp2 = pdc_errprintf(pdc, "%d", dopt->maxnum);
errcode = PDC_E_OPT_TOOMANYVALUES;
goto PDC_OPT_SYNTAXERROR;
}
/* number of values must be even */
if (dopt->flags & PDC_OPT_EVENNUM && (nvalues % 2))
{
errcode = PDC_E_OPT_ODDNUM;
goto PDC_OPT_SYNTAXERROR;
}
/* number of values must be odd */
if (dopt->flags & PDC_OPT_ODDNUM && !(nvalues % 2))
{
errcode = PDC_E_OPT_EVENNUM;
goto PDC_OPT_SYNTAXERROR;
}
/* deprecated option since PDFlib 7 */
if (dopt->flags & PDC_OPT_PDFLIB_7)
{
pdc_logg_cond(pdc, 2, trc_api,
"[Option \"%s\" is deprecated since PDFlib 7]\n",
keyword);
}
/* option already exists */
if (resopt[it].num)
{
pdc_delete_optvalue(pdc, &resopt[it]);
}
/* no values */
if (!nvalues ) continue;
/* maximal value */
switch (dopt->type)
{
case pdc_3ddatahandle:
maxval = clientdata->max3ddata;
break;
case pdc_3dviewhandle:
maxval = clientdata->max3dview;
break;
case pdc_actionhandle:
maxval = clientdata->maxaction;
break;
case pdc_bookmarkhandle:
maxval = clientdata->maxbookmark;
break;
case pdc_colorhandle:
maxval = clientdata->maxcolor;
break;
case pdc_documenthandle:
maxval = clientdata->maxdocument;
break;
case pdc_fonthandle:
maxval = clientdata->maxfont;
break;
case pdc_gstatehandle:
maxval = clientdata->maxgstate;
break;
case pdc_iccprofilehandle:
maxval = clientdata->maxiccprofile;
break;
case pdc_imagehandle:
maxval = clientdata->maximage;
break;
case pdc_layerhandle:
maxval = clientdata->maxlayer;
break;
case pdc_pagehandle:
maxval = clientdata->maxpage;
break;
case pdc_patternhandle:
maxval = clientdata->maxpattern;
break;
case pdc_shadinghandle:
maxval = clientdata->maxshading;
break;
case pdc_tablehandle:
maxval = clientdata->maxtable;
break;
case pdc_templatehandle:
maxval = clientdata->maxtemplate;
break;
case pdc_textflowhandle:
maxval = clientdata->maxtextflow;
break;
case pdc_stringhandle:
maxval = clientdata->maxstring;
break;
case pdc_polylinelist:
ncoords = 0;
default:
maxval = dopt->maxval;
ishandle = pdc_false;
break;
}
/* allocate value array */
resopt[it].val = pdc_calloc(pdc,
(size_t) (nvalues * pdc_typesizes[dopt->type]), fn);
resopt[it].num = nvalues;
resopt[it].currind = it;
if (dopt->flags & PDC_OPT_PERCENT)
memset(resopt[it].pcbits, 0, PDC_PCBITS_SIZE);
if (logg5)
pdc_logg(pdc, "{");
/* analyze type */
resval = resopt[it].val;
for (iv = 0; iv < nvalues; iv++)
{
errcode = 0;
if (dopt->maxnum > 1 && nvalues)
value = values[iv];
else
value = items[is];
if (logg5)
pdc_logg(pdc, "%s{%T}", iv ? " " : "", value, 0);
switch (dopt->type)
{
/* boolean list */
case pdc_booleanlist:
if (boolval == pdc_true || !pdc_stricmp(value, "true"))
{
*(pdc_bool *) resval = pdc_true;
}
else if (boolval == pdc_false || !pdc_stricmp(value, "false"))
{
*(pdc_bool *) resval = pdc_false;
}
else
{
errcode = PDC_E_OPT_ILLBOOLEAN;
}
break;
/* string list */
case pdc_stringlist:
if (dopt->flags & PDC_OPT_NOSPACES)
{
if (pdc_split_stringlist(pdc, value, NULL, 0, &strings) > 1)
errcode = PDC_E_OPT_ILLSPACES;
pdc_cleanup_stringlist(pdc, strings);
}
if (!errcode)
{
len = strlen(value);
dz = (double) len;
if (dz < dopt->minval)
{
stemp3 = pdc_errprintf(pdc, "%d", (int) dopt->minval);
errcode = PDC_E_OPT_TOOSHORTSTR;
}
else if (dz > maxval)
{
stemp3 = pdc_errprintf(pdc, "%d", (int) maxval);
errcode = PDC_E_OPT_TOOLONGSTR;
}
if (dopt->flags & PDC_OPT_CONVUTF8)
{
int flags = PDC_CONV_EBCDIC | PDC_CONV_WITHBOM;
if (isutf8 || (resopt[it].flags & PDC_OPT_ISUTF8))
flags |= PDC_CONV_ISUTF8;
*((char **) resval) =
pdc_convert_name(pdc, value, 0, flags);
}
else
{
*((char **) resval) = pdc_strdup(pdc, value);
}
}
break;
/* keyword list */
case pdc_keywordlist:
if (dopt->flags & PDC_OPT_CASESENS)
iz = pdc_get_keycode(value, dopt->keylist);
else
iz = pdc_get_keycode_ci(value, dopt->keylist);
if (iz == PDC_KEY_NOTFOUND)
{
errcode = PDC_E_OPT_ILLKEYWORD;
}
else
{
*(int *) resval = iz;
}
break;
/* character list */
case pdc_unicharlist:
iz = pdc_string2unicode(pdc, value, dopt->flags, dopt->keylist,
pdc_false);
if (iz < 0)
{
errcode = PDC_E_OPT_ILLCHAR;
break;
}
dz = iz;
if (dz < dopt->minval)
{
stemp3 = pdc_errprintf(pdc, "%g", dopt->minval);
errcode = PDC_E_OPT_TOOSMALLVAL;
}
else if (dz > maxval)
{
stemp3 = pdc_errprintf(pdc, "%g", maxval);
errcode = PDC_E_OPT_TOOBIGVAL;
}
*(int *) resval = iz;
break;
/* string list */
case pdc_polylinelist:
{
int np = pdc_split_stringlist(pdc, value, NULL, 0,
&strings);
pdc_polyline *pl = (pdc_polyline *) resval;
pl->np = np / 2;
pl->p = NULL;
/* number of coordinates must be even */
if (np % 2)
{
errcode = PDC_E_OPT_ODDNUM;
np = 0;
}
/* polyline must be a box */
else if ((dopt->flags & PDC_OPT_ISBOX) && np != 4)
{
errcode = PDC_E_OPT_ILLBOX;
np = 0;
}
/* polyline will be closed */
else if ((dopt->flags & PDC_OPT_CLOSEPOLY) && np <= 4)
{
errcode = PDC_E_OPT_ILLPOLYLINE;
np = 0;
}
/* polyline not empty */
if (np)
{
if (dopt->flags & PDC_OPT_CLOSEPOLY)
pl->np += 1;
pl->p = (pdc_vector *) pdc_malloc(pdc,
pl->np * sizeof(pdc_vector), fn);
iz = PDC_KEY_NOTFOUND;
j = 0;
icoord = ncoords;
for (i = 0; i < np; i++)
{
char *sk = strings[i];
if (dopt->keylist)
{
/* optional keyword list */
if (dopt->flags & PDC_OPT_CASESENS)
iz = pdc_get_keycode(sk, dopt->keylist);
else
iz = pdc_get_keycode_ci(sk, dopt->keylist);
}
if (iz == PDC_KEY_NOTFOUND)
{
/* percentage */
if (dopt->flags & PDC_OPT_PERCENT)
{
k = (int) strlen(sk) - 1;
if (sk[k] == '%')
{
sk[k] = 0;
if (ncoords < PDC_MAX_PERCENTS)
{
pdc_setbit(resopt[it].pcbits,
ncoords);
}
else
{
errcode = PDC_E_OPT_TOOMANYPERCVALS;
}
}
}
retval = pdc_str2double(sk, &dz);
if (!retval)
{
errcode = PDC_E_OPT_ILLNUMBER;
}
else if (pdc_getbit(resopt[it].pcbits, ncoords))
{
if (dopt->flags & PDC_OPT_PERCRANGE)
{
if (dz < 0)
errcode = PDC_E_OPT_TOOSMALLPERCVAL;
if (dz > 100)
errcode = PDC_E_OPT_TOOBIGPERCVAL;
}
dz /= 100.0;
}
}
else
{
dz = (double) iz;
}
if (!(i % 2))
{
pl->p[j].x = dz;
}
else
{
pl->p[j].y = dz;
j++;
}
ncoords++;
}
if (dopt->flags & PDC_OPT_CLOSEPOLY)
{
pl->p[pl->np - 1] = pl->p[0];
if (pdc_getbit(resopt[it].pcbits, icoord))
pdc_setbit(resopt[it].pcbits, ncoords);
ncoords++;
if (pdc_getbit(resopt[it].pcbits, icoord + 1))
pdc_setbit(resopt[it].pcbits, ncoords);
ncoords++;
}
}
pdc_cleanup_stringlist(pdc, strings);
}
break;
/* number list */
case pdc_3ddatahandle:
case pdc_3dviewhandle:
case pdc_actionhandle:
case pdc_bookmarkhandle:
case pdc_colorhandle:
case pdc_documenthandle:
case pdc_fonthandle:
case pdc_gstatehandle:
case pdc_iccprofilehandle:
case pdc_imagehandle:
case pdc_layerhandle:
case pdc_pagehandle:
case pdc_patternhandle:
case pdc_shadinghandle:
case pdc_tablehandle:
case pdc_templatehandle:
case pdc_textflowhandle:
case pdc_integerlist:
case pdc_floatlist:
case pdc_doublelist:
case pdc_scalarlist:
if (dopt->keylist &&
(!(dopt->flags & PDC_OPT_KEYLIST1) || !iv))
{
/* optional keyword and/or allowed integer list */
if (dopt->flags & PDC_OPT_CASESENS)
iz = pdc_get_keycode(value, dopt->keylist);
else
iz = pdc_get_keycode_ci(value, dopt->keylist);
if (iz == PDC_KEY_NOTFOUND)
{
if (dopt->flags & PDC_OPT_INTLIST)
{
errcode = PDC_E_OPT_ILLINTEGER;
break;
}
}
else
{
switch (dopt->type)
{
default:
case pdc_integerlist:
*(int *) resval = iz;
break;
case pdc_floatlist:
*(float *) resval = (float) iz;
break;
case pdc_doublelist:
*(double *) resval = (double) iz;
break;
case pdc_scalarlist:
*(pdc_scalar *) resval = (pdc_scalar) iz;
break;
}
break;
}
}
/* percentage */
if (dopt->flags & PDC_OPT_PERCENT)
{
i = (int) strlen(value) - 1;
if (value[i] == '%')
{
value[i] = 0;
if (iv < PDC_MAX_PERCENTS)
{
pdc_setbit(resopt[it].pcbits, iv);
}
else
{
errcode = PDC_E_OPT_TOOMANYPERCVALS;
}
}
}
case pdc_stringhandle:
if (dopt->type == pdc_floatlist ||
dopt->type == pdc_doublelist ||
dopt->type == pdc_scalarlist)
{
retval = pdc_str2double(value, &dz);
}
else
{
if (dopt->minval >= 0)
{
retval = pdc_str2integer(value, PDC_INT_UNSIGNED, &ulz);
dz = ulz;
}
else
{
retval = pdc_str2integer(value, 0, &lz);
dz = lz;
}
if (retval && ishandle && pdc->hastobepos &&
dopt->type != pdc_bookmarkhandle &&
dopt->type != pdc_stringhandle)
{
dz -= 1;
lz = (pdc_sint32) dz;
ulz = (pdc_uint32) dz;
}
}
if (!retval)
{
errcode = PDC_E_OPT_ILLNUMBER;
}
else
{
if (pdc_getbit(resopt[it].pcbits, iv))
{
if (dopt->flags & PDC_OPT_PERCRANGE)
{
if (dz < 0)
errcode = PDC_E_OPT_TOOSMALLPERCVAL;
if (dz > 100)
errcode = PDC_E_OPT_TOOBIGPERCVAL;
}
dz /= 100.0;
}
if (errcode == 0)
{
if (dz < dopt->minval)
{
if (ishandle)
{
stemp3 = pdc_get_keyword(dopt->type,
pdc_handletypes);
errcode = PDC_E_OPT_ILLHANDLE;
}
else
{
stemp3 = pdc_errprintf(pdc, "%g", dopt->minval);
errcode = PDC_E_OPT_TOOSMALLVAL;
}
}
else if (dz > maxval)
{
if (ishandle)
{
stemp3 = pdc_get_keyword(dopt->type,
pdc_handletypes);
errcode = PDC_E_OPT_ILLHANDLE;
}
else
{
stemp3 = pdc_errprintf(pdc, "%g", maxval);
errcode = PDC_E_OPT_TOOBIGVAL;
}
}
else if (dopt->flags & PDC_OPT_NOZERO &&
fabs(dz) < PDC_FLOAT_PREC)
{
errcode = PDC_E_OPT_ZEROVAL;
}
else if (dopt->type == pdc_scalarlist)
{
*(pdc_scalar *) resval = dz;
}
else if (dopt->type == pdc_doublelist)
{
*(double *) resval = dz;
}
else if (dopt->type == pdc_floatlist)
{
*(float *) resval = (float) dz;
}
else
{
if (dopt->minval >= 0)
*(pdc_uint32 *) resval = ulz;
else
*(pdc_sint32 *) resval = lz;
}
}
}
break;
}
if (errcode)
{
stemp2 = pdc_errprintf(pdc, "%.*s", PDC_ERR_MAXSTRLEN, value);
goto PDC_OPT_SYNTAXERROR;
}
/* increment value pointer */
resval = (void *) ((char *)(resval) + pdc_typesizes[dopt->type]);
}
pdc_cleanup_stringlist(pdc, values);
values = NULL;
if (logg5)
pdc_logg(pdc, "}\n");
/* build OR bit pattern */
if (dopt->flags & PDC_OPT_BUILDOR && nvalues > 1)
{
int *bcode = (int *) resopt[it].val;
for (iv = 1; iv < nvalues; iv++)
{
bcode[0] |= bcode[iv];
}
resopt[it].num = 1;
}
}
pdc_cleanup_stringlist(pdc, items);
items = NULL;
/* required and to be ignored options */
for (is = 0; tocheck && is < numdef; is++)
{
/* to be ignored option */
if (resopt[is].num)
{
nd = 0;
if (defopt[is].flags & PDC_OPT_IGNOREIF1) nd = 1;
if (defopt[is].flags & PDC_OPT_IGNOREIF2) nd = 2;
for (it = is - 1; it >= is - nd && it >= 0; it--)
{
if (resopt[it].num)
{
pdc_delete_optvalue(pdc, &resopt[is]);
if (verbose)
pdc_warning(pdc, PDC_E_OPT_IGNORE, defopt[is].name,
defopt[it].name, 0, 0);
}
}
}
/* required option */
if (!resopt[is].num &&
((defopt[is].flags & PDC_OPT_REQUIRED) ||
(defopt[is].flags & PDC_OPT_REQUIRIF1 && resopt[is-1].num) ||
(defopt[is].flags & PDC_OPT_REQUIRIF2 &&
(resopt[is-1].num || resopt[is-2].num))))
{
keyword = (char *) defopt[is].name;
errcode = PDC_E_OPT_NOTFOUND;
goto PDC_OPT_SYNTAXERROR;
}
}
/* is no sorted */
if (!issorted)
{
qsort((void *)resopt, (size_t) numdef, sizeof(pdc_resopt),
pdc_optname_compare);
}
/* global UTF-8 check after sort */
if (isutf8)
resopt[0].isutf8 = pdc_true;
/* index of last got option */
resopt[0].lastind = -1;
/* protocol */
if (pdc_logg_is_enabled(pdc, 1, trc_optlist))
{
for (is = 0; is < numdef; is++)
{
if (resopt[is].num)
pdc_logg(pdc, "\tOption \"%s\": %d value%s found\n",
resopt[is].defopt->name, resopt[is].num,
resopt[is].num == 1 ? "" : "s");
else if (logg5)
pdc_logg(pdc, "\t\t\toption \"%s\" not specified\n",
resopt[is].defopt->name);
for (iv = 0; iv < resopt[is].num; iv++)
{
switch (resopt[is].defopt->type)
{
case pdc_booleanlist:
case pdc_keywordlist:
case pdc_integerlist:
case pdc_3ddatahandle:
case pdc_3dviewhandle:
case pdc_actionhandle:
case pdc_bookmarkhandle:
case pdc_colorhandle:
case pdc_documenthandle:
case pdc_fonthandle:
case pdc_gstatehandle:
case pdc_iccprofilehandle:
case pdc_imagehandle:
case pdc_layerhandle:
case pdc_pagehandle:
case pdc_patternhandle:
case pdc_shadinghandle:
case pdc_tablehandle:
case pdc_templatehandle:
case pdc_textflowhandle:
case pdc_stringhandle:
pdc_logg(pdc, "\tValue %d: %d\n",
iv + 1, *((int *) resopt[is].val + iv));
break;
case pdc_stringlist:
pdc_logg(pdc, "\tValue %d: \"%T\"\n",
iv + 1, *((char **) resopt[is].val + iv), 0);
break;
case pdc_floatlist:
pdc_logg(pdc, "\tValue %d: %f\n",
iv + 1, *((float *) resopt[is].val + iv));
break;
case pdc_doublelist:
pdc_logg(pdc, "\tValue %d: %f\n",
iv + 1, *((double *) resopt[is].val + iv));
break;
case pdc_scalarlist:
pdc_logg(pdc, "\tValue %d: %f\n",
iv + 1, *((pdc_scalar *) resopt[is].val + iv));
break;
case pdc_unicharlist:
pdc_logg(pdc, "\tValue %d: %d\n",
iv + 1, *((int *) resopt[is].val + iv));
break;
case pdc_polylinelist:
pdc_logg(pdc, "\t\t#%d: ", iv + 1);
{
pdc_polyline *pl = (pdc_polyline *) resopt[is].val + iv;
for (j = 0; j < pl->np; j++)
pdc_logg(pdc, "%f,%f ", pl->p[j].x, pl->p[j].y);
pdc_logg(pdc, "\n");
}
break;
}
}
}
}
return resopt;
PDC_OPT_SYNTAXERROR:
stemp1 = pdc_errprintf(pdc, "%.*s", PDC_ERR_MAXSTRLEN, keyword);
pdc_cleanup_stringlist(pdc, items);
pdc_cleanup_stringlist(pdc, values);
pdc_set_errmsg(pdc, errcode, stemp1, stemp2, stemp3, 0);
if (verbose)
pdc_error(pdc, -1, 0, 0, 0, 0);
return NULL;
}
int
pdf__create_action(PDF *p, const char *type, const char *optlist)
{
pdc_resopt *resopts = NULL;
pdc_clientdata data;
pdf_action *action;
pdf_actiontype atype;
pdf_dest *dest = NULL;
pdc_bool verbose = pdc_true;
pdc_bool hasdest = pdc_false;
pdc_encoding htenc;
int htcp;
const char *keyword;
char **strlist;
int i, k, ns;
if (type == NULL || *type == '\0')
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "type", 0, 0, 0);
k = pdc_get_keycode_ci(type, pdf_action_pdfkeylist);
if (k == PDC_KEY_NOTFOUND)
pdc_error(p->pdc, PDC_E_ILLARG_STRING, "type", type, 0, 0);
atype = (pdf_actiontype) k;
if (atype == pdf_javascript)
pdc_error(p->pdc, PDF_E_UNSUPP_JAVASCRIPT, 0, 0, 0, 0);
/* compatibility */
if (p->compatibility < PDC_1_6 && atype == pdf_goto3dview)
{
pdc_error(p->pdc, PDC_E_PAR_VERSION, type,
pdc_get_pdfversion(p->pdc, PDC_1_6), 0, 0);
}
if (p->compatibility < PDC_1_5 &&
(atype == pdf_setocgstate || atype == pdf_trans))
{
pdc_error(p->pdc, PDC_E_PAR_VERSION, type,
pdc_get_pdfversion(p->pdc, PDC_1_5), 0, 0);
}
/* new action */
action = pdf_new_action(p);
action->atype = atype;
/* Parsing option list */
pdf_set_clientdata(p, &data);
resopts = pdc_parse_optionlist(p->pdc, optlist, pdf_create_action_options,
&data, pdc_true);
keyword = "actionwarning";
pdc_get_optvalues(keyword, resopts, &verbose, NULL);
verbose = pdf_get_errorpolicy(p, resopts, verbose);
htenc = pdf_get_hypertextencoding_opt(p, resopts, &htcp, pdc_true);
keyword = "destination";
if (pdc_get_optvalues(keyword, resopts, NULL, &strlist))
{
if (!pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) (pdf_goto | pdf_gotor)))
{
action->dest = pdf_parse_destination_optlist(p, strlist[0],
(atype == pdf_goto) ? 0 : 1,
(atype == pdf_goto) ? pdf_locallink : pdf_remotelink);
hasdest = pdc_true;
}
}
else
{
keyword = "destname";
if (atype == pdf_goto || atype == pdf_gotor)
dest = pdf_get_option_destname(p, resopts, htenc, htcp);
else if (pdc_get_optvalues(keyword, resopts, NULL, NULL))
pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) (pdf_goto | pdf_gotor));
if (dest)
{
action->dest = dest;
hasdest = pdc_true;
}
}
/* filename or url */
for (i = 0; ; i++)
{
keyword = pdf_filename_keylist[i].word;
if (keyword == NULL)
break;
if (!pdc_get_optvalues(keyword, resopts, NULL, NULL) ||
pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) pdf_filename_keylist[i].code))
continue;
/* DON'T change order */
/* native filename */
if (!i)
action->nativefilename = pdf_get_opt_filename(p, keyword, resopts,
htenc, htcp);
/* Unicode filename */
pdf_get_opt_textlist(p, keyword, resopts, htenc, htcp, pdc_true,
NULL, &action->filename, NULL);
pdc_save_lastopt(resopts, PDC_OPT_SAVE1ELEM);
}
keyword = "parameters";
if (pdc_get_optvalues(keyword, resopts, NULL, NULL) &&
!pdf_opt_effectless(p, keyword, atype, pdf_launch))
action->parameters =
(char *) pdc_save_lastopt(resopts, PDC_OPT_SAVE1ELEM);
keyword = "operation";
if (pdc_get_optvalues(keyword, resopts, &k, NULL) &&
!pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) (pdf_launch | pdf_movie)))
{
if ((atype == pdf_launch && k >= PDF_MIN_MOVIEKEY) ||
(atype == pdf_movie && k < PDF_MIN_MOVIEKEY))
{
pdc_error(p->pdc, PDC_E_OPT_ILLKEYWORD, keyword,
pdc_get_keyword(k, pdf_operation_pdfkeylist), 0, 0);
}
action->operation =
(char *) pdc_get_keyword(k, pdf_operation_pdfkeylist);
}
keyword = "defaultdir";
if (pdc_get_optvalues(keyword, resopts, NULL, NULL) &&
!pdf_opt_effectless(p, keyword, atype, pdf_launch))
action->defaultdir =
(char *) pdc_save_lastopt(resopts, PDC_OPT_SAVE1ELEM);
keyword = "menuname";
if (pdc_get_optvalues(keyword, resopts, NULL, NULL) &&
!pdf_opt_effectless(p, keyword, atype, pdf_named))
{
action->menuname =
(char *) pdc_save_lastopt(resopts, PDC_OPT_SAVE1ELEM);
}
keyword = "namelist";
ns = pdc_get_optvalues(keyword, resopts, NULL, NULL);
if (ns && !pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) (pdf_hide | pdf_submitform | pdf_resetform)))
{
action->namelist = (char **) pdc_save_lastopt(resopts, PDC_OPT_SAVEALL);
action->nsnames = ns;
}
keyword = "exportmethod";
if (pdc_get_optvalues(keyword, resopts, &k, NULL))
{
action->exportmethod = (pdf_exportmethod) k;
if (!pdf_opt_effectless(p, keyword, atype, pdf_submitform))
{
if ((action->exportmethod & pdf_exp_fdf &&
(action->exportmethod | pdf_allfdf) != pdf_allfdf) ||
(action->exportmethod & pdf_exp_html &&
(action->exportmethod | pdf_allhtml) != pdf_allhtml) ||
(action->exportmethod & pdf_exp_xfdf &&
(action->exportmethod | pdf_allxfdf) != pdf_allxfdf) ||
(action->exportmethod & pdf_exp_pdf &&
(action->exportmethod | pdf_allpdf) != pdf_allpdf))
{
pdc_error(p->pdc, PDC_E_OPT_ILLCOMB, keyword, 0, 0, 0);
}
if (action->exportmethod & pdf_exp_fdf)
action->exportmethod = (pdf_exportmethod)
(action->exportmethod & ~pdf_exp_fdf);
}
}
keyword = "newwindow";
if (pdc_get_optvalues(keyword, resopts, &action->newwindow, NULL))
pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) (pdf_gotor | pdf_launch));
keyword = "ismap";
if (pdc_get_optvalues(keyword, resopts, &action->ismap, NULL))
pdf_opt_effectless(p, keyword, atype, pdf_uri);
keyword = "hide";
if (pdc_get_optvalues(keyword, resopts, &action->hide, NULL))
pdf_opt_effectless(p, keyword, atype, pdf_hide);
keyword = "exclude";
if (pdc_get_optvalues(keyword, resopts, &action->exclude, NULL))
pdf_opt_effectless(p, keyword, atype,
(pdf_actiontype) (pdf_submitform | pdf_resetform));
keyword = "submitemptyfields";
if (pdc_get_optvalues(keyword, resopts, &action->submitemptyfields, NULL))
pdf_opt_effectless(p, keyword, atype, pdf_submitform);
keyword = "canonicaldate";
if (pdc_get_optvalues(keyword, resopts, &action->canonicaldate, NULL))
pdf_opt_effectless(p, keyword, atype, pdf_submitform);
keyword = "transition";
if (pdc_get_optvalues(keyword, resopts, &action->transition, NULL))
pdf_opt_effectless(p, keyword, atype, pdf_trans);
keyword = "duration";
if (pdc_get_optvalues(keyword, resopts, &action->duration, NULL))
pdf_opt_effectless(p, keyword, atype, pdf_trans);
/* required options */
keyword = NULL;
if (!hasdest &&
(atype == pdf_goto || atype == pdf_gotor))
keyword = "destination";
if (!action->filename &&
(atype == pdf_gotor || atype == pdf_launch || atype == pdf_importdata))
keyword = "filename";
if (!action->menuname && atype == pdf_named)
keyword = "menuname";
if (!action->namelist && atype == pdf_hide)
keyword = "namelist";
if (!action->filename &&
(atype == pdf_uri || atype == pdf_submitform))
keyword = "url";
if (keyword)
pdc_error(p->pdc, PDC_E_OPT_NOTFOUND, keyword, 0, 0, 0);
return pdf_get_max_action(p);
}
const char *
pdf_get_ordering_cid(PDF *p, pdc_font *font)
{
(void) p;
return pdc_get_keyword(font->charcoll, charcoll_names); /* in ASCII */
}
pdc_bool
pdf_check_pfm_encoding(PDF *p, pdf_font *font, pdc_encoding enc)
{
const char *encname =
pdc_errprintf(p->pdc, "%.*s", PDC_ERR_MAXSTRLEN,
pdf_get_encoding_name(p, enc, font));
const char *intencname = NULL;
pdc_encoding intenc = pdc_invalidenc;
pdc_bool issymbfont = pdc_undef;
pdc_logg_cond(p->pdc, 2, trc_font,
"\tFont internal charset (dfCharSet): %d\n", font->ft.enc);
/* Font encoding */
intencname = pdc_get_keyword(font->ft.enc, pdf_charset_keylist);
if (intencname == NULL)
{
pdc_set_errmsg(p->pdc, PDF_E_T1_BADCHARSET,
pdc_errprintf(p->pdc, "%d", font->ft.enc), 0, 0, 0);
return pdc_false;
}
if (strlen(intencname))
{
int codepage = 0;
pdc_logg_cond(p->pdc, 2, trc_font,
"\tFont internal encoding \"%s\" found\n", intencname);
intenc = pdc_find_encoding(p->pdc, intencname);
if (intenc == pdc_invalidenc)
intenc = pdc_insert_encoding(p->pdc, intencname, &codepage,
pdc_true);
font->ft.issymbfont = pdc_false;
}
else
{
pdc_logg_cond(p->pdc, 2, trc_font, "\tSymbol font\n");
font->ft.issymbfont = pdc_true;
intenc = pdc_builtin;
/* auto */
if (!strcmp(font->encapiname, "auto"))
{
issymbfont = pdc_true;
enc = pdc_builtin;
}
}
/* builtin */
if (enc == pdc_builtin)
issymbfont = pdc_true;
/* unicode */
if (enc == pdc_unicode)
{
font->unibyte = pdc_true;
issymbfont = pdc_false;
enc = intenc;
}
/* encoding is subset of 8-bit encoding */
if (enc >= pdc_winansi && intenc >= pdc_winansi)
{
if (pdc_is_encoding_subset(p->pdc, pdc_get_encoding_vector(p->pdc, enc),
pdc_get_encoding_vector(p->pdc, intenc)))
{
if (enc != pdc_winansi && intenc == pdc_winansi &&
strcmp(encname, "iso8859-1"))
{
font->towinansi = intenc;
}
else
{
enc = intenc;
}
issymbfont = pdc_false;
}
}
/* illegal encoding */
if (issymbfont == pdc_undef || font->ft.issymbfont == pdc_undef)
{
pdc_set_errmsg(p->pdc, PDF_E_FONT_BADENC, 0, 0, 0, 0);
return pdc_false;
}
font->ft.enc = enc;
if (issymbfont && !font->ft.issymbfont)
{
pdc_warning(p->pdc, PDF_E_FONT_FORCEENC,
pdf_get_encoding_name(p, intenc, NULL),
0, 0, 0);
font->ft.enc = intenc;
}
if (!issymbfont && font->ft.issymbfont)
{
pdc_warning(p->pdc, PDF_E_FONT_FORCEENC,
pdf_get_encoding_name(p, pdc_builtin, NULL),
0, 0, 0);
font->ft.enc = pdc_builtin;
font->towinansi = pdc_invalidenc;
}
if (font->towinansi != pdc_invalidenc)
pdf_transform_fontwidths(p, font,
pdc_get_encoding_vector(p->pdc, font->ft.enc),
pdc_get_encoding_vector(p->pdc, font->towinansi));
return pdc_true;
}
void
pdf_write_doc_extgstates(PDF *p)
{
int i, j;
pdf_extgstateresource *gs;
for (i = 0; i < p->extgstates_number; i++)
{
gs = &p->extgstates[i];
pdc_begin_obj(p->out, gs->obj_id); /* ExtGState resource */
pdc_begin_dict(p->out);
pdc_puts(p->out, "/Type/ExtGState\n");
if (gs->font_obj != PDC_NEW_ID)
pdc_printf(p->out, "/Font[%ld 0 R %f]\n",
gs->font_obj, gs->font_size);
if (gs->line_width != pdc_undef)
pdc_printf(p->out, "/LW %f\n", gs->line_width);
if (gs->line_cap != pdc_undef)
pdc_printf(p->out, "/LC %d\n", gs->line_cap);
if (gs->line_join != pdc_undef)
pdc_printf(p->out, "/LJ %d\n", gs->line_join);
if (gs->miter_limit != pdc_undef)
pdc_printf(p->out, "/ML %f\n", gs->miter_limit);
if (gs->dash_count > 0)
{
pdc_printf(p->out, "/D[[");
for (j = 0; j < gs->dash_count; ++j)
pdc_printf(p->out, "%f ", gs->dash_array[j]);
pdc_printf(p->out, "] %f]\n", gs->dash_phase);
/* but see page 157 of PDF Reference: integer */
}
if (gs->ri != AutoIntent)
pdc_printf(p->out, "/RI/%s\n",
pdc_get_keyword((long) gs->ri, gs_renderingintents));
if (gs->stroke_adjust != pdc_undef)
pdc_printf(p->out, "/SA %s\n",
gs->stroke_adjust ? "true" : "false");
if (gs->overprint_stroke != pdc_undef)
pdc_printf(p->out, "/OP %s\n",
gs->overprint_stroke ? "true" : "false");
if (gs->overprint_fill != pdc_undef)
pdc_printf(p->out, "/op %s\n",
gs->overprint_fill ? "true" : "false");
else if (gs->overprint_stroke == pdc_true)
pdc_puts(p->out, "/op false\n");
if (gs->overprint_mode != pdc_undef)
pdc_printf(p->out, "/OPM %d\n", gs->overprint_mode);
if (gs->flatness != pdc_undef)
pdc_printf(p->out, "/FL %f\n", gs->flatness);
if (gs->smoothness != pdc_undef)
pdc_printf(p->out, "/SM %f\n", gs->smoothness);
if (gs->opacity_fill != pdc_undef)
pdc_printf(p->out, "/ca %f\n", gs->opacity_fill);
if (gs->blendmode != BM_None) {
const char *modename;
pdc_printf(p->out, "/BM[");
for (j = 0; ; j++) {
modename = gs_blendmodes[j].word;
if (!modename) break;
if (gs->blendmode & gs_blendmodes[j].code)
pdc_printf(p->out, "/%s", modename);
}
pdc_printf(p->out, "]\n");
}
if (gs->opacity_stroke != pdc_undef)
pdc_printf(p->out, "/CA %f\n", gs->opacity_stroke);
if (gs->alpha_is_shape != pdc_undef)
pdc_printf(p->out, "/AIS %s\n",
gs->alpha_is_shape ? "true" : "false");
if (gs->text_knockout != pdc_undef)
pdc_printf(p->out, "/TK %s\n",
gs->text_knockout ? "true" : "false");
pdc_end_dict(p->out);
pdc_end_obj(p->out); /* ExtGState resource */
}
}
