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;
}
pdc_bool
pdf_get_metrics_tt(PDF *p, pdf_font *font, const char *fontname,
pdc_encoding enc, const char *filename)
{
pdc_bool logg1 = pdc_logg_is_enabled(p->pdc, 1, trc_font);
pdc_bool logg2 = pdc_logg_is_enabled(p->pdc, 2, trc_font);
int filesize = 0;
double kbfilesize = 0;
int foundglyphs, flags = 0;
tt_file *ttf;
pdc_bool retval;
pdc_encoding enc_req;
pdc_encodingvector *ev = NULL;
pdc_bool isotf;
int errcode = 0;
(void) logg2;
/*
* Initialisation
*/
ttf = fnt_new_tt(p->pdc, &font->ft);
ttf->filename = filename;
ttf->fontname = fontname;
ttf->verbose = font->verbose;
ttf->incore = pdc_true;
ttf->monospace = font->opt.monospace;
filesize = font->ft.filelen;
kbfilesize = filesize / 1024.0;
/*
* Read font file
*/
retval = fnt_read_tt(ttf);
if (retval == pdc_false)
goto PDF_TRUETYPE_ERROR2;
/*
* Font type
*/
if (ttf->tab_CFF_)
{
isotf = pdc_true;
font->ft.m.type = fnt_Type1C;
font->cff_offset = (long) ttf->tab_CFF_->offset;
font->cff_length = ttf->tab_CFF_->length;
}
else
{
isotf = pdc_false;
font->ft.m.type = fnt_TrueType;
TT_IOCHECK(ttf, tt_tag2idx(ttf, fnt_str_glyf) != -1);
TT_IOCHECK(ttf, tt_tag2idx(ttf, fnt_str_loca) != -1);
}
/* Number of Glyphs */
if (ttf->numGlyphs <= 1)
{
errcode = FNT_E_TT_NOGLYFDESC;
goto PDF_TRUETYPE_ERROR1;
}
/*
* Encoding
*/
if (isotf)
{
/* OpenType font with CFF table */
if (ttf->charcoll != cc_none)
{
/* CID font */
if (font->ft.m.charcoll != cc_none)
{
if (!ttf->regisadobe)
{
errcode = PDF_E_CJK_UNSUPP_REGISTRY;
goto PDF_TRUETYPE_ERROR1;
}
if (font->ft.m.charcoll != ttf->charcoll)
{
errcode = PDF_E_CJK_UNSUPP_CHARCOLL;
goto PDF_TRUETYPE_ERROR1;
}
if (font->outcmapname != NULL)
enc = pdc_cid;
if (logg1)
pdc_logg(p->pdc, "\tCID font ordering: \"%s\"\n",
fnt_get_ordering_cid(ttf->charcoll));
}
else if (enc == pdc_unicode || enc == pdc_glyphid)
{
font->ft.m.charcoll = ttf->charcoll;
font->supplement = ttf->supplement;
}
else
{
errcode = PDF_E_FONT_ONLY_CMAP;
goto PDF_TRUETYPE_ERROR1;
}
}
else if (font->ft.m.charcoll != cc_none)
{
/* SID font */
errcode = PDF_E_FONT_UNSUPP_CMAP;
goto PDF_TRUETYPE_ERROR1;
}
}
else
{
if (font->ft.m.charcoll != cc_none)
{
int i;
pdc_bool iscjk = pdc_false;
for (i = 0; i < PDC_NUMCHARCOLL; i++)
{
if (ttf->tab_OS_2->charcolls[i])
iscjk = pdc_true;
if (ttf->tab_OS_2->charcolls[i] == font->ft.m.charcoll)
break;
}
if (i == PDC_NUMCHARCOLL)
{
if (iscjk)
{
/* CJK font */
errcode = PDF_E_CJK_UNSUPP_CHARCOLL;
goto PDF_TRUETYPE_ERROR1;
}
else
{
/* no CJK font */
errcode = PDF_E_FONT_UNSUPP_CMAP;
goto PDF_TRUETYPE_ERROR1;
}
}
else
{
if (font->outcmapname != NULL)
{
ttf->charcoll = font->ft.m.charcoll;
enc = pdc_cid;
}
}
}
}
/* encoding vector */
enc_req = fnt_get_tt_encoding_key(ttf, enc);
if (enc_req == pdc_invalidenc)
{
errcode = FNT_E_TT_BADCMAP;
goto PDF_TRUETYPE_ERROR1;
}
else if (enc_req != enc)
{
if (strcmp(font->encapiname, "auto"))
{
pdc_warning(p->pdc, PDF_E_FONT_FORCEENC,
pdf_get_encoding_name(p, enc_req, NULL),
0, 0, 0);
}
enc = enc_req;
}
if (enc >= 0)
ev = pdc_get_encoding_vector(p->pdc, enc);
font->ft.enc = enc;
font->ft.issymbfont = ttf->issymbol;
font->hasnomac = !ttf->tab_cmap || !ttf->tab_cmap->mac;
/* builtin encoding */
if (enc == pdc_builtin)
{
if (font->ft.issymbfont == pdc_false)
{
errcode = PDF_E_FONT_BADENC;
goto PDF_TRUETYPE_ERROR1;
}
else
{
/* encoding vector for builtin */
ev = pdf_create_font_encoding(p, enc, font, fontname, pdc_true);
font->symenc = font->ft.enc;
}
}
{
/* optimizing PDF output */
if (enc == pdc_ebcdic ||
enc == pdc_ebcdic_37 ||
enc == pdc_ebcdic_winansi)
font->towinansi = pdc_winansi;
}
/* /FontName in FontDescriptor */
font->ft.m.name = pdc_strdup(p->pdc, ttf->tab_name->englishname4);
/* /BaseFont name */
font->ft.name = pdc_strdup(p->pdc, ttf->tab_name->englishname6);
#define PDF_RESTRICTED_TT_EMBEDDING 0x02
/* check embedding flags */
if ((font->opt.embedding) && ttf->tab_OS_2 &&
ttf->tab_OS_2->fsType == PDF_RESTRICTED_TT_EMBEDDING)
{
errcode = FNT_E_TT_EMBED;
goto PDF_TRUETYPE_ERROR1;
}
if (logg1)
{
pdc_logg(p->pdc,
"\tFull font name: \"%s\"\n"
"\tPostScript font name: \"%s\"\n"
"\tFont embedding: %s\n"
"\tVertical font: %s\n",
font->ft.name, font->ft.m.name,
PDC_BOOLSTR(font->opt.embedding),
PDC_BOOLSTR(font->ft.vertical));
if (ttf->tab_name->producer != NULL)
pdc_logg(p->pdc, "\tFont producer: \"%s\"\n",
ttf->tab_name->producer);
pdc_logg(p->pdc, "\tNumber of Glyphs: %d\n", ttf->numGlyphs);
}
/* Save font values */
fnt_set_tt_fontvalues(ttf);
/* Flags for creating font arrays */
flags = TT_FONT_code2gid | TT_FONT_m_widths;
/* Create font mapping and width arrays */
foundglyphs = fnt_set_tt_fontarrays(ttf, flags);
/***********************************/
if (font->symenc != pdc_invalidenc)
font->ft.enc = pdc_builtin;
/***********************************/
if (!foundglyphs)
{
errcode = PDF_E_FONT_BADENC;
goto PDF_TRUETYPE_ERROR1;
}
fnt_delete_tt(ttf);
if (!pdf_make_fontflag(p, font))
return pdc_false;
return pdc_true;
PDF_TRUETYPE_ERROR1:
pdc_set_errmsg(p->pdc, errcode, 0, 0, 0, 0);
PDF_TRUETYPE_ERROR2:
fnt_delete_tt(ttf);
return pdc_false;
}
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 */
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 */
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 */
}
}
