static void pdf_init_all(PDF *p) { pdf_init_document(p); pdf_init_info(p); pdf_init_images(p); pdf_init_xobjects(p); pdf_init_fonts(p); pdf_init_transition(p); pdf_init_outlines(p); pdf_init_annots(p); pdf_init_stream(p); pdf_init_colorspaces(p); pdf_init_pattern(p); /* clients may set char/word spacing and horizontal scaling outside pages ** for PDF_stringwidth() calculations, and they may set a color for use ** in PDF_makespotcolor(). here we set the defaults. */ p->sl = 0; pdf_init_tstate(p); pdf_init_cstate(p); #ifdef HAVE_PDI pdf_reset_pdi(p); /* reset all PDI contexts */ #endif }
PDFLIB_API void PDFLIB_CALL PDF_end_page(PDF *p) { static const char fn[] = "PDF_end_page"; int index; PDF_TRACE(("%s\t(pdf[%p]);\n", fn, (void *) p)); if (PDF_SANITY_CHECK_FAILED(p)) return; PDF_CHECK_SCOPE(p, fn, pdf_state_page); /* check whether PDF_save() and PDF_restore() calls are balanced */ if (p->sl > 0) pdf_error(p, PDF_RuntimeError, "Unmatched save level at end of page"); /* restore text parameter and color defaults for out-of-page usage. */ pdf_init_tstate(p); pdf_init_cstate(p); pdf_end_contents_section(p); /* Page object */ pdf_begin_obj(p, p->pages[p->current_page]); pdf_begin_dict(p); pdf_puts(p, "/Type/Page\n"); pdf_printf(p, "/Parent %ld 0 R\n", pdf_get_pnode_id(p)); p->res_id = pdf_alloc_id(p); pdf_printf(p, "/Resources %ld 0 R\n", p->res_id); pdf_printf(p, "/MediaBox[0 0 %f %f]\n", p->width, p->height); if (p->CropBox.llx != (float) 0 || p->CropBox.lly != (float) 0 || p->CropBox.urx != (float) 0 || p->CropBox.ury != (float) 0 ) { if (p->CropBox.urx <= p->CropBox.llx || p->CropBox.ury <= p->CropBox.lly) pdf_error(p, PDF_ValueError, "Illegal CropBox dimensions"); pdf_printf(p, "/CropBox[%f %f %f %f]\n", p->CropBox.llx, p->CropBox.lly, p->CropBox.urx, p->CropBox.ury); } if (p->BleedBox.llx != (float) 0 || p->BleedBox.lly != (float) 0 || p->BleedBox.urx != (float) 0 || p->BleedBox.ury != (float) 0 ) { if (p->BleedBox.urx <= p->BleedBox.llx || p->BleedBox.ury <= p->BleedBox.lly) pdf_error(p, PDF_ValueError, "Illegal BleedBox dimensions"); pdf_printf(p, "/BleedBox[%f %f %f %f]\n", p->BleedBox.llx, p->BleedBox.lly, p->BleedBox.urx, p->BleedBox.ury); } if (p->TrimBox.llx != (float) 0 || p->TrimBox.lly != (float) 0 || p->TrimBox.urx != (float) 0 || p->TrimBox.ury != (float) 0 ) { if (p->TrimBox.urx <= p->TrimBox.llx || p->TrimBox.ury <= p->TrimBox.lly) pdf_error(p, PDF_ValueError, "Illegal TrimBox dimensions"); pdf_printf(p, "/TrimBox[%f %f %f %f]\n", p->TrimBox.llx, p->TrimBox.lly, p->TrimBox.urx, p->TrimBox.ury); } if (p->ArtBox.llx != (float) 0 || p->ArtBox.lly != (float) 0 || p->ArtBox.urx != (float) 0 || p->ArtBox.ury != (float) 0 ) { if (p->ArtBox.urx <= p->ArtBox.llx || p->ArtBox.ury <= p->ArtBox.lly) pdf_error(p, PDF_ValueError, "Illegal ArtBox dimensions"); pdf_printf(p, "/ArtBox[%f %f %f %f]\n", p->ArtBox.llx, p->ArtBox.lly, p->ArtBox.urx, p->ArtBox.ury); } /* * The duration can be placed in the transition dictionary (/D) * or in the page dictionary (/Dur). We put it here so it can * be used without setting a transition effect. */ if (p->duration > 0) pdf_printf(p, "/Dur %f\n", p->duration); pdf_write_page_transition(p); pdf_puts(p, "/Contents["); for (index = 0; index < p->next_content; index++) { pdf_printf(p, "%ld 0 R", p->contents_ids[index]); pdf_putc(p, (char) (index + 1 % 8 ? PDF_SPACE : PDF_NEWLINE)); } pdf_puts(p, "]\n"); /* Thumbnail image */ if (p->thumb_id != BAD_ID) pdf_printf(p, "/Thumb %ld 0 R\n", p->thumb_id); pdf_write_annots_root(p); pdf_end_dict(p); /* Page object */ pdf_end_obj(p); pdf_write_page_annots(p); /* Annotation dicts */ pdf_begin_obj(p, p->res_id); /* resource object */ pdf_begin_dict(p); /* resource dict */ pdf_write_page_procsets(p); /* ProcSet resources */ pdf_write_page_fonts(p); /* Font resources */ pdf_write_page_colorspaces(p); /* Color space resources */ pdf_write_page_pattern(p); /* Pattern resources */ pdf_write_xobjects(p); /* XObject resources */ pdf_end_dict(p); /* resource dict */ pdf_end_obj(p); /* resource object */ pdf_cleanup_page(p); PDF_SET_STATE(p, fn, pdf_state_document); if (p->flush & PDF_FLUSH_PAGE) pdf_flush_stream(p); }
PDFLIB_API void PDFLIB_CALL PDF_begin_page(PDF *p, float width, float height) { static const char fn[] = "PDF_begin_page"; PDF_TRACE(("%s\t(pdf[%p], %f, %f);\n", fn, (void *) p, width, height)); if (PDF_SANITY_CHECK_FAILED(p)) return; PDF_CHECK_SCOPE(p, fn, pdf_state_document); if (width <= 0 || height <= 0) pdf_error(p, PDF_ValueError, "Page size must be positive"); if (p->compatibility >= PDF_1_3 && (height < PDF_ACRO4_MINPAGE || width < PDF_ACRO4_MINPAGE || height > PDF_ACRO4_MAXPAGE || width > PDF_ACRO4_MAXPAGE)) pdf_error(p, PDF_NonfatalError, "Page size incompatible with Acrobat 4"); else if (p->compatibility == PDF_1_2 && (height < PDF_ACRO3_MINPAGE || width < PDF_ACRO3_MINPAGE || height > PDF_ACRO3_MAXPAGE || width > PDF_ACRO3_MAXPAGE)) pdf_error(p, PDF_RuntimeError, "Page size incompatible with Acrobat 3"); if (++(p->current_page) >= p->pages_capacity) pdf_grow_pages(p); /* no id has been preallocated */ if (p->pages[p->current_page] == BAD_ID) p->pages[p->current_page] = pdf_alloc_id(p); p->height = height; p->width = width; p->thumb_id = BAD_ID; p->next_content = 0; p->contents = c_none; p->procset = 0; p->sl = 0; p->CropBox.llx = (float) 0; p->CropBox.lly = (float) 0; p->CropBox.urx = (float) 0; p->CropBox.ury = (float) 0; p->BleedBox.llx = (float) 0; p->BleedBox.lly = (float) 0; p->BleedBox.urx = (float) 0; p->BleedBox.ury = (float) 0; p->TrimBox.llx = (float) 0; p->TrimBox.lly = (float) 0; p->TrimBox.urx = (float) 0; p->TrimBox.ury = (float) 0; p->ArtBox.llx = (float) 0; p->ArtBox.lly = (float) 0; p->ArtBox.urx = (float) 0; p->ArtBox.ury = (float) 0; PDF_SET_STATE(p, fn, pdf_state_page); pdf_init_page_annots(p); pdf_init_tstate(p); pdf_init_gstate(p); pdf_init_cstate(p); pdf_begin_contents_section(p); }
void pdf__begin_glyph( PDF *p, const char *glyphname, pdc_scalar wx, pdc_scalar llx, pdc_scalar lly, pdc_scalar urx, pdc_scalar ury) { static const char fn[] = "pdf__begin_glyph"; pdf_font *font; pdf_t3font *t3font; pdf_t3glyph *glyph = NULL; pdc_scalar tbc; int ig; if (glyphname == NULL || *glyphname == '\0') pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "glyphname", 0, 0, 0); font = &p->fonts[p->t3slot]; t3font = font->t3font; /* error message prefix */ pdc_push_errmsg(p->pdc, PDF_E_T3_FONT_PREFIX, font->apiname, 0, 0, 0); for (ig = 0; ig < t3font->next_glyph; ig++) { glyph = &t3font->glyphs[ig]; if (!pdc_strcmp(glyph->name, glyphname)) { if (t3font->pass == glyph->pass) pdc_error(p->pdc, PDF_E_T3_GLYPH, glyphname, 0, 0, 0); else break; } } /* new glyph */ if (ig == t3font->next_glyph) { if (t3font->pass == 2) pdc_error(p->pdc, PDF_E_T3_UNKOWNGLYPH, glyphname, 0, 0, 0); pdc_check_number(p->pdc, "wx", wx); pdc_check_number(p->pdc, "llx", llx); pdc_check_number(p->pdc, "lly", lly); pdc_check_number(p->pdc, "urx", urx); pdc_check_number(p->pdc, "ury", ury); if (t3font->colorized == pdc_true && (llx != 0 || lly != 0 || urx != 0 || ury != 0)) pdc_error(p->pdc, PDF_E_T3_BADBBOX, 0, 0, 0, 0); if (urx < llx) { tbc = llx; llx = urx; urx = tbc; } if (ury < lly) { tbc = lly; lly = ury; ury = tbc; } if (ig == t3font->capacity) { t3font->capacity *= 2; t3font->glyphs = (pdf_t3glyph *) pdc_realloc(p->pdc, t3font->glyphs, t3font->capacity * sizeof (pdf_t3glyph), fn); } glyph = &t3font->glyphs[ig]; glyph->charproc_id = PDC_BAD_ID; glyph->name = pdc_strdup(p->pdc, glyphname); glyph->wx = wx; glyph->llx = llx; glyph->lly = lly; glyph->urx = urx; glyph->ury = ury; /* see comment in p_font.c for explanation */ glyph->width = 1000 * wx * font->ft.matrix.a; /* if the strdup above fails, cleanup won't touch this slot. */ t3font->next_glyph++; } glyph->pass = t3font->pass; t3font->curr_glyph = ig; pdc_logg_cond(p->pdc, 1, trc_font, "\tBegin of Type3 font glyph \"%s\"\n", glyphname); if (t3font->pass != 1) { if (t3font->pass == 2) pdc_logg_cond(p->pdc, 2, trc_font, "\t\tglyph [%d] was used in text\n", ig); glyph->charproc_id = pdc_begin_obj(p->out, PDC_NEW_ID); pdc_begin_dict(p->out); p->length_id = pdc_alloc_id(p->out); pdc_objref(p->out, "/Length", p->length_id); if (pdc_get_compresslevel(p->out)) pdc_puts(p->out, "/Filter/FlateDecode\n"); pdc_end_dict(p->out); pdc_begin_pdfstream(p->out); if (t3font->colorized == pdc_true) pdc_printf(p->out, "%f 0 d0\n", glyph->wx); else { pdc_printf(p->out, "%f 0 %f %f %f %f d1\n", glyph->wx, glyph->llx, glyph->lly, glyph->urx, glyph->ury); /* adjust the font's bounding box */ if (glyph->llx < font->ft.bbox.llx) font->ft.bbox.llx = glyph->llx; if (glyph->lly < font->ft.bbox.lly) font->ft.bbox.lly = glyph->lly; if (glyph->urx > font->ft.bbox.urx) font->ft.bbox.urx = glyph->urx; if (glyph->ury > font->ft.bbox.ury) font->ft.bbox.ury = glyph->ury; } /* we must initialize the text, graphics and color state * otherwise the user get unpredictable appearance of a * glyph because of optimizing outputting graphics properties. * Following statements were inserted due to bug #719 */ pdf_init_tstate(p); pdf_init_gstate(p); pdf_init_cstate(p); PDF_SET_STATE(p, pdf_state_glyph); } else { PDF_SET_STATE(p, pdf_state_glyphmetrics); } pdc_pop_errmsg(p->pdc); if (!p->pdc->smokerun) pdc_logg_cond(p->pdc, 1, trc_api, "[Begin glyph %d]\n", ig); }
void pdf__end_font(PDF *p) { int ig; pdf_font *font; pdf_t3font *t3font; PDF_SET_STATE(p, pdf_state_document); font = &p->fonts[p->t3slot]; t3font = font->t3font; /* error message prefix */ pdc_push_errmsg(p->pdc, PDF_E_T3_FONT_PREFIX, font->apiname, 0, 0, 0); if (t3font->pass == 0) { pdf_t3glyph glyph0 = t3font->glyphs[0]; /* search for .notdef glyph */ if (pdc_strcmp(glyph0.name, (char *) pdc_get_notdef_glyphname())) { for (ig = 0; ig < t3font->next_glyph; ig++) { if (!pdc_strcmp(t3font->glyphs[ig].name, (char *) pdc_get_notdef_glyphname())) break; } if (ig < t3font->next_glyph) { pdc_logg_cond(p->pdc, 2, trc_font, "\tGlyph id %d: \"%s\" will be exchanged " "with glyph id 0: \"%s\"\n", ig, t3font->glyphs[ig].name, glyph0.name); t3font->glyphs[0] = t3font->glyphs[ig]; t3font->glyphs[ig] = glyph0; } else { pdc_warning(p->pdc, PDF_E_T3_MISSNOTDEF, 0, 0, 0, 0); } } } if (t3font->pass != 1) { t3font->charprocs_id = pdc_alloc_id(p->out); pdc_begin_obj(p->out, t3font->charprocs_id); /* CharProcs dict */ pdc_begin_dict(p->out); for (ig = 0; ig < t3font->next_glyph; ig++) { pdf_t3glyph *glyph = &t3font->glyphs[ig]; if (glyph->charproc_id != PDC_BAD_ID) { pdf_put_pdfname(p, glyph->name); pdc_objref(p->out, "", glyph->charproc_id); } } pdc_end_dict(p->out); pdc_end_obj(p->out); /* CharProcs dict */ pdc_begin_obj(p->out, t3font->res_id); pdc_begin_dict(p->out); /* Resource dict */ pdf_write_page_fonts(p); /* Font resources */ pdf_write_page_colorspaces(p); /* Color space resources */ pdf_write_page_pattern(p); /* Pattern resources */ pdf_write_xobjects(p); /* XObject resources */ pdc_end_dict(p->out); /* Resource dict */ pdc_end_obj(p->out); /* Resource object */ pdf_pg_resume(p, -1); if (p->flush & pdc_flush_content) pdc_flush_stream(p->out); /* see pdf__begin_glyph */ pdf_init_tstate(p); pdf_init_gstate(p); pdf_init_cstate(p); } pdc_logg_cond(p->pdc, 1, trc_font, "\tEnd of Type3 font \"%s\"\n", font->apiname); pdc_pop_errmsg(p->pdc); if (!p->pdc->smokerun) pdc_logg_cond(p->pdc, 1, trc_api, "[End font %d]\n", p->t3slot); p->t3slot = -1; }
/* Start a new pattern definition. */ PDFLIB_API int PDFLIB_CALL PDF_begin_pattern( PDF *p, float width, float height, float xstep, float ystep, int painttype) { static const char fn[] = "PDF_begin_pattern"; PDF_TRACE(("%s\t(pdf[%p], %f, %f, %f, %f, %d);\n", fn, (void *) p, width, height, xstep, ystep, painttype)); if (PDF_SANITY_CHECK_FAILED(p)) return -1; PDF_CHECK_SCOPE(p, fn, pdf_state_document); if (width <= 0 || height <= 0) pdf_error(p, PDF_ValueError, "Pattern size must be positive"); /* Acrobat 3 doesn't display patterns on screen so we disable it */ if (p->compatibility == PDF_1_2) pdf_error(p, PDF_RuntimeError, "Patterns not fully supported in Acrobat 3"); if (painttype != 1 && painttype != 2) pdf_error(p, PDF_ValueError, "Bad pattern paint type %d in PDF_begin_pattern", painttype); if (p->pattern_number == p->pattern_capacity) pdf_grow_pattern(p); p->pattern[p->pattern_number].obj_id = pdf_begin_obj(p, NEW_ID); p->pattern[p->pattern_number].painttype = painttype; p->height = height; p->width = width; p->thumb_id = BAD_ID; PDF_PUSH_STATE(p, fn, pdf_state_pattern); p->next_content = 0; p->contents = c_page; p->procset = 0; p->sl = 0; pdf_init_tstate(p); pdf_init_gstate(p); pdf_init_cstate(p); pdf_begin_dict(p); /* pattern dict*/ p->res_id = pdf_alloc_id(p); pdf_puts(p, "/PatternType 1\n"); /* colored or uncolored pattern */ pdf_printf(p, "/PaintType %d\n", painttype); pdf_puts(p, "/TilingType 1\n"); /* constant spacing */ pdf_printf(p, "/BBox[0 0 %f %f]\n", p->width, p->height); pdf_printf(p, "/XStep %f\n", xstep); pdf_printf(p, "/YStep %f\n", ystep); pdf_printf(p, "/Resources %ld 0 R\n", p->res_id); p->contents_length_id = pdf_alloc_id(p); pdf_printf(p, "/Length %ld 0 R\n", p->contents_length_id); if (p->compresslevel) pdf_puts(p, "/Filter/FlateDecode\n"); pdf_end_dict(p); /* pattern dict*/ pdf_begin_stream(p); pdf_compress_init(p); p->start_contents_pos = pdf_tell(p); p->next_content++; return p->pattern_number++; }
void pdf__begin_font( PDF *p, const char *fontname, float a, float b, float c, float d, float e, float f, const char *optlist) { static const char fn[] = "pdf__begin_font"; pdc_resopt *results; pdc_font *font; float det; int colorized = pdc_false; int slot; /* parsing optlist */ results = pdc_parse_optionlist(p->pdc, optlist, pdf_begin_font_options, NULL, pdc_true); pdc_get_optvalues(p->pdc, "colorized", results, &colorized, NULL); pdc_cleanup_optionlist(p->pdc, results); det = a*d - b*c; if (det == 0) pdc_error(p->pdc, PDC_E_ILLARG_MATRIX, pdc_errprintf(p->pdc, "%f %f %f %f %f %f", a, b, c, d, e, f), 0, 0, 0); /* look for an already existing font */ for (slot = 0; slot < p->fonts_number; slot++) { if (!strcmp(p->fonts[slot].apiname, fontname)) { pdc_error(p->pdc, PDF_E_T3_FONTEXISTS, fontname, 0, 0, 0); } } PDF_SET_STATE(p, pdf_state_font); pdf_init_tstate(p); pdf_init_gstate(p); pdf_init_cstate(p); /* slot for new font struct */ slot = pdf_init_newfont(p); font = &p->fonts[slot]; p->fonts_number++; /* * We store the new font in a font slot marked with "invalidenc" encoding. * When the font is used for the first time we modify the encoding. * Later uses will make a copy if the encoding is different. */ font->type = pdc_Type3; font->obj_id = pdc_alloc_id(p->out); font->name = NULL; font->apiname = pdc_strdup(p->pdc, fontname); font->encoding = pdc_invalidenc; /* initially there is no encoding */ font->widths = (int *) pdc_calloc(p->pdc, font->numOfCodes * sizeof(int), fn); font->t3font = (pdc_t3font*) pdc_malloc(p->pdc, sizeof(pdc_t3font), fn); pdf_init_t3font_struct(p, font->t3font, T3GLYPHS_CHUNKSIZE); font->t3font->fontname = pdc_strdup(p->pdc, fontname); font->t3font->colorized = colorized; /* the resource id is needed until the font dict is written */ font->t3font->res_id = pdc_alloc_id(p->out); font->t3font->matrix.a = a; font->t3font->matrix.b = b; font->t3font->matrix.c = c; font->t3font->matrix.d = d; font->t3font->matrix.e = e; font->t3font->matrix.f = f; /* We won't receive glyph bounding box values for colorized true, * so we use the font matrix to get an approximation instead. * * Writing the font matrix should be optional according to the * PDF reference, but we must write it in order to work around a * display bug in Acrobat. */ if (font->t3font->colorized == pdc_true) { font->t3font->bbox.llx = 0; font->t3font->bbox.lly = 0; font->t3font->bbox.urx = (d-b)/det; font->t3font->bbox.ury = (a-c)/det; } /* * We must store a pointer to the current font because its glyph * definitions may use other fonts and we would be unable to find * "our" current font again. This pointer lives throughout the * font definition, and will be reset in PDF_end_font() below. */ p->t3font = font->t3font; }