/* 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__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);
}
