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 */ } }