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);
}
/* Start a new pattern definition. */
int
pdf__begin_pattern(
PDF *p,
pdc_scalar width,
pdc_scalar height,
pdc_scalar xstep,
pdc_scalar ystep,
int painttype)
{
int slot = -1;
pdc_check_number_limits(p->pdc, "width", width,
PDC_FLOAT_PREC, PDC_FLOAT_MAX);
pdc_check_number_limits(p->pdc, "height", height,
PDC_FLOAT_PREC, PDC_FLOAT_MAX);
pdc_check_number_zero(p->pdc, "xstep", xstep);
pdc_check_number_zero(p->pdc, "ystep", ystep);
if (painttype != 1 && painttype != 2)
pdc_error(p->pdc, PDC_E_ILLARG_INT,
"painttype", pdc_errprintf(p->pdc, "%d", painttype), 0, 0);
if (p->pattern_number == p->pattern_capacity)
pdf_grow_pattern(p);
pdf_pg_suspend(p);
PDF_SET_STATE(p, pdf_state_pattern);
p->pattern[p->pattern_number].obj_id = pdc_begin_obj(p->out, PDC_NEW_ID);
p->pattern[p->pattern_number].painttype = painttype;
pdc_begin_dict(p->out); /* pattern dict*/
p->res_id = pdc_alloc_id(p->out);
pdc_puts(p->out, "/PatternType 1\n"); /* tiling pattern */
/* colored or uncolored pattern */
pdc_printf(p->out, "/PaintType %d\n", painttype);
pdc_puts(p->out, "/TilingType 1\n"); /* constant spacing */
pdc_printf(p->out, "/BBox[0 0 %f %f]\n", width, height);
pdc_printf(p->out, "/XStep %f\n", xstep);
pdc_printf(p->out, "/YStep %f\n", ystep);
pdc_objref(p->out, "/Resources", p->res_id);
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); /* pattern dict*/
pdc_begin_pdfstream(p->out);
slot = p->pattern_number;
p->pattern_number++;
/* top-down y-coordinates */
pdf_set_topdownsystem(p, height);
/* set color differing from PDF default */
pdf_set_default_color(p, pdc_false);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[Begin pattern %d]\n", slot);
return slot;
}
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;
}
void
pdf__begin_font(
PDF *p,
const char *fontname, int len,
pdc_scalar a, pdc_scalar b, pdc_scalar c, pdc_scalar d,
pdc_scalar e, pdc_scalar f,
const char *optlist)
{
static const char fn[] = "pdf__begin_font";
pdc_resopt *results;
pdf_font tmpfont, *font;
pdf_font_options fo;
pdc_scalar det;
pdc_clientdata cdata;
int colorized = pdc_false;
int metricsonly = pdc_false;
int slot;
if (fontname == NULL)
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "fontname", 0, 0, 0);
/* Converting fontname */
fontname = pdf_convert_name(p, fontname, len,
PDC_CONV_WITHBOM | PDC_CONV_TMPALLOC);
if (fontname == NULL || *fontname == '\0')
pdc_error(p->pdc, PDC_E_ILLARG_EMPTY, "fontname", 0, 0, 0);
pdc_logg_cond(p->pdc, 1, trc_font,
"\tBegin of Type3 font \"%s\"\n", fontname);
/* error message prefix */
pdc_push_errmsg(p->pdc, PDF_E_T3_FONT_PREFIX, fontname, 0, 0, 0);
/* look for an already existing font */
for (slot = 0; slot < p->fonts_number; slot++)
{
if (!pdc_strcmp(p->fonts[slot].apiname, fontname))
{
if (p->fonts[slot].t3font->pass == 1)
{
pdc_logg_cond(p->pdc, 1, trc_font,
"\tType3 font [%d] with metric definition found\n", slot);
PDF_CHECK_STATE(p, pdf_state_document);
p->fonts[slot].t3font->pass = 2;
p->t3slot = slot;
pdc_pop_errmsg(p->pdc);
pdf_pg_suspend(p);
PDF_SET_STATE(p, pdf_state_font);
return;
}
pdc_error(p->pdc, PDF_E_T3_FONTEXISTS, 0, 0, 0, 0);
}
}
pdc_check_number(p->pdc, "a", a);
pdc_check_number(p->pdc, "b", b);
pdc_check_number(p->pdc, "c", c);
pdc_check_number(p->pdc, "d", d);
pdc_check_number(p->pdc, "e", e);
pdc_check_number(p->pdc, "f", f);
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);
/* parsing optlist */
pdf_set_clientdata(p, &cdata);
results = pdc_parse_optionlist(p->pdc, optlist, pdf_begin_font_options,
&cdata, pdc_true);
pdc_get_optvalues("colorized", results, &colorized, NULL);
pdc_get_optvalues("widthsonly", results, &metricsonly, NULL);
pdc_cleanup_optionlist(p->pdc, results);
/* initialize font struct */
font = &tmpfont;
pdf_init_font_options(p, &fo);
pdf_init_font(p, font, &fo);
/*
* 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.
*/
/* API font name */
font->apiname = pdc_strdup(p->pdc, fontname);
font->ft.m.type = fnt_Type3;
font->hasoriginal = pdc_true;
font->ft.matrix.a = a;
font->ft.matrix.b = b;
font->ft.matrix.c = c;
font->ft.matrix.d = d;
font->ft.matrix.e = e;
font->ft.matrix.f = f;
font->t3font = (pdf_t3font*) pdc_malloc(p->pdc, sizeof(pdf_t3font), fn);
pdf_init_t3font(p, font->t3font, T3GLYPHS_CHUNKSIZE);
font->t3font->colorized = colorized;
/* the resource id is needed until the font dict is written */
font->t3font->res_id = pdc_alloc_id(p->out);
/* Now everything is fine, insert Type3 font with invalid encoding */
slot = pdf_insert_font(p, font);
/*
* 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->t3slot = slot;
if (metricsonly)
{
font->t3font->pass = 1;
pdc_logg_cond(p->pdc, 2, trc_font,
"\t\tonly for metric definition\n");
}
else
{
pdf_pg_suspend(p);
}
pdc_pop_errmsg(p->pdc);
PDF_SET_STATE(p, pdf_state_font);
if (!p->pdc->smokerun)
pdc_logg_cond(p->pdc, 1, trc_api, "[Begin font %d]\n", p->t3slot);
}
PDF *
pdf__new(
void (*errorhandler)(PDF *p, int type, const char *msg),
void* (*allocproc)(PDF *p, size_t size, const char *caller),
void* (*reallocproc)(PDF *p, void *mem, size_t size, const char *caller),
void (*freeproc)(PDF *p, void *mem),
void *opaque)
{
PDF * p;
pdc_core * pdc;
/* If allocproc is NULL, all entries are supplied internally by PDFlib */
if (allocproc == NULL) {
allocproc = default_malloc;
reallocproc = default_realloc;
freeproc = default_free;
}
p = (PDF *) (*allocproc) (NULL, sizeof(PDF), "PDF_new");
if (p == NULL)
return NULL;
/*
* Guard against crashes when PDF_delete is called without any
* PDF_open_*() in between.
*/
memset((void *)p, 0, (size_t) sizeof(PDF));
/* these two are required by PDF_get_opaque() */
p->magic = PDC_MAGIC;
p->opaque = opaque;
pdc = pdc_new_core(
(pdc_error_fp) errorhandler,
(pdc_alloc_fp) allocproc,
(pdc_realloc_fp) reallocproc,
(pdc_free_fp) freeproc, p,
PDFLIB_PRODUCTNAME,
PDFLIB_VERSIONSTRING);
if (pdc == NULL)
{
(*freeproc)(p, p);
return NULL;
}
pdc_register_errtab(pdc, PDC_ET_PDFLIB, pdf_errors, N_PDF_ERRORS);
fnt_register_errtab(pdc);
PDC_TRY(pdc)
{
p->freeproc = freeproc;
p->pdc = pdc;
p->compatibility = PDF_DEF_COMPATIBILITY;
p->errorpolicy = errpol_legacy;
p->userinfo = NULL;
p->document = NULL;
p->errorhandler = errorhandler;
p->flush = pdc_flush_page;
p->hypertextencoding= pdc_invalidenc;
p->hypertextformat = pdc_auto;
p->hypertextcodepage= 0;
p->usercoordinates = pdc_false;
p->usehyptxtenc = pdc_false;
p->currfo = NULL;
p->curr_ppt = NULL;
p->glyphcheck = text_nocheck;
p->textformat = pdc_auto;
p->in_text = pdc_false;
p->rendintent = AutoIntent;
p->preserveoldpantonenames = pdc_false;
p->spotcolorlookup = pdc_true;
p->ydirection = 1;
p->names = NULL;
p->names_capacity = 0;
p->xobjects = NULL;
p->state_sp = 0;
p->doc_pages = NULL;
p->actions = NULL;
PDF_SET_STATE(p, pdf_state_object);
/* all debug flags are cleared by default
* because of the above memset... */
/* ...but warning messages for non-fatal errors should be set,
* as well as font warnings -- the client must explicitly disable these.
*/
p->debug[(int) 'e'] = pdc_true;
p->debug[(int) 'F'] = pdc_true;
p->debug[(int) 'I'] = pdc_true;
pdf_init_stringlists(p);
pdf_init_font_options(p, NULL);
p->out = pdc_boot_output(p->pdc);
}
PDC_CATCH(pdc)
{
pdc_delete_core(pdc);
return (PDF *) 0;
}
return p;
} /* pdf__new */
void
pdf__begin_glyph(
PDF *p,
const char *glyphname,
float wx, float llx, float lly, float urx, float ury)
{
static const char fn[] = "pdf__begin_glyph";
pdc_t3font *t3font;
pdc_t3glyph *glyph;
int i;
t3font = p->t3font;
if (t3font->colorized == pdc_true &&
(llx != (float) 0 || lly != (float) 0 ||
urx != (float) 0 || ury != (float) 0))
pdc_error(p->pdc, PDF_E_T3_BADBBOX, t3font->fontname, 0, 0, 0);
PDF_SET_STATE(p, pdf_state_glyph);
for (i = 0; i < t3font->next_glyph; ++i) {
if (!strcmp(t3font->glyphs[i].name, glyphname)) {
pdc_error(p->pdc, PDF_E_T3_GLYPH, glyphname,
t3font->fontname, 0, 0);
}
}
if (t3font->next_glyph == t3font->capacity) {
t3font->capacity *= 2;
t3font->glyphs = (pdc_t3glyph *) pdc_realloc(p->pdc, t3font->glyphs,
t3font->capacity * sizeof (pdc_t3glyph), fn);
}
glyph = &t3font->glyphs[t3font->next_glyph];
glyph->charproc_id = pdc_begin_obj(p->out, PDC_NEW_ID);
glyph->name = pdc_strdup(p->pdc, glyphname);
/* see comment in p_font.c for explanation */
glyph->width = 1000 * wx * t3font->matrix.a;
/* if the strdup above fails, cleanup won't touch this slot. */
++t3font->next_glyph;
p->contents = c_page;
/* glyph description */
pdc_begin_dict(p->out); /* glyph description dict */
p->length_id = pdc_alloc_id(p->out);
pdc_printf(p->out, "/Length %ld 0 R\n", p->length_id);
if (pdc_get_compresslevel(p->out))
pdc_puts(p->out, "/Filter/FlateDecode\n");
pdc_end_dict(p->out); /* glyph description dict */
pdc_begin_pdfstream(p->out); /* glyph description stream */
p->next_content++;
if (t3font->colorized == pdc_true)
pdc_printf(p->out, "%f 0 d0\n", wx);
else {
pdc_printf(p->out, "%f 0 %f %f %f %f d1\n", wx, llx, lly, urx, ury);
/* adjust the font's bounding box */
if (llx < t3font->bbox.llx)
t3font->bbox.llx = llx;
if (lly < t3font->bbox.lly)
t3font->bbox.lly = lly;
if (urx > t3font->bbox.urx)
t3font->bbox.urx = urx;
if (ury > t3font->bbox.ury)
t3font->bbox.ury = ury;
}
}
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;
}
