/*
* Set the text matrix for writing text. The translation component of the
* matrix is the text origin. If the non-translation components of the
* matrix differ from the current ones, write a Tm command; if there is only
* a Y translation, set use_leading so the next text string will be written
* with ' rather than Tj; otherwise, write a Td command.
*/
static int
pdf_set_text_matrix(gx_device_pdf * pdev)
{
pdf_text_state_t *pts = pdev->text->text_state;
stream *s = pdev->strm;
pts->use_leading = false;
if (matrix_is_compatible(&pts->out.matrix, &pts->in.matrix)) {
gs_point dist;
int code;
code = set_text_distance(&dist, pts->start.x - pts->line_start.x,
pts->start.y - pts->line_start.y, &pts->in.matrix);
if (code < 0)
return code;
if (dist.x == 0 && dist.y < 0) {
/* Use TL, if needed, and T* or '. */
float dist_y = (float)-dist.y;
if (fabs(pts->leading - dist_y) > 0.0005) {
pprintg1(s, "%g TL\n", dist_y);
pts->leading = dist_y;
}
pts->use_leading = true;
} else {
/* Use Td. */
pprintg2(s, "%g %g Td\n", dist.x, dist.y);
}
} else { /* Use Tm. */
/*
* See stream_to_text in gdevpdfu.c for why we need the following
* matrix adjustments.
*/
double sx = 72.0 / pdev->HWResolution[0],
sy = 72.0 / pdev->HWResolution[1];
pprintg6(s, "%g %g %g %g %g %g Tm\n",
pts->in.matrix.xx * sx, pts->in.matrix.xy * sy,
pts->in.matrix.yx * sx, pts->in.matrix.yy * sy,
pts->start.x * sx, pts->start.y * sy);
}
pts->line_start.x = pts->start.x;
pts->line_start.y = pts->start.y;
pts->out.matrix = pts->in.matrix;
return 0;
}
/* Write the definition of a Type 1 font. */
int
psf_write_type1_font(stream *s, gs_font_type1 *pfont, int options,
gs_glyph *orig_subset_glyphs, uint orig_subset_size,
const gs_const_string *alt_font_name, int lengths[3])
{
stream *es = s;
long start = stell(s);
param_printer_params_t ppp;
printer_param_list_t rlist;
gs_param_list *const plist = (gs_param_list *)&rlist;
stream AXE_stream;
stream_AXE_state AXE_state;
byte AXE_buf[200]; /* arbitrary */
stream exE_stream;
stream_exE_state exE_state;
byte exE_buf[200]; /* arbitrary */
psf_outline_glyphs_t glyphs;
int lenIV = pfont->data.lenIV;
int (*write_CharString)(stream *, const void *, uint) = stream_write;
int code = psf_get_type1_glyphs(&glyphs, pfont, orig_subset_glyphs,
orig_subset_size);
if (code < 0)
return code;
/* Initialize the parameter printer. */
ppp = param_printer_params_default;
ppp.item_suffix = " def\n";
ppp.print_ok =
(options & WRITE_TYPE1_ASCIIHEX ? 0 : PRINT_BINARY_OK) |
PRINT_HEX_NOT_OK;
code = s_init_param_printer(&rlist, &ppp, s);
if (code < 0)
return code;
/* Write the font header. */
stream_puts(s, "%!FontType1-1.0: ");
write_font_name(s, pfont, alt_font_name, false);
stream_puts(s, "\n11 dict begin\n");
/* Write FontInfo. */
stream_puts(s, "/FontInfo 5 dict dup begin");
{
gs_font_info_t info;
int code = pfont->procs.font_info((gs_font *)pfont, NULL,
(FONT_INFO_COPYRIGHT | FONT_INFO_NOTICE |
FONT_INFO_FAMILY_NAME | FONT_INFO_FULL_NAME),
&info);
if (code >= 0) {
write_font_info(s, "Copyright", &info.Copyright,
info.members & FONT_INFO_COPYRIGHT);
write_font_info(s, "Notice", &info.Notice,
info.members & FONT_INFO_NOTICE);
write_font_info(s, "FamilyName", &info.FamilyName,
info.members & FONT_INFO_FAMILY_NAME);
write_font_info(s, "FullName", &info.FullName,
info.members & FONT_INFO_FULL_NAME);
}
}
stream_puts(s, "\nend readonly def\n");
/* Write the main font dictionary. */
stream_puts(s, "/FontName ");
write_font_name(s, pfont, alt_font_name, true);
stream_puts(s, " def\n");
code = write_Encoding(s, pfont, options, glyphs.subset_glyphs,
glyphs.subset_size, glyphs.notdef);
if (code < 0)
return code;
pprintg6(s, "/FontMatrix [%g %g %g %g %g %g] readonly def\n",
pfont->FontMatrix.xx, pfont->FontMatrix.xy,
pfont->FontMatrix.yx, pfont->FontMatrix.yy,
pfont->FontMatrix.tx, pfont->FontMatrix.ty);
write_uid(s, &pfont->UID);
pprintg4(s, "/FontBBox {%g %g %g %g} readonly def\n",
pfont->FontBBox.p.x, pfont->FontBBox.p.y,
pfont->FontBBox.q.x, pfont->FontBBox.q.y);
{
static const gs_param_item_t font_items[] = {
{"FontType", gs_param_type_int,
offset_of(gs_font_type1, FontType)},
{"PaintType", gs_param_type_int,
offset_of(gs_font_type1, PaintType)},
{"StrokeWidth", gs_param_type_float,
offset_of(gs_font_type1, StrokeWidth)},
gs_param_item_end
};
code = gs_param_write_items(plist, pfont, NULL, font_items);
if (code < 0)
return code;
}
{
const gs_type1_data *const pdata = &pfont->data;
write_float_array(plist, "WeightVector", pdata->WeightVector.values,
pdata->WeightVector.count);
}
stream_puts(s, "currentdict end\n");
/* Write the Private dictionary. */
if (lenIV < 0 && (options & WRITE_TYPE1_WITH_LENIV)) {
/* We'll have to encrypt the CharStrings. */
lenIV = 0;
write_CharString = stream_write_encrypted;
}
if (options & WRITE_TYPE1_EEXEC) {
stream_puts(s, "currentfile eexec\n");
lengths[0] = stell(s) - start;
start = stell(s);
if (options & WRITE_TYPE1_ASCIIHEX) {
s_init(&AXE_stream, s->memory);
s_init_state((stream_state *)&AXE_state, &s_AXE_template, NULL);
AXE_state.EndOfData = false;
s_init_filter(&AXE_stream, (stream_state *)&AXE_state,
AXE_buf, sizeof(AXE_buf), es);
es = &AXE_stream;
}
s_init(&exE_stream, s->memory);
s_init_state((stream_state *)&exE_state, &s_exE_template, NULL);
exE_state.cstate = 55665;
s_init_filter(&exE_stream, (stream_state *)&exE_state,
exE_buf, sizeof(exE_buf), es);
es = &exE_stream;
/*
* Note: eexec encryption always writes/skips 4 initial bytes, not
* the number of initial bytes given by pdata->lenIV.
*/
stream_puts(es, "****");
}
code = write_Private(es, pfont, glyphs.subset_glyphs, glyphs.subset_size,
glyphs.notdef, lenIV, write_CharString, &ppp);
if (code < 0)
return code;
stream_puts(es, "dup/FontName get exch definefont pop\n");
if (options & WRITE_TYPE1_EEXEC) {
if (options & (WRITE_TYPE1_EEXEC_PAD | WRITE_TYPE1_EEXEC_MARK))
stream_puts(es, "mark ");
stream_puts(es, "currentfile closefile\n");
s_close_filters(&es, s);
lengths[1] = stell(s) - start;
start = stell(s);
if (options & WRITE_TYPE1_EEXEC_PAD) {
int i;
for (i = 0; i < 8; ++i)
stream_puts(s, "\n0000000000000000000000000000000000000000000000000000000000000000");
stream_puts(s, "\ncleartomark\n");
}
lengths[2] = stell(s) - start;
} else {
lengths[0] = stell(s) - start;
lengths[1] = lengths[2] = 0;
}
/* Wrap up. */
s_release_param_printer(&rlist);
return 0;
}
