diff options
Diffstat (limited to 'source/xps')
| -rw-r--r-- | source/xps/xps-common.c | 56 | ||||
| -rw-r--r-- | source/xps/xps-doc.c | 269 | ||||
| -rw-r--r-- | source/xps/xps-glyphs.c | 123 | ||||
| -rw-r--r-- | source/xps/xps-gradient.c | 100 | ||||
| -rw-r--r-- | source/xps/xps-image.c | 50 | ||||
| -rw-r--r-- | source/xps/xps-outline.c | 56 | ||||
| -rw-r--r-- | source/xps/xps-path.c | 259 | ||||
| -rw-r--r-- | source/xps/xps-resource.c | 47 | ||||
| -rw-r--r-- | source/xps/xps-tile.c | 131 | ||||
| -rw-r--r-- | source/xps/xps-util.c | 12 | ||||
| -rw-r--r-- | source/xps/xps-zip.c | 106 |
11 files changed, 607 insertions, 602 deletions
diff --git a/source/xps/xps-common.c b/source/xps/xps-common.c index 04b78d2b..667b0631 100644 --- a/source/xps/xps-common.c +++ b/source/xps/xps-common.c @@ -9,7 +9,7 @@ static inline int unhex(int a) } fz_xml * -xps_lookup_alternate_content(fz_xml *node) +xps_lookup_alternate_content(fz_context *ctx, xps_document *doc, fz_xml *node) { for (node = fz_xml_down(node); node; node = fz_xml_next(node)) { @@ -29,48 +29,49 @@ xps_lookup_alternate_content(fz_xml *node) } void -xps_parse_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) +xps_parse_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) { if (doc->cookie && doc->cookie->abort) return; /* SolidColorBrushes are handled in a special case and will never show up here */ if (fz_xml_is_tag(node, "ImageBrush")) - xps_parse_image_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_image_brush(ctx, doc, ctm, area, base_uri, dict, node); else if (fz_xml_is_tag(node, "VisualBrush")) - xps_parse_visual_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_visual_brush(ctx, doc, ctm, area, base_uri, dict, node); else if (fz_xml_is_tag(node, "LinearGradientBrush")) - xps_parse_linear_gradient_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_linear_gradient_brush(ctx, doc, ctm, area, base_uri, dict, node); else if (fz_xml_is_tag(node, "RadialGradientBrush")) - xps_parse_radial_gradient_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_radial_gradient_brush(ctx, doc, ctm, area, base_uri, dict, node); else - fz_warn(doc->ctx, "unknown brush tag: %s", fz_xml_tag(node)); + fz_warn(ctx, "unknown brush tag: %s", fz_xml_tag(node)); } void -xps_parse_element(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) +xps_parse_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) { if (doc->cookie && doc->cookie->abort) return; if (fz_xml_is_tag(node, "Path")) - xps_parse_path(doc, ctm, base_uri, dict, node); + xps_parse_path(ctx, doc, ctm, base_uri, dict, node); if (fz_xml_is_tag(node, "Glyphs")) - xps_parse_glyphs(doc, ctm, base_uri, dict, node); + xps_parse_glyphs(ctx, doc, ctm, base_uri, dict, node); if (fz_xml_is_tag(node, "Canvas")) - xps_parse_canvas(doc, ctm, area, base_uri, dict, node); + xps_parse_canvas(ctx, doc, ctm, area, base_uri, dict, node); if (fz_xml_is_tag(node, "AlternateContent")) { - node = xps_lookup_alternate_content(node); + node = xps_lookup_alternate_content(ctx, doc, node); if (node) - xps_parse_element(doc, ctm, area, base_uri, dict, node); + xps_parse_element(ctx, doc, ctm, area, base_uri, dict, node); } /* skip unknown tags (like Foo.Resources and similar) */ } void -xps_begin_opacity(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_begin_opacity(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag) { + fz_device *dev = doc->dev; float opacity; if (!opacity_att && !opacity_mask_tag) @@ -90,7 +91,7 @@ xps_begin_opacity(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, { fz_colorspace *colorspace; float samples[FZ_MAX_COLORS]; - xps_parse_color(doc, base_uri, scb_color_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, scb_color_att, &colorspace, samples); opacity = opacity * samples[0]; } opacity_mask_tag = NULL; @@ -104,16 +105,18 @@ xps_begin_opacity(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, if (opacity_mask_tag) { - fz_begin_mask(doc->dev, area, 0, NULL, NULL); - xps_parse_brush(doc, ctm, area, base_uri, dict, opacity_mask_tag); - fz_end_mask(doc->dev); + fz_begin_mask(ctx, dev, area, 0, NULL, NULL); + xps_parse_brush(ctx, doc, ctm, area, base_uri, dict, opacity_mask_tag); + fz_end_mask(ctx, dev); } } void -xps_end_opacity(xps_document *doc, char *base_uri, xps_resource *dict, +xps_end_opacity(fz_context *ctx, xps_document *doc, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag) { + fz_device *dev = doc->dev; + if (!opacity_att && !opacity_mask_tag) return; @@ -123,12 +126,12 @@ xps_end_opacity(xps_document *doc, char *base_uri, xps_resource *dict, if (opacity_mask_tag) { if (strcmp(fz_xml_tag(opacity_mask_tag), "SolidColorBrush")) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); } } void -xps_parse_render_transform(xps_document *doc, char *transform, fz_matrix *matrix) +xps_parse_render_transform(fz_context *ctx, xps_document *doc, char *transform, fz_matrix *matrix) { float args[6]; char *s = transform; @@ -153,7 +156,7 @@ xps_parse_render_transform(xps_document *doc, char *transform, fz_matrix *matrix } void -xps_parse_matrix_transform(xps_document *doc, fz_xml *root, fz_matrix *matrix) +xps_parse_matrix_transform(fz_context *ctx, xps_document *doc, fz_xml *root, fz_matrix *matrix) { char *transform; @@ -163,12 +166,12 @@ xps_parse_matrix_transform(xps_document *doc, fz_xml *root, fz_matrix *matrix) { transform = fz_xml_att(root, "Matrix"); if (transform) - xps_parse_render_transform(doc, transform, matrix); + xps_parse_render_transform(ctx, doc, transform, matrix); } } void -xps_parse_rectangle(xps_document *doc, char *text, fz_rect *rect) +xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text, fz_rect *rect) { float args[4]; char *s = text; @@ -205,10 +208,9 @@ static int count_commas(char *s) } void -xps_parse_color(xps_document *doc, char *base_uri, char *string, +xps_parse_color(fz_context *ctx, xps_document *doc, char *base_uri, char *string, fz_colorspace **csp, float *samples) { - fz_context *ctx = doc->ctx; char *p; int i, n; char buf[1024]; @@ -307,7 +309,7 @@ xps_parse_color(xps_document *doc, char *base_uri, char *string, } void -xps_set_color(xps_document *doc, fz_colorspace *colorspace, float *samples) +xps_set_color(fz_context *ctx, xps_document *doc, fz_colorspace *colorspace, float *samples) { int i; doc->colorspace = colorspace; diff --git a/source/xps/xps-doc.c b/source/xps/xps-doc.c index 4bcf92cb..41823d56 100644 --- a/source/xps/xps-doc.c +++ b/source/xps/xps-doc.c @@ -15,7 +15,7 @@ "http://schemas.openxps.org/oxps/v1.0/documentstructure" static void -xps_rels_for_part(char *buf, char *name, int buflen) +xps_rels_for_part(fz_context *ctx, xps_document *doc, char *buf, char *name, int buflen) { char *p, *basename; p = strrchr(name, '/'); @@ -34,10 +34,10 @@ xps_rels_for_part(char *buf, char *name, int buflen) */ void -xps_print_page_list(xps_document *doc) +xps_print_page_list(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc = doc->first_fixdoc; - xps_page *page = doc->first_page; + xps_fixpage *page = doc->first_page; if (doc->start_part) printf("start part %s\n", doc->start_part); @@ -56,7 +56,7 @@ xps_print_page_list(xps_document *doc) } static void -xps_add_fixed_document(xps_document *doc, char *name) +xps_add_fixed_document(fz_context *ctx, xps_document *doc, char *name) { xps_fixdoc *fixdoc; @@ -65,8 +65,8 @@ xps_add_fixed_document(xps_document *doc, char *name) if (!strcmp(fixdoc->name, name)) return; - fixdoc = fz_malloc_struct(doc->ctx, xps_fixdoc); - fixdoc->name = fz_strdup(doc->ctx, name); + fixdoc = fz_malloc_struct(ctx, xps_fixdoc); + fixdoc->name = fz_strdup(ctx, name); fixdoc->outline = NULL; fixdoc->next = NULL; @@ -83,7 +83,7 @@ xps_add_fixed_document(xps_document *doc, char *name) } void -xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri) +xps_add_link(fz_context *ctx, xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri) { int len; char *buffer = NULL; @@ -91,7 +91,6 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe xps_target *target; fz_link_dest dest; fz_link *link; - fz_context *ctx = doc->ctx; fz_var(buffer); @@ -102,9 +101,9 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe { len = 2 + (base_uri ? strlen(base_uri) : 0) + (target_uri ? strlen(target_uri) : 0); - buffer = fz_malloc(doc->ctx, len); - xps_resolve_url(buffer, base_uri, target_uri, len); - if (xps_url_is_remote(buffer)) + buffer = fz_malloc(ctx, len); + xps_resolve_url(ctx, doc, buffer, base_uri, target_uri, len); + if (xps_url_is_remote(ctx, doc, buffer)) { dest.kind = FZ_LINK_URI; dest.ld.uri.is_map = 0; @@ -140,13 +139,13 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe dest.ld.gotor.new_window = 0; } - link = fz_new_link(doc->ctx, area, dest); + link = fz_new_link(ctx, area, dest); link->next = doc->current_page->links; doc->current_page->links = link; } fz_always(ctx) { - fz_free(doc->ctx, buffer); + fz_free(ctx, buffer); } fz_catch(ctx) { @@ -154,32 +153,23 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe } } -fz_link * -xps_load_links(xps_document *doc, xps_page *page) -{ - if (!page->links_resolved) - fz_warn(doc->ctx, "xps_load_links before page has been executed!"); - return fz_keep_link(doc->ctx, page->links); -} - static void -xps_add_fixed_page(xps_document *doc, char *name, int width, int height) +xps_add_fixed_page(fz_context *ctx, xps_document *doc, char *name, int width, int height) { - xps_page *page; + xps_fixpage *page; /* Check for duplicates first */ for (page = doc->first_page; page; page = page->next) if (!strcmp(page->name, name)) return; - page = fz_malloc_struct(doc->ctx, xps_page); - page->name = fz_strdup(doc->ctx, name); + page = fz_malloc_struct(ctx, xps_fixpage); + page->name = fz_strdup(ctx, name); page->number = doc->page_count++; page->width = width; page->height = height; page->links = NULL; page->links_resolved = 0; - page->root = NULL; page->next = NULL; if (!doc->first_page) @@ -195,18 +185,18 @@ xps_add_fixed_page(xps_document *doc, char *name, int width, int height) } static void -xps_add_link_target(xps_document *doc, char *name) +xps_add_link_target(fz_context *ctx, xps_document *doc, char *name) { - xps_page *page = doc->last_page; - xps_target *target = fz_malloc_struct(doc->ctx, xps_target); - target->name = fz_strdup(doc->ctx, name); + xps_fixpage *page = doc->last_page; + xps_target *target = fz_malloc_struct(ctx, xps_target); + target->name = fz_strdup(ctx, name); target->page = page->number; target->next = doc->target; doc->target = target; } int -xps_lookup_link_target(xps_document *doc, char *target_uri) +xps_lookup_link_target(fz_context *ctx, xps_document *doc, char *target_uri) { xps_target *target; char *needle = strrchr(target_uri, '#'); @@ -218,29 +208,28 @@ xps_lookup_link_target(xps_document *doc, char *target_uri) } static void -xps_free_link_targets(xps_document *doc) +xps_drop_link_targets(fz_context *ctx, xps_document *doc) { xps_target *target = doc->target, *next; while (target) { next = target->next; - fz_free(doc->ctx, target->name); - fz_free(doc->ctx, target); + fz_free(ctx, target->name); + fz_free(ctx, target); target = next; } } static void -xps_free_fixed_pages(xps_document *doc) +xps_drop_fixed_pages(fz_context *ctx, xps_document *doc) { - xps_page *page = doc->first_page; + xps_fixpage *page = doc->first_page; while (page) { - xps_page *next = page->next; - xps_free_page(doc, page); - fz_drop_link(doc->ctx, page->links); - fz_free(doc->ctx, page->name); - fz_free(doc->ctx, page); + xps_fixpage *next = page->next; + fz_drop_link(ctx, page->links); + fz_free(ctx, page->name); + fz_free(ctx, page); page = next; } doc->first_page = NULL; @@ -248,15 +237,15 @@ xps_free_fixed_pages(xps_document *doc) } static void -xps_free_fixed_documents(xps_document *doc) +xps_drop_fixed_documents(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc = doc->first_fixdoc; while (fixdoc) { xps_fixdoc *next = fixdoc->next; - fz_free(doc->ctx, fixdoc->name); - fz_free(doc->ctx, fixdoc->outline); - fz_free(doc->ctx, fixdoc); + fz_free(ctx, fixdoc->name); + fz_free(ctx, fixdoc->outline); + fz_free(ctx, fixdoc); fixdoc = next; } doc->first_fixdoc = NULL; @@ -264,11 +253,11 @@ xps_free_fixed_documents(xps_document *doc) } void -xps_free_page_list(xps_document *doc) +xps_drop_page_list(fz_context *ctx, xps_document *doc) { - xps_free_fixed_documents(doc); - xps_free_fixed_pages(doc); - xps_free_link_targets(doc); + xps_drop_fixed_documents(ctx, doc); + xps_drop_fixed_pages(ctx, doc); + xps_drop_link_targets(ctx, doc); } /* @@ -276,7 +265,7 @@ xps_free_page_list(xps_document *doc) */ static void -xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) +xps_parse_metadata_imp(fz_context *ctx, xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) { while (item) { @@ -287,13 +276,13 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) if (target && type) { char tgtbuf[1024]; - xps_resolve_url(tgtbuf, doc->base_uri, target, sizeof tgtbuf); + xps_resolve_url(ctx, doc, tgtbuf, doc->base_uri, target, sizeof tgtbuf); if (!strcmp(type, REL_START_PART) || !strcmp(type, REL_START_PART_OXPS)) - doc->start_part = fz_strdup(doc->ctx, tgtbuf); + doc->start_part = fz_strdup(ctx, tgtbuf); if ((!strcmp(type, REL_DOC_STRUCTURE) || !strcmp(type, REL_DOC_STRUCTURE_OXPS)) && fixdoc) - fixdoc->outline = fz_strdup(doc->ctx, tgtbuf); + fixdoc->outline = fz_strdup(ctx, tgtbuf); if (!fz_xml_att(item, "Id")) - fz_warn(doc->ctx, "missing relationship id for %s", target); + fz_warn(ctx, "missing relationship id for %s", target); } } @@ -303,8 +292,8 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) if (source) { char srcbuf[1024]; - xps_resolve_url(srcbuf, doc->base_uri, source, sizeof srcbuf); - xps_add_fixed_document(doc, srcbuf); + xps_resolve_url(ctx, doc, srcbuf, doc->base_uri, source, sizeof srcbuf); + xps_add_fixed_document(ctx, doc, srcbuf); } } @@ -318,8 +307,8 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) if (source) { char srcbuf[1024]; - xps_resolve_url(srcbuf, doc->base_uri, source, sizeof srcbuf); - xps_add_fixed_page(doc, srcbuf, width, height); + xps_resolve_url(ctx, doc, srcbuf, doc->base_uri, source, sizeof srcbuf); + xps_add_fixed_page(ctx, doc, srcbuf, width, height); } } @@ -327,17 +316,17 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) { char *name = fz_xml_att(item, "Name"); if (name) - xps_add_link_target(doc, name); + xps_add_link_target(ctx, doc, name); } - xps_parse_metadata_imp(doc, fz_xml_down(item), fixdoc); + xps_parse_metadata_imp(ctx, doc, fz_xml_down(item), fixdoc); item = fz_xml_next(item); } } static void -xps_parse_metadata(xps_document *doc, xps_part *part, xps_fixdoc *fixdoc) +xps_parse_metadata(fz_context *ctx, xps_document *doc, xps_part *part, xps_fixdoc *fixdoc) { fz_xml *root; char buf[1024]; @@ -360,31 +349,30 @@ xps_parse_metadata(xps_document *doc, xps_part *part, xps_fixdoc *fixdoc) doc->base_uri = buf; doc->part_uri = part->name; - root = fz_parse_xml(doc->ctx, part->data, part->size, 0); - xps_parse_metadata_imp(doc, root, fixdoc); - fz_free_xml(doc->ctx, root); + root = fz_parse_xml(ctx, part->data, part->size, 0); + xps_parse_metadata_imp(ctx, doc, root, fixdoc); + fz_drop_xml(ctx, root); doc->base_uri = NULL; doc->part_uri = NULL; } static void -xps_read_and_process_metadata_part(xps_document *doc, char *name, xps_fixdoc *fixdoc) +xps_read_and_process_metadata_part(fz_context *ctx, xps_document *doc, char *name, xps_fixdoc *fixdoc) { - fz_context *ctx = doc->ctx; xps_part *part; - if (!xps_has_part(doc, name)) + if (!xps_has_part(ctx, doc, name)) return; - part = xps_read_part(doc, name); + part = xps_read_part(ctx, doc, name); fz_try(ctx) { - xps_parse_metadata(doc, part, fixdoc); + xps_parse_metadata(ctx, doc, part, fixdoc); } fz_always(ctx) { - xps_free_part(doc, part); + xps_drop_part(ctx, doc, part); } fz_catch(ctx) { @@ -393,57 +381,56 @@ xps_read_and_process_metadata_part(xps_document *doc, char *name, xps_fixdoc *fi } void -xps_read_page_list(xps_document *doc) +xps_read_page_list(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc; - xps_read_and_process_metadata_part(doc, "/_rels/.rels", NULL); + xps_read_and_process_metadata_part(ctx, doc, "/_rels/.rels", NULL); if (!doc->start_part) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find fixed document sequence start part"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find fixed document sequence start part"); - xps_read_and_process_metadata_part(doc, doc->start_part, NULL); + xps_read_and_process_metadata_part(ctx, doc, doc->start_part, NULL); for (fixdoc = doc->first_fixdoc; fixdoc; fixdoc = fixdoc->next) { char relbuf[1024]; - fz_try(doc->ctx) + fz_try(ctx) { - xps_rels_for_part(relbuf, fixdoc->name, sizeof relbuf); - xps_read_and_process_metadata_part(doc, relbuf, fixdoc); + xps_rels_for_part(ctx, doc, relbuf, fixdoc->name, sizeof relbuf); + xps_read_and_process_metadata_part(ctx, doc, relbuf, fixdoc); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot process FixedDocument rels part"); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot process FixedDocument rels part"); } - xps_read_and_process_metadata_part(doc, fixdoc->name, fixdoc); + xps_read_and_process_metadata_part(ctx, doc, fixdoc->name, fixdoc); } } int -xps_count_pages(xps_document *doc) +xps_count_pages(fz_context *ctx, xps_document *doc) { return doc->page_count; } -static void -xps_load_fixed_page(xps_document *doc, xps_page *page) +static fz_xml * +xps_load_fixed_page(fz_context *ctx, xps_document *doc, xps_fixpage *page) { xps_part *part; fz_xml *root; char *width_att; char *height_att; - fz_context *ctx = doc->ctx; - part = xps_read_part(doc, page->name); + part = xps_read_part(ctx, doc, page->name); fz_try(ctx) { - root = fz_parse_xml(doc->ctx, part->data, part->size, 0); + root = fz_parse_xml(ctx, part->data, part->size, 0); } fz_always(ctx) { - xps_free_part(doc, part); + xps_drop_part(ctx, doc, part); } fz_catch(ctx) { @@ -451,89 +438,117 @@ xps_load_fixed_page(xps_document *doc, xps_page *page) root = NULL; } if (!root) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing root element"); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing root element"); if (fz_xml_is_tag(root, "AlternateContent")) { - fz_xml *node = xps_lookup_alternate_content(root); + fz_xml *node = xps_lookup_alternate_content(ctx, doc, root); if (!node) { - fz_free_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing alternate root element"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing alternate root element"); } fz_detach_xml(node); - fz_free_xml(doc->ctx, root); + fz_drop_xml(ctx, root); root = node; } if (strcmp(fz_xml_tag(root), "FixedPage")) { - fz_free_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected FixedPage element"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected FixedPage element"); } width_att = fz_xml_att(root, "Width"); if (!width_att) { - fz_free_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Width"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Width"); } height_att = fz_xml_att(root, "Height"); if (!height_att) { - fz_free_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Height"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Height"); } page->width = atoi(width_att); page->height = atoi(height_att); - page->root = root; + + return root; } -xps_page * -xps_load_page(xps_document *doc, int number) +fz_link * +xps_load_links(fz_context *ctx, xps_page *page) { - xps_page *page; - int n = 0; - - for (page = doc->first_page; page; page = page->next) - { - if (n == number) - { - doc->current_page = page; - if (!page->root) - xps_load_fixed_page(doc, page); - return page; - } - n ++; - } - - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find page %d", number + 1); + if (!page->fix->links_resolved) + fz_warn(ctx, "xps_load_links before page has been executed!"); + return fz_keep_link(ctx, page->fix->links); } fz_rect * -xps_bound_page(xps_document *doc, xps_page *page, fz_rect *bounds) +xps_bound_page(fz_context *ctx, xps_page *page, fz_rect *bounds) { bounds->x0 = bounds->y0 = 0; - bounds->x1 = page->width * 72.0f / 96.0f; - bounds->y1 = page->height * 72.0f / 96.0f; + bounds->x1 = page->fix->width * 72.0f / 96.0f; + bounds->y1 = page->fix->height * 72.0f / 96.0f; return bounds; } void -xps_free_page(xps_document *doc, xps_page *page) +xps_drop_page_imp(fz_context *ctx, xps_page *page) { if (page == NULL) return; - /* only free the XML contents */ - if (page->root) - fz_free_xml(doc->ctx, page->root); - page->root = NULL; + fz_drop_document(ctx, &page->doc->super); + fz_drop_xml(ctx, page->root); +} + +xps_page * +xps_load_page(fz_context *ctx, xps_document *doc, int number) +{ + xps_page *page = NULL; + xps_fixpage *fix; + fz_xml *root; + int n = 0; + + fz_var(page); + + for (fix = doc->first_page; fix; fix = fix->next) + { + if (n == number) + { + doc->current_page = fix; + + root = xps_load_fixed_page(ctx, doc, fix); + fz_try(ctx) + { + page = fz_new_page(ctx, sizeof *page); + page->super.load_links = (fz_page_load_links_fn *)xps_load_links; + page->super.bound_page = (fz_page_bound_page_fn *)xps_bound_page; + page->super.run_page_contents = (fz_page_run_page_contents_fn *)xps_run_page; + page->super.drop_page_imp = (fz_page_drop_page_imp_fn *)xps_drop_page_imp; + + page->doc = (xps_document*) fz_keep_document(ctx, &doc->super); + page->fix = fix; + page->root = root; + } + fz_catch(ctx) + { + fz_drop_xml(ctx, root); + fz_rethrow(ctx); + } + return page; + } + n ++; + } + + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find page %d", number + 1); } static int -xps_recognize(fz_context *doc, const char *magic) +xps_recognize(fz_context *ctx, const char *magic) { char *ext = strrchr(magic, '.'); diff --git a/source/xps/xps-glyphs.c b/source/xps/xps-glyphs.c index ee16fb6f..e15eb726 100644 --- a/source/xps/xps-glyphs.c +++ b/source/xps/xps-glyphs.c @@ -52,12 +52,11 @@ xps_encode_font_char(fz_font *font, int code) } void -xps_measure_font_glyph(xps_document *doc, fz_font *font, int gid, xps_glyph_metrics *mtx) +xps_measure_font_glyph(fz_context *ctx, xps_document *doc, fz_font *font, int gid, xps_glyph_metrics *mtx) { int mask = FT_LOAD_NO_SCALE | FT_LOAD_IGNORE_TRANSFORM; FT_Face face = font->ft_face; FT_Fixed hadv = 0, vadv = 0; - fz_context *ctx = doc->ctx; fz_lock(ctx, FZ_LOCK_FREETYPE); FT_Get_Advance(face, gid, mask, &hadv); @@ -70,21 +69,21 @@ xps_measure_font_glyph(xps_document *doc, fz_font *font, int gid, xps_glyph_metr } static fz_font * -xps_lookup_font(xps_document *doc, char *name) +xps_lookup_font(fz_context *ctx, xps_document *doc, char *name) { xps_font_cache *cache; for (cache = doc->font_table; cache; cache = cache->next) if (!xps_strcasecmp(cache->name, name)) - return fz_keep_font(doc->ctx, cache->font); + return fz_keep_font(ctx, cache->font); return NULL; } static void -xps_insert_font(xps_document *doc, char *name, fz_font *font) +xps_insert_font(fz_context *ctx, xps_document *doc, char *name, fz_font *font) { - xps_font_cache *cache = fz_malloc_struct(doc->ctx, xps_font_cache); - cache->name = fz_strdup(doc->ctx, name); - cache->font = fz_keep_font(doc->ctx, font); + xps_font_cache *cache = fz_malloc_struct(ctx, xps_font_cache); + cache->name = fz_strdup(ctx, name); + cache->font = fz_keep_font(ctx, font); cache->next = doc->font_table; doc->font_table = cache; } @@ -94,7 +93,7 @@ xps_insert_font(xps_document *doc, char *name, fz_font *font) * data with the GUID in the fontname. */ static void -xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) +xps_deobfuscate_font_resource(fz_context *ctx, xps_document *doc, xps_part *part) { unsigned char buf[33]; unsigned char key[16]; @@ -103,7 +102,7 @@ xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) if (part->size < 32) { - fz_warn(doc->ctx, "insufficient data for font deobfuscation"); + fz_warn(ctx, "insufficient data for font deobfuscation"); return; } @@ -120,7 +119,7 @@ xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) if (i != 32) { - fz_warn(doc->ctx, "cannot extract GUID from obfuscated font part name"); + fz_warn(ctx, "cannot extract GUID from obfuscated font part name"); return; } @@ -135,7 +134,7 @@ xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) } static void -xps_select_best_font_encoding(xps_document *doc, fz_font *font) +xps_select_best_font_encoding(fz_context *ctx, xps_document *doc, fz_font *font) { static struct { int pid, eid; } xps_cmap_list[] = { @@ -166,7 +165,7 @@ xps_select_best_font_encoding(xps_document *doc, fz_font *font) } } - fz_warn(doc->ctx, "cannot find a suitable cmap"); + fz_warn(ctx, "cannot find a suitable cmap"); } /* @@ -257,7 +256,7 @@ xps_parse_glyph_metrics(char *s, float *advance, float *uofs, float *vofs) * Calculate metrics for positioning. */ static fz_text * -xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, +xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, fz_font *font, float size, float originx, float originy, int is_sideways, int bidi_level, char *indices, char *unicode) @@ -273,7 +272,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, int un = 0; if (!unicode && !indices) - fz_warn(doc->ctx, "glyphs element with neither characters nor indices"); + fz_warn(ctx, "glyphs element with neither characters nor indices"); if (us) { @@ -289,7 +288,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, else fz_scale(&tm, size, -size); - text = fz_new_text(doc->ctx, font, &tm, is_sideways); + text = fz_new_text(ctx, font, &tm, is_sideways); while ((us && un > 0) || (is && *is)) { @@ -331,7 +330,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, if (glyph_index == -1) glyph_index = xps_encode_font_char(font, char_code); - xps_measure_font_glyph(doc, font, glyph_index, &mtx); + xps_measure_font_glyph(ctx, doc, font, glyph_index, &mtx); if (is_sideways) advance = mtx.vadv * 100; else if (bidi_level & 1) @@ -366,7 +365,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, f = y - v_offset; } - fz_add_text(doc->ctx, text, glyph_index, char_code, e, f); + fz_add_text(ctx, text, glyph_index, char_code, e, f); x += advance * 0.01f * size; } @@ -376,9 +375,11 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, } void -xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, +xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root) { + fz_device *dev = doc->dev; + fz_xml *node; char *fill_uri; @@ -459,17 +460,17 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, fill_uri = base_uri; opacity_mask_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &clip_att, &clip_tag, NULL); - xps_resolve_resource_reference(doc, dict, &fill_att, &fill_tag, &fill_uri); - xps_resolve_resource_reference(doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &fill_att, &fill_tag, &fill_uri); + xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); /* * Check that we have all the necessary information. */ if (!font_size_att || !font_uri_att || !origin_x_att || !origin_y_att) { - fz_warn(doc->ctx, "missing attributes in glyphs element"); + fz_warn(ctx, "missing attributes in glyphs element"); return; } @@ -486,7 +487,7 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, * Find and load the font resource */ - xps_resolve_url(partname, base_uri, font_uri_att, sizeof partname); + xps_resolve_url(ctx, doc, partname, base_uri, font_uri_att, sizeof partname); subfont = strrchr(partname, '#'); if (subfont) { @@ -506,45 +507,45 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, fz_strlcat(fakename, "#BoldItalic", sizeof fakename); } - font = xps_lookup_font(doc, fakename); + font = xps_lookup_font(ctx, doc, fakename); if (!font) { fz_buffer *buf = NULL; fz_var(buf); - fz_try(doc->ctx) + fz_try(ctx) { - part = xps_read_part(doc, partname); + part = xps_read_part(ctx, doc, partname); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot find font resource part '%s'", partname); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot find font resource part '%s'", partname); return; } /* deobfuscate if necessary */ if (strstr(part->name, ".odttf")) - xps_deobfuscate_font_resource(doc, part); + xps_deobfuscate_font_resource(ctx, doc, part); if (strstr(part->name, ".ODTTF")) - xps_deobfuscate_font_resource(doc, part); + xps_deobfuscate_font_resource(ctx, doc, part); - fz_try(doc->ctx) + fz_try(ctx) { - buf = fz_new_buffer_from_data(doc->ctx, part->data, part->size); + buf = fz_new_buffer_from_data(ctx, part->data, part->size); /* part->data is now owned by buf */ part->data = NULL; - font = fz_new_font_from_buffer(doc->ctx, NULL, buf, subfontid, 1); + font = fz_new_font_from_buffer(ctx, NULL, buf, subfontid, 1); } - fz_always(doc->ctx) + fz_always(ctx) { - fz_drop_buffer(doc->ctx, buf); - xps_free_part(doc, part); + fz_drop_buffer(ctx, buf); + xps_drop_part(ctx, doc, part); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot load font resource '%s'", partname); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot load font resource '%s'", partname); return; } @@ -554,8 +555,8 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, font->ft_italic = !!strstr(style_att, "Italic"); } - xps_select_best_font_encoding(doc, font); - xps_insert_font(doc, fakename, font); + xps_select_best_font_encoding(ctx, doc, font); + xps_insert_font(ctx, doc, fakename, font); } /* @@ -566,27 +567,27 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, { fz_matrix transform; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&local_ctm, &transform, &local_ctm); } if (clip_att || clip_tag) - xps_clip(doc, &local_ctm, dict, clip_att, clip_tag); + xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag); font_size = fz_atof(font_size_att); - text = xps_parse_glyphs_imp(doc, &local_ctm, font, font_size, + text = xps_parse_glyphs_imp(ctx, doc, &local_ctm, font, font_size, fz_atof(origin_x_att), fz_atof(origin_y_att), is_sideways, bidi_level, indices_att, unicode_att); - fz_bound_text(doc->ctx, text, NULL, &local_ctm, &area); + fz_bound_text(ctx, text, NULL, &local_ctm, &area); if (navigate_uri_att) - xps_add_link(doc, &area, base_uri, navigate_uri_att); + xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att); - xps_begin_opacity(doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_begin_opacity(ctx, doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); /* If it's a solid color brush fill/stroke do a simple fill */ @@ -602,12 +603,12 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, float samples[FZ_MAX_COLORS]; fz_colorspace *colorspace; - xps_parse_color(doc, base_uri, fill_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, fill_att, &colorspace, samples); if (fill_opacity_att) samples[0] *= fz_atof(fill_opacity_att); - xps_set_color(doc, colorspace, samples); + xps_set_color(ctx, doc, colorspace, samples); - fz_fill_text(doc->dev, text, &local_ctm, + fz_fill_text(ctx, dev, text, &local_ctm, doc->colorspace, doc->color, doc->alpha); } @@ -615,17 +616,17 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, if (fill_tag) { - fz_clip_text(doc->dev, text, &local_ctm, 0); - xps_parse_brush(doc, &local_ctm, &area, fill_uri, dict, fill_tag); - fz_pop_clip(doc->dev); + fz_clip_text(ctx, dev, text, &local_ctm, 0); + xps_parse_brush(ctx, doc, &local_ctm, &area, fill_uri, dict, fill_tag); + fz_pop_clip(ctx, dev); } - xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); - fz_free_text(doc->ctx, text); + fz_drop_text(ctx, text); if (clip_att || clip_tag) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); - fz_drop_font(doc->ctx, font); + fz_drop_font(ctx, font); } diff --git a/source/xps/xps-gradient.c b/source/xps/xps-gradient.c index 4c1d0851..f3a9f8e8 100644 --- a/source/xps/xps-gradient.c +++ b/source/xps/xps-gradient.c @@ -35,7 +35,7 @@ static inline float lerp(float a, float b, float x) } static int -xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, +xps_parse_gradient_stops(fz_context *ctx, xps_document *doc, char *base_uri, fz_xml *node, struct stop *stops, int maxcount) { fz_colorspace *colorspace; @@ -60,9 +60,9 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, stops[count].offset = fz_atof(offset); stops[count].index = count; - xps_parse_color(doc, base_uri, color, &colorspace, sample); + xps_parse_color(ctx, doc, base_uri, color, &colorspace, sample); - fz_convert_color(doc->ctx, fz_device_rgb(doc->ctx), rgb, colorspace, sample + 1); + fz_convert_color(ctx, fz_device_rgb(ctx), rgb, colorspace, sample + 1); stops[count].r = rgb[0]; stops[count].g = rgb[1]; @@ -77,7 +77,7 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, if (count == 0) { - fz_warn(doc->ctx, "gradient brush has no gradient stops"); + fz_warn(ctx, "gradient brush has no gradient stops"); stops[0].offset = 0; stops[0].r = 0; stops[0].g = 0; @@ -92,7 +92,7 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, } if (count == maxcount) - fz_warn(doc->ctx, "gradient brush exceeded maximum number of gradient stops"); + fz_warn(ctx, "gradient brush exceeded maximum number of gradient stops"); /* Postprocess to make sure the range of offsets is 0.0 to 1.0 */ @@ -175,7 +175,7 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, } static void -xps_sample_gradient_stops(fz_shade *shade, struct stop *stops, int count) +xps_sample_gradient_stops(fz_context *ctx, xps_document *doc, fz_shade *shade, struct stop *stops, int count) { float offset, d; int i, k; @@ -204,18 +204,19 @@ xps_sample_gradient_stops(fz_shade *shade, struct stop *stops, int count) */ static void -xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, +xps_draw_one_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, struct stop *stops, int count, int extend, float x0, float y0, float r0, float x1, float y1, float r1) { + fz_device *dev = doc->dev; fz_shade *shade; /* TODO: this (and the stuff in pdf_shade) should move to res_shade.c */ - shade = fz_malloc_struct(doc->ctx, fz_shade); - FZ_INIT_STORABLE(shade, 1, fz_free_shade_imp); - shade->colorspace = fz_device_rgb(doc->ctx); + shade = fz_malloc_struct(ctx, fz_shade); + FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp); + shade->colorspace = fz_device_rgb(ctx); shade->bbox = fz_infinite_rect; shade->matrix = fz_identity; shade->use_background = 0; @@ -224,7 +225,7 @@ xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.extend[0] = extend; shade->u.l_or_r.extend[1] = extend; - xps_sample_gradient_stops(shade, stops, count); + xps_sample_gradient_stops(ctx, doc, shade, stops, count); shade->u.l_or_r.coords[0][0] = x0; shade->u.l_or_r.coords[0][1] = y0; @@ -233,9 +234,9 @@ xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.coords[1][1] = y1; shade->u.l_or_r.coords[1][2] = r1; - fz_fill_shade(doc->dev, shade, ctm, 1); + fz_fill_shade(ctx, dev, shade, ctm, 1); - fz_drop_shade(doc->ctx, shade); + fz_drop_shade(ctx, shade); } /* @@ -243,17 +244,18 @@ xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, */ static void -xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, +xps_draw_one_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, struct stop *stops, int count, int extend, float x0, float y0, float x1, float y1) { + fz_device *dev = doc->dev; fz_shade *shade; /* TODO: this (and the stuff in pdf_shade) should move to res_shade.c */ - shade = fz_malloc_struct(doc->ctx, fz_shade); - FZ_INIT_STORABLE(shade, 1, fz_free_shade_imp); - shade->colorspace = fz_device_rgb(doc->ctx); + shade = fz_malloc_struct(ctx, fz_shade); + FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp); + shade->colorspace = fz_device_rgb(ctx); shade->bbox = fz_infinite_rect; shade->matrix = fz_identity; shade->use_background = 0; @@ -262,7 +264,7 @@ xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.extend[0] = extend; shade->u.l_or_r.extend[1] = extend; - xps_sample_gradient_stops(shade, stops, count); + xps_sample_gradient_stops(ctx, doc, shade, stops, count); shade->u.l_or_r.coords[0][0] = x0; shade->u.l_or_r.coords[0][1] = y0; @@ -271,9 +273,9 @@ xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.coords[1][1] = y1; shade->u.l_or_r.coords[1][2] = 0; - fz_fill_shade(doc->dev, shade, ctm, doc->opacity[doc->opacity_top]); + fz_fill_shade(ctx, dev, shade, ctm, doc->opacity[doc->opacity_top]); - fz_drop_shade(doc->ctx, shade); + fz_drop_shade(ctx, shade); } /* @@ -292,7 +294,7 @@ static inline float point_inside_circle(float px, float py, float x, float y, fl } static void -xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, struct stop *stops, int count, fz_xml *root, int spread) { @@ -317,9 +319,9 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect yrad = 1.0; if (origin_att) - xps_parse_point(origin_att, &x0, &y0); + xps_parse_point(ctx, doc, origin_att, &x0, &y0); if (center_att) - xps_parse_point(center_att, &x1, &y1); + xps_parse_point(ctx, doc, center_att, &x1, &y1); if (radius_x_att) xrad = fz_atof(radius_x_att); if (radius_y_att) @@ -353,7 +355,7 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect if (spread == SPREAD_REPEAT) { for (i = ma - 1; i >= 0; i--) - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); } else if (spread == SPREAD_REFLECT) { @@ -361,13 +363,13 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect ma++; for (i = ma - 2; i >= 0; i -= 2) { - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad); } } else { - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1); } } @@ -377,7 +379,7 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect */ static void -xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, struct stop *stops, int count, fz_xml *root, int spread) { @@ -395,9 +397,9 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect x1 = y1 = 1; if (start_point_att) - xps_parse_point(start_point_att, &x0, &y0); + xps_parse_point(ctx, doc, start_point_att, &x0, &y0); if (end_point_att) - xps_parse_point(end_point_att, &x1, &y1); + xps_parse_point(ctx, doc, end_point_att, &x1, &y1); p1.x = x0; p1.y = y0; p2.x = x1; p2.y = y1; fz_transform_rect(&local_area, fz_invert_matrix(&inv, ctm)); @@ -415,7 +417,7 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect if (spread == SPREAD_REPEAT) { for (i = mi; i < ma; i++) - xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); } else if (spread == SPREAD_REFLECT) { @@ -423,13 +425,13 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect mi--; for (i = mi; i < ma; i += 2) { - xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); - xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + (i + 2) * dx, y0 + (i + 2) * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 0, x0 + (i + 2) * dx, y0 + (i + 2) * dy, x1 + i * dx, y1 + i * dy); } } else { - xps_draw_one_linear_gradient(doc, ctm, stops, count, 1, x0, y0, x1, y1); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 1, x0, y0, x1, y1); } } @@ -439,9 +441,9 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect */ static void -xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, - void (*draw)(xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int)) + void (*draw)(fz_context *ctx, xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int)) { fz_xml *node; @@ -473,7 +475,7 @@ xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect stop_tag = fz_xml_down(node); } - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); spread_method = SPREAD_PAD; if (spread_att) @@ -488,40 +490,40 @@ xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&transform, &transform, ctm); if (!stop_tag) { - fz_warn(doc->ctx, "missing gradient stops tag"); + fz_warn(ctx, "missing gradient stops tag"); return; } - stop_count = xps_parse_gradient_stops(doc, base_uri, stop_tag, stop_list, MAX_STOPS); + stop_count = xps_parse_gradient_stops(ctx, doc, base_uri, stop_tag, stop_list, MAX_STOPS); if (stop_count == 0) { - fz_warn(doc->ctx, "no gradient stops found"); + fz_warn(ctx, "no gradient stops found"); return; } - xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL); + xps_begin_opacity(ctx, doc, &transform, area, base_uri, dict, opacity_att, NULL); - draw(doc, &transform, area, stop_list, stop_count, root, spread_method); + draw(ctx, doc, &transform, area, stop_list, stop_count, root, spread_method); - xps_end_opacity(doc, base_uri, dict, opacity_att, NULL); + xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL); } void -xps_parse_linear_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_linear_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { - xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient); + xps_parse_gradient_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient); } void -xps_parse_radial_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_radial_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { - xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient); + xps_parse_gradient_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient); } diff --git a/source/xps/xps-image.c b/source/xps/xps-image.c index 9b2aefcb..b0d00a2f 100644 --- a/source/xps/xps-image.c +++ b/source/xps/xps-image.c @@ -1,7 +1,7 @@ #include "mupdf/xps.h" static fz_image * -xps_load_image(fz_context *ctx, xps_part *part) +xps_load_image(fz_context *ctx, xps_document *doc, xps_part *part) { /* Ownership of data always passes in here */ unsigned char *data = part->data; @@ -11,7 +11,7 @@ xps_load_image(fz_context *ctx, xps_part *part) /* FIXME: area unused! */ static void -xps_paint_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, +xps_paint_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, void *vimage) { fz_image *image = vimage; @@ -23,11 +23,11 @@ xps_paint_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *ar xs = image->w * 96 / image->xres; ys = image->h * 96 / image->yres; fz_pre_scale(&local_ctm, xs, ys); - fz_fill_image(doc->dev, image, &local_ctm, doc->opacity[doc->opacity_top]); + fz_fill_image(ctx, doc->dev, image, &local_ctm, doc->opacity[doc->opacity_top]); } static void -xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root, xps_part **image_part, xps_part **profile_part) +xps_find_image_brush_source_part(fz_context *ctx, xps_document *doc, char *base_uri, fz_xml *root, xps_part **image_part, xps_part **profile_part) { char *image_source_att; char buf[1024]; @@ -38,7 +38,7 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root image_source_att = fz_xml_att(root, "ImageSource"); if (!image_source_att) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find image source attribute"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find image source attribute"); /* "{ColorConvertedBitmap /Resources/Image.tiff /Resources/Profile.icc}" */ if (strstr(image_source_att, "{ColorConvertedBitmap") == image_source_att) @@ -69,20 +69,20 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root } if (!image_name) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find image source"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find image source"); if (image_part) { - xps_resolve_url(partname, base_uri, image_name, sizeof partname); - *image_part = xps_read_part(doc, partname); + xps_resolve_url(ctx, doc, partname, base_uri, image_name, sizeof partname); + *image_part = xps_read_part(ctx, doc, partname); } if (profile_part) { if (profile_name) { - xps_resolve_url(partname, base_uri, profile_name, sizeof partname); - *profile_part = xps_read_part(doc, partname); + xps_resolve_url(ctx, doc, partname, base_uri, profile_name, sizeof partname); + *profile_part = xps_read_part(ctx, doc, partname); } else *profile_part = NULL; @@ -90,40 +90,40 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root } void -xps_parse_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { xps_part *part; fz_image *image; - fz_try(doc->ctx) + fz_try(ctx) { - xps_find_image_brush_source_part(doc, base_uri, root, &part, NULL); + xps_find_image_brush_source_part(ctx, doc, base_uri, root, &part, NULL); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot find image source"); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot find image source"); return; } - fz_try(doc->ctx) + fz_try(ctx) { - image = xps_load_image(doc->ctx, part); + image = xps_load_image(ctx, doc, part); image->invert_cmyk_jpeg = 1; } - fz_always(doc->ctx) + fz_always(ctx) { - xps_free_part(doc, part); + xps_drop_part(ctx, doc, part); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot decode image resource"); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot decode image resource"); return; } - xps_parse_tiling_brush(doc, ctm, area, base_uri, dict, root, xps_paint_image_brush, image); + xps_parse_tiling_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_paint_image_brush, image); - fz_drop_image(doc->ctx, image); + fz_drop_image(ctx, image); } diff --git a/source/xps/xps-outline.c b/source/xps/xps-outline.c index e314e83e..b6e68c29 100644 --- a/source/xps/xps-outline.c +++ b/source/xps/xps-outline.c @@ -5,17 +5,17 @@ */ static fz_outline * -xps_lookup_last_outline_at_level(fz_outline *node, int level, int target_level) +xps_lookup_last_outline_at_level(fz_context *ctx, xps_document *doc, fz_outline *node, int level, int target_level) { while (node->next) node = node->next; if (level == target_level || !node->down) return node; - return xps_lookup_last_outline_at_level(node->down, level + 1, target_level); + return xps_lookup_last_outline_at_level(ctx, doc, node->down, level + 1, target_level); } static fz_outline * -xps_parse_document_outline(xps_document *doc, fz_xml *root) +xps_parse_document_outline(fz_context *ctx, xps_document *doc, fz_xml *root) { fz_xml *node; fz_outline *head = NULL, *entry, *tail; @@ -30,11 +30,11 @@ xps_parse_document_outline(xps_document *doc, fz_xml *root) if (!target || !description) continue; - entry = fz_malloc_struct(doc->ctx, fz_outline); - entry->title = fz_strdup(doc->ctx, description); + entry = fz_malloc_struct(ctx, fz_outline); + entry->title = fz_strdup(ctx, description); entry->dest.kind = FZ_LINK_GOTO; entry->dest.ld.gotor.flags = 0; - entry->dest.ld.gotor.page = xps_lookup_link_target(doc, target); + entry->dest.ld.gotor.page = xps_lookup_link_target(ctx, doc, target); entry->down = NULL; entry->next = NULL; @@ -46,7 +46,7 @@ xps_parse_document_outline(xps_document *doc, fz_xml *root) } else { - tail = xps_lookup_last_outline_at_level(head, 1, this_level); + tail = xps_lookup_last_outline_at_level(ctx, doc, head, 1, this_level); if (this_level > last_level) tail->down = entry; else @@ -60,7 +60,7 @@ xps_parse_document_outline(xps_document *doc, fz_xml *root) } static fz_outline * -xps_parse_document_structure(xps_document *doc, fz_xml *root) +xps_parse_document_structure(fz_context *ctx, xps_document *doc, fz_xml *root) { fz_xml *node; if (fz_xml_is_tag(root, "DocumentStructure")) @@ -70,53 +70,53 @@ xps_parse_document_structure(xps_document *doc, fz_xml *root) { node = fz_xml_down(node); if (node && fz_xml_is_tag(node, "DocumentOutline")) - return xps_parse_document_outline(doc, node); + return xps_parse_document_outline(ctx, doc, node); } } return NULL; } static fz_outline * -xps_load_document_structure(xps_document *doc, xps_fixdoc *fixdoc) +xps_load_document_structure(fz_context *ctx, xps_document *doc, xps_fixdoc *fixdoc) { xps_part *part; fz_xml *root; fz_outline *outline; - part = xps_read_part(doc, fixdoc->outline); - fz_try(doc->ctx) + part = xps_read_part(ctx, doc, fixdoc->outline); + fz_try(ctx) { - root = fz_parse_xml(doc->ctx, part->data, part->size, 0); + root = fz_parse_xml(ctx, part->data, part->size, 0); } - fz_always(doc->ctx) + fz_always(ctx) { - xps_free_part(doc, part); + xps_drop_part(ctx, doc, part); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow(doc->ctx); + fz_rethrow(ctx); } if (!root) return NULL; - fz_try(doc->ctx) + fz_try(ctx) { - outline = xps_parse_document_structure(doc, root); + outline = xps_parse_document_structure(ctx, doc, root); } - fz_always(doc->ctx) + fz_always(ctx) { - fz_free_xml(doc->ctx, root); + fz_drop_xml(ctx, root); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow(doc->ctx); + fz_rethrow(ctx); } return outline; } fz_outline * -xps_load_outline(xps_document *doc) +xps_load_outline(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc; fz_outline *head = NULL, *tail, *outline; @@ -125,13 +125,13 @@ xps_load_outline(xps_document *doc) { if (fixdoc->outline) { - fz_try(doc->ctx) + fz_try(ctx) { - outline = xps_load_document_structure(doc, fixdoc); + outline = xps_load_document_structure(ctx, doc, fixdoc); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); outline = NULL; } if (!outline) diff --git a/source/xps/xps-path.c b/source/xps/xps-path.c index 49240ee4..e1245a9a 100644 --- a/source/xps/xps-path.c +++ b/source/xps/xps-path.c @@ -1,7 +1,7 @@ #include "mupdf/xps.h" static char * -xps_parse_float_array(char *s, int num, float *x) +xps_parse_float_array(fz_context *ctx, xps_document *doc, char *s, int num, float *x) { int k = 0; @@ -24,12 +24,12 @@ xps_parse_float_array(char *s, int num, float *x) } char * -xps_parse_point(char *s_in, float *x, float *y) +xps_parse_point(fz_context *ctx, xps_document *doc, char *s_in, float *x, float *y) { char *s_out = s_in; float xy[2]; - s_out = xps_parse_float_array(s_out, 2, &xy[0]); + s_out = xps_parse_float_array(ctx, doc, s_out, 2, &xy[0]); *x = xy[0]; *y = xy[1]; return s_out; @@ -44,7 +44,7 @@ xps_parse_point(char *s_in, float *x, float *y) * calculated by th0, and on exit, a point is generated for us at th0. */ static void -xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float th0, float th1, int iscw) +xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, const fz_matrix *mtx, float th0, float th1, int iscw) { float t, d; fz_point p; @@ -59,7 +59,7 @@ xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float for (t = th0 + d; t < th1 - d/2; t += d) { fz_transform_point_xy(&p, mtx, cosf(t), sinf(t)); - fz_lineto(doc, path, p.x, p.y); + fz_lineto(ctx, path, p.x, p.y); } } else @@ -68,7 +68,7 @@ xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float for (t = th0 - d; t > th1 + d/2; t -= d) { fz_transform_point_xy(&p, mtx, cosf(t), sinf(t)); - fz_lineto(doc, path, p.x, p.y); + fz_lineto(ctx, path, p.x, p.y); } } } @@ -106,7 +106,7 @@ angle_between(const fz_point u, const fz_point v) If is_clockwise, then the arc sweeps clockwise. */ static void -xps_draw_arc(fz_context *doc, fz_path *path, +xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path, float size_x, float size_y, float rotation_angle, int is_large_arc, int is_clockwise, float point_x, float point_y) @@ -122,7 +122,7 @@ xps_draw_arc(fz_context *doc, fz_path *path, float sign; float th1, dth; - pt = fz_currentpoint(doc, path); + pt = fz_currentpoint(ctx, path); x1 = pt.x; y1 = pt.y; x2 = point_x; @@ -146,7 +146,7 @@ xps_draw_arc(fz_context *doc, fz_path *path, ry = fabsf(ry); if (rx < 0.001f || ry < 0.001f || (x1 == x2 && y1 == y2)) { - fz_lineto(doc, path, x2, y2); + fz_lineto(ctx, path, x2, y2); return; } @@ -203,9 +203,9 @@ xps_draw_arc(fz_context *doc, fz_path *path, } fz_pre_scale(fz_pre_rotate(fz_translate(&mtx, cx, cy), rotation_angle), rx, ry); - xps_draw_arc_segment(doc, path, &mtx, th1, th1 + dth, is_clockwise); + xps_draw_arc_segment(ctx, doc, path, &mtx, th1, th1 + dth, is_clockwise); - fz_lineto(doc, path, point_x, point_y); + fz_lineto(ctx, path, point_x, point_y); } /* @@ -215,7 +215,7 @@ xps_draw_arc(fz_context *doc, fz_path *path, */ static fz_path * -xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) +xps_parse_abbreviated_geometry(fz_context *ctx, xps_document *doc, char *geom, int *fill_rule) { fz_path *path; char **args; @@ -228,9 +228,9 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) float smooth_x, smooth_y; /* saved cubic bezier control point for smooth curves */ int reset_smooth; - path = fz_new_path(doc->ctx); + path = fz_new_path(ctx); - args = fz_malloc_array(doc->ctx, strlen(geom) + 1, sizeof(char*)); + args = fz_malloc_array(ctx, strlen(geom) + 1, sizeof(char*)); pargs = args; while (*s) @@ -288,51 +288,51 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'M': if (i + 1 >= n) break; - fz_moveto(doc->ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); + fz_moveto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); i += 2; break; case 'm': if (i + 1 >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_moveto(doc->ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); + pt = fz_currentpoint(ctx, path); + fz_moveto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); i += 2; break; case 'L': if (i + 1 >= n) break; - fz_lineto(doc->ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); + fz_lineto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); i += 2; break; case 'l': if (i + 1 >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); i += 2; break; case 'H': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, fz_atof(args[i]), pt.y); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, fz_atof(args[i]), pt.y); i += 1; break; case 'h': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x + fz_atof(args[i]), pt.y); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y); i += 1; break; case 'V': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x, fz_atof(args[i])); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x, fz_atof(args[i])); i += 1; break; case 'v': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x, pt.y + fz_atof(args[i])); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x, pt.y + fz_atof(args[i])); i += 1; break; @@ -344,7 +344,7 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) y2 = fz_atof(args[i+3]); x3 = fz_atof(args[i+4]); y3 = fz_atof(args[i+5]); - fz_curveto(doc->ctx, path, x1, y1, x2, y2, x3, y3); + fz_curveto(ctx, path, x1, y1, x2, y2, x3, y3); i += 6; reset_smooth = 0; smooth_x = x3 - x2; @@ -353,14 +353,14 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'c': if (i + 5 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]) + pt.x; y1 = fz_atof(args[i+1]) + pt.y; x2 = fz_atof(args[i+2]) + pt.x; y2 = fz_atof(args[i+3]) + pt.y; x3 = fz_atof(args[i+4]) + pt.x; y3 = fz_atof(args[i+5]) + pt.y; - fz_curveto(doc->ctx, path, x1, y1, x2, y2, x3, y3); + fz_curveto(ctx, path, x1, y1, x2, y2, x3, y3); i += 6; reset_smooth = 0; smooth_x = x3 - x2; @@ -369,12 +369,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'S': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]); y1 = fz_atof(args[i+1]); x2 = fz_atof(args[i+2]); y2 = fz_atof(args[i+3]); - fz_curveto(doc->ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); + fz_curveto(ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); i += 4; reset_smooth = 0; smooth_x = x2 - x1; @@ -383,12 +383,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 's': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]) + pt.x; y1 = fz_atof(args[i+1]) + pt.y; x2 = fz_atof(args[i+2]) + pt.x; y2 = fz_atof(args[i+3]) + pt.y; - fz_curveto(doc->ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); + fz_curveto(ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); i += 4; reset_smooth = 0; smooth_x = x2 - x1; @@ -397,12 +397,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'Q': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]); y1 = fz_atof(args[i+1]); x2 = fz_atof(args[i+2]); y2 = fz_atof(args[i+3]); - fz_curveto(doc->ctx, path, + fz_curveto(ctx, path, (pt.x + 2 * x1) / 3, (pt.y + 2 * y1) / 3, (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3, x2, y2); @@ -410,12 +410,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) break; case 'q': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]) + pt.x; y1 = fz_atof(args[i+1]) + pt.y; x2 = fz_atof(args[i+2]) + pt.x; y2 = fz_atof(args[i+3]) + pt.y; - fz_curveto(doc->ctx, path, + fz_curveto(ctx, path, (pt.x + 2 * x1) / 3, (pt.y + 2 * y1) / 3, (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3, x2, y2); @@ -424,7 +424,7 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'A': if (i + 6 >= n) break; - xps_draw_arc(doc->ctx, path, + xps_draw_arc(ctx, doc, path, fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]), atoi(args[i+3]), atoi(args[i+4]), fz_atof(args[i+5]), fz_atof(args[i+6])); @@ -432,8 +432,8 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) break; case 'a': if (i + 6 >= n) break; - pt = fz_currentpoint(doc->ctx, path); - xps_draw_arc(doc->ctx, path, + pt = fz_currentpoint(ctx, path); + xps_draw_arc(ctx, doc, path, fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]), atoi(args[i+3]), atoi(args[i+4]), fz_atof(args[i+5]) + pt.x, fz_atof(args[i+6]) + pt.y); @@ -442,12 +442,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'Z': case 'z': - fz_closepath(doc->ctx, path); + fz_closepath(ctx, path); break; default: /* eek */ - fz_warn(doc->ctx, "ignoring invalid command '%c'", cmd); + fz_warn(ctx, "ignoring invalid command '%c'", cmd); /* Skip any trailing numbers to avoid an infinite loop */ while (i < n && (args[i][0] == '+' || args[i][0] == '.' || args[i][0] == '-' || (args[i][0] >= '0' && args[i][0] <= '9'))) i ++; @@ -457,12 +457,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) old = cmd; } - fz_free(doc->ctx, args); + fz_free(ctx, args); return path; } static void -xps_parse_arc_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { /* ArcSegment pretty much follows the SVG algorithm for converting an * arc in endpoint representation to an arc in centerpoint @@ -484,7 +484,7 @@ xps_parse_arc_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking if (!point_att || !size_att || !rotation_angle_att || !is_large_arc_att || !sweep_direction_att) { - fz_warn(doc, "ArcSegment element is missing attributes"); + fz_warn(ctx, "ArcSegment element is missing attributes"); return; } @@ -497,23 +497,23 @@ xps_parse_arc_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking point_x = point_y = 0; size_x = size_y = 0; - xps_parse_point(point_att, &point_x, &point_y); - xps_parse_point(size_att, &size_x, &size_y); + xps_parse_point(ctx, doc, point_att, &point_x, &point_y); + xps_parse_point(ctx, doc, size_att, &size_x, &size_y); rotation_angle = fz_atof(rotation_angle_att); is_large_arc = !strcmp(is_large_arc_att, "true"); is_clockwise = !strcmp(sweep_direction_att, "Clockwise"); if (stroking && !is_stroked) { - fz_moveto(doc, path, point_x, point_y); + fz_moveto(ctx, path, point_x, point_y); return; } - xps_draw_arc(doc, path, size_x, size_y, rotation_angle, is_large_arc, is_clockwise, point_x, point_y); + xps_draw_arc(ctx, doc, path, size_x, size_y, rotation_angle, is_large_arc, is_clockwise, point_x, point_y); } static void -xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_poly_quadratic_bezier_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { char *points_att = fz_xml_att(root, "Points"); char *is_stroked_att = fz_xml_att(root, "IsStroked"); @@ -525,7 +525,7 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml * if (!points_att) { - fz_warn(doc, "PolyQuadraticBezierSegment element has no points"); + fz_warn(ctx, "PolyQuadraticBezierSegment element has no points"); return; } @@ -540,18 +540,18 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml * while (*s != 0) { while (*s == ' ') s++; - s = xps_parse_point(s, &x[n], &y[n]); + s = xps_parse_point(ctx, doc, s, &x[n], &y[n]); n ++; if (n == 2) { if (stroking && !is_stroked) { - fz_moveto(doc, path, x[1], y[1]); + fz_moveto(ctx, path, x[1], y[1]); } else { - pt = fz_currentpoint(doc, path); - fz_curveto(doc, path, + pt = fz_currentpoint(ctx, path); + fz_curveto(ctx, path, (pt.x + 2 * x[0]) / 3, (pt.y + 2 * y[0]) / 3, (x[1] + 2 * x[0]) / 3, (y[1] + 2 * y[0]) / 3, x[1], y[1]); @@ -562,7 +562,7 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml * } static void -xps_parse_poly_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_poly_bezier_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { char *points_att = fz_xml_att(root, "Points"); char *is_stroked_att = fz_xml_att(root, "IsStroked"); @@ -573,7 +573,7 @@ xps_parse_poly_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int if (!points_att) { - fz_warn(doc, "PolyBezierSegment element has no points"); + fz_warn(ctx, "PolyBezierSegment element has no points"); return; } @@ -588,21 +588,21 @@ xps_parse_poly_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int while (*s != 0) { while (*s == ' ') s++; - s = xps_parse_point(s, &x[n], &y[n]); + s = xps_parse_point(ctx, doc, s, &x[n], &y[n]); n ++; if (n == 3) { if (stroking && !is_stroked) - fz_moveto(doc, path, x[2], y[2]); + fz_moveto(ctx, path, x[2], y[2]); else - fz_curveto(doc, path, x[0], y[0], x[1], y[1], x[2], y[2]); + fz_curveto(ctx, path, x[0], y[0], x[1], y[1], x[2], y[2]); n = 0; } } } static void -xps_parse_poly_line_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_poly_line_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { char *points_att = fz_xml_att(root, "Points"); char *is_stroked_att = fz_xml_att(root, "IsStroked"); @@ -612,7 +612,7 @@ xps_parse_poly_line_segment(fz_context *doc, fz_path *path, fz_xml *root, int st if (!points_att) { - fz_warn(doc, "PolyLineSegment element has no points"); + fz_warn(ctx, "PolyLineSegment element has no points"); return; } @@ -626,16 +626,16 @@ xps_parse_poly_line_segment(fz_context *doc, fz_path *path, fz_xml *root, int st while (*s != 0) { while (*s == ' ') s++; - s = xps_parse_point(s, &x, &y); + s = xps_parse_point(ctx, doc, s, &x, &y); if (stroking && !is_stroked) - fz_moveto(doc, path, x, y); + fz_moveto(ctx, path, x, y); else - fz_lineto(doc, path, x, y); + fz_lineto(ctx, path, x, y); } } static void -xps_parse_path_figure(fz_context *doc, fz_path *path, fz_xml *root, int stroking) +xps_parse_path_figure(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking) { fz_xml *node; @@ -659,36 +659,36 @@ xps_parse_path_figure(fz_context *doc, fz_path *path, fz_xml *root, int stroking if (is_filled_att) is_filled = !strcmp(is_filled_att, "true"); if (start_point_att) - xps_parse_point(start_point_att, &start_x, &start_y); + xps_parse_point(ctx, doc, start_point_att, &start_x, &start_y); if (!stroking && !is_filled) /* not filled, when filling */ return; - fz_moveto(doc, path, start_x, start_y); + fz_moveto(ctx, path, start_x, start_y); for (node = fz_xml_down(root); node; node = fz_xml_next(node)) { if (fz_xml_is_tag(node, "ArcSegment")) - xps_parse_arc_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_arc_segment(ctx, doc, path, node, stroking, &skipped_stroke); if (fz_xml_is_tag(node, "PolyBezierSegment")) - xps_parse_poly_bezier_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_poly_bezier_segment(ctx, doc, path, node, stroking, &skipped_stroke); if (fz_xml_is_tag(node, "PolyLineSegment")) - xps_parse_poly_line_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_poly_line_segment(ctx, doc, path, node, stroking, &skipped_stroke); if (fz_xml_is_tag(node, "PolyQuadraticBezierSegment")) - xps_parse_poly_quadratic_bezier_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_poly_quadratic_bezier_segment(ctx, doc, path, node, stroking, &skipped_stroke); } if (is_closed) { if (stroking && skipped_stroke) - fz_lineto(doc, path, start_x, start_y); /* we've skipped using fz_moveto... */ + fz_lineto(ctx, path, start_x, start_y); /* we've skipped using fz_moveto... */ else - fz_closepath(doc, path); /* no skipped segments, safe to closepath properly */ + fz_closepath(ctx, path); /* no skipped segments, safe to closepath properly */ } } fz_path * -xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule) +xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule) { fz_xml *node; @@ -712,8 +712,8 @@ xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int transform_tag = fz_xml_down(node); } - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &figures_att, &figures_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &figures_att, &figures_tag, NULL); if (fill_rule_att) { @@ -725,26 +725,26 @@ xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); if (figures_att) - path = xps_parse_abbreviated_geometry(doc, figures_att, fill_rule); + path = xps_parse_abbreviated_geometry(ctx, doc, figures_att, fill_rule); else - path = fz_new_path(doc->ctx); + path = fz_new_path(ctx); if (figures_tag) - xps_parse_path_figure(doc->ctx, path, figures_tag, stroking); + xps_parse_path_figure(ctx, doc, path, figures_tag, stroking); for (node = fz_xml_down(root); node; node = fz_xml_next(node)) { if (fz_xml_is_tag(node, "PathFigure")) - xps_parse_path_figure(doc->ctx, path, node, stroking); + xps_parse_path_figure(ctx, doc, path, node, stroking); } if (transform_att || transform_tag) - fz_transform_path(doc->ctx, path, &transform); + fz_transform_path(ctx, path, &transform); return path; } @@ -763,19 +763,20 @@ xps_parse_line_cap(char *attr) } void -xps_clip(xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag) +xps_clip(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag) { + fz_device *dev = doc->dev; fz_path *path; int fill_rule = 0; if (clip_att) - path = xps_parse_abbreviated_geometry(doc, clip_att, &fill_rule); + path = xps_parse_abbreviated_geometry(ctx, doc, clip_att, &fill_rule); else if (clip_tag) - path = xps_parse_path_geometry(doc, dict, clip_tag, 0, &fill_rule); + path = xps_parse_path_geometry(ctx, doc, dict, clip_tag, 0, &fill_rule); else - path = fz_new_path(doc->ctx); - fz_clip_path(doc->dev, path, NULL, fill_rule == 0, ctm); - fz_free_path(doc->ctx, path); + path = fz_new_path(ctx); + fz_clip_path(ctx, dev, path, NULL, fill_rule == 0, ctm); + fz_drop_path(ctx, path); } /* @@ -784,8 +785,10 @@ xps_clip(xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip */ void -xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root) +xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root) { + fz_device *dev = doc->dev; + fz_xml *node; char *fill_uri; @@ -873,12 +876,12 @@ xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_reso stroke_uri = base_uri; opacity_mask_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &data_att, &data_tag, NULL); - xps_resolve_resource_reference(doc, dict, &clip_att, &clip_tag, NULL); - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &fill_att, &fill_tag, &fill_uri); - xps_resolve_resource_reference(doc, dict, &stroke_att, &stroke_tag, &stroke_uri); - xps_resolve_resource_reference(doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); + xps_resolve_resource_reference(ctx, doc, dict, &data_att, &data_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &fill_att, &fill_tag, &fill_uri); + xps_resolve_resource_reference(ctx, doc, dict, &stroke_att, &stroke_tag, &stroke_uri); + xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); /* * Act on the information we have gathered: @@ -918,7 +921,7 @@ xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_reso s++; } } - stroke = fz_new_stroke_state_with_dash_len(doc->ctx, dash_len); + stroke = fz_new_stroke_state_with_dash_len(ctx, dash_len); stroke->start_cap = xps_parse_line_cap(stroke_start_line_cap_att); stroke->dash_cap = xps_parse_line_cap(stroke_dash_cap_att); stroke->end_cap = xps_parse_line_cap(stroke_end_line_cap_att); @@ -973,87 +976,87 @@ xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_reso transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&local_ctm, &transform, ctm); if (clip_att || clip_tag) - xps_clip(doc, &local_ctm, dict, clip_att, clip_tag); + xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag); fill_rule = 0; if (data_att) - path = xps_parse_abbreviated_geometry(doc, data_att, &fill_rule); + path = xps_parse_abbreviated_geometry(ctx, doc, data_att, &fill_rule); else if (data_tag) { - path = xps_parse_path_geometry(doc, dict, data_tag, 0, &fill_rule); + path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 0, &fill_rule); if (stroke_att || stroke_tag) - stroke_path = xps_parse_path_geometry(doc, dict, data_tag, 1, &fill_rule); + stroke_path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 1, &fill_rule); } if (!stroke_path) stroke_path = path; if (stroke_att || stroke_tag) { - fz_bound_path(doc->ctx, stroke_path, stroke, &local_ctm, &area); + fz_bound_path(ctx, stroke_path, stroke, &local_ctm, &area); if (stroke_path != path && (fill_att || fill_tag)) { fz_rect bounds; - fz_bound_path(doc->ctx, path, NULL, &local_ctm, &bounds); + fz_bound_path(ctx, path, NULL, &local_ctm, &bounds); fz_union_rect(&area, &bounds); } } else - fz_bound_path(doc->ctx, path, NULL, &local_ctm, &area); + fz_bound_path(ctx, path, NULL, &local_ctm, &area); if (navigate_uri_att) - xps_add_link(doc, &area, base_uri, navigate_uri_att); + xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att); - xps_begin_opacity(doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_begin_opacity(ctx, doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (fill_att) { - xps_parse_color(doc, base_uri, fill_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, fill_att, &colorspace, samples); if (fill_opacity_att) samples[0] *= fz_atof(fill_opacity_att); - xps_set_color(doc, colorspace, samples); + xps_set_color(ctx, doc, colorspace, samples); - fz_fill_path(doc->dev, path, fill_rule == 0, &local_ctm, + fz_fill_path(ctx, dev, path, fill_rule == 0, &local_ctm, doc->colorspace, doc->color, doc->alpha); } if (fill_tag) { - fz_clip_path(doc->dev, path, &area, fill_rule == 0, &local_ctm); - xps_parse_brush(doc, &local_ctm, &area, fill_uri, dict, fill_tag); - fz_pop_clip(doc->dev); + fz_clip_path(ctx, dev, path, &area, fill_rule == 0, &local_ctm); + xps_parse_brush(ctx, doc, &local_ctm, &area, fill_uri, dict, fill_tag); + fz_pop_clip(ctx, dev); } if (stroke_att) { - xps_parse_color(doc, base_uri, stroke_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, stroke_att, &colorspace, samples); if (stroke_opacity_att) samples[0] *= fz_atof(stroke_opacity_att); - xps_set_color(doc, colorspace, samples); + xps_set_color(ctx, doc, colorspace, samples); - fz_stroke_path(doc->dev, stroke_path, stroke, &local_ctm, + fz_stroke_path(ctx, dev, stroke_path, stroke, &local_ctm, doc->colorspace, doc->color, doc->alpha); } if (stroke_tag) { - fz_clip_stroke_path(doc->dev, stroke_path, &area, stroke, &local_ctm); - xps_parse_brush(doc, &local_ctm, &area, stroke_uri, dict, stroke_tag); - fz_pop_clip(doc->dev); + fz_clip_stroke_path(ctx, dev, stroke_path, &area, stroke, &local_ctm); + xps_parse_brush(ctx, doc, &local_ctm, &area, stroke_uri, dict, stroke_tag); + fz_pop_clip(ctx, dev); } - xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (stroke_path != path) - fz_free_path(doc->ctx, stroke_path); - fz_free_path(doc->ctx, path); + fz_drop_path(ctx, stroke_path); + fz_drop_path(ctx, path); path = NULL; - fz_drop_stroke_state(doc->ctx, stroke); + fz_drop_stroke_state(ctx, stroke); if (clip_att || clip_tag) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); } diff --git a/source/xps/xps-resource.c b/source/xps/xps-resource.c index 85fd7c49..712ed1cc 100644 --- a/source/xps/xps-resource.c +++ b/source/xps/xps-resource.c @@ -1,7 +1,7 @@ #include "mupdf/xps.h" static fz_xml * -xps_lookup_resource(xps_document *doc, xps_resource *dict, char *name, char **urip) +xps_lookup_resource(fz_context *ctx, xps_document *doc, xps_resource *dict, char *name, char **urip) { xps_resource *head, *node; for (head = dict; head; head = head->parent) @@ -20,7 +20,7 @@ xps_lookup_resource(xps_document *doc, xps_resource *dict, char *name, char **ur } static fz_xml * -xps_parse_resource_reference(xps_document *doc, xps_resource *dict, char *att, char **urip) +xps_parse_resource_reference(fz_context *ctx, xps_document *doc, xps_resource *dict, char *att, char **urip) { char name[1024]; char *s; @@ -33,16 +33,16 @@ xps_parse_resource_reference(xps_document *doc, xps_resource *dict, char *att, c if (s) *s = 0; - return xps_lookup_resource(doc, dict, name, urip); + return xps_lookup_resource(ctx, doc, dict, name, urip); } void -xps_resolve_resource_reference(xps_document *doc, xps_resource *dict, +xps_resolve_resource_reference(fz_context *ctx, xps_document *doc, xps_resource *dict, char **attp, fz_xml **tagp, char **urip) { if (*attp) { - fz_xml *rsrc = xps_parse_resource_reference(doc, dict, *attp, urip); + fz_xml *rsrc = xps_parse_resource_reference(ctx, doc, dict, *attp, urip); if (rsrc) { *attp = NULL; @@ -52,7 +52,7 @@ xps_resolve_resource_reference(xps_document *doc, xps_resource *dict, } static xps_resource * -xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *source_att) +xps_parse_remote_resource_dictionary(fz_context *ctx, xps_document *doc, char *base_uri, char *source_att) { char part_name[1024]; char part_uri[1024]; @@ -60,18 +60,17 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so xps_part *part; fz_xml *xml; char *s; - fz_context *ctx = doc->ctx; /* External resource dictionaries MUST NOT reference other resource dictionaries */ - xps_resolve_url(part_name, base_uri, source_att, sizeof part_name); - part = xps_read_part(doc, part_name); + xps_resolve_url(ctx, doc, part_name, base_uri, source_att, sizeof part_name); + part = xps_read_part(ctx, doc, part_name); fz_try(ctx) { - xml = fz_parse_xml(doc->ctx, part->data, part->size, 0); + xml = fz_parse_xml(ctx, part->data, part->size, 0); } fz_always(ctx) { - xps_free_part(doc, part); + xps_drop_part(ctx, doc, part); } fz_catch(ctx) { @@ -84,8 +83,8 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so if (strcmp(fz_xml_tag(xml), "ResourceDictionary")) { - fz_free_xml(doc->ctx, xml); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected ResourceDictionary element"); + fz_drop_xml(ctx, xml); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected ResourceDictionary element"); } fz_strlcpy(part_uri, part_name, sizeof part_uri); @@ -93,7 +92,7 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so if (s) s[1] = 0; - dict = xps_parse_resource_dictionary(doc, part_uri, xml); + dict = xps_parse_resource_dictionary(ctx, doc, part_uri, xml); if (dict) dict->base_xml = xml; /* pass on ownership */ @@ -101,7 +100,7 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so } xps_resource * -xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) +xps_parse_resource_dictionary(fz_context *ctx, xps_document *doc, char *base_uri, fz_xml *root) { xps_resource *head; xps_resource *entry; @@ -111,7 +110,7 @@ xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) source = fz_xml_att(root, "Source"); if (source) - return xps_parse_remote_resource_dictionary(doc, base_uri, source); + return xps_parse_remote_resource_dictionary(ctx, doc, base_uri, source); head = NULL; @@ -120,7 +119,7 @@ xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) key = fz_xml_att(node, "x:Key"); if (key) { - entry = fz_malloc_struct(doc->ctx, xps_resource); + entry = fz_malloc_struct(ctx, xps_resource); entry->name = key; entry->base_uri = NULL; entry->base_xml = NULL; @@ -132,29 +131,29 @@ xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) } if (head) - head->base_uri = fz_strdup(doc->ctx, base_uri); + head->base_uri = fz_strdup(ctx, base_uri); return head; } void -xps_free_resource_dictionary(xps_document *doc, xps_resource *dict) +xps_drop_resource_dictionary(fz_context *ctx, xps_document *doc, xps_resource *dict) { xps_resource *next; while (dict) { next = dict->next; if (dict->base_xml) - fz_free_xml(doc->ctx, dict->base_xml); + fz_drop_xml(ctx, dict->base_xml); if (dict->base_uri) - fz_free(doc->ctx, dict->base_uri); - fz_free(doc->ctx, dict); + fz_free(ctx, dict->base_uri); + fz_free(ctx, dict); dict = next; } } void -xps_print_resource_dictionary(xps_resource *dict) +xps_print_resource_dictionary(fz_context *ctx, xps_document *doc, xps_resource *dict) { while (dict) { @@ -164,7 +163,7 @@ xps_print_resource_dictionary(xps_resource *dict) if (dict->parent) { printf("PARENT = {\n"); - xps_print_resource_dictionary(dict->parent); + xps_print_resource_dictionary(ctx, doc, dict->parent); printf("}\n"); } dict = dict->next; diff --git a/source/xps/xps-tile.c b/source/xps/xps-tile.c index b65981a2..a74ef562 100644 --- a/source/xps/xps-tile.c +++ b/source/xps/xps-tile.c @@ -15,58 +15,61 @@ struct closure xps_resource *dict; fz_xml *root; void *user; - void (*func)(xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*); + void (*func)(fz_context *ctx, xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*); }; static void -xps_paint_tiling_brush_clipped(xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c) +xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c) { - fz_path *path = fz_new_path(doc->ctx); - fz_moveto(doc->ctx, path, viewbox->x0, viewbox->y0); - fz_lineto(doc->ctx, path, viewbox->x0, viewbox->y1); - fz_lineto(doc->ctx, path, viewbox->x1, viewbox->y1); - fz_lineto(doc->ctx, path, viewbox->x1, viewbox->y0); - fz_closepath(doc->ctx, path); - fz_clip_path(doc->dev, path, NULL, 0, ctm); - fz_free_path(doc->ctx, path); - c->func(doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user); - fz_pop_clip(doc->dev); + fz_device *dev = doc->dev; + + fz_path *path = fz_new_path(ctx); + fz_moveto(ctx, path, viewbox->x0, viewbox->y0); + fz_lineto(ctx, path, viewbox->x0, viewbox->y1); + fz_lineto(ctx, path, viewbox->x1, viewbox->y1); + fz_lineto(ctx, path, viewbox->x1, viewbox->y0); + fz_closepath(ctx, path); + fz_clip_path(ctx, dev, path, NULL, 0, ctm); + fz_drop_path(ctx, path); + c->func(ctx, doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user); + fz_pop_clip(ctx, dev); } static void -xps_paint_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c) +xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c) { fz_matrix ttm; - xps_paint_tiling_brush_clipped(doc, ctm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, ctm, viewbox, c); if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y) { ttm = *ctm; fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, 0), -1, 1); - xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c); } if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y) { ttm = *ctm; fz_pre_scale(fz_pre_translate(&ttm, 0, viewbox->y1 * 2), 1, -1); - xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c); } if (tile_mode == TILE_FLIP_X_Y) { ttm = *ctm; fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, viewbox->y1 * 2), -1, -1); - xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c); } } void -xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, - void (*func)(xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user) + void (*func)(fz_context *ctx, xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user) { + fz_device *dev = doc->dev; fz_xml *node; struct closure c; @@ -105,27 +108,27 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a transform_tag = fz_xml_down(node); } - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&transform, &transform, ctm); viewbox = fz_unit_rect; if (viewbox_att) - xps_parse_rectangle(doc, viewbox_att, &viewbox); + xps_parse_rectangle(ctx, doc, viewbox_att, &viewbox); viewport = fz_unit_rect; if (viewport_att) - xps_parse_rectangle(doc, viewport_att, &viewport); + xps_parse_rectangle(ctx, doc, viewport_att, &viewport); if (fabsf(viewport.x1 - viewport.x0) < 0.01f || fabsf(viewport.y1 - viewport.y0) < 0.01f) - fz_warn(doc->ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0); + fz_warn(ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0); else if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f || fabsf(viewbox.y1 - viewbox.y0) < 0.01f) - fz_warn(doc->ctx, "not drawing tile for viewbox size %.4f x %.4f", viewbox.x1 - viewbox.x0, viewbox.y1 - viewbox.y0); + fz_warn(ctx, "not drawing tile for viewbox size %.4f x %.4f", viewbox.x1 - viewbox.x0, viewbox.y1 - viewbox.y0); /* some sanity checks on the viewport/viewbox size */ if (fabsf(viewport.x1 - viewport.x0) < 0.01f) return; @@ -159,7 +162,7 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y) ystep *= 2; - xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL); + xps_begin_opacity(ctx, doc, &transform, area, base_uri, dict, opacity_att, NULL); fz_pre_translate(&transform, viewport.x0, viewport.y0); fz_pre_scale(&transform, xscale, yscale); @@ -185,9 +188,9 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a fz_rect bigview = viewbox; bigview.x1 = bigview.x0 + xstep; bigview.y1 = bigview.y0 + ystep; - fz_begin_tile(doc->dev, &local_area, &bigview, xstep, ystep, &transform); - xps_paint_tiling_brush(doc, &transform, &viewbox, tile_mode, &c); - fz_end_tile(doc->dev); + fz_begin_tile(ctx, dev, &local_area, &bigview, xstep, ystep, &transform); + xps_paint_tiling_brush(ctx, doc, &transform, &viewbox, tile_mode, &c); + fz_end_tile(ctx, dev); } else { @@ -198,28 +201,28 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a { fz_matrix ttm = transform; fz_pre_translate(&ttm, xstep * x, ystep * y); - xps_paint_tiling_brush(doc, &ttm, &viewbox, tile_mode, &c); + xps_paint_tiling_brush(ctx, doc, &ttm, &viewbox, tile_mode, &c); } } } } else { - xps_paint_tiling_brush(doc, &transform, &viewbox, tile_mode, &c); + xps_paint_tiling_brush(ctx, doc, &transform, &viewbox, tile_mode, &c); } - xps_end_opacity(doc, base_uri, dict, opacity_att, NULL); + xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL); } static void -xps_paint_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_paint_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, void *visual_tag) { - xps_parse_element(doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag); + xps_parse_element(ctx, doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag); } void -xps_parse_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { fz_xml *node; @@ -237,18 +240,19 @@ xps_parse_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a } visual_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &visual_att, &visual_tag, &visual_uri); + xps_resolve_resource_reference(ctx, doc, dict, &visual_att, &visual_tag, &visual_uri); if (visual_tag) { - xps_parse_tiling_brush(doc, ctm, area, + xps_parse_tiling_brush(ctx, doc, ctm, area, visual_uri, dict, root, xps_paint_visual_brush, visual_tag); } } void -xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) +xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { + fz_device *dev = doc->dev; xps_resource *new_dict = NULL; fz_xml *node; char *opacity_mask_uri; @@ -277,11 +281,11 @@ xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, c { if (new_dict) { - fz_warn(doc->ctx, "ignoring follow-up resource dictionaries"); + fz_warn(ctx, "ignoring follow-up resource dictionaries"); } else { - new_dict = xps_parse_resource_dictionary(doc, base_uri, fz_xml_down(node)); + new_dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node)); if (new_dict) { new_dict->parent = dict; @@ -299,41 +303,41 @@ xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, c } opacity_mask_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &clip_att, &clip_tag, NULL); - xps_resolve_resource_reference(doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&transform, &transform, ctm); if (navigate_uri_att) - xps_add_link(doc, area, base_uri, navigate_uri_att); + xps_add_link(ctx, doc, area, base_uri, navigate_uri_att); if (clip_att || clip_tag) - xps_clip(doc, &transform, dict, clip_att, clip_tag); + xps_clip(ctx, doc, &transform, dict, clip_att, clip_tag); - xps_begin_opacity(doc, &transform, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_begin_opacity(ctx, doc, &transform, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); for (node = fz_xml_down(root); node; node = fz_xml_next(node)) { - xps_parse_element(doc, &transform, area, base_uri, dict, node); + xps_parse_element(ctx, doc, &transform, area, base_uri, dict, node); } - xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (clip_att || clip_tag) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); if (new_dict) - xps_free_resource_dictionary(doc, new_dict); + xps_drop_resource_dictionary(ctx, doc, new_dict); } void -xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page) +xps_parse_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_page *page) { fz_xml *node; xps_resource *dict; @@ -342,7 +346,7 @@ xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page) char *s; fz_matrix scm; - fz_strlcpy(base_uri, page->name, sizeof base_uri); + fz_strlcpy(base_uri, page->fix->name, sizeof base_uri); s = strrchr(base_uri, '/'); if (s) s[1] = 0; @@ -356,35 +360,36 @@ xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page) return; area = fz_unit_rect; - fz_transform_rect(&area, fz_scale(&scm, page->width, page->height)); + fz_transform_rect(&area, fz_scale(&scm, page->fix->width, page->fix->height)); for (node = fz_xml_down(page->root); node; node = fz_xml_next(node)) { if (fz_xml_is_tag(node, "FixedPage.Resources") && fz_xml_down(node)) { if (dict) - fz_warn(doc->ctx, "ignoring follow-up resource dictionaries"); + fz_warn(ctx, "ignoring follow-up resource dictionaries"); else - dict = xps_parse_resource_dictionary(doc, base_uri, fz_xml_down(node)); + dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node)); } - xps_parse_element(doc, ctm, &area, base_uri, dict, node); + xps_parse_element(ctx, doc, ctm, &area, base_uri, dict, node); } if (dict) - xps_free_resource_dictionary(doc, dict); + xps_drop_resource_dictionary(ctx, doc, dict); } void -xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +xps_run_page(fz_context *ctx, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { + xps_document *doc = page->doc; fz_matrix page_ctm = *ctm; fz_pre_scale(&page_ctm, 72.0f / 96.0f, 72.0f / 96.0f); doc->cookie = cookie; doc->dev = dev; - xps_parse_fixed_page(doc, &page_ctm, page); + xps_parse_fixed_page(ctx, doc, &page_ctm, page); doc->cookie = NULL; doc->dev = NULL; - page->links_resolved = 1; + page->fix->links_resolved = 1; } diff --git a/source/xps/xps-util.c b/source/xps/xps-util.c index a74dc30f..5d708eaa 100644 --- a/source/xps/xps-util.c +++ b/source/xps/xps-util.c @@ -81,7 +81,7 @@ skip_authority(char *path) #define SEP(x) ((x)=='/' || (x) == 0) static char * -xps_clean_path(char *name) +clean_path(char *name) { char *p, *q, *dotdot, *start; int rooted; @@ -138,7 +138,7 @@ xps_clean_path(char *name) } void -xps_resolve_url(char *output, char *base_uri, char *path, int output_size) +xps_resolve_url(fz_context *ctx, xps_document *doc, char *output, char *base_uri, char *path, int output_size) { char *p = skip_authority(skip_scheme(path)); @@ -153,13 +153,11 @@ xps_resolve_url(char *output, char *base_uri, char *path, int output_size) fz_strlcat(output, "/", output_size); fz_strlcat(output, path, output_size); } - xps_clean_path(output); + clean_path(output); } int -xps_url_is_remote(char *path) +xps_url_is_remote(fz_context *ctx, xps_document *doc, char *path) { - char *p = skip_authority(skip_scheme(path)); - - return p != path; + return path != skip_authority(skip_scheme(path)); } diff --git a/source/xps/xps-zip.c b/source/xps/xps-zip.c index e3d006ba..3759c4b6 100644 --- a/source/xps/xps-zip.c +++ b/source/xps/xps-zip.c @@ -1,45 +1,44 @@ #include "mupdf/xps.h" -static void xps_init_document(xps_document *doc); +static void xps_init_document(fz_context *ctx, xps_document *doc); xps_part * -xps_new_part(xps_document *doc, char *name, unsigned char *data, int size) +xps_new_part(fz_context *ctx, xps_document *doc, char *name, unsigned char *data, int size) { xps_part *part; - part = fz_malloc_struct(doc->ctx, xps_part); - fz_try(doc->ctx) + part = fz_malloc_struct(ctx, xps_part); + fz_try(ctx) { - part->name = fz_strdup(doc->ctx, name); + part->name = fz_strdup(ctx, name); part->data = data; part->size = size; } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_free(doc->ctx, part->name); - fz_free(doc->ctx, part->data); - fz_free(doc->ctx, part); - fz_rethrow(doc->ctx); + fz_free(ctx, part->name); + fz_free(ctx, part->data); + fz_free(ctx, part); + fz_rethrow(ctx); } return part; } void -xps_free_part(xps_document *doc, xps_part *part) +xps_drop_part(fz_context *ctx, xps_document *doc, xps_part *part) { - fz_free(doc->ctx, part->name); - fz_free(doc->ctx, part->data); - fz_free(doc->ctx, part); + fz_free(ctx, part->name); + fz_free(ctx, part->data); + fz_free(ctx, part); } /* * Read and interleave split parts from a ZIP file. */ xps_part * -xps_read_part(xps_document *doc, char *partname) +xps_read_part(fz_context *ctx, xps_document *doc, char *partname) { - fz_context *ctx = doc->ctx; fz_archive *zip = doc->zip; fz_buffer *buf, *tmp; char path[2048]; @@ -85,6 +84,7 @@ xps_read_part(xps_document *doc, char *partname) } else { + fz_drop_buffer(ctx, buf); fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find all pieces for part '%s'", partname); } } @@ -95,25 +95,26 @@ xps_read_part(xps_document *doc, char *partname) /* take over the data */ data = buf->data; - size = buf->len; + /* size doesn't include the added zero-terminator */ + size = buf->len - 1; fz_free(ctx, buf); - return xps_new_part(doc, partname, data, size); + return xps_new_part(ctx, doc, partname, data, size); } int -xps_has_part(xps_document *doc, char *name) +xps_has_part(fz_context *ctx, xps_document *doc, char *name) { char buf[2048]; if (name[0] == '/') name++; - if (fz_has_archive_entry(doc->ctx, doc->zip, name)) + if (fz_has_archive_entry(ctx, doc->zip, name)) return 1; sprintf(buf, "%s/[0].piece", name); - if (fz_has_archive_entry(doc->ctx, doc->zip, buf)) + if (fz_has_archive_entry(ctx, doc->zip, buf)) return 1; sprintf(buf, "%s/[0].last.piece", name); - if (fz_has_archive_entry(doc->ctx, doc->zip, buf)) + if (fz_has_archive_entry(ctx, doc->zip, buf)) return 1; return 0; } @@ -124,17 +125,16 @@ xps_open_document_with_directory(fz_context *ctx, const char *directory) xps_document *doc; doc = fz_malloc_struct(ctx, xps_document); - xps_init_document(doc); - doc->ctx = ctx; + xps_init_document(ctx, doc); doc->zip = fz_open_directory(ctx, directory); fz_try(ctx) { - xps_read_page_list(doc); + xps_read_page_list(ctx, doc); } fz_catch(ctx) { - xps_close_document(doc); + xps_close_document(ctx, doc); fz_rethrow(ctx); } @@ -147,17 +147,16 @@ xps_open_document_with_stream(fz_context *ctx, fz_stream *file) xps_document *doc; doc = fz_malloc_struct(ctx, xps_document); - xps_init_document(doc); - doc->ctx = ctx; - doc->zip = fz_open_archive_with_stream(ctx, file); + xps_init_document(ctx, doc); fz_try(ctx) { - xps_read_page_list(doc); + doc->zip = fz_open_archive_with_stream(ctx, file); + xps_read_page_list(ctx, doc); } fz_catch(ctx) { - xps_close_document(doc); + xps_close_document(ctx, doc); fz_rethrow(ctx); } @@ -183,26 +182,19 @@ xps_open_document(fz_context *ctx, const char *filename) } file = fz_open_file(ctx, filename); - if (!file) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); fz_try(ctx) - { doc = xps_open_document_with_stream(ctx, file); - } fz_always(ctx) - { - fz_close(file); - } + fz_drop_stream(ctx, file); fz_catch(ctx) - { fz_rethrow_message(ctx, "cannot load document '%s'", filename); - } + return doc; } void -xps_close_document(xps_document *doc) +xps_close_document(fz_context *ctx, xps_document *doc) { xps_font_cache *font, *next; @@ -210,26 +202,26 @@ xps_close_document(xps_document *doc) return; if (doc->zip) - fz_close_archive(doc->ctx, doc->zip); + fz_drop_archive(ctx, doc->zip); font = doc->font_table; while (font) { next = font->next; - fz_drop_font(doc->ctx, font->font); - fz_free(doc->ctx, font->name); - fz_free(doc->ctx, font); + fz_drop_font(ctx, font->font); + fz_free(ctx, font->name); + fz_free(ctx, font); font = next; } - xps_free_page_list(doc); + xps_drop_page_list(ctx, doc); - fz_free(doc->ctx, doc->start_part); - fz_free(doc->ctx, doc); + fz_free(ctx, doc->start_part); + fz_free(ctx, doc); } static int -xps_meta(xps_document *doc, int key, void *ptr, int size) +xps_meta(fz_context *ctx, xps_document *doc, int key, void *ptr, int size) { switch (key) { @@ -242,24 +234,12 @@ xps_meta(xps_document *doc, int key, void *ptr, int size) } static void -xps_rebind(xps_document *doc, fz_context *ctx) -{ - doc->ctx = ctx; - fz_rebind_archive(doc->zip, ctx); - fz_rebind_device(doc->dev, ctx); -} - -static void -xps_init_document(xps_document *doc) +xps_init_document(fz_context *ctx, xps_document *doc) { + doc->super.refs = 1; doc->super.close = (fz_document_close_fn *)xps_close_document; doc->super.load_outline = (fz_document_load_outline_fn *)xps_load_outline; doc->super.count_pages = (fz_document_count_pages_fn *)xps_count_pages; doc->super.load_page = (fz_document_load_page_fn *)xps_load_page; - doc->super.load_links = (fz_document_load_links_fn *)xps_load_links; - doc->super.bound_page = (fz_document_bound_page_fn *)xps_bound_page; - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)xps_run_page; - doc->super.free_page = (fz_document_free_page_fn *)xps_free_page; doc->super.meta = (fz_document_meta_fn *)xps_meta; - doc->super.rebind = (fz_document_rebind_fn *)xps_rebind; } |