static void pdf__setdashpattern(PDF *p, float *darray, int length, float phase) { pdf_gstate *gs = &p->gstate[p->sl]; /* length == 0 or 1 means solid line */ if (length < 2) { if (gs->dashed || PDF_FORCE_OUTPUT()) { pdc_puts(p->out, "[] 0 d\n"); gs->dashed = pdc_false; } } else { int i; pdc_puts(p->out, "["); for (i = 0; i < length; i++) { pdc_printf(p->out, "%f ", darray[i]); } pdc_printf(p->out, "] %f d\n", phase); gs->dashed = pdc_true; } }
void pdf__clip(PDF *p) { if (p->curr_ppt->fillrule == pdf_fill_winding) pdc_puts(p->out, "W n\n"); else if (p->curr_ppt->fillrule == pdf_fill_evenodd) pdc_puts(p->out, "W* n\n"); pdf_end_path(p); }
void pdf__closepath_fill_stroke(PDF *p) { if (p->curr_ppt->fillrule == pdf_fill_winding) pdc_puts(p->out, "b\n"); else if (p->curr_ppt->fillrule == pdf_fill_evenodd) pdc_puts(p->out, "b*\n"); pdf_end_path(p); }
pdc_bool pdc_init_output( void *opaque, pdc_output *out, const char *filename, FILE *fp, size_t (*writeproc)(pdc_output *out, void *data, size_t size), int compatibility) { static const char *fn = "pdc_init_output"; pdc_core *pdc = out->pdc; int i; out->lastobj = 0; if (out->file_offset == NULL) { out->file_offset_capacity = + ID_CHUNKSIZE; out->file_offset = (long *) pdc_malloc(pdc, sizeof(long) * out->file_offset_capacity, fn); } for (i = 1; i < out->file_offset_capacity; ++i) out->file_offset[i] = PDC_BAD_ID; out->compresslevel = PDF_DEFAULT_COMPRESSION; out->compr_changed = pdc_false; out->opaque = opaque; memcpy(out->id[0], out->id[1], MD5_DIGEST_LENGTH); if (!pdc_init_stream(pdc, out, filename, fp, writeproc)) return pdc_false; /* Write the document header */ if (compatibility == PDC_1_5) pdc_puts(out, "%PDF-1.5\n"); else if (compatibility == PDC_1_4) pdc_puts(out, "%PDF-1.4\n"); else pdc_puts(out, "%PDF-1.3\n"); /* binary magic number */ #define PDC_MAGIC_BINARY "\045\344\343\317\322\012" pdc_write(out, PDC_MAGIC_BINARY, sizeof(PDC_MAGIC_BINARY) - 1); return pdc_true; }
void pdf_write_page_extgstates(PDF *p) { int i, total = 0; int bias = p->curr_ppt->eg_bias; for (i = 0; i < p->extgstates_number; i++) if (p->extgstates[i].used_on_current_page) total++; if (total > 0 || bias) { pdc_puts(p->out, "/ExtGState"); pdc_begin_dict(p->out); } if (total > 0) { for (i = 0; i < p->extgstates_number; i++) { if (p->extgstates[i].used_on_current_page) { p->extgstates[i].used_on_current_page = pdc_false; /* reset */ pdc_printf(p->out, "/GS%d", bias + i); pdc_objref(p->out, "", p->extgstates[i].obj_id); } } if (!bias) pdc_end_dict(p->out); } }
void pdf_write_page_shadings(PDF *p) { int i, total = 0; for (i = 0; i < p->shadings_number; i++) if (p->shadings[i].used_on_current_page) total++; if (total > 0) { pdc_puts(p->out, "/Shading"); pdc_begin_dict(p->out); } if (total > 0) { for (i = 0; i < p->shadings_number; i++) { if (p->shadings[i].used_on_current_page) { p->shadings[i].used_on_current_page = pdc_false; /* reset */ pdc_printf(p->out, "/Sh%d", i); pdc_objref(p->out, "", p->shadings[i].obj_id); } } pdc_end_dict(p->out); } }
void pdf_write_page_extgstates(PDF *p) { int i, total = 0; for (i = 0; i < p->extgstates_number; i++) if (p->extgstates[i].used_on_current_page) total++; if (total > 0) { pdc_puts(p->out, "/ExtGState"); pdc_begin_dict(p->out); /* ExtGState names */ for (i = 0; i < p->extgstates_number; i++) { if (p->extgstates[i].used_on_current_page) { p->extgstates[i].used_on_current_page = pdc_false; /* reset */ pdc_printf(p->out, "/GS%d %ld 0 R\n", i, p->extgstates[i].obj_id); } } pdc_end_dict(p->out); /* ExtGState names */ } }
void pdf_setdashpattern_internal(PDF *p, pdc_scalar *darray, int length, pdc_scalar phase) { pdf_gstate *gs = &p->curr_ppt->gstate[p->curr_ppt->sl]; /* length == 0 or 1 means solid line */ if (length < 2) { if (gs->dashed || PDF_FORCE_OUTPUT()) { pdc_puts(p->out, "[] 0 d\n"); gs->dashed = pdc_false; } } else { int i; pdc_begin_array(p->out); for (i = 0; i < length; i++) { pdc_printf(p->out, "%f ", darray[i]); } pdc_end_array_c(p->out); pdc_printf(p->out, "%f d\n", phase); gs->dashed = pdc_true; } }
void pdf_write_function_dict(PDF *p, pdf_color *c0, pdf_color *c1, pdc_scalar N) { static const char *fn = "pdf_write_function_dict"; pdf_colorspace *cs; cs = &p->colorspaces[c1->cs]; pdc_begin_dict(p->out); /* function dict */ pdc_puts(p->out, "/FunctionType 2\n"); pdc_puts(p->out, "/Domain[0 1]\n"); pdc_printf(p->out, "/N %f\n", N); switch (cs->type) { case DeviceGray: pdc_puts(p->out, "/Range[0 1]\n"); if (c0->val.gray != 0) pdc_printf(p->out, "/C0[%f]\n", c0->val.gray); if (c1->val.gray != 1) pdc_printf(p->out, "/C1[%f]", c1->val.gray); break; case DeviceRGB: pdc_puts(p->out, "/Range[0 1 0 1 0 1]\n"); pdc_printf(p->out, "/C0[%f %f %f]\n", c0->val.rgb.r, c0->val.rgb.g, c0->val.rgb.b); pdc_printf(p->out, "/C1[%f %f %f]", c1->val.rgb.r, c1->val.rgb.g, c1->val.rgb.b); break; case DeviceCMYK: pdc_puts(p->out, "/Range[0 1 0 1 0 1 0 1]\n"); pdc_printf(p->out, "/C0[%f %f %f %f]\n", c0->val.cmyk.c, c0->val.cmyk.m, c0->val.cmyk.y, c0->val.cmyk.k); pdc_printf(p->out, "/C1[%f %f %f %f]", c1->val.cmyk.c, c1->val.cmyk.m, c1->val.cmyk.y, c1->val.cmyk.k); break; default: pdc_error(p->pdc, PDF_E_INT_BADCS, fn, "(unknown)", pdc_errprintf(p->pdc, "%d", cs->type), 0); } pdc_end_dict_c(p->out); /* function dict */ } /* pdf_write_function_dict */
int pdf__shading_pattern(PDF *p, int shading, const char *optlist) { pdc_resopt *results; pdc_clientdata data; int gstate = -1; int retval = -1; if (p->compatibility == PDC_1_3) pdc_error(p->pdc, PDF_E_SHADING13, 0, 0, 0, 0); pdf_check_handle(p, shading, pdc_shadinghandle); if (optlist && strlen(optlist)) { pdf_set_clientdata(p, &data); results = pdc_parse_optionlist(p->pdc, optlist, pdf_shading_pattern_options, &data, pdc_true); (void) pdc_get_optvalues("gstate", results, &gstate, NULL); pdc_cleanup_optionlist(p->pdc, results); } if (p->pattern_number == p->pattern_capacity) pdf_grow_pattern(p); if (PDF_GET_STATE(p) == pdf_state_page) pdf_end_contents_section(p); /* Pattern object */ p->pattern[p->pattern_number].obj_id = pdc_begin_obj(p->out, PDC_NEW_ID); /* Shadings don't have a painttype, but this signals to the * code which writes the pattern usage that no color values * will be required when setting the pattern color space. */ p->pattern[p->pattern_number].painttype = 1; pdc_begin_dict(p->out); /* Pattern dict*/ pdc_puts(p->out, "/PatternType 2\n"); /* shading pattern */ pdc_objref(p->out, "/Shading", p->shadings[shading].obj_id); p->shadings[shading].used_on_current_page = pdc_true; if (gstate != -1) pdc_objref(p->out, "/ExtGState", pdf_get_gstate_id(p, gstate)); pdc_end_dict(p->out); /* Pattern dict*/ pdc_end_obj(p->out); /* Pattern object */ if (PDF_GET_STATE(p) == pdf_state_page) pdf_begin_contents_section(p); retval = p->pattern_number; p->pattern_number++; return retval; }
void pdc_begin_pdfstream(pdc_output *out) { pdc_puts(out, "stream\n"); out->start_pos = pdc_tell_out(out); if (out->compresslevel) pdc_begin_compress(out); }
void pdf__closepath(PDF *p) { pdf_ppt *ppt = p->curr_ppt; pdc_puts(p->out, "h\n"); ppt->gstate[ppt->sl].x = ppt->gstate[ppt->sl].startx; ppt->gstate[ppt->sl].y = ppt->gstate[ppt->sl].starty; }
void pdf_put_cidglyph_widths(PDF *p, pdf_font *font) { if (font->opt.monospace) { if (font->opt.monospace != FNT_DEFAULT_CIDWIDTH) pdc_printf(p->out, "/DW %d\n", font->opt.monospace); } else { const char **widths = fnt_get_cid_widths_array(p->pdc, &font->ft); int i; pdc_puts(p->out, "/W"); pdc_begin_array(p->out); for (i = 0; i < FNT_CIDMETRIC_INCR - 1; i++) pdc_puts(p->out, widths[i]); pdc_end_array(p->out); } }
void pdf__restore(PDF *p) { if (p->sl == 0) pdc_error(p->pdc, PDF_E_GSTATE_RESTORE, 0, 0, 0, 0); pdf_end_text(p); pdc_puts(p->out, "Q\n"); p->sl--; }
void pdc_end_pdfstream(pdc_output *out) { if (out->compresslevel) pdc_end_compress(out); out->length = pdc_tell_out(out) - out->start_pos; /* some PDF consumers seem to need the additional "\n" before "endstream", ** the PDF reference allows it, and Acrobat's "repair" feature relies on it. */ pdc_puts(out, "\nendstream\n"); }
void pdf_write_colormap(PDF *p, int slot) { PDF_data_source src; pdf_colorspace *cs, *base; pdc_id length_id; cs = &p->colorspaces[slot]; if (cs->type != Indexed || cs->val.indexed.colormap_done == pdc_true) return; base = &p->colorspaces[cs->val.indexed.base]; pdc_begin_obj(p->out, cs->val.indexed.colormap_id); /* colormap object */ pdc_begin_dict(p->out); if (pdc_get_compresslevel(p->out)) pdc_puts(p->out, "/Filter/FlateDecode\n"); /* Length of colormap object */ length_id = pdc_alloc_id(p->out); pdc_objref(p->out, "/Length", length_id); pdc_end_dict(p->out); src.init = NULL; src.fill = pdf_data_source_buf_fill; src.terminate = NULL; src.buffer_start = (unsigned char *) cs->val.indexed.colormap; src.buffer_length = (size_t) (cs->val.indexed.palette_size * pdf_color_components(p, cs->val.indexed.base)); src.bytes_available = 0; src.next_byte = NULL; /* Write colormap data */ pdf_copy_stream(p, &src, pdc_true); /* colormap data */ pdc_end_obj(p->out); /* colormap object */ pdc_put_pdfstreamlength(p->out, length_id); /* free the colormap now that it's written */ pdc_free(p->pdc, cs->val.indexed.colormap); cs->val.indexed.colormap = NULL; cs->val.indexed.colormap_done = pdc_true; } /* pdf_write_colormap */
void pdf__save(PDF *p) { if (p->sl == PDF_MAX_SAVE_LEVEL - 1) pdc_error(p->pdc, PDF_E_GSTATE_SAVELEVEL, pdc_errprintf(p->pdc, "%d", PDF_MAX_SAVE_LEVEL - 1), 0, 0, 0); pdf_end_text(p); pdc_puts(p->out, "q\n"); /* propagate states to next level */ p->sl++; memcpy(&p->gstate[p->sl], &p->gstate[p->sl - 1], sizeof(pdf_gstate)); memcpy(&p->tstate[p->sl], &p->tstate[p->sl - 1], sizeof(pdf_tstate)); memcpy(&p->cstate[p->sl], &p->cstate[p->sl - 1], sizeof(pdf_cstate)); }
void pdf_put_cidglyph_widths(PDF *p, pdc_font *font) { int slot; /* Check whether the font name is among the known CID fonts */ for (slot = 0; slot < SIZEOF_CID_METRICS; slot++) { if (!strcmp(pdf_cid_metrics[slot].name, font->apiname)) break; } pdc_printf(p->out, "/DW %d\n", font->monospace ? font->monospace : PDF_DEFAULT_CIDWIDTH); if (!font->monospace) { if (slot < SIZEOF_CID_METRICS && pdf_cid_width_arrays[slot]) { pdc_puts(p->out, pdf_cid_width_arrays[slot]); } } }
void pdf__save(PDF *p) { pdf_ppt * ppt = p->curr_ppt; int sl = ppt->sl; if (sl == PDF_MAX_SAVE_LEVEL - 1) pdc_error(p->pdc, PDF_E_GSTATE_SAVELEVEL, pdc_errprintf(p->pdc, "%d", PDF_MAX_SAVE_LEVEL - 1), 0, 0, 0); pdf_end_text(p); pdc_puts(p->out, "q\n"); /* propagate states to next level */ memcpy(&ppt->gstate[sl + 1], &ppt->gstate[sl], sizeof(pdf_gstate)); pdf_save_cstate(p); pdf_save_tstate(p); ++ppt->sl; }
void pdf_write_doc_colorspaces(PDF *p) { int i; for (i = 0; i < p->colorspaces_number; i++) { pdf_colorspace *cs = &p->colorspaces[i]; /* don't write simple color spaces as resource */ if (PDF_SIMPLE_COLORSPACE(cs)) continue; pdc_begin_obj(p->out, cs->obj_id); pdf_write_colorspace(p, i, pdc_true); pdc_puts(p->out, "\n"); pdc_end_obj(p->out); /* color space resource */ pdf_write_colormap(p, i); /* write pending colormaps */ } }
void pdf_write_page_colorspaces(PDF *p) { int i, total = 0; for (i = 0; i < p->colorspaces_number; i++) if (p->colorspaces[i].used_on_current_page) total++; if (total > 0 ) { pdc_puts(p->out, "/ColorSpace"); pdc_begin_dict(p->out); if (total > 0) { for (i = 0; i < p->colorspaces_number; i++) { pdf_colorspace *cs = &p->colorspaces[i]; if (cs->used_on_current_page) { cs->used_on_current_page = pdc_false; /* reset */ /* don't write simple color spaces as resource */ if (!PDF_SIMPLE_COLORSPACE(cs)) { pdc_printf(p->out, "/C%d", i); pdc_objref(p->out, "", cs->obj_id); } } } } pdc_end_dict(p->out); /* color space names */ } } /* pdf_write_page_colorspaces */
void pdf_write_destination(PDF *p, pdf_dest *dest) { if (dest->type == nameddest) { pdf_put_hypertext(p, dest->name); pdc_puts(p->out, "\n"); return; } pdc_begin_array(p->out); if (dest->remote_page) { pdc_printf(p->out, "%d", dest->remote_page - 1); /* zero-based */ } else { if (dest->page == PDC_BAD_ID) dest->page = pdf_get_page_id(p, dest->pgnum); pdc_objref_c(p->out, dest->page); } switch (dest->type) { case fixed: pdc_puts(p->out, "/XYZ "); if (dest->left != -1) pdc_printf(p->out, "%f ", dest->left); else pdc_puts(p->out, "null "); if (dest->top != -1) pdc_printf(p->out, "%f ", dest->top); else pdc_puts(p->out, "null "); if (dest->zoom != -1) pdc_printf(p->out, "%f", dest->zoom); else pdc_puts(p->out, "null"); break; case fitwindow: pdc_puts(p->out, "/Fit"); break; case fitwidth: pdc_printf(p->out, "/FitH %f", dest->top); break; case fitheight: pdc_printf(p->out, "/FitV %f", dest->left); break; case fitrect: pdc_printf(p->out, "/FitR %f %f %f %f", dest->left, dest->bottom, dest->right, dest->top); break; case fitvisible: pdc_puts(p->out, "/FitB"); break; case fitvisiblewidth: pdc_printf(p->out, "/FitBH %f", dest->top); break; case fitvisibleheight: pdc_printf(p->out, "/FitBV %f", dest->left); break; default: break; } pdc_end_array(p->out); }
int pdf__shading( PDF *p, const char *type, pdc_scalar x_0, pdc_scalar y_0, pdc_scalar x_1, pdc_scalar y_1, pdc_scalar c_1, pdc_scalar c_2, pdc_scalar c_3, pdc_scalar c_4, const char *optlist) { pdf_shadingtype_e shtype = shnone; pdf_color *color0, color1; pdf_colorspace *cs; pdc_resopt *results; pdc_scalar N = 1.0; pdc_scalar r_0, r_1; pdc_bool extend0 = pdc_false, extend1 = pdc_false, antialias = pdc_false; int retval = -1; if (p->compatibility == PDC_1_3) pdc_error(p->pdc, PDF_E_SHADING13, 0, 0, 0, 0); if (!pdc_stricmp(type, "axial")) { shtype = axial; } else if (!pdc_stricmp(type, "radial")) { shtype = radial; } else pdc_error(p->pdc, PDC_E_ILLARG_STRING, "type", type, 0, 0); pdc_check_number(p->pdc, "x_0", x_0); pdc_check_number(p->pdc, "y_0", y_0); pdc_check_number(p->pdc, "x_1", x_1); pdc_check_number(p->pdc, "y_1", y_1); pdc_check_number(p->pdc, "c_1", c_1); pdc_check_number(p->pdc, "c_2", c_2); pdc_check_number(p->pdc, "c_3", c_3); pdc_check_number(p->pdc, "c_4", c_4); color0 = pdf_get_cstate(p, pdf_fill); color1.cs = color0->cs; cs = &p->colorspaces[color0->cs]; switch (cs->type) { case DeviceGray: color1.val.gray = c_1; break; case DeviceRGB: color1.val.rgb.r = c_1; color1.val.rgb.g = c_2; color1.val.rgb.b = c_3; break; case DeviceCMYK: color1.val.cmyk.c = c_1; color1.val.cmyk.m = c_2; color1.val.cmyk.y = c_3; color1.val.cmyk.k = c_4; break; default: pdc_error(p->pdc, PDF_E_INT_BADCS, pdc_errprintf(p->pdc, "%d", color0->cs), 0, 0, 0); } results = pdc_parse_optionlist(p->pdc, optlist, pdf_shading_options, NULL, pdc_true); (void) pdc_get_optvalues("N", results, &N, NULL); (void) pdc_get_optvalues("antialias", results, &antialias,NULL); if (shtype == radial) { if (pdc_get_optvalues("r0", results, &r_0, NULL) != 1) pdc_error(p->pdc, PDC_E_OPT_NOTFOUND, "r0", 0, 0, 0); if (pdc_get_optvalues("r1", results, &r_1, NULL) != 1) pdc_error(p->pdc, PDC_E_OPT_NOTFOUND, "r1", 0, 0, 0); } if (shtype == axial) { if (pdc_get_optvalues("r0", results, &r_0, NULL) == 1) pdc_warning(p->pdc, PDC_E_OPT_IGNORED, "r0", 0, 0, 0); if (pdc_get_optvalues("r1", results, &r_1, NULL) == 1) pdc_warning(p->pdc, PDC_E_OPT_IGNORED, "r1", 0, 0, 0); } if (shtype == radial || shtype == axial) { pdc_get_optvalues("extend0", results, &extend0, NULL); pdc_get_optvalues("extend1", results, &extend1, NULL); } pdc_cleanup_optionlist(p->pdc, results); if (p->shadings_number == p->shadings_capacity) pdf_grow_shadings(p); if (PDF_GET_STATE(p) == pdf_state_page) pdf_end_contents_section(p); /* Shading object */ p->shadings[p->shadings_number].obj_id = pdc_begin_obj(p->out, PDC_NEW_ID); pdc_begin_dict(p->out); /* Shading dict*/ pdc_printf(p->out, "/ShadingType %d\n", (int) shtype); pdc_printf(p->out, "/ColorSpace"); pdf_write_colorspace(p, color1.cs, pdc_false); pdc_puts(p->out, "\n"); if (antialias) pdc_printf(p->out, "/AntiAlias true\n"); switch (shtype) { case axial: /* Type 2 */ pdc_printf(p->out, "/Coords[%f %f %f %f]\n", x_0, y_0, x_1, y_1); if (extend0 || extend1) pdc_printf(p->out, "/Extend[%s %s]\n", extend0 ? "true" : "false", extend1 ? "true" : "false"); pdc_puts(p->out, "/Function"); pdf_write_function_dict(p, color0, &color1, N); break; case radial: /* Type 3 */ pdc_printf(p->out, "/Coords[%f %f %f %f %f %f]\n", x_0, y_0, r_0, x_1, y_1, r_1); if (extend0 || extend1) pdc_printf(p->out, "/Extend[%s %s]\n", extend0 ? "true" : "false", extend1 ? "true" : "false"); pdc_puts(p->out, "/Function"); pdf_write_function_dict(p, color0, &color1, N); break; default: break; } pdc_end_dict(p->out); /* Shading dict */ pdc_end_obj(p->out); /* Shading object */ if (PDF_GET_STATE(p) == pdf_state_page) pdf_begin_contents_section(p); retval = p->shadings_number; p->shadings_number++; return retval; }
static void pdf_write_color_values(PDF *p, pdf_color *color, pdf_drawmode drawmode) { static const char fn[] = "pdf_write_color_values"; pdf_colorspace * cs = &p->colorspaces[color->cs]; switch (cs->type) { case DeviceGray: { pdc_printf(p->out, "%f", color->val.gray); if (drawmode == pdf_fill) pdc_puts(p->out, " g\n"); else if (drawmode == pdf_stroke) pdc_puts(p->out, " G\n"); break; } case DeviceRGB: { pdc_printf(p->out, "%f %f %f", color->val.rgb.r, color->val.rgb.g, color->val.rgb.b); if (drawmode == pdf_fill) pdc_puts(p->out, " rg\n"); else if (drawmode == pdf_stroke) pdc_puts(p->out, " RG\n"); break; } case DeviceCMYK: { pdc_printf(p->out, "%f %f %f %f", color->val.cmyk.c, color->val.cmyk.m, color->val.cmyk.y, color->val.cmyk.k); if (drawmode == pdf_fill) pdc_puts(p->out, " k\n"); else if (drawmode == pdf_stroke) pdc_puts(p->out, " K\n"); break; } case PatternCS: { if (drawmode == pdf_fill) { if (p->pattern[color->val.pattern].painttype == 1) { pdc_puts(p->out, "/Pattern cs"); } else if (p->pattern[color->val.pattern].painttype == 2) { pdf_color *fillcolor = pdf_get_cstate(p, pdf_fill); pdc_printf(p->out, "/C%d cs ", color->cs); pdf_write_color_values(p, fillcolor, pdf_none); } pdc_printf(p->out, "/P%d scn\n", color->val.pattern); } else if (drawmode == pdf_stroke) { if (p->pattern[color->val.pattern].painttype == 1) { pdc_puts(p->out, "/Pattern CS"); } else if (p->pattern[color->val.pattern].painttype == 2) { pdf_color *strokecolor = pdf_get_cstate(p, pdf_stroke); pdc_printf(p->out, "/C%d CS ", color->cs); pdf_write_color_values(p, strokecolor, pdf_none); } pdc_printf(p->out, "/P%d SCN\n", color->val.pattern); } p->pattern[color->val.pattern].used_on_current_page = pdc_true; break; } case Indexed: /* LATER */ default: pdc_error(p->pdc, PDF_E_INT_BADCS, fn, pdc_errprintf(p->pdc, "%d", color->cs), pdc_errprintf(p->pdc, "%d", cs->type), 0); } } /* pdf_write_color_values */
void pdf_write_colorspace(PDF *p, int slot, pdc_bool direct) { static const char *fn = "pdf_write_colorspace"; pdf_colorspace *cs; int base; if (slot < 0 || slot >= p->colorspaces_number) pdc_error(p->pdc, PDF_E_INT_BADCS, fn, pdc_errprintf(p->pdc, "%d", slot), "(unknown)", 0); cs = &p->colorspaces[slot]; /* we always write simple colorspaces directly */ if (PDF_SIMPLE_COLORSPACE(cs)) direct = pdc_true; if (!direct) { pdc_objref_c(p->out, cs->obj_id); return; } switch (cs->type) { case DeviceGray: pdc_printf(p->out, "/DeviceGray"); break; case DeviceRGB: pdc_printf(p->out, "/DeviceRGB"); break; case DeviceCMYK: pdc_printf(p->out, "/DeviceCMYK"); break; case Indexed: base = cs->val.indexed.base; pdc_begin_array(p->out); pdc_puts(p->out, "/Indexed"); pdf_write_colorspace(p, base, pdc_false); pdc_printf(p->out, " %d", cs->val.indexed.palette_size - 1); pdc_objref_c(p->out, cs->val.indexed.colormap_id); pdc_end_array_c(p->out); break; case PatternCS: pdc_begin_array(p->out); pdc_printf(p->out, "/Pattern"); pdf_write_colorspace(p, cs->val.pattern.base, pdc_false); pdc_end_array(p->out); break; default: pdc_error(p->pdc, PDF_E_INT_BADCS, fn, pdc_errprintf(p->pdc, "%d", slot), pdc_errprintf(p->pdc, "%d", cs->type), 0); } } /* pdf_write_colorspace */
static void pdf_write_outline_dict(PDF *p, int entry) { pdf_outline *outline = &p->outlines[entry]; pdc_id act_idlist[PDF_MAX_EVENTS]; /* write action objects */ if (outline->action) pdf_parse_and_write_actionlist(p, event_bookmark, act_idlist, (const char *) outline->action); pdc_begin_obj(p->out, OBJ_ID(entry)); /* outline object */ pdc_begin_dict(p->out); pdc_objref(p->out, "/Parent", OBJ_ID(PARENT(entry))); /* outline destination */ if (outline->dest) { pdc_puts(p->out, "/Dest"); pdf_write_destination(p, outline->dest); } /* write Action entries */ else if (outline->action) pdf_write_action_entries(p, event_bookmark, act_idlist); pdc_puts(p->out, "/Title"); /* outline text */ pdf_put_hypertext(p, outline->text); pdc_puts(p->out, "\n"); if (PREV(entry)) pdc_objref(p->out, "/Prev", OBJ_ID(PREV(entry))); if (NEXT(entry)) pdc_objref(p->out, "/Next", OBJ_ID(NEXT(entry))); if (FIRST(entry)) { pdc_objref(p->out, "/First", OBJ_ID(FIRST(entry))); pdc_objref(p->out, "/Last", OBJ_ID(LAST(entry))); } if (COUNT(entry)) { if (OPEN(entry)) pdc_printf(p->out, "/Count %d\n", COUNT(entry)); /* open */ else pdc_printf(p->out, "/Count %d\n", -COUNT(entry));/* closed */ } /* Color */ if (outline->textcolor[0] != 0.0 || outline->textcolor[1] != 0.0 || outline->textcolor[2] != 0.0) pdc_printf(p->out, "/C[%f %f %f]\n", outline->textcolor[0], outline->textcolor[1], outline->textcolor[2]); /* FontStyle */ if (outline->fontstyle != fnt_Normal) { int fontstyle = 0; if (outline->fontstyle == fnt_Bold) fontstyle = 2; if (outline->fontstyle == fnt_Italic) fontstyle = 1; if (outline->fontstyle == fnt_BoldItalic) fontstyle = 3; pdc_printf(p->out, "/F %d\n", fontstyle); } pdc_end_dict(p->out); pdc_end_obj(p->out); /* outline object */ }
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_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_id pdf_write_info(PDF *p, pdc_bool moddate) { pdc_bool logg3 = pdc_logg_is_enabled(p->pdc, 3, trc_xmp); char time_str[PDC_TIME_SBUF_SIZE]; char producer[PDC_GEN_BUFSIZE]; pdf_info *info; pdc_id info_id; const char *product = "PDFlib Lite"; const char *security = ""; (void) logg3; if (!p->pdc->smokerun) pdc_logg_cond(p->pdc, 1, trc_api, "[Full product name: \"%s\"]\n", product); info_id = pdc_begin_obj(p->out, PDC_NEW_ID); /* Info object */ pdc_begin_dict(p->out); /* * Although it would be syntactically correct, we must not remove * the space characters after the dictionary keys since this * would break the PDF properties feature in Windows Explorer. */ if (p->userinfo) { for (info = p->userinfo; info != NULL; info = info->next) { pdf_put_pdfname(p, info->key); pdc_puts(p->out, " "); if (strcmp(info->key, "Trapped")) pdf_put_hypertext(p, info->value); else pdf_put_pdfname(p, info->value); pdc_puts(p->out, "\n"); } } pdc_get_timestr(time_str, pdc_false); /* creation date and time */ pdc_puts(p->out, "/CreationDate "); pdf_put_hypertext(p, time_str); pdc_puts(p->out, "\n"); /* modification date and time */ if (moddate) { pdc_puts(p->out, "/ModDate "); pdf_put_hypertext(p, time_str); pdc_puts(p->out, "\n"); } /* * If you change the /Producer entry your license to use * PDFlib will be void! */ if (p->pdc->binding) pdc_sprintf(p->pdc, pdc_false, producer, "%s %s%s (%s/%s)", product, PDFLIB_VERSIONSTRING, security, p->pdc->binding, PDF_PLATFORM); else pdc_sprintf(p->pdc, pdc_false, producer, "%s %s%s (%s)", product, PDFLIB_VERSIONSTRING, security, PDF_PLATFORM); pdc_puts(p->out, "/Producer "); pdf_put_hypertext(p, producer); pdc_puts(p->out, "\n"); pdc_end_dict(p->out); pdc_end_obj(p->out); /* Info object */ return info_id; }
void pdf__add_nameddest( PDF *p, const char *name, int len, const char *optlist) { pdc_resopt *resopts = NULL; pdc_text_format hypertextformat = p->hypertextformat; pdc_encoding hypertextencoding; int hypertextcodepage; pdc_id obj_id = PDC_BAD_ID; char *name2 = NULL; pdf_dest *dest; int inum; len = pdc_check_text_length(p->pdc, &name, len, PDF_MAXSTRINGSIZE); if (!len) pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "name", 0, 0, 0); resopts = pdc_parse_optionlist(p->pdc, optlist, pdf_destination_options, NULL, pdc_true); hypertextencoding = pdf_get_hypertextencoding_opt(p, resopts, &hypertextcodepage, pdc_true); if (pdc_get_optvalues("hypertextformat", resopts, &inum, NULL)) { hypertextformat = (pdc_text_format) inum; pdf_check_hypertextformat(p, hypertextformat); } pdc_cleanup_optionlist(p->pdc, resopts); /* create hypertext string */ name2 = pdf_convert_hypertext(p, name, len, hypertextformat, hypertextencoding, hypertextcodepage, &len, pdc_true, pdc_true); if (name2 == NULL || len == 0) pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "name", 0, 0, 0); /* parsing option list */ dest = pdf_parse_destination_optlist(p, optlist, 0, pdf_nameddest); /* interrupt the content stream if we are on a page */ if (PDF_GET_STATE(p) == pdf_state_page) pdf_end_contents_section(p); obj_id = pdc_begin_obj(p->out, PDC_NEW_ID); /* Dest object */ pdc_begin_dict(p->out); /* Destination dict */ pdc_puts(p->out, "/D"); pdf_write_destination(p, dest); pdc_end_dict(p->out); /* Destination dict */ pdc_end_obj(p->out); /* Dest object */ /* continue the contents stream */ if (PDF_GET_STATE(p) == pdf_state_page) pdf_begin_contents_section(p); pdf_cleanup_destination(p, dest); /* insert name in tree */ pdf_insert_name(p, name2, names_dests, obj_id); }