static pdf_annot *
pdf_create_freetext_annot(pdf_xref *xref, fz_obj *obj)
{
fz_context *ctx = xref->ctx;
fz_buffer *content = fz_new_buffer(ctx, 256);
fz_buffer *base_ap = fz_new_buffer(ctx, 256);
fz_obj *ap = fz_dict_gets(ctx, obj, "DA");
fz_obj *value = fz_dict_gets(ctx, obj, "Contents");
fz_rect rect = pdf_to_rect(ctx, fz_dict_gets(ctx, obj, "Rect"));
int align = fz_to_int(ctx, fz_dict_gets(ctx, obj, "Q"));
fz_obj *res = pdf_dict_from_string(xref, ANNOT_FREETEXT_AP_RESOURCES);
unsigned short *ucs2, *rest;
float x;
char *font_name = NULL;
float font_size = pdf_extract_font_size(xref, fz_to_str_buf(ctx, ap), &font_name);
if (!font_size)
font_size = 10;
/* TODO: what resource dictionary does this font name refer to? */
if (font_name)
{
fz_obj *font = fz_dict_gets(ctx, res, "Font");
fz_dict_puts(ctx, font, font_name, fz_dict_gets(ctx, font, "Default"));
fz_free(ctx, font_name);
}
fz_buffer_printf(ctx, content, "q 1 1 %.4f %.4f re W n BT %s ",
rect.x1 - rect.x0 - 2.0f, rect.y1 - rect.y0 - 2.0f, fz_to_str_buf(ctx, ap));
fz_buffer_printf(ctx, base_ap, "q BT %s ", fz_to_str_buf(ctx, ap));
fz_buffer_printf(ctx, content, "/Default %.4f Tf ", font_size);
fz_buffer_printf(ctx, base_ap, "/Default %.4f Tf ", font_size);
fz_buffer_printf(ctx, content, "1 0 0 1 2 %.4f Tm ", rect.y1 - rect.y0 - 2);
/* Adobe Reader seems to consider "[1 0 0] r" and "1 0 0 rg" to mean the same(?) */
if (strchr(base_ap->data, '['))
{
float r, g, b;
if (sscanf(strchr(base_ap->data, '['), "[%f %f %f] r", &r, &g, &b) == 3)
fz_buffer_printf(ctx, content, "%.4f %.4f %.4f rg ", r, g, b);
}
ucs2 = pdf_to_ucs2(ctx, value);
for (rest = ucs2; *rest; rest++)
if (*rest > 0xFF)
*rest = '?';
x = 0;
rest = ucs2;
while (*rest)
rest = pdf_append_line(xref, res, content, base_ap, rest, font_size, align, rect.x1 - rect.x0 - 4.0f, 1, &x);
fz_free(ctx, ucs2);
fz_buffer_printf(ctx, content, "ET Q");
fz_drop_buffer(ctx, base_ap);
return pdf_create_annot(ctx, rect, fz_keep_obj(obj), content, res, 0);
}
static pdf_obj *draw_check_button(fz_context *ctx, pdf_annot *annot, fz_rect bbox, fz_matrix matrix, float w, float h, int yes)
{
float black[3] = { 0, 0, 0 };
pdf_obj *ap, *res = NULL;
fz_buffer *buf;
float b;
fz_var(res);
buf = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
fz_append_string(ctx, buf, "q\n");
if (pdf_write_MK_BG_appearance(ctx, annot, buf))
fz_append_printf(ctx, buf, "0 0 %g %g re\nf\n", w, h);
b = pdf_write_border_appearance(ctx, annot, buf);
if (b > 0 && pdf_write_MK_BC_appearance(ctx, annot, buf))
fz_append_printf(ctx, buf, "%g %g %g %g re\nS\n", b/2, b/2, w-b, h-b);
if (yes)
write_variable_text(ctx, annot, buf, &res, "3", "ZaDb", h, black, 0, w, h, b+h/10, 0.8f, 1.2f, 0, 0, 0);
fz_append_string(ctx, buf, "Q\n");
ap = pdf_new_xobject(ctx, annot->page->doc, bbox, matrix, res, buf);
}
fz_always(ctx)
{
pdf_drop_obj(ctx, res);
fz_drop_buffer(ctx, buf);
}
fz_catch(ctx)
fz_rethrow(ctx);
return ap;
}
static fz_buffer *hexbuf(unsigned char *p, int n)
{
static const char hex[16] = "0123456789abcdef";
fz_buffer *buf;
int x = 0;
buf = fz_new_buffer(ctx, n * 2 + (n / 32) + 2);
while (n--)
{
buf->data[buf->len++] = hex[*p >> 4];
buf->data[buf->len++] = hex[*p & 15];
if (++x == 32)
{
buf->data[buf->len++] = '\n';
x = 0;
}
p++;
}
buf->data[buf->len++] = '>';
buf->data[buf->len++] = '\n';
return buf;
}
static pdf_annot *
pdf_create_highlight_annot(pdf_xref *xref, fz_obj *obj)
{
fz_context *ctx = xref->ctx;
fz_buffer *content = fz_new_buffer(ctx, 512);
fz_rect rect = pdf_to_rect(ctx, fz_dict_gets(ctx, obj, "Rect"));
fz_obj *quad_points = fz_dict_gets(ctx, obj, "QuadPoints");
fz_obj *resources = pdf_dict_from_string(xref, ANNOT_HIGHLIGHT_AP_RESOURCES);
fz_rect a, b;
float rgb[3];
float skew;
int i;
for (i = 0; i < fz_array_len(ctx, quad_points) / 8; i++)
{
pdf_get_quadrilaterals(ctx, quad_points, i, &a, &b);
skew = 0.15 * fabs(a.y0 - b.y0);
b.x0 -= skew; b.x1 += skew;
rect = fz_union_rect(rect, fz_union_rect(a, b));
}
pdf_get_annot_color(ctx, obj, rgb);
fz_buffer_printf(ctx, content, "q /GS gs %.4f %.4f %.4f rg 1 0 0 1 -%.4f -%.4f cm ",
rgb[0], rgb[1], rgb[2], rect.x0, rect.y0);
for (i = 0; i < fz_array_len(ctx, quad_points) / 8; i++)
{
pdf_get_quadrilaterals(ctx, quad_points, i, &a, &b);
skew = 0.15 * fabs(a.y0 - b.y0);
fz_buffer_printf(ctx, content, "%.4f %.4f m %.4f %.4f l %.4f %.4f l %.4f %.4f l h ",
a.x0, a.y0, b.x1 + skew, b.y1, a.x1, a.y1, b.x0 - skew, b.y0);
}
fz_buffer_printf(ctx, content, "f Q");
return pdf_create_annot(ctx, rect, fz_keep_obj(obj), content, resources, 1);
}
/* SumatraPDF: partial support for file attachment icons */
static pdf_annot *
pdf_create_file_annot(pdf_xref *xref, fz_obj *obj)
{
fz_buffer *content = fz_new_buffer(xref->ctx, 512);
fz_rect rect = pdf_to_rect(xref->ctx, fz_dict_gets(xref->ctx, obj, "Rect"));
char *icon_name = fz_to_name(xref->ctx, fz_dict_gets(xref->ctx, obj, "Name"));
char *content_ap = ANNOT_FILE_ATTACHMENT_AP_PUSHPIN;
float rgb[3];
pdf_get_annot_color(xref->ctx, obj, rgb);
if (!strcmp(icon_name, "Graph"))
content_ap = ANNOT_FILE_ATTACHMENT_AP_GRAPH;
else if (!strcmp(icon_name, "Paperclip"))
content_ap = ANNOT_FILE_ATTACHMENT_AP_PAPERCLIP;
else if (!strcmp(icon_name, "Tag"))
content_ap = ANNOT_FILE_ATTACHMENT_AP_TAG;
fz_buffer_printf(xref->ctx, content, "q %.4f 0 0 %.4f 0 0 cm ",
(rect.x1 - rect.x0) / 24, (rect.y1 - rect.y0) / 24);
fz_buffer_printf(xref->ctx, content, content_ap, 0.5, 0.5, 0.5);
fz_buffer_printf(xref->ctx, content, " 1 0 0 1 0 1 cm ");
fz_buffer_printf(xref->ctx, content, content_ap, rgb[0], rgb[1], rgb[2]);
fz_buffer_printf(xref->ctx, content, " Q", content_ap);
obj = pdf_clone_for_view_only(xref, obj);
return pdf_create_annot(xref->ctx, rect, obj, content, NULL, 0);
}
static pdf_obj *draw_radio_button(fz_context *ctx, pdf_annot *annot, fz_rect bbox, fz_matrix matrix, float w, float h, int yes)
{
pdf_obj *ap;
fz_buffer *buf;
float b;
buf = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
fz_append_string(ctx, buf, "q\n");
if (pdf_write_MK_BG_appearance(ctx, annot, buf))
draw_circle_in_box(ctx, buf, "f\n", 0, 0, 0, w, h);
b = pdf_write_border_appearance(ctx, annot, buf);
if (b > 0 && pdf_write_MK_BC_appearance(ctx, annot, buf))
draw_circle_in_box(ctx, buf, "s\n", b, 0, 0, w, h);
if (yes)
{
fz_append_string(ctx, buf, "0 g\n");
draw_circle(ctx, buf, "f\n", (w-b*2)/4, (h-b*2)/4, w/2, h/2);
}
fz_append_string(ctx, buf, "Q\n");
ap = pdf_new_xobject(ctx, annot->page->doc, bbox, matrix, NULL, buf);
}
fz_always(ctx)
fz_drop_buffer(ctx, buf);
fz_catch(ctx)
fz_rethrow(ctx);
return ap;
}
/* SumatraPDF: partial support for link borders */
static pdf_annot *
pdf_create_link_annot(pdf_xref *xref, fz_obj *obj)
{
fz_obj *border, *dashes;
fz_buffer *content;
fz_rect rect;
float rgb[3];
int i;
border = fz_dict_gets(xref->ctx, obj, "Border");
if (fz_to_real(xref->ctx, fz_array_get(xref->ctx, border, 2)) <= 0)
return NULL;
pdf_get_annot_color(xref->ctx, obj, rgb);
dashes = fz_array_get(xref->ctx, border, 3);
rect = pdf_to_rect(xref->ctx, fz_dict_gets(xref->ctx, obj, "Rect"));
obj = pdf_clone_for_view_only(xref, obj);
// TODO: draw rounded rectangles if the first two /Border values are non-zero
content = fz_new_buffer(xref->ctx, 128);
fz_buffer_printf(xref->ctx, content, "q %.4f w [", fz_to_real(xref->ctx, fz_array_get(xref->ctx, border, 2)));
for (i = 0; i < fz_array_len(xref->ctx, dashes); i++)
fz_buffer_printf(xref->ctx, content, "%.4f ", fz_to_real(xref->ctx, fz_array_get(xref->ctx, dashes, i)));
fz_buffer_printf(xref->ctx, content, "] 0 d %.4f %.4f %.4f RG 0 0 %.4f %.4f re S Q",
rgb[0], rgb[1], rgb[2], rect.x1 - rect.x0, rect.y1 - rect.y0);
return pdf_create_annot(xref->ctx, rect, obj, content, NULL, 0);
}
char *
fz_copy_selection(fz_context *ctx, fz_stext_page *page, fz_rect rect)
{
fz_buffer *buffer;
fz_rect hitbox;
int c, i, block_num, seen = 0;
unsigned char *s;
float x0 = rect.x0;
float x1 = rect.x1;
float y0 = rect.y0;
float y1 = rect.y1;
buffer = fz_new_buffer(ctx, 1024);
for (block_num = 0; block_num < page->len; block_num++)
{
fz_stext_block *block;
fz_stext_line *line;
fz_stext_span *span;
if (page->blocks[block_num].type != FZ_PAGE_BLOCK_TEXT)
continue;
block = page->blocks[block_num].u.text;
for (line = block->lines; line < block->lines + block->len; line++)
{
for (span = line->first_span; span; span = span->next)
{
if (seen)
{
fz_write_buffer_byte(ctx, buffer, '\n');
}
seen = 0;
for (i = 0; i < span->len; i++)
{
fz_stext_char_bbox(ctx, &hitbox, span, i);
c = span->text[i].c;
if (c < 32)
c = 0xFFFD;
if (hitbox.x1 >= x0 && hitbox.x0 <= x1 && hitbox.y1 >= y0 && hitbox.y0 <= y1)
{
fz_write_buffer_rune(ctx, buffer, c);
seen = 1;
}
}
seen = (seen && span == line->last_span);
}
}
}
fz_write_buffer_byte(ctx, buffer, 0);
fz_buffer_extract(ctx, buffer, &s);
fz_drop_buffer(ctx, buffer);
return (char*)s;
}
static void
pdf_clean_stream_object(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie, int own_res,
pdf_text_filter_fn *text_filter, pdf_after_text_object_fn *after_text, void *arg,
int sanitize, int ascii)
{
pdf_processor *proc_buffer = NULL;
pdf_processor *proc_filter = NULL;
pdf_obj *res = NULL;
pdf_obj *ref;
fz_buffer *buffer;
if (!obj)
return;
fz_var(res);
fz_var(proc_buffer);
fz_var(proc_filter);
buffer = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
if (own_res)
{
pdf_obj *r = pdf_dict_get(ctx, obj, PDF_NAME(Resources));
if (r)
orig_res = r;
}
res = pdf_new_dict(ctx, doc, 1);
proc_buffer = pdf_new_buffer_processor(ctx, buffer, ascii);
proc_filter = pdf_new_filter_processor_with_text_filter(ctx, doc, proc_buffer, orig_res, res, text_filter, after_text, arg);
pdf_process_contents(ctx, proc_filter, doc, orig_res, obj, cookie);
pdf_close_processor(ctx, proc_filter);
pdf_close_processor(ctx, proc_buffer);
pdf_update_stream(ctx, doc, obj, buffer, 0);
if (own_res)
{
ref = pdf_add_object(ctx, doc, res);
pdf_dict_put_drop(ctx, obj, PDF_NAME(Resources), ref);
}
}
fz_always(ctx)
{
pdf_drop_processor(ctx, proc_filter);
pdf_drop_processor(ctx, proc_buffer);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, res);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
char *
fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_rect rect)
{
fz_buffer *buffer;
fz_rect hitbox;
fz_text_block *block;
fz_text_line *line;
int c, i, seen = 0;
char *s;
float x0 = rect.x0;
float x1 = rect.x1;
float y0 = rect.y0;
float y1 = rect.y1;
buffer = fz_new_buffer(ctx, 1024);
for (block = page->blocks; block < page->blocks + page->len; block++)
{
for (line = block->lines; line < block->lines + block->len; line++)
{
int span_num;
for (span_num = 0; span_num < line->len; span_num++)
{
fz_text_span *span = line->spans[span_num];
if (seen)
{
fz_write_buffer_byte(ctx, buffer, '\n');
}
seen = 0;
for (i = 0; i < span->len; i++)
{
fz_text_char_bbox(&hitbox, span, i);
c = span->text[i].c;
if (c < 32)
c = '?';
if (hitbox.x1 >= x0 && hitbox.x0 <= x1 && hitbox.y1 >= y0 && hitbox.y0 <= y1)
{
fz_write_buffer_rune(ctx, buffer, c);
seen = 1;
}
}
seen = (seen && span_num + 1 == line->len);
}
}
}
fz_write_buffer_byte(ctx, buffer, 0);
s = (char*)buffer->data;
fz_free(ctx, buffer);
return s;
}
fz_buffer *
fz_read_best(fz_stream *stm, int initial, int *truncated)
{
fz_buffer *buf = NULL;
int n;
fz_context *ctx = stm->ctx;
fz_var(buf);
if (truncated)
*truncated = 0;
fz_try(ctx)
{
if (initial < 1024)
initial = 1024;
buf = fz_new_buffer(ctx, initial+1);
while (1)
{
if (buf->len == buf->cap)
fz_grow_buffer(ctx, buf);
if (buf->len >= MIN_BOMB && buf->len / 200 > initial)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "compression bomb detected");
}
n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
if (n == 0)
break;
buf->len += n;
}
}
fz_catch(ctx)
{
if (fz_caught(ctx) == FZ_ERROR_TRYLATER)
{
fz_drop_buffer(ctx, buf);
fz_rethrow(ctx);
}
if (truncated)
{
*truncated = 1;
}
else
{
fz_drop_buffer(ctx, buf);
fz_rethrow(ctx);
}
}
return buf;
}
static void
pdf_clean_stream_object(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie, int own_res)
{
pdf_processor *proc_buffer = NULL;
pdf_processor *proc_filter = NULL;
pdf_obj *res = NULL;
pdf_obj *ref = NULL;
fz_buffer *buffer;
if (!obj)
return;
fz_var(res);
fz_var(ref);
fz_var(proc_buffer);
fz_var(proc_filter);
buffer = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
if (own_res)
{
pdf_obj *r = pdf_dict_get(ctx, obj, PDF_NAME_Resources);
if (r)
orig_res = r;
}
res = pdf_new_dict(ctx, doc, 1);
proc_buffer = pdf_new_buffer_processor(ctx, buffer);
proc_filter = pdf_new_filter_processor(ctx, proc_buffer, doc, orig_res, res);
pdf_process_contents(ctx, proc_filter, doc, orig_res, obj, cookie);
pdf_update_stream(ctx, doc, obj, buffer, 0);
if (own_res)
{
ref = pdf_new_ref(ctx, doc, res);
pdf_dict_put(ctx, obj, PDF_NAME_Resources, ref);
}
}
fz_always(ctx)
{
pdf_drop_processor(ctx, proc_filter);
pdf_drop_processor(ctx, proc_buffer);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, res);
pdf_drop_obj(ctx, ref);
}
fz_catch(ctx)
{
fz_rethrow_message(ctx, "Failed while cleaning xobject");
}
}
/*
* Read and interleave split parts from a ZIP file.
*/
xps_part *
xps_read_part(fz_context *ctx, xps_document *doc, char *partname)
{
fz_archive *zip = doc->zip;
fz_buffer *buf, *tmp;
char path[2048];
int count;
char *name;
int seen_last;
name = partname;
if (name[0] == '/')
name ++;
/* All in one piece */
if (fz_has_archive_entry(ctx, zip, name))
{
buf = fz_read_archive_entry(ctx, zip, name);
}
/* Assemble all the pieces */
else
{
buf = fz_new_buffer(ctx, 512);
seen_last = 0;
for (count = 0; !seen_last; ++count)
{
fz_snprintf(path, sizeof path, "%s/[%d].piece", name, count);
if (fz_has_archive_entry(ctx, zip, path))
{
tmp = fz_read_archive_entry(ctx, zip, path);
fz_append_buffer(ctx, buf, tmp);
fz_drop_buffer(ctx, tmp);
}
else
{
fz_snprintf(path, sizeof path, "%s/[%d].last.piece", name, count);
if (fz_has_archive_entry(ctx, zip, path))
{
tmp = fz_read_archive_entry(ctx, zip, path);
fz_append_buffer(ctx, buf, tmp);
fz_drop_buffer(ctx, tmp);
seen_last = 1;
}
else
{
fz_drop_buffer(ctx, buf);
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find all pieces for part '%s'", partname);
}
}
}
}
return xps_new_part(ctx, doc, partname, buf);
}
static int add_to_srcpage_stream(pdf_document *xref,fz_context *ctx,int pageref,int pagegen,
pdf_obj *srcdict)
{
fz_buffer *srcbuf;
fz_buffer *dstbuf;
int dstlen;
// printf("@add_to_srcpage_stream()...pageref=%d\n",pageref);
srcbuf=pdf_load_stream(xref,pdf_to_num(srcdict),pdf_to_gen(srcdict));
if (srcbuf==NULL)
{
dstbuf=pdf_load_stream(xref,pageref,pagegen);
if (dstbuf==NULL)
return(0);
dstlen=fz_buffer_storage(ctx,dstbuf,NULL);
fz_drop_buffer(ctx,dstbuf);
return(dstlen);
}
if (!pdf_is_stream(xref,pageref,pagegen))
dstbuf=fz_new_buffer(ctx,16);
else
{
dstbuf=pdf_load_stream(xref,pageref,pagegen);
if (dstbuf==NULL)
dstbuf=fz_new_buffer(ctx,16);
}
/* Concatenate srcbuf to dstbuf: (Will srcbuf->data be allowed?) */
dstlen=fz_buffer_storage(ctx,dstbuf,NULL);
/*
printf(" dstlen before = %d\n",dstlen);
printf(" srclen = %d\n",fz_buffer_storage(ctx,srcbuf,NULL));
printf(" srcptr = %p\n",srcbuf->data);
*/
fz_write_buffer(ctx,dstbuf,srcbuf->data,fz_buffer_storage(ctx,srcbuf,NULL));
dstlen=fz_buffer_storage(ctx,dstbuf,NULL);
// printf(" dstlen after = %d\n",dstlen);
fz_drop_buffer(ctx,srcbuf);
pdf_update_stream(xref,pageref,dstbuf);
fz_drop_buffer(ctx,dstbuf);
return(dstlen);
}
char *
fz_copy_selection(fz_context *ctx, fz_stext_page *page, fz_rect rect)
{
fz_buffer *buffer;
fz_rect hitbox;
int c, seen = 0;
unsigned char *s;
fz_stext_block *block;
fz_stext_line *line;
fz_stext_char *ch;
float x0 = rect.x0;
float x1 = rect.x1;
float y0 = rect.y0;
float y1 = rect.y1;
buffer = fz_new_buffer(ctx, 1024);
for (block = page->first_block; block; block = block->next)
{
if (block->type != FZ_STEXT_BLOCK_TEXT)
continue;
for (line = block->u.t.first_line; line; line = line->next)
{
if (seen)
{
fz_append_byte(ctx, buffer, '\n');
}
seen = 0;
for (ch = line->first_char; ch; ch = ch->next)
{
fz_stext_char_bbox(ctx, &hitbox, line, ch);
c = ch->c;
if (c < 32)
c = FZ_REPLACEMENT_CHARACTER;
if (hitbox.x1 >= x0 && hitbox.x0 <= x1 && hitbox.y1 >= y0 && hitbox.y0 <= y1)
{
fz_append_rune(ctx, buffer, c);
seen = 1;
}
}
seen = (seen && line == block->u.t.last_line);
}
}
fz_terminate_buffer(ctx, buffer);
fz_buffer_extract(ctx, buffer, &s); /* take over the data */
fz_drop_buffer(ctx, buffer);
return (char*)s;
}
static fz_output *
start_def(fz_context *ctx, svg_device *sdev)
{
sdev->def_count++;
if (sdev->def_count == 2)
{
if (sdev->defs == NULL)
{
if (sdev->defs_buffer == NULL)
sdev->defs_buffer = fz_new_buffer(ctx, 1024);
sdev->defs = fz_new_output_with_buffer(ctx, sdev->defs_buffer);
}
sdev->out = sdev->defs;
}
return sdev->out;
}
static int make_fake_doc(pdfapp_t *app)
{
fz_context *ctx = app->ctx;
pdf_document *pdf = NULL;
fz_buffer *contents = NULL;
pdf_obj *page_obj = NULL;
fz_var(contents);
fz_var(page_obj);
fz_try(ctx)
{
fz_rect mediabox = { 0, 0, app->winw, app->winh };
int i;
pdf = pdf_create_document(ctx);
contents = fz_new_buffer(ctx, 100);
fz_append_printf(ctx, contents, "1 0 0 RG %g w 0 0 m %g %g l 0 %g m %g 0 l s\n",
fz_min(mediabox.x1, mediabox.y1) / 20,
mediabox.x1, mediabox.y1,
mediabox.y1, mediabox.x1);
/* Create enough copies of our blank(ish) page so that the
* page number is preserved if and when a subsequent load
* works. */
page_obj = pdf_add_page(ctx, pdf, &mediabox, 0, NULL, contents);
for (i = 0; i < app->pagecount; i++)
pdf_insert_page(ctx, pdf, -1, page_obj);
}
fz_always(ctx)
{
pdf_drop_obj(ctx, page_obj);
fz_drop_buffer(ctx, contents);
}
fz_catch(ctx)
{
fz_drop_document(ctx, (fz_document *) pdf);
return 1;
}
app->doc = (fz_document*)pdf;
return 0;
}
static fz_image *pack_jp2(fz_context *ctx, const char *data, size_t len, SizeI size)
{
fz_compressed_buffer *buf = nullptr;
fz_var(buf);
fz_try(ctx) {
buf = fz_malloc_struct(ctx, fz_compressed_buffer);
buf->buffer = fz_new_buffer(ctx, (int)len);
memcpy(buf->buffer->data, data, (buf->buffer->len = (int)len));
buf->params.type = FZ_IMAGE_JPX;
}
fz_catch(ctx) {
fz_free_compressed_buffer(ctx, buf);
fz_rethrow(ctx);
}
return fz_new_image(ctx, size.dx, size.dy, 8, fz_device_rgb(ctx), 96, 96, 0, 0, nullptr, nullptr, buf, nullptr);
}
static fz_image *pack_jpeg(fz_context *ctx, const char *data, size_t len, SizeI size)
{
fz_compressed_buffer *buf = NULL;
fz_var(buf);
fz_try(ctx) {
buf = fz_malloc_struct(ctx, fz_compressed_buffer);
buf->buffer = fz_new_buffer(ctx, (int)len);
memcpy(buf->buffer->data, data, (buf->buffer->len = (int)len));
buf->params.type = FZ_IMAGE_JPEG;
buf->params.u.jpeg.color_transform = -1;
}
fz_catch(ctx) {
fz_free_compressed_buffer(ctx, buf);
fz_rethrow(ctx);
}
return fz_new_image(ctx, size.dx, size.dy, 8, fz_device_rgb(ctx), 96, 96, 0, 0, NULL, NULL, buf, NULL);
}
static int new_stream_object(pdf_document *xref,fz_context *ctx,char *buf)
{
int ref;
pdf_obj *obj,*len;
fz_buffer *fzbuf;
ref = pdf_create_object(xref);
obj = pdf_new_dict(ctx,1);
len=pdf_new_int(ctx,strlen(buf));
pdf_dict_puts(obj,"Length",len);
pdf_drop_obj(len);
pdf_update_object(xref,ref,obj);
pdf_drop_obj(obj);
fzbuf=fz_new_buffer(ctx,strlen(buf));
fz_write_buffer(ctx,fzbuf,(unsigned char *)buf,strlen(buf));
pdf_update_stream(xref,ref,fzbuf);
fz_drop_buffer(ctx,fzbuf);
return(ref);
}
/*
Return a newly allocated UTF-8 string with the text for a given selection.
crlf: If true, write "\r\n" style line endings (otherwise "\n" only).
*/
char *
fz_copy_selection(fz_context *ctx, fz_stext_page *page, fz_point a, fz_point b, int crlf)
{
struct callbacks cb;
fz_buffer *buffer;
unsigned char *s;
buffer = fz_new_buffer(ctx, 1024);
cb.on_char = on_copy_char;
cb.on_line = crlf ? on_copy_line_crlf : on_copy_line_lf;
cb.arg = buffer;
fz_enumerate_selection(ctx, page, a, b, &cb);
fz_terminate_buffer(ctx, buffer);
fz_buffer_extract(ctx, buffer, &s); /* take over the data */
fz_drop_buffer(ctx, buffer);
return (char*)s;
}
static void
pdf_write_ch_widget_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf,
fz_rect *rect, fz_rect *bbox, fz_matrix *matrix, pdf_obj **res)
{
int ff = pdf_field_flags(ctx, annot->obj);
if (ff & PDF_CH_FIELD_IS_COMBO)
{
/* TODO: Pop-down arrow */
pdf_write_tx_widget_appearance(ctx, annot, buf, rect, bbox, matrix, res,
pdf_field_value(ctx, annot->obj), 0);
}
else
{
fz_buffer *text = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
pdf_obj *opt = pdf_dict_get(ctx, annot->obj, PDF_NAME(Opt));
int i = pdf_dict_get_int(ctx, annot->obj, PDF_NAME(TI));
int n = pdf_array_len(ctx, opt);
/* TODO: Scrollbar */
/* TODO: Highlight selected items */
if (i < 0)
i = 0;
for (; i < n; ++i)
{
pdf_obj *val = pdf_array_get(ctx, opt, i);
if (pdf_is_array(ctx, val))
fz_append_string(ctx, text, pdf_array_get_text_string(ctx, val, 1));
else
fz_append_string(ctx, text, pdf_to_text_string(ctx, val));
fz_append_byte(ctx, text, '\n');
}
pdf_write_tx_widget_appearance(ctx, annot, buf, rect, bbox, matrix, res,
fz_string_from_buffer(ctx, text), PDF_TX_FIELD_IS_MULTILINE);
}
fz_always(ctx)
fz_drop_buffer(ctx, text);
fz_catch(ctx)
fz_rethrow(ctx);
}
}
/* SumatraPDF: partial support for text icons */
static pdf_annot *
pdf_create_text_annot(pdf_xref *xref, fz_obj *obj)
{
fz_context *ctx = xref->ctx;
fz_buffer *content = fz_new_buffer(ctx, 512);
fz_rect rect = pdf_to_rect(ctx, fz_dict_gets(ctx, obj, "Rect"));
char *icon_name = fz_to_name(ctx, fz_dict_gets(ctx, obj, "Name"));
char *content_ap = ANNOT_TEXT_AP_NOTE;
float rgb[3];
rect.x1 = rect.x0 + 24;
rect.y0 = rect.y1 - 24;
pdf_get_annot_color(ctx, obj, rgb);
if (!strcmp(icon_name, "Comment"))
content_ap = ANNOT_TEXT_AP_COMMENT;
else if (!strcmp(icon_name, "Key"))
content_ap = ANNOT_TEXT_AP_KEY;
else if (!strcmp(icon_name, "Help"))
content_ap = ANNOT_TEXT_AP_HELP;
else if (!strcmp(icon_name, "Paragraph"))
content_ap = ANNOT_TEXT_AP_PARAGRAPH;
else if (!strcmp(icon_name, "NewParagraph"))
content_ap = ANNOT_TEXT_AP_NEW_PARAGRAPH;
else if (!strcmp(icon_name, "Insert"))
content_ap = ANNOT_TEXT_AP_INSERT;
else if (!strcmp(icon_name, "Cross"))
content_ap = ANNOT_TEXT_AP_CROSS;
else if (!strcmp(icon_name, "Circle"))
content_ap = ANNOT_TEXT_AP_CIRCLE;
// TODO: make icons semi-transparent (cf. pdf_create_highlight_annot)?
fz_buffer_printf(ctx, content, "q ");
fz_buffer_printf(ctx, content, content_ap, 0.5, 0.5, 0.5);
fz_buffer_printf(ctx, content, " 1 0 0 1 0 1 cm ");
fz_buffer_printf(ctx, content, content_ap, rgb[0], rgb[1], rgb[2]);
fz_buffer_printf(ctx, content, " Q", content_ap);
obj = pdf_clone_for_view_only(xref, obj);
return pdf_create_annot(ctx, rect, obj, content, NULL, 0);
}
fz_buffer *
fz_read_all(fz_stream *stm, int initial)
{
fz_buffer *buf = NULL;
int n;
fz_context *ctx = stm->ctx;
try
{
if (initial < 1024)
initial = 1024;
buf = fz_new_buffer(ctx, initial+1);
while (1)
{
if (buf->len == buf->cap)
fz_grow_buffer(ctx, buf);
if (buf->len >= MIN_BOMB && buf->len / 200 > initial)
{
throw("compression bomb detected");
}
n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
if (n == 0)
break;
buf->len += n;
}
}
catch(...)
{
fz_drop_buffer(ctx, buf);
throw("");
}
fz_trim_buffer(ctx, buf);
return buf;
}
static int make_fake_doc(pdfapp_t *app)
{
fz_context *ctx = app->ctx;
pdf_document *pdf = NULL;
fz_buffer *contents = NULL;
fz_try(ctx)
{
fz_rect mediabox = { 0, 0, app->winw, app->winh };
pdf_obj *page_obj;
int i;
contents = fz_new_buffer(ctx, 100);
pdf = pdf_create_document(ctx);
app->doc = (fz_document*)pdf;
fz_buffer_printf(ctx, contents, "1 0 0 rg %f w 0 0 m %f %f l 0 %f m %f 0 l\n",
fz_min(mediabox.x1, mediabox.y1) / 4,
mediabox.x1, mediabox.y1,
mediabox.y1, mediabox.x1);
/* Create enough copies of our blank(ish) page so that the
* page number is preserved if and when a subsequent load
* works. */
page_obj = pdf_add_page(ctx, pdf, &mediabox, 0, contents, NULL);
for (i = 0; i < app->pagecount; i++)
pdf_insert_page(ctx, pdf, -1, page_obj);
pdf_drop_obj(ctx, page_obj);
}
fz_always(ctx)
{
fz_drop_buffer(ctx, contents);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
return 0;
}
void
pdf_load_compressed_inline_image(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int length, fz_stream *stm, int indexed, fz_image *image)
{
fz_compressed_buffer *bc = fz_malloc_struct(ctx, fz_compressed_buffer);
fz_try(ctx)
{
int dummy_l2factor = 0;
bc->buffer = fz_new_buffer(ctx, 1024);
stm = pdf_open_inline_stream(ctx, doc, dict, length, stm, &bc->params);
stm = fz_open_leecher(ctx, stm, bc->buffer);
stm = fz_open_image_decomp_stream(ctx, stm, &bc->params, &dummy_l2factor);
image->tile = fz_decomp_image_from_stream(ctx, stm, image, indexed, 0, 0);
}
fz_catch(ctx)
{
fz_drop_compressed_buffer(ctx, bc);
fz_rethrow(ctx);
}
image->buffer = bc;
}
static pdf_annot *
pdf_create_markup_annot(pdf_xref *xref, fz_obj *obj, char *type)
{
fz_context *ctx = xref->ctx;
fz_buffer *content = fz_new_buffer(ctx, 512);
fz_rect rect = pdf_to_rect(ctx, fz_dict_gets(ctx, obj, "Rect"));
fz_obj *quad_points = fz_dict_gets(ctx, obj, "QuadPoints");
fz_rect a, b;
float rgb[3];
int i;
for (i = 0; i < fz_array_len(ctx, quad_points) / 8; i++)
{
pdf_get_quadrilaterals(ctx, quad_points, i, &a, &b);
b.y0 -= 0.25; a.y1 += 0.25;
rect = fz_union_rect(rect, fz_union_rect(a, b));
}
pdf_get_annot_color(ctx, obj, rgb);
fz_buffer_printf(ctx, content, "q %.4f %.4f %.4f RG 1 0 0 1 -%.4f -%.4f cm 0.5 w ",
rgb[0], rgb[1], rgb[2], rect.x0, rect.y0);
if (!strcmp(type, "Squiggly"))
fz_buffer_printf(ctx, content, "[1 1] d ");
for (i = 0; i < fz_array_len(ctx, quad_points) / 8; i++)
{
pdf_get_quadrilaterals(ctx, quad_points, i, &a, &b);
if (!strcmp(type, "StrikeOut"))
fz_buffer_printf(ctx, content, "%.4f %.4f m %.4f %.4f l ",
(a.x0 + b.x0) / 2, (a.y0 + b.y0) / 2, (a.x1 + b.x1) / 2, (a.y1 + b.y1) / 2);
else
fz_buffer_printf(ctx, content, "%.4f %.4f m %.4f %.4f l ", b.x0, b.y0, a.x1, a.y1);
}
fz_buffer_printf(ctx, content, "S Q");
return pdf_create_annot(ctx, rect, fz_keep_obj(obj), content, NULL, 0);
}
static void
pdf_clean_type3(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie, int sanitize, int ascii)
{
pdf_processor *proc_buffer = NULL;
pdf_processor *proc_filter = NULL;
pdf_obj *res = NULL;
pdf_obj *ref;
pdf_obj *charprocs;
int i, l;
fz_var(res);
fz_var(proc_buffer);
fz_var(proc_filter);
fz_try(ctx)
{
res = pdf_dict_get(ctx, obj, PDF_NAME(Resources));
if (res)
orig_res = res;
res = NULL;
res = pdf_new_dict(ctx, doc, 1);
charprocs = pdf_dict_get(ctx, obj, PDF_NAME(CharProcs));
l = pdf_dict_len(ctx, charprocs);
for (i = 0; i < l; i++)
{
pdf_obj *val = pdf_dict_get_val(ctx, charprocs, i);
fz_buffer *buffer = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
proc_buffer = pdf_new_buffer_processor(ctx, buffer, ascii);
if (sanitize)
{
proc_filter = pdf_new_filter_processor(ctx, doc, proc_buffer, orig_res, res);
pdf_process_contents(ctx, proc_filter, doc, orig_res, val, cookie);
pdf_close_processor(ctx, proc_filter);
}
else
{
pdf_process_contents(ctx, proc_filter, doc, orig_res, val, cookie);
}
pdf_close_processor(ctx, proc_buffer);
pdf_update_stream(ctx, doc, val, buffer, 0);
}
fz_always(ctx)
{
pdf_drop_processor(ctx, proc_filter);
pdf_drop_processor(ctx, proc_buffer);
fz_drop_buffer(ctx, buffer);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
/* ProcSet - no cleaning possible. Inherit this from the old dict. */
pdf_dict_put(ctx, res, PDF_NAME(ProcSet), pdf_dict_get(ctx, orig_res, PDF_NAME(ProcSet)));
ref = pdf_add_object(ctx, doc, res);
pdf_dict_put_drop(ctx, obj, PDF_NAME(Resources), ref);
}
fz_always(ctx)
{
pdf_drop_obj(ctx, res);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
/*
Performs the same task as
pdf_clean_page_contents, but with an optional text filter
function.
text_filter: Function to assess whether a given character
should be kept (return 0) or removed (return 1).
after_text: Function called after each text object is closed
to allow other output to be sent.
arg: Opaque value to be passed to callback functions.
*/
void pdf_filter_page_contents(fz_context *ctx, pdf_document *doc, pdf_page *page, fz_cookie *cookie,
pdf_page_contents_process_fn *proc_fn, pdf_text_filter_fn *text_filter, pdf_after_text_object_fn *after_text, void *proc_arg,
int sanitize, int ascii)
{
pdf_processor *proc_buffer = NULL;
pdf_processor *proc_filter = NULL;
pdf_obj *new_obj = NULL;
pdf_obj *new_ref = NULL;
pdf_obj *res = NULL;
pdf_obj *obj;
pdf_obj *contents;
pdf_obj *resources;
fz_buffer *buffer;
fz_var(new_obj);
fz_var(new_ref);
fz_var(res);
fz_var(proc_buffer);
fz_var(proc_filter);
buffer = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
contents = pdf_page_contents(ctx, page);
resources = pdf_page_resources(ctx, page);
proc_buffer = pdf_new_buffer_processor(ctx, buffer, ascii);
if (sanitize)
{
res = pdf_new_dict(ctx, doc, 1);
proc_filter = pdf_new_filter_processor_with_text_filter(ctx, doc, proc_buffer, resources, res, text_filter, after_text, proc_arg);
pdf_process_contents(ctx, proc_filter, doc, resources, contents, cookie);
pdf_close_processor(ctx, proc_filter);
}
else
{
res = pdf_keep_obj(ctx, resources);
pdf_process_contents(ctx, proc_buffer, doc, resources, contents, cookie);
}
pdf_close_processor(ctx, proc_buffer);
/* Deal with page content stream. */
if (pdf_is_array(ctx, contents))
{
/* create a new object to replace the array */
new_obj = pdf_new_dict(ctx, doc, 1);
new_ref = pdf_add_object(ctx, doc, new_obj);
contents = new_ref;
pdf_dict_put(ctx, page->obj, PDF_NAME(Contents), contents);
}
else
{
pdf_dict_del(ctx, contents, PDF_NAME(Filter));
pdf_dict_del(ctx, contents, PDF_NAME(DecodeParms));
}
pdf_update_stream(ctx, doc, contents, buffer, 0);
/* Now deal with resources. The spec allows for Type3 fonts and form
* XObjects to omit a resource dictionary and look in the parent.
* Avoid that by flattening here as part of the cleaning. This could
* conceivably cause changes in rendering, but we don't care. */
/* ExtGState */
obj = pdf_dict_get(ctx, res, PDF_NAME(ExtGState));
if (obj)
{
int i, l;
l = pdf_dict_len(ctx, obj);
for (i = 0; i < l; i++)
{
pdf_obj *o = pdf_dict_get(ctx, pdf_dict_get_val(ctx, obj, i), PDF_NAME(SMask));
if (!o)
continue;
o = pdf_dict_get(ctx, o, PDF_NAME(G));
if (!o)
continue;
/* Transparency group XObject */
pdf_clean_stream_object(ctx, doc, o, resources, cookie, 1, text_filter, after_text, proc_arg, sanitize, ascii);
}
}
/* Pattern */
obj = pdf_dict_get(ctx, res, PDF_NAME(Pattern));
if (obj)
{
int i, l;
l = pdf_dict_len(ctx, obj);
for (i = 0; i < l; i++)
{
pdf_obj *pat_res;
pdf_obj *pat = pdf_dict_get_val(ctx, obj, i);
if (!pat)
continue;
pat_res = pdf_dict_get(ctx, pat, PDF_NAME(Resources));
if (pat_res == NULL)
pat_res = resources;
if (pdf_dict_get_int(ctx, pat, PDF_NAME(PatternType)) == 1)
pdf_clean_stream_object(ctx, doc, pat, pat_res, cookie, 0, text_filter, after_text, proc_arg, sanitize, ascii);
}
}
/* XObject */
obj = pdf_dict_get(ctx, res, PDF_NAME(XObject));
if (obj)
{
int i, l;
l = pdf_dict_len(ctx, obj);
for (i = 0; i < l; i++)
{
pdf_obj *xobj_res;
pdf_obj *xobj = pdf_dict_get_val(ctx, obj, i);
if (!xobj)
continue;
xobj_res = pdf_dict_get(ctx, xobj, PDF_NAME(Resources));
if (xobj_res == NULL)
xobj_res = resources;
if (pdf_name_eq(ctx, PDF_NAME(Form), pdf_dict_get(ctx, xobj, PDF_NAME(Subtype))))
pdf_clean_stream_object(ctx, doc, xobj, xobj_res, cookie, 1, text_filter, after_text, proc_arg, sanitize, ascii);
}
}
/* Font */
obj = pdf_dict_get(ctx, res, PDF_NAME(Font));
if (obj)
{
int i, l;
l = pdf_dict_len(ctx, obj);
for (i = 0; i < l; i++)
{
pdf_obj *o = pdf_dict_get_val(ctx, obj, i);
if (!o)
continue;
if (pdf_name_eq(ctx, PDF_NAME(Type3), pdf_dict_get(ctx, o, PDF_NAME(Subtype))))
pdf_clean_type3(ctx, doc, o, resources, cookie, sanitize, ascii);
}
}
/* ProcSet - no cleaning possible. Inherit this from the old dict. */
obj = pdf_dict_get(ctx, resources, PDF_NAME(ProcSet));
if (obj)
pdf_dict_put(ctx, res, PDF_NAME(ProcSet), obj);
/* ColorSpace - no cleaning possible. */
/* Properties - no cleaning possible. */
if (proc_fn)
(*proc_fn)(ctx, buffer, res, proc_arg);
/* Update resource dictionary */
if (sanitize)
{
pdf_dict_put(ctx, page->obj, PDF_NAME(Resources), res);
}
}
fz_always(ctx)
{
pdf_drop_processor(ctx, proc_filter);
pdf_drop_processor(ctx, proc_buffer);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, new_obj);
pdf_drop_obj(ctx, new_ref);
pdf_drop_obj(ctx, res);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
/*
* Read and interleave split parts from a ZIP file.
*/
xps_part *
xps_read_part(fz_context *ctx, xps_document *doc, char *partname)
{
fz_archive *zip = doc->zip;
fz_buffer *buf, *tmp;
char path[2048];
unsigned char *data;
int size;
int count;
char *name;
int seen_last;
name = partname;
if (name[0] == '/')
name ++;
/* All in one piece */
if (fz_has_archive_entry(ctx, zip, name))
{
buf = fz_read_archive_entry(ctx, zip, name);
}
/* Assemble all the pieces */
else
{
buf = fz_new_buffer(ctx, 512);
seen_last = 0;
for (count = 0; !seen_last; ++count)
{
sprintf(path, "%s/[%d].piece", name, count);
if (fz_has_archive_entry(ctx, zip, path))
{
tmp = fz_read_archive_entry(ctx, zip, path);
fz_append_buffer(ctx, buf, tmp);
fz_drop_buffer(ctx, tmp);
}
else
{
sprintf(path, "%s/[%d].last.piece", name, count);
if (fz_has_archive_entry(ctx, zip, path))
{
tmp = fz_read_archive_entry(ctx, zip, path);
fz_append_buffer(ctx, buf, tmp);
fz_drop_buffer(ctx, tmp);
seen_last = 1;
}
else
{
fz_drop_buffer(ctx, buf);
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find all pieces for part '%s'", partname);
}
}
}
}
fz_write_buffer_byte(ctx, buf, 0); /* zero-terminate */
/* take over the data */
data = buf->data;
/* size doesn't include the added zero-terminator */
size = buf->len - 1;
fz_free(ctx, buf);
return xps_new_part(ctx, doc, partname, data, size);
}
