/* Write one FontInfo entry. */
static void
write_font_info(stream *s, const char *key, const gs_const_string *pvalue,
int do_write)
{
if (do_write) {
pprints1(s, "\n/%s ", key);
s_write_ps_string(s, pvalue->data, pvalue->size, PRINT_HEX_NOT_OK);
stream_puts(s, " def");
}
}
/* Create colored and uncolored Pattern color spaces. */
static int
pdf_pattern_space(gx_device_pdf *pdev, cos_value_t *pvalue,
pdf_resource_t **ppres, const char *cs_name)
{
int code;
if (!*ppres) {
int code = pdf_begin_resource_body(pdev, resourceColorSpace, gs_no_id,
ppres);
if (code < 0)
return code;
pprints1(pdev->strm, "%s\n", cs_name);
pdf_end_resource(pdev);
(*ppres)->object->written = true; /* don't write at end */
((pdf_color_space_t *)*ppres)->ranges = 0;
((pdf_color_space_t *)*ppres)->serialized = 0;
}
code = pdf_add_resource(pdev, pdev->substream_Resources, "/ColorSpace", *ppres);
if (code < 0)
return code;
cos_resource_value(pvalue, (*ppres)->object);
return 0;
}
/*
* Transition from string context to text context.
*/
static int
sync_text_state(gx_device_pdf *pdev)
{
pdf_text_state_t *pts = pdev->text->text_state;
stream *s = pdev->strm;
int code;
if (pts->buffer.count_chars == 0)
return 0; /* nothing to output */
if (pts->continue_line)
return flush_text_buffer(pdev);
/* Bring text state parameters up to date. */
if (pts->out.character_spacing != pts->in.character_spacing) {
pprintg1(s, "%g Tc\n", pts->in.character_spacing);
pts->out.character_spacing = pts->in.character_spacing;
}
if (pts->out.pdfont != pts->in.pdfont || pts->out.size != pts->in.size) {
pdf_font_resource_t *pdfont = pts->in.pdfont;
code = pdf_assign_font_object_id(pdev, pdfont);
if (code < 0)
return code;
pprints1(s, "/%s ", pdfont->rname);
pprintg1(s, "%g Tf\n", pts->in.size);
pts->out.pdfont = pdfont;
pts->out.size = pts->in.size;
/*
* In PDF, the only place to specify WMode is in the CMap
* (a.k.a. Encoding) of a Type 0 font.
*/
pts->wmode =
(pdfont->FontType == ft_composite ?
pdfont->u.type0.WMode : 0);
code = pdf_used_charproc_resources(pdev, pdfont);
if (code < 0)
return code;
}
if (memcmp(&pts->in.matrix, &pts->out.matrix, sizeof(pts->in.matrix)) ||
((pts->start.x != pts->out_pos.x || pts->start.y != pts->out_pos.y) &&
(pts->buffer.count_chars != 0 || pts->buffer.count_moves != 0))) {
/* pdf_set_text_matrix sets out.matrix = in.matrix */
code = pdf_set_text_matrix(pdev);
if (code < 0)
return code;
}
if (pts->out.render_mode != pts->in.render_mode) {
pprintg1(s, "%g Tr\n", pts->in.render_mode);
pts->out.render_mode = pts->in.render_mode;
}
if (pts->out.word_spacing != pts->in.word_spacing) {
if (memchr(pts->buffer.chars, 32, pts->buffer.count_chars)) {
pprintg1(s, "%g Tw\n", pts->in.word_spacing);
pts->out.word_spacing = pts->in.word_spacing;
}
}
return flush_text_buffer(pdev);
}
static int
param_print_typed(gs_param_list * plist, gs_param_name pkey,
gs_param_typed_value * pvalue)
{
printer_param_list_t *const prlist = (printer_param_list_t *)plist;
stream *s = prlist->strm;
if (!prlist->any) {
if (prlist->params.prefix)
stream_puts(s, prlist->params.prefix);
prlist->any = true;
}
if (prlist->params.item_prefix)
stream_puts(s, prlist->params.item_prefix);
pprints1(s, "/%s", pkey);
switch (pvalue->type) {
case gs_param_type_null:
stream_puts(s, " null");
break;
case gs_param_type_bool:
stream_puts(s, (pvalue->value.b ? " true" : " false"));
break;
case gs_param_type_int:
pprintd1(s, " %d", pvalue->value.i);
break;
case gs_param_type_long:
pprintld1(s, " %l", pvalue->value.l);
break;
case gs_param_type_float:
pprintg1(s, " %g", pvalue->value.f);
break;
case gs_param_type_string:
s_write_ps_string(s, pvalue->value.s.data, pvalue->value.s.size,
prlist->params.print_ok);
break;
case gs_param_type_name:
/****** SHOULD USE #-ESCAPES FOR PDF ******/
stream_putc(s, '/');
stream_write(s, pvalue->value.n.data, pvalue->value.n.size);
break;
case gs_param_type_int_array:
{
uint i;
char sepr = (pvalue->value.ia.size <= 10 ? ' ' : '\n');
stream_putc(s, '[');
for (i = 0; i < pvalue->value.ia.size; ++i) {
pprintd1(s, "%d", pvalue->value.ia.data[i]);
stream_putc(s, sepr);
}
stream_putc(s, ']');
}
break;
case gs_param_type_float_array:
{
uint i;
char sepr = (pvalue->value.fa.size <= 10 ? ' ' : '\n');
stream_putc(s, '[');
for (i = 0; i < pvalue->value.fa.size; ++i) {
pprintg1(s, "%g", pvalue->value.fa.data[i]);
stream_putc(s, sepr);
}
stream_putc(s, ']');
}
break;
/*case gs_param_type_string_array: */
/*case gs_param_type_name_array: */
default:
return_error(gs_error_typecheck);
}
if (prlist->params.item_suffix)
stream_puts(s, prlist->params.item_suffix);
return 0;
}
const char *
pprints3(stream * s, const char *format, const char *str1, const char *str2,
const char *str3)
{
return pprints2(s, pprints1(s, format, str1), str2, str3);
}
/* Write a FontDescriptor. */
int
pdf_write_FontDescriptor(gx_device_pdf *pdev, pdf_resource_t *pres)
{
pdf_font_descriptor_t *pfd = (pdf_font_descriptor_t *)pres;
font_type ftype = pfd->FontType;
long cidset_id = 0;
int code = 0;
stream *s;
if (pfd->common.object->written)
return 0;
if (pfd->common.object->id == -1)
return 0;
/* If this is a CIDFont subset, write the CIDSet now. */
switch (ftype) {
case ft_CID_encrypted:
case ft_CID_TrueType:
if (pdf_do_subset_font(pdev, pfd->base_font, pfd->common.rid)) {
if (pdev->PDFA < 2) {
code = pdf_write_CIDSet(pdev, pfd->base_font, &cidset_id);
if (code < 0)
return code;
}
}
default:
break;
}
{
/*
* Hack: make all embedded TrueType fonts "symbolic" to
* work around undocumented assumptions in Acrobat Reader.
*/
pdf_font_descriptor_common_t fd;
fd = pfd->common;
if (pfd->embed && pfd->FontType == ft_TrueType)
fd.values.Flags =
(fd.values.Flags & ~(FONT_IS_ADOBE_ROMAN)) | FONT_IS_SYMBOLIC;
code = write_FontDescriptor_common(pdev, &fd, pfd->embed);
}
if (code < 0)
return code;
s = pdev->strm;
if (cidset_id != 0)
pprintld1(s, "/CIDSet %ld 0 R\n", cidset_id);
else if (pdf_do_subset_font(pdev, pfd->base_font, pfd->common.rid) &&
(ftype == ft_encrypted || ftype == ft_encrypted2)
) {
stream_puts(s, "/CharSet");
code = pdf_write_CharSet(pdev, pfd->base_font);
if (code < 0)
return code;
}
if (pfd->embed && pfd->base_font->FontFile) {
code = pdf_write_FontFile_entry(pdev, pfd->base_font);
if (code < 0)
return code;
}
if (pfd->cid.Style) {
stream_puts(s, "/Style");
COS_WRITE(pfd->cid.Style, pdev);
}
if (pfd->cid.Lang[0]) {
pprints1(s, "/Lang(%s)", pfd->cid.Lang);
}
if (pfd->cid.FD) {
stream_puts(s, "/FD");
COS_WRITE(pfd->cid.FD, pdev);
}
stream_puts(s, ">>\n");
pdf_end_separate(pdev, resourceFontDescriptor);
pfd->common.object->written = true;
{ const cos_object_t *pco = (const cos_object_t *)pdf_get_FontFile_object(pfd->base_font);
if (pco != NULL) {
code = COS_WRITE_OBJECT(pco, pdev, resourceFontFile);
if (code < 0)
return code;
}
}
return 0;
}
