pdf_pattern *
pdf_load_pattern(fz_context *ctx, pdf_document *doc, pdf_obj *dict)
{
pdf_pattern *pat;
pdf_obj *obj;
if ((pat = pdf_find_item(ctx, pdf_drop_pattern_imp, dict)) != NULL)
{
return pat;
}
pat = fz_malloc_struct(ctx, pdf_pattern);
FZ_INIT_STORABLE(pat, 1, pdf_drop_pattern_imp);
pat->document = doc;
pat->resources = NULL;
pat->contents = NULL;
fz_try(ctx)
{
/* Store pattern now, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, pat, pdf_pattern_size(pat));
pat->ismask = pdf_to_int(ctx, pdf_dict_get(ctx, dict, PDF_NAME_PaintType)) == 2;
pat->xstep = pdf_to_real(ctx, pdf_dict_get(ctx, dict, PDF_NAME_XStep));
pat->ystep = pdf_to_real(ctx, pdf_dict_get(ctx, dict, PDF_NAME_YStep));
obj = pdf_dict_gets(ctx, dict, "BBox");
pdf_to_rect(ctx, obj, &pat->bbox);
obj = pdf_dict_gets(ctx, dict, "Matrix");
if (obj)
pdf_to_matrix(ctx, obj, &pat->matrix);
else
pat->matrix = fz_identity;
pat->resources = pdf_dict_get(ctx, dict, PDF_NAME_Resources);
if (pat->resources)
pdf_keep_obj(ctx, pat->resources);
pat->contents = pdf_keep_obj(ctx, dict);
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_drop_pattern_imp, dict);
pdf_drop_pattern(ctx, pat);
fz_rethrow_message(ctx, "cannot load pattern (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict));
}
return pat;
}
pdf_pattern *
pdf_load_pattern(pdf_document *xref, pdf_obj *dict)
{
pdf_pattern *pat;
pdf_obj *obj;
fz_context *ctx = xref->ctx;
if ((pat = pdf_find_item(ctx, pdf_free_pattern_imp, dict)))
{
return pat;
}
pat = fz_malloc_struct(ctx, pdf_pattern);
FZ_INIT_STORABLE(pat, 1, pdf_free_pattern_imp);
pat->resources = NULL;
pat->contents = NULL;
/* Store pattern now, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, pat, pdf_pattern_size(pat));
pat->ismask = pdf_to_int(pdf_dict_gets(dict, "PaintType")) == 2;
pat->xstep = pdf_to_real(pdf_dict_gets(dict, "XStep"));
pat->ystep = pdf_to_real(pdf_dict_gets(dict, "YStep"));
obj = pdf_dict_gets(dict, "BBox");
pdf_to_rect(ctx, obj, &pat->bbox);
obj = pdf_dict_gets(dict, "Matrix");
if (obj)
pdf_to_matrix(ctx, obj, &pat->matrix);
else
pat->matrix = fz_identity;
pat->resources = pdf_dict_gets(dict, "Resources");
if (pat->resources)
pdf_keep_obj(pat->resources);
fz_try(ctx)
{
pat->contents = pdf_keep_obj(dict);
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_free_pattern_imp, dict);
pdf_drop_pattern(ctx, pat);
fz_throw(ctx, "cannot load pattern stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
}
return pat;
}
static fz_link *
pdf_load_link(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int pagenum, const fz_matrix *page_ctm)
{
pdf_obj *action;
pdf_obj *obj;
fz_rect bbox;
char *uri;
fz_link *link = NULL;
obj = pdf_dict_get(ctx, dict, PDF_NAME_Subtype);
if (!pdf_name_eq(ctx, obj, PDF_NAME_Link))
return NULL;
obj = pdf_dict_get(ctx, dict, PDF_NAME_Rect);
if (!obj)
return NULL;
pdf_to_rect(ctx, obj, &bbox);
fz_transform_rect(&bbox, page_ctm);
obj = pdf_dict_get(ctx, dict, PDF_NAME_Dest);
if (obj)
uri = pdf_parse_link_dest(ctx, doc, obj);
else
{
action = pdf_dict_get(ctx, dict, PDF_NAME_A);
/* fall back to additional action button's down/up action */
if (!action)
action = pdf_dict_geta(ctx, pdf_dict_get(ctx, dict, PDF_NAME_AA), PDF_NAME_U, PDF_NAME_D);
uri = pdf_parse_link_action(ctx, doc, action, pagenum);
}
if (!uri)
return NULL;
fz_try(ctx)
link = fz_new_link(ctx, &bbox, doc, uri);
fz_always(ctx)
fz_free(ctx, uri);
fz_catch(ctx)
fz_rethrow(ctx);
return link;
}
static void
gatherdimensions(int page, pdf_obj *pageref, pdf_obj *pageobj)
{
fz_rect bbox;
pdf_obj *obj;
int j;
obj = pdf_dict_gets(pageobj, "MediaBox");
if (!pdf_is_array(obj))
return;
pdf_to_rect(ctx, obj, &bbox);
obj = pdf_dict_gets(pageobj, "UserUnit");
if (pdf_is_real(obj))
{
float unit = pdf_to_real(obj);
bbox.x0 *= unit;
bbox.y0 *= unit;
bbox.x1 *= unit;
bbox.y1 *= unit;
}
for (j = 0; j < dims; j++)
if (!memcmp(dim[j].u.dim.bbox, &bbox, sizeof (fz_rect)))
break;
if (j < dims)
return;
dim = fz_resize_array(ctx, dim, dims+1, sizeof(struct info));
dims++;
dim[dims - 1].page = page;
dim[dims - 1].pageref = pageref;
dim[dims - 1].pageobj = pageobj;
dim[dims - 1].u.dim.bbox = fz_malloc(ctx, sizeof(fz_rect));
memcpy(dim[dims - 1].u.dim.bbox, &bbox, sizeof (fz_rect));
return;
}
/* 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);
}
static fz_link *
pdf_load_link(pdf_document *xref, pdf_obj *dict, fz_matrix page_ctm)
{
pdf_obj *dest = NULL;
pdf_obj *action;
pdf_obj *obj;
fz_rect bbox;
fz_context *ctx = xref->ctx;
fz_link_dest ld;
dest = NULL;
obj = pdf_dict_gets(dict, "Rect");
if (obj)
bbox = pdf_to_rect(ctx, obj);
else
bbox = fz_empty_rect;
bbox = fz_transform_rect(page_ctm, bbox);
obj = pdf_dict_gets(dict, "Dest");
if (obj)
{
dest = resolve_dest(xref, obj);
ld = pdf_parse_link_dest(xref, dest);
}
else
{
action = pdf_dict_gets(dict, "A");
/* fall back to additional action button's down/up action */
if (!action)
action = pdf_dict_getsa(pdf_dict_gets(dict, "AA"), "U", "D");
ld = pdf_parse_action(xref, action);
}
if (ld.kind == FZ_LINK_NONE)
return NULL;
return fz_new_link(ctx, bbox, ld);
}
static int
showbox(fz_context *ctx, fz_output *out, pdf_obj *page, char *text, pdf_obj *name)
{
fz_rect bbox;
pdf_obj *obj;
int failed = 0;
fz_try(ctx)
{
obj = pdf_dict_get(ctx, page, name);
if (!pdf_is_array(ctx, obj))
break;
pdf_to_rect(ctx, obj, &bbox);
fz_printf(ctx, out, "<%s l=\"%g\" b=\"%g\" r=\"%g\" t=\"%g\" />\n", text, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
}
fz_catch(ctx)
{
failed = 1;
}
return failed;
}
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 fz_shade *
pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, fz_matrix transform)
{
fz_shade *shade = NULL;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
pdf_obj *obj;
int funcs = 0;
int type = 0;
int i, in, out;
fz_context *ctx = xref->ctx;
fz_var(shade);
fz_var(func);
fz_var(funcs);
fz_var(type);
fz_try(ctx)
{
shade = fz_malloc_struct(ctx, fz_shade);
FZ_INIT_STORABLE(shade, 1, fz_free_shade_imp);
shade->type = FZ_MESH_TYPE4;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = transform;
shade->bbox = fz_infinite_rect;
shade->colorspace = NULL;
funcs = 0;
obj = pdf_dict_gets(dict, "ShadingType");
type = pdf_to_int(obj);
obj = pdf_dict_gets(dict, "ColorSpace");
if (!obj)
fz_throw(ctx, "shading colorspace is missing");
shade->colorspace = pdf_load_colorspace(xref, obj);
obj = pdf_dict_gets(dict, "Background");
if (obj)
{
shade->use_background = 1;
for (i = 0; i < shade->colorspace->n; i++)
shade->background[i] = pdf_to_real(pdf_array_get(obj, i));
}
obj = pdf_dict_gets(dict, "BBox");
if (pdf_is_array(obj))
{
shade->bbox = pdf_to_rect(ctx, obj);
}
obj = pdf_dict_gets(dict, "Function");
if (pdf_is_dict(obj))
{
funcs = 1;
if (type == 1)
in = 2;
else
in = 1;
out = shade->colorspace->n;
func[0] = pdf_load_function(xref, obj, in, out);
if (!func[0])
fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
else if (pdf_is_array(obj))
{
funcs = pdf_array_len(obj);
if (funcs != 1 && funcs != shade->colorspace->n)
{
funcs = 0;
fz_throw(ctx, "incorrect number of shading functions");
}
if (funcs > FZ_MAX_COLORS)
{
funcs = 0;
fz_throw(ctx, "too many shading functions");
}
if (type == 1)
in = 2;
else
in = 1;
out = 1;
for (i = 0; i < funcs; i++)
{
func[i] = pdf_load_function(xref, pdf_array_get(obj, i), in, out);
if (!func[i])
fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
}
else if (type < 4)
{
/* Functions are compulsory for types 1,2,3 */
fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
}
shade->type = type;
switch (type)
{
case 1:
pdf_load_function_based_shading(shade, xref, dict, func[0]);
break;
case 2:
pdf_load_linear_shading(shade, xref, dict, funcs, func);
break;
case 3:
pdf_load_radial_shading(shade, xref, dict, funcs, func);
break;
case 4:
pdf_load_type4_shade(shade, xref, dict, funcs, func);
break;
case 5:
pdf_load_type5_shade(shade, xref, dict, funcs, func);
break;
case 6:
pdf_load_type6_shade(shade, xref, dict, funcs, func);
break;
case 7:
pdf_load_type7_shade(shade, xref, dict, funcs, func);
break;
default:
fz_throw(ctx, "unknown shading type: %d", type);
}
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(ctx, func[i]);
}
fz_catch(ctx)
{
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(ctx, func[i]);
fz_drop_shade(ctx, shade);
fz_throw(ctx, "cannot load shading type %d (%d %d R)", type, pdf_to_num(dict), pdf_to_gen(dict));
}
return shade;
}
pdf_annot *
pdf_load_annots(pdf_document *xref, pdf_obj *annots, fz_matrix page_ctm)
{
pdf_annot *annot, *head, *tail;
pdf_obj *obj, *ap, *as, *n, *d, *c, *rect;
int i, len;
int mouse_states;
int has_states = 0;
fz_context *ctx = xref->ctx;
head = tail = NULL;
annot = NULL;
len = pdf_array_len(annots);
for (i = 0; i < len; i++)
{
obj = pdf_array_get(annots, i);
pdf_update_appearance(xref, obj);
rect = pdf_dict_gets(obj, "Rect");
ap = pdf_dict_gets(obj, "AP");
as = pdf_dict_gets(obj, "AS");
if (pdf_is_dict(ap))
{
pdf_hotspot *hp = &xref->hotspot;
n = pdf_dict_gets(ap, "N"); /* normal state */
d = pdf_dict_gets(ap, "D"); /* down state */
if (n && d)
{
if (hp->num == pdf_to_num(obj)
&& hp->gen == pdf_to_gen(obj)
&& (hp->state & HOTSPOT_POINTER_DOWN))
{
/* Use the down appearance, but as we also have
* a normal appearance, it is suitable only for mouse
* down */
c = d;
mouse_states = MOUSE_DOWN_APPEARANCE;
}
else
{
/* Use the normal appearance, but as we also have
* a down appearance, it is suitable only for mouse
* up */
c = n;
mouse_states = MOUSE_UP_APPEARANCE;
}
}
else
{
/* Use whichever appearance we have for both states */
c = n?n:d;
mouse_states = MOUSE_UP_APPEARANCE|MOUSE_DOWN_APPEARANCE;
}
/* lookup current state in sub-dictionary */
if (!pdf_is_stream(xref, pdf_to_num(c), pdf_to_gen(c)))
{
has_states = 1;
c = pdf_dict_get(c, as);
}
annot = fz_malloc_struct(ctx, pdf_annot);
annot->obj = pdf_keep_obj(obj);
annot->rect = pdf_to_rect(ctx, rect);
annot->pagerect = fz_transform_rect(page_ctm, annot->rect);
annot->ap = NULL;
annot->type = pdf_field_type(xref, obj);
annot->mouse_states = mouse_states;
annot->has_states = has_states;
if (pdf_is_stream(xref, pdf_to_num(c), pdf_to_gen(c)))
{
fz_try(ctx)
{
annot->ap = pdf_load_xobject(xref, c);
pdf_transform_annot(annot);
}
fz_catch(ctx)
{
fz_warn(ctx, "ignoring broken annotation");
}
}
annot->next = NULL;
if (obj == xref->focus_obj)
xref->focus = annot;
if (!head)
head = tail = annot;
else
{
tail->next = annot;
tail = annot;
}
}
}
return head;
}
pdf_font_desc *
pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict)
{
char buf[256];
char *estrings[256];
pdf_font_desc *fontdesc = NULL;
pdf_obj *encoding;
pdf_obj *widths;
pdf_obj *charprocs;
pdf_obj *obj;
int first, last;
int i, k, n;
fz_rect bbox;
fz_matrix matrix;
fz_context *ctx = doc->ctx;
fz_var(fontdesc);
/* Make a new type3 font entry in the document */
if (doc->num_type3_fonts == doc->max_type3_fonts)
{
int new_max = doc->max_type3_fonts * 2;
if (new_max == 0)
new_max = 4;
doc->type3_fonts = fz_resize_array(doc->ctx, doc->type3_fonts, new_max, sizeof(*doc->type3_fonts));
doc->max_type3_fonts = new_max;
}
fz_try(ctx)
{
obj = pdf_dict_gets(dict, "Name");
if (pdf_is_name(obj))
fz_strlcpy(buf, pdf_to_name(obj), sizeof buf);
else
sprintf(buf, "Unnamed-T3");
fontdesc = pdf_new_font_desc(ctx);
obj = pdf_dict_gets(dict, "FontMatrix");
pdf_to_matrix(ctx, obj, &matrix);
obj = pdf_dict_gets(dict, "FontBBox");
fz_transform_rect(pdf_to_rect(ctx, obj, &bbox), &matrix);
fontdesc->font = fz_new_type3_font(ctx, buf, &matrix);
fontdesc->size += sizeof(fz_font) + 256 * (sizeof(fz_buffer*) + sizeof(float));
fz_set_font_bbox(ctx, fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/* SumatraPDF: expose Type3 FontDescriptor flags */
fontdesc->flags = pdf_to_int(pdf_dict_gets(pdf_dict_gets(dict, "FontDescriptor"), "Flags"));
/* Encoding */
for (i = 0; i < 256; i++)
estrings[i] = NULL;
encoding = pdf_dict_gets(dict, "Encoding");
if (!encoding)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing Encoding");
}
if (pdf_is_name(encoding))
pdf_load_encoding(estrings, pdf_to_name(encoding));
if (pdf_is_dict(encoding))
{
pdf_obj *base, *diff, *item;
base = pdf_dict_gets(encoding, "BaseEncoding");
if (pdf_is_name(base))
pdf_load_encoding(estrings, pdf_to_name(base));
diff = pdf_dict_gets(encoding, "Differences");
if (pdf_is_array(diff))
{
n = pdf_array_len(diff);
k = 0;
for (i = 0; i < n; i++)
{
item = pdf_array_get(diff, i);
if (pdf_is_int(item))
k = pdf_to_int(item);
if (pdf_is_name(item) && k >= 0 && k < nelem(estrings))
estrings[k++] = pdf_to_name(item);
}
}
}
fontdesc->encoding = pdf_new_identity_cmap(ctx, 0, 1);
fontdesc->size += pdf_cmap_size(ctx, fontdesc->encoding);
pdf_load_to_unicode(doc, fontdesc, estrings, NULL, pdf_dict_gets(dict, "ToUnicode"));
/* SumatraPDF: trying to match Adobe Reader's behavior */
if (!(fontdesc->flags & PDF_FD_SYMBOLIC) && fontdesc->cid_to_ucs_len >= 128)
for (i = 32; i < 128; i++)
if (fontdesc->cid_to_ucs[i] == '?' || fontdesc->cid_to_ucs[i] == '\0')
fontdesc->cid_to_ucs[i] = i;
/* Widths */
pdf_set_default_hmtx(ctx, fontdesc, 0);
first = pdf_to_int(pdf_dict_gets(dict, "FirstChar"));
last = pdf_to_int(pdf_dict_gets(dict, "LastChar"));
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=1966 */
if (first >= 256 && last - first < 256)
{
fz_warn(ctx, "ignoring out-of-bound values for FirstChar/LastChar: %d/%d", first, last);
last -= first;
first = 0;
}
if (first < 0 || last > 255 || first > last)
first = last = 0;
widths = pdf_dict_gets(dict, "Widths");
if (!widths)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing Widths");
}
for (i = first; i <= last; i++)
{
float w = pdf_to_real(pdf_array_get(widths, i - first));
w = fontdesc->font->t3matrix.a * w * 1000;
fontdesc->font->t3widths[i] = w * 0.001f;
pdf_add_hmtx(ctx, fontdesc, i, i, w);
}
pdf_end_hmtx(ctx, fontdesc);
/* Resources -- inherit page resources if the font doesn't have its own */
fontdesc->font->t3freeres = pdf_t3_free_resources;
fontdesc->font->t3resources = pdf_dict_gets(dict, "Resources");
if (!fontdesc->font->t3resources)
fontdesc->font->t3resources = rdb;
if (fontdesc->font->t3resources)
pdf_keep_obj(fontdesc->font->t3resources);
if (!fontdesc->font->t3resources)
fz_warn(ctx, "no resource dictionary for type 3 font!");
fontdesc->font->t3doc = doc;
fontdesc->font->t3run = pdf_run_glyph_func;
/* CharProcs */
charprocs = pdf_dict_gets(dict, "CharProcs");
if (!charprocs)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing CharProcs");
}
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
/* SumatraPDF: don't reject fonts with few broken glyphs */
fz_try(ctx)
{
obj = pdf_dict_gets(charprocs, estrings[i]);
if (pdf_is_stream(doc, pdf_to_num(obj), pdf_to_gen(obj)))
{
fontdesc->font->t3procs[i] = pdf_load_stream(doc, pdf_to_num(obj), pdf_to_gen(obj));
fontdesc->size += fontdesc->font->t3procs[i]->cap;
fontdesc->size += 0; // TODO: display list size calculation
}
}
fz_catch(ctx)
{
fz_warn(ctx, "failed to get data for type 3 glyph '%s'", estrings[i]);
}
}
}
}
fz_catch(ctx)
{
if (fontdesc)
pdf_drop_font(ctx, fontdesc);
fz_rethrow_message(ctx, "cannot load type3 font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
}
doc->type3_fonts[doc->num_type3_fonts++] = fz_keep_font(ctx, fontdesc->font);
return fontdesc;
}
static void update_rect(fz_context *ctx, pdf_annot *annot)
{
pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME_Rect), &annot->rect);
annot->pagerect = annot->rect;
fz_transform_rect(&annot->pagerect, &annot->page->ctm);
}
static fz_shade *
pdf_load_shading_dict(fz_context *ctx, pdf_document *doc, pdf_obj *dict, const fz_matrix *transform)
{
fz_shade *shade = NULL;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
pdf_obj *obj;
int funcs = 0;
int type = 0;
int i, in, out, n;
fz_var(shade);
fz_var(func);
fz_var(funcs);
fz_var(type);
fz_try(ctx)
{
shade = fz_malloc_struct(ctx, fz_shade);
FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp);
shade->type = FZ_MESH_TYPE4;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = *transform;
shade->bbox = fz_infinite_rect;
shade->colorspace = NULL;
funcs = 0;
obj = pdf_dict_get(ctx, dict, PDF_NAME(ShadingType));
type = pdf_to_int(ctx, obj);
obj = pdf_dict_get(ctx, dict, PDF_NAME(ColorSpace));
if (!obj)
fz_throw(ctx, FZ_ERROR_SYNTAX, "shading colorspace is missing");
shade->colorspace = pdf_load_colorspace(ctx, obj);
n = fz_colorspace_n(ctx, shade->colorspace);
obj = pdf_dict_get(ctx, dict, PDF_NAME(Background));
if (obj)
{
shade->use_background = 1;
for (i = 0; i < n; i++)
shade->background[i] = pdf_array_get_real(ctx, obj, i);
}
obj = pdf_dict_get(ctx, dict, PDF_NAME(BBox));
if (pdf_is_array(ctx, obj))
pdf_to_rect(ctx, obj, &shade->bbox);
obj = pdf_dict_get(ctx, dict, PDF_NAME(Function));
if (pdf_is_dict(ctx, obj))
{
funcs = 1;
if (type == 1)
in = 2;
else
in = 1;
out = n;
func[0] = pdf_load_function(ctx, obj, in, out);
if (!func[0])
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
else if (pdf_is_array(ctx, obj))
{
funcs = pdf_array_len(ctx, obj);
if (funcs != 1 && funcs != n)
{
funcs = 0;
fz_throw(ctx, FZ_ERROR_SYNTAX, "incorrect number of shading functions");
}
if (funcs > FZ_MAX_COLORS)
{
funcs = 0;
fz_throw(ctx, FZ_ERROR_SYNTAX, "too many shading functions");
}
if (type == 1)
in = 2;
else
in = 1;
out = 1;
for (i = 0; i < funcs; i++)
{
func[i] = pdf_load_function(ctx, pdf_array_get(ctx, obj, i), in, out);
if (!func[i])
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
}
else if (type < 4)
{
/* Functions are compulsory for types 1,2,3 */
fz_throw(ctx, FZ_ERROR_SYNTAX, "cannot load shading function (%d 0 R)", pdf_to_num(ctx, obj));
}
shade->type = type;
switch (type)
{
case 1: pdf_load_function_based_shading(ctx, doc, shade, dict, func[0]); break;
case 2: pdf_load_linear_shading(ctx, doc, shade, dict, funcs, func); break;
case 3: pdf_load_radial_shading(ctx, doc, shade, dict, funcs, func); break;
case 4: pdf_load_type4_shade(ctx, doc, shade, dict, funcs, func); break;
case 5: pdf_load_type5_shade(ctx, doc, shade, dict, funcs, func); break;
case 6: pdf_load_type6_shade(ctx, doc, shade, dict, funcs, func); break;
case 7: pdf_load_type7_shade(ctx, doc, shade, dict, funcs, func); break;
default:
fz_throw(ctx, FZ_ERROR_SYNTAX, "unknown shading type: %d", type);
}
}
fz_always(ctx)
{
for (i = 0; i < funcs; i++)
pdf_drop_function(ctx, func[i]);
}
fz_catch(ctx)
{
fz_drop_shade(ctx, shade);
fz_rethrow(ctx);
}
return shade;
}
static fz_error
pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix transform)
{
fz_error error;
fz_shade *shade;
pdf_function *func[FZ_MAX_COLORS] = { NULL };
fz_stream *stream = NULL;
fz_obj *obj;
int funcs;
int type;
int i;
shade = fz_malloc(sizeof(fz_shade));
shade->refs = 1;
shade->type = FZ_MESH;
shade->use_background = 0;
shade->use_function = 0;
shade->matrix = transform;
shade->bbox = fz_infinite_rect;
shade->extend[0] = 0;
shade->extend[1] = 0;
shade->mesh_len = 0;
shade->mesh_cap = 0;
shade->mesh = NULL;
shade->colorspace = NULL;
funcs = 0;
obj = fz_dict_gets(dict, "ShadingType");
type = fz_to_int(obj);
obj = fz_dict_gets(dict, "ColorSpace");
if (!obj)
{
fz_drop_shade(shade);
return fz_throw("shading colorspace is missing");
}
error = pdf_load_colorspace(&shade->colorspace, xref, obj);
if (error)
{
fz_drop_shade(shade);
return fz_rethrow(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
}
obj = fz_dict_gets(dict, "Background");
if (obj)
{
shade->use_background = 1;
for (i = 0; i < shade->colorspace->n; i++)
shade->background[i] = fz_to_real(fz_array_get(obj, i));
}
obj = fz_dict_gets(dict, "BBox");
if (fz_is_array(obj))
{
shade->bbox = pdf_to_rect(obj);
}
obj = fz_dict_gets(dict, "Function");
if (fz_is_dict(obj))
{
funcs = 1;
error = pdf_load_function(&func[0], xref, obj);
if (error)
{
error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
}
else if (fz_is_array(obj))
{
funcs = fz_array_len(obj);
if (funcs != 1 && funcs != shade->colorspace->n)
{
error = fz_throw("incorrect number of shading functions");
goto cleanup;
}
for (i = 0; i < funcs; i++)
{
error = pdf_load_function(&func[i], xref, fz_array_get(obj, i));
if (error)
{
error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
goto cleanup;
}
}
}
if (type >= 4 && type <= 7)
{
error = pdf_open_stream(&stream, xref, fz_to_num(dict), fz_to_gen(dict));
if (error)
{
error = fz_rethrow(error, "cannot open shading stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
goto cleanup;
}
}
switch (type)
{
case 1: pdf_load_function_based_shading(shade, xref, dict, func[0]); break;
case 2: pdf_load_axial_shading(shade, xref, dict, funcs, func); break;
case 3: pdf_load_radial_shading(shade, xref, dict, funcs, func); break;
case 4: pdf_load_type4_shade(shade, xref, dict, funcs, func, stream); break;
case 5: pdf_load_type5_shade(shade, xref, dict, funcs, func, stream); break;
case 6: pdf_load_type6_shade(shade, xref, dict, funcs, func, stream); break;
case 7: pdf_load_type7_shade(shade, xref, dict, funcs, func, stream); break;
default:
error = fz_throw("unknown shading type: %d", type);
goto cleanup;
}
if (stream)
fz_close(stream);
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(func[i]);
*shadep = shade;
return fz_okay;
cleanup:
if (stream)
fz_close(stream);
for (i = 0; i < funcs; i++)
if (func[i])
pdf_drop_function(func[i]);
fz_drop_shade(shade);
return fz_rethrow(error, "cannot load shading type %d (%d %d R)", type, fz_to_num(dict), fz_to_gen(dict));
}
void
pdf_load_annots(pdf_annot **annotp, pdf_xref *xref, fz_obj *annots)
{
pdf_annot *annot, *head, *tail;
fz_obj *obj, *ap, *as, *n, *rect;
pdf_xobject *form;
fz_error error;
int i;
fz_context *ctx = xref->ctx;
head = tail = NULL;
annot = NULL;
for (i = 0; i < fz_array_len(ctx, annots); i++)
{
obj = fz_array_get(ctx, annots, i);
/* cf. http://bugs.ghostscript.com/show_bug.cgi?id=692078 */
if ((annot = pdf_update_tx_widget_annot(xref, obj)))
{
if (!head)
head = tail = annot;
else
{
tail->next = annot;
tail = annot;
}
continue;
}
rect = fz_dict_gets(ctx, obj, "Rect");
ap = fz_dict_gets(ctx, obj, "AP");
as = fz_dict_gets(ctx, obj, "AS");
if (fz_is_dict(ctx, ap))
{
n = fz_dict_gets(ctx, ap, "N"); /* normal state */
/* lookup current state in sub-dictionary */
if (!pdf_is_stream(xref, fz_to_num(n), fz_to_gen(n)))
n = fz_dict_get(ctx, n, as);
if (pdf_is_stream(xref, fz_to_num(n), fz_to_gen(n)))
{
error = pdf_load_xobject(&form, xref, n);
if (error)
{
fz_error_handle(ctx, error, "ignoring broken annotation");
continue;
}
annot = fz_malloc(ctx, sizeof(pdf_annot));
annot->obj = fz_keep_obj(obj);
annot->rect = pdf_to_rect(ctx, rect);
annot->ap = form;
annot->next = NULL;
pdf_transform_annot(annot);
if (annot)
{
if (!head)
head = tail = annot;
else
{
tail->next = annot;
tail = annot;
}
}
}
}
/* SumatraPDF: synthesize appearance streams for a few more annotations */
else if ((annot = pdf_create_annot_with_appearance(xref, obj)))
{
if (!head)
head = tail = annot;
else
{
tail->next = annot;
tail = annot;
}
}
}
*annotp = head;
}
static pdf_annot *
pdf_update_tx_widget_annot(pdf_xref *xref, fz_obj *obj)
{
fz_obj *ap, *res, *value;
fz_rect rect;
fz_buffer *content, *base_ap;
int flags, align, rotate, is_multiline;
float font_size, x, y;
char *font_name;
unsigned short *ucs2, *rest;
fz_context *ctx = xref->ctx;
if (strcmp(fz_to_name(ctx, fz_dict_gets(ctx, obj, "Subtype")), "Widget") != 0)
return NULL;
if (!fz_to_bool(ctx, pdf_dict_get_inheritable(xref, NULL, "NeedAppearances")) && pdf_get_ap_stream(xref, obj))
return NULL;
value = pdf_dict_get_inheritable(xref, obj, "FT");
if (strcmp(fz_to_name(ctx, value), "Tx") != 0)
return NULL;
ap = pdf_dict_get_inheritable(xref, obj, "DA");
value = pdf_dict_get_inheritable(xref, obj, "V");
if (!ap || !value)
return NULL;
res = pdf_dict_get_inheritable(xref, obj, "DR");
rect = pdf_to_rect(ctx, fz_dict_gets(ctx, obj, "Rect"));
rotate = fz_to_int(ctx, fz_dict_gets(ctx, fz_dict_gets(ctx, obj, "MK"), "R"));
rect = fz_transform_rect(fz_rotate(rotate), rect);
flags = fz_to_int(ctx, fz_dict_gets(ctx, obj, "Ff"));
is_multiline = (flags & (1 << 12)) != 0;
if ((flags & (1 << 25) /* richtext */))
fz_warn(ctx, "missing support for richtext fields");
align = fz_to_int(ctx, fz_dict_gets(ctx, obj, "Q"));
font_size = pdf_extract_font_size(xref, fz_to_str_buf(ctx, ap), &font_name);
if (!font_size || !font_name)
font_size = is_multiline ? 10 /* FIXME */ : floor(rect.y1 - rect.y0 - 2);
content = fz_new_buffer(ctx, 256);
base_ap = fz_new_buffer(ctx, 256);
pdf_prepend_ap_background(content, xref, obj);
fz_buffer_printf(ctx, content, "/Tx BMC 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, "/Tx BMC q BT %s ", fz_to_str_buf(ctx, ap));
if (font_name)
{
fz_buffer_printf(ctx, content, "/%s %.4f Tf ", font_name, font_size);
fz_buffer_printf(ctx, base_ap, "/%s %.4f Tf ", font_name, font_size);
fz_free(ctx, font_name);
}
y = 0.5f * (rect.y1 - rect.y0) + 0.6f * font_size;
if (is_multiline)
y = rect.y1 - rect.y0 - 2;
fz_buffer_printf(ctx, content, "1 0 0 1 2 %.4f Tm ", y);
ucs2 = pdf_to_ucs2(ctx, value);
for (rest = ucs2; *rest; rest++)
if (*rest > 0xFF)
*rest = '?';
if ((flags & (1 << 13) /* password */))
for (rest = ucs2; *rest; rest++)
*rest = '*';
x = 0;
rest = ucs2;
if ((flags & (1 << 24) /* comb */))
{
pdf_append_combed_line(xref, res, content, base_ap, ucs2, font_size, rect.x1 - rect.x0, fz_to_int(ctx, pdf_dict_get_inheritable(xref, obj, "MaxLen")));
rest = L"";
}
while (*rest)
rest = pdf_append_line(xref, res, content, base_ap, rest, font_size, align, rect.x1 - rect.x0 - 4.0f, is_multiline, &x);
fz_free(ctx, ucs2);
fz_buffer_printf(ctx, content, "ET Q EMC");
fz_drop_buffer(ctx, base_ap);
rect = fz_transform_rect(fz_rotate(-rotate), rect);
return pdf_create_annot(ctx, rect, fz_keep_obj(obj), content, res ? fz_keep_obj(res) : NULL, 0);
}
pdf_page *
pdf_load_page_by_obj(pdf_document *doc, int number, pdf_obj *pageref)
{
fz_context *ctx = doc->ctx;
pdf_page *page;
pdf_annot *annot;
pdf_obj *pageobj, *obj;
fz_rect mediabox, cropbox, realbox;
float userunit;
fz_matrix mat;
/* SumatraPDF: allow replacing potentially slow pdf_lookup_page_obj */
pageobj = pdf_resolve_indirect(pageref);
page = fz_malloc_struct(ctx, pdf_page);
page->resources = NULL;
page->contents = NULL;
page->transparency = 0;
page->links = NULL;
page->annots = NULL;
page->annot_tailp = &page->annots;
page->deleted_annots = NULL;
page->tmp_annots = NULL;
page->me = pdf_keep_obj(pageobj);
page->incomplete = 0;
obj = pdf_dict_gets(pageobj, "UserUnit");
if (pdf_is_real(obj))
userunit = pdf_to_real(obj);
else
userunit = 1;
pdf_to_rect(ctx, pdf_lookup_inherited_page_item(doc, pageobj, "MediaBox"), &mediabox);
if (fz_is_empty_rect(&mediabox))
{
fz_warn(ctx, "cannot find page size for page %d", number + 1);
mediabox.x0 = 0;
mediabox.y0 = 0;
mediabox.x1 = 612;
mediabox.y1 = 792;
}
pdf_to_rect(ctx, pdf_lookup_inherited_page_item(doc, pageobj, "CropBox"), &cropbox);
if (!fz_is_empty_rect(&cropbox))
fz_intersect_rect(&mediabox, &cropbox);
page->mediabox.x0 = fz_min(mediabox.x0, mediabox.x1) * userunit;
page->mediabox.y0 = fz_min(mediabox.y0, mediabox.y1) * userunit;
page->mediabox.x1 = fz_max(mediabox.x0, mediabox.x1) * userunit;
page->mediabox.y1 = fz_max(mediabox.y0, mediabox.y1) * userunit;
if (page->mediabox.x1 - page->mediabox.x0 < 1 || page->mediabox.y1 - page->mediabox.y0 < 1)
{
fz_warn(ctx, "invalid page size in page %d", number + 1);
page->mediabox = fz_unit_rect;
}
page->rotate = pdf_to_int(pdf_lookup_inherited_page_item(doc, pageobj, "Rotate"));
/* Snap page->rotate to 0, 90, 180 or 270 */
if (page->rotate < 0)
page->rotate = 360 - ((-page->rotate) % 360);
if (page->rotate >= 360)
page->rotate = page->rotate % 360;
page->rotate = 90*((page->rotate + 45)/90);
if (page->rotate > 360)
page->rotate = 0;
fz_pre_rotate(fz_scale(&page->ctm, 1, -1), -page->rotate);
realbox = page->mediabox;
fz_transform_rect(&realbox, &page->ctm);
fz_pre_scale(fz_translate(&mat, -realbox.x0, -realbox.y0), userunit, userunit);
fz_concat(&page->ctm, &page->ctm, &mat);
fz_try(ctx)
{
obj = pdf_dict_gets(pageobj, "Annots");
if (obj)
{
page->links = pdf_load_link_annots(doc, obj, &page->ctm);
pdf_load_annots(doc, page, obj);
}
}
fz_catch(ctx)
{
if (fz_caught(ctx) != FZ_ERROR_TRYLATER)
/* SumatraPDF: ignore annotations in case of unexpected errors */
fz_warn(ctx, "unexpectedly failed to load page annotations");
page->incomplete |= PDF_PAGE_INCOMPLETE_ANNOTS;
}
page->duration = pdf_to_real(pdf_dict_gets(pageobj, "Dur"));
obj = pdf_dict_gets(pageobj, "Trans");
page->transition_present = (obj != NULL);
if (obj)
{
pdf_load_transition(doc, page, obj);
}
// TODO: inherit
page->resources = pdf_lookup_inherited_page_item(doc, pageobj, "Resources");
if (page->resources)
pdf_keep_obj(page->resources);
obj = pdf_dict_gets(pageobj, "Contents");
fz_try(ctx)
{
page->contents = pdf_keep_obj(obj);
if (pdf_resources_use_blending(doc, page->resources))
page->transparency = 1;
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=2107 */
else if (!strcmp(pdf_to_name(pdf_dict_getp(pageobj, "Group/S")), "Transparency"))
page->transparency = 1;
for (annot = page->annots; annot && !page->transparency; annot = annot->next)
if (annot->ap && pdf_resources_use_blending(doc, annot->ap->resources))
page->transparency = 1;
}
fz_catch(ctx)
{
if (fz_caught(ctx) != FZ_ERROR_TRYLATER)
{
pdf_free_page(doc, page);
fz_rethrow_message(ctx, "cannot load page %d contents (%d 0 R)", number + 1, pdf_to_num(pageref));
}
page->incomplete |= PDF_PAGE_INCOMPLETE_CONTENTS;
}
return page;
}
pdf_font_desc *
pdf_load_type3_font(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict)
{
char buf[256];
char *estrings[256];
pdf_font_desc *fontdesc = NULL;
pdf_obj *encoding;
pdf_obj *widths;
pdf_obj *charprocs;
pdf_obj *obj;
int first, last;
int i, k, n;
fz_rect bbox;
fz_matrix matrix;
fz_context *ctx = xref->ctx;
fz_var(fontdesc);
fz_try(ctx)
{
obj = pdf_dict_gets(dict, "Name");
if (pdf_is_name(obj))
fz_strlcpy(buf, pdf_to_name(obj), sizeof buf);
else
sprintf(buf, "Unnamed-T3");
fontdesc = pdf_new_font_desc(ctx);
obj = pdf_dict_gets(dict, "FontMatrix");
pdf_to_matrix(ctx, obj, &matrix);
obj = pdf_dict_gets(dict, "FontBBox");
fz_transform_rect(pdf_to_rect(ctx, obj, &bbox), &matrix);
fontdesc->font = fz_new_type3_font(ctx, buf, &matrix);
fontdesc->size += sizeof(fz_font) + 256 * (sizeof(fz_buffer*) + sizeof(float));
fz_set_font_bbox(ctx, fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/* Encoding */
for (i = 0; i < 256; i++)
estrings[i] = NULL;
encoding = pdf_dict_gets(dict, "Encoding");
if (!encoding)
{
fz_throw(ctx, "syntaxerror: Type3 font missing Encoding");
}
if (pdf_is_name(encoding))
pdf_load_encoding(estrings, pdf_to_name(encoding));
if (pdf_is_dict(encoding))
{
pdf_obj *base, *diff, *item;
base = pdf_dict_gets(encoding, "BaseEncoding");
if (pdf_is_name(base))
pdf_load_encoding(estrings, pdf_to_name(base));
diff = pdf_dict_gets(encoding, "Differences");
if (pdf_is_array(diff))
{
n = pdf_array_len(diff);
k = 0;
for (i = 0; i < n; i++)
{
item = pdf_array_get(diff, i);
if (pdf_is_int(item))
k = pdf_to_int(item);
if (pdf_is_name(item) && k >= 0 && k < nelem(estrings))
estrings[k++] = pdf_to_name(item);
}
}
}
fontdesc->encoding = pdf_new_identity_cmap(ctx, 0, 1);
fontdesc->size += pdf_cmap_size(ctx, fontdesc->encoding);
pdf_load_to_unicode(xref, fontdesc, estrings, NULL, pdf_dict_gets(dict, "ToUnicode"));
/* Widths */
pdf_set_default_hmtx(ctx, fontdesc, 0);
first = pdf_to_int(pdf_dict_gets(dict, "FirstChar"));
last = pdf_to_int(pdf_dict_gets(dict, "LastChar"));
if (first < 0 || last > 255 || first > last)
first = last = 0;
widths = pdf_dict_gets(dict, "Widths");
if (!widths)
{
fz_throw(ctx, "syntaxerror: Type3 font missing Widths");
}
for (i = first; i <= last; i++)
{
float w = pdf_to_real(pdf_array_get(widths, i - first));
w = fontdesc->font->t3matrix.a * w * 1000;
fontdesc->font->t3widths[i] = w * 0.001f;
pdf_add_hmtx(ctx, fontdesc, i, i, w);
}
pdf_end_hmtx(ctx, fontdesc);
/* Resources -- inherit page resources if the font doesn't have its own */
fontdesc->font->t3freeres = pdf_t3_free_resources;
fontdesc->font->t3resources = pdf_dict_gets(dict, "Resources");
if (!fontdesc->font->t3resources)
fontdesc->font->t3resources = rdb;
if (fontdesc->font->t3resources)
pdf_keep_obj(fontdesc->font->t3resources);
if (!fontdesc->font->t3resources)
fz_warn(ctx, "no resource dictionary for type 3 font!");
fontdesc->font->t3doc = xref;
fontdesc->font->t3run = pdf_run_glyph_func;
/* CharProcs */
charprocs = pdf_dict_gets(dict, "CharProcs");
if (!charprocs)
{
fz_throw(ctx, "syntaxerror: Type3 font missing CharProcs");
}
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
obj = pdf_dict_gets(charprocs, estrings[i]);
if (pdf_is_stream(xref, pdf_to_num(obj), pdf_to_gen(obj)))
{
fontdesc->font->t3procs[i] = pdf_load_stream(xref, pdf_to_num(obj), pdf_to_gen(obj));
fontdesc->size += fontdesc->font->t3procs[i]->cap;
fontdesc->size += 0; // TODO: display list size calculation
}
}
}
}
fz_catch(ctx)
{
if (fontdesc)
pdf_drop_font(ctx, fontdesc);
fz_throw(ctx, "cannot load type3 font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
}
return fontdesc;
}
pdf_font_desc *
pdf_load_type3_font(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict)
{
char buf[256];
char *estrings[256];
pdf_font_desc *fontdesc = NULL;
pdf_obj *encoding;
pdf_obj *widths;
pdf_obj *charprocs;
pdf_obj *obj;
int first, last;
int i, k, n;
fz_rect bbox;
fz_matrix matrix;
fz_font *font;
fz_var(fontdesc);
/* Make a new type3 font entry in the document */
if (doc->num_type3_fonts == doc->max_type3_fonts)
{
int new_max = doc->max_type3_fonts * 2;
if (new_max == 0)
new_max = 4;
doc->type3_fonts = fz_resize_array(ctx, doc->type3_fonts, new_max, sizeof(*doc->type3_fonts));
doc->max_type3_fonts = new_max;
}
fz_try(ctx)
{
obj = pdf_dict_get(ctx, dict, PDF_NAME_Name);
if (pdf_is_name(ctx, obj))
fz_strlcpy(buf, pdf_to_name(ctx, obj), sizeof buf);
else
fz_strlcpy(buf, "Unnamed-T3", sizeof buf);
fontdesc = pdf_new_font_desc(ctx);
obj = pdf_dict_get(ctx, dict, PDF_NAME_FontMatrix);
pdf_to_matrix(ctx, obj, &matrix);
obj = pdf_dict_get(ctx, dict, PDF_NAME_FontBBox);
fz_transform_rect(pdf_to_rect(ctx, obj, &bbox), &matrix);
font = fz_new_type3_font(ctx, buf, &matrix);
fontdesc->font = font;
fontdesc->size += sizeof(fz_font) + 256 * (sizeof(fz_buffer*) + sizeof(float));
fz_set_font_bbox(ctx, font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
/* Encoding */
for (i = 0; i < 256; i++)
estrings[i] = NULL;
encoding = pdf_dict_get(ctx, dict, PDF_NAME_Encoding);
if (!encoding)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing Encoding");
}
if (pdf_is_name(ctx, encoding))
pdf_load_encoding(estrings, pdf_to_name(ctx, encoding));
if (pdf_is_dict(ctx, encoding))
{
pdf_obj *base, *diff, *item;
base = pdf_dict_get(ctx, encoding, PDF_NAME_BaseEncoding);
if (pdf_is_name(ctx, base))
pdf_load_encoding(estrings, pdf_to_name(ctx, base));
diff = pdf_dict_get(ctx, encoding, PDF_NAME_Differences);
if (pdf_is_array(ctx, diff))
{
n = pdf_array_len(ctx, diff);
k = 0;
for (i = 0; i < n; i++)
{
item = pdf_array_get(ctx, diff, i);
if (pdf_is_int(ctx, item))
k = pdf_to_int(ctx, item);
if (pdf_is_name(ctx, item) && k >= 0 && k < nelem(estrings))
estrings[k++] = pdf_to_name(ctx, item);
}
}
}
fontdesc->encoding = pdf_new_identity_cmap(ctx, 0, 1);
fontdesc->size += pdf_cmap_size(ctx, fontdesc->encoding);
pdf_load_to_unicode(ctx, doc, fontdesc, estrings, NULL, pdf_dict_get(ctx, dict, PDF_NAME_ToUnicode));
/* Widths */
pdf_set_default_hmtx(ctx, fontdesc, 0);
first = pdf_to_int(ctx, pdf_dict_get(ctx, dict, PDF_NAME_FirstChar));
last = pdf_to_int(ctx, pdf_dict_get(ctx, dict, PDF_NAME_LastChar));
if (first < 0 || last > 255 || first > last)
first = last = 0;
widths = pdf_dict_get(ctx, dict, PDF_NAME_Widths);
if (!widths)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing Widths");
}
for (i = first; i <= last; i++)
{
float w = pdf_to_real(ctx, pdf_array_get(ctx, widths, i - first));
w = font->t3matrix.a * w * 1000;
font->t3widths[i] = w * 0.001f;
pdf_add_hmtx(ctx, fontdesc, i, i, w);
}
pdf_end_hmtx(ctx, fontdesc);
/* Resources -- inherit page resources if the font doesn't have its own */
font->t3freeres = pdf_t3_free_resources;
font->t3resources = pdf_dict_get(ctx, dict, PDF_NAME_Resources);
if (!font->t3resources)
font->t3resources = rdb;
if (font->t3resources)
pdf_keep_obj(ctx, font->t3resources);
if (!font->t3resources)
fz_warn(ctx, "no resource dictionary for type 3 font!");
font->t3doc = doc;
font->t3run = pdf_run_glyph_func;
/* CharProcs */
charprocs = pdf_dict_get(ctx, dict, PDF_NAME_CharProcs);
if (!charprocs)
{
fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing CharProcs");
}
for (i = 0; i < 256; i++)
{
if (estrings[i])
{
obj = pdf_dict_gets(ctx, charprocs, estrings[i]);
if (pdf_is_stream(ctx, obj))
{
font->t3procs[i] = pdf_load_stream(ctx, obj);
fz_trim_buffer(ctx, font->t3procs[i]);
fontdesc->size += fz_buffer_storage(ctx, font->t3procs[i], NULL);
fontdesc->size += 0; // TODO: display list size calculation
}
}
}
}
fz_catch(ctx)
{
pdf_drop_font(ctx, fontdesc);
fz_rethrow(ctx);
}
doc->type3_fonts[doc->num_type3_fonts++] = fz_keep_font(ctx, font);
return fontdesc;
}
pdf_link *
pdf_load_link(pdf_xref *xref, fz_obj *dict)
{
fz_obj *dest;
fz_obj *action;
fz_obj *obj;
fz_rect bbox;
pdf_link_kind kind;
fz_context *ctx = xref->ctx;
dest = NULL;
obj = fz_dict_gets(ctx, dict, "Rect");
if (obj)
bbox = pdf_to_rect(ctx, obj);
else
bbox = fz_empty_rect;
obj = fz_dict_gets(ctx, dict, "Dest");
if (obj)
{
kind = PDF_LINK_GOTO;
dest = resolve_dest(xref, obj);
}
action = fz_dict_gets(ctx, dict, "A");
/* fall back to additional action button's down/up action */
if (!action)
action = fz_dict_getsa(ctx, fz_dict_gets(ctx, dict, "AA"), "U", "D");
if (action)
{
obj = fz_dict_gets(ctx, action, "S");
if (fz_is_name(ctx, obj) && !strcmp(fz_to_name(ctx, obj), "GoTo"))
{
kind = PDF_LINK_GOTO;
dest = resolve_dest(xref, fz_dict_gets(ctx, action, "D"));
}
else if (fz_is_name(ctx, obj) && !strcmp(fz_to_name(ctx, obj), "URI"))
{
kind = PDF_LINK_URI;
dest = fz_dict_gets(ctx, action, "URI");
}
else if (fz_is_name(ctx, obj) && !strcmp(fz_to_name(ctx, obj), "Launch"))
{
kind = PDF_LINK_LAUNCH;
dest = fz_dict_gets(ctx, action, "F");
}
else if (fz_is_name(ctx, obj) && !strcmp(fz_to_name(ctx, obj), "Named"))
{
kind = PDF_LINK_NAMED;
dest = fz_dict_gets(ctx, action, "N");
}
else if (fz_is_name(ctx, obj) && (!strcmp(fz_to_name(ctx, obj), "GoToR")))
{
kind = PDF_LINK_ACTION;
dest = action;
}
else
{
dest = NULL;
}
}
if (dest)
{
pdf_link *link = fz_malloc(ctx, sizeof(pdf_link));
link->kind = kind;
link->rect = bbox;
link->dest = fz_keep_obj(dest);
link->next = NULL;
return link;
}
return NULL;
}
static int _pdf_doc_load(struct _pdf_doc *self, mume_stream_t *stm)
{
fz_error error;
fz_stream *fzstm;
fz_rect *mbox;
fz_obj *page_obj, *box_obj;
int i, c;
_pdf_doc_clear(self);
fzstm = fz_new_stream(stm, _pdf_stream_read, _pdf_stream_close);
mume_stream_reference(stm);
fzstm->seek = _pdf_stream_seek;
error = pdf_open_xref_with_stream(&self->xref, fzstm, NULL);
fz_close(fzstm);
if (error) {
mume_error(("Read xref failed\n", error));
return 0;
}
assert(!pdf_needs_password(self->xref));
/* Load meta information. */
error = pdf_load_page_tree(self->xref);
if (error) {
mume_error(("Cannot load page tree\n"));
return 0;
}
c = pdf_count_pages(self->xref);
self->glyph_cache = fz_new_glyph_cache();
self->pages = calloc_abort(c, sizeof(pdf_page*));
self->disps = calloc_abort(c, sizeof(fz_display_list*));
self->media_boxes = malloc_abort(c * sizeof(fz_rect));
self->page_rotates = malloc_abort(c * sizeof(int));
/* Extract each pages' media box and rotation. */
for (i = 0; i < c; ++i) {
mbox = self->media_boxes + i;
page_obj = self->xref->page_objs[i];
if (!page_obj) {
*mbox = fz_empty_rect;
continue;
}
box_obj = fz_dict_gets(page_obj, "MediaBox");
*mbox = pdf_to_rect(box_obj);
if (fz_is_empty_rect(*mbox)) {
fz_warn("Cannot find page bounds, guessing page bounds.");
mbox->x1 = 612;
mbox->y1 = 792;
}
box_obj = fz_dict_gets(page_obj, "CropBox");
if (fz_is_array(box_obj))
*mbox = fz_intersect_rect(*mbox, pdf_to_rect(box_obj));
self->page_rotates[i] = fz_to_int(
fz_dict_gets(page_obj, "Rotate"));
if (self->page_rotates[i] % 90)
self->page_rotates[i] = 0;
}
return 1;
}
pdf_xobject *
pdf_load_xobject(pdf_document *xref, pdf_obj *dict)
{
pdf_xobject *form;
pdf_obj *obj;
fz_context *ctx = xref->ctx;
if ((form = pdf_find_item(ctx, pdf_free_xobject_imp, dict)))
{
return form;
}
form = fz_malloc_struct(ctx, pdf_xobject);
FZ_INIT_STORABLE(form, 1, pdf_free_xobject_imp);
form->resources = NULL;
form->contents = NULL;
form->colorspace = NULL;
form->me = NULL;
/* Store item immediately, to avoid possible recursion if objects refer back to this one */
pdf_store_item(ctx, dict, form, pdf_xobject_size(form));
obj = pdf_dict_gets(dict, "BBox");
form->bbox = pdf_to_rect(ctx, obj);
obj = pdf_dict_gets(dict, "Matrix");
if (obj)
form->matrix = pdf_to_matrix(ctx, obj);
else
form->matrix = fz_identity;
form->isolated = 0;
form->knockout = 0;
form->transparency = 0;
obj = pdf_dict_gets(dict, "Group");
if (obj)
{
pdf_obj *attrs = obj;
form->isolated = pdf_to_bool(pdf_dict_gets(attrs, "I"));
form->knockout = pdf_to_bool(pdf_dict_gets(attrs, "K"));
obj = pdf_dict_gets(attrs, "S");
if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "Transparency"))
form->transparency = 1;
obj = pdf_dict_gets(attrs, "CS");
if (obj)
{
form->colorspace = pdf_load_colorspace(xref, obj);
if (!form->colorspace)
fz_throw(ctx, "cannot load xobject colorspace");
}
}
form->resources = pdf_dict_gets(dict, "Resources");
if (form->resources)
pdf_keep_obj(form->resources);
fz_try(ctx)
{
form->contents = pdf_load_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
}
fz_catch(ctx)
{
pdf_remove_item(ctx, pdf_free_xobject_imp, dict);
pdf_drop_xobject(ctx, form);
fz_throw(ctx, "cannot load xobject content stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
}
form->me = pdf_keep_obj(dict);
return form;
}
