static int xps_find_doc_props_path(xps_context *ctx, char path[1024]) { xml_element *root; int code = xps_open_and_parse(ctx, "/[Content_Types].xml", &root); if (code != fz_okay) return code; *path = '\0'; if (root && !strcmp(xml_tag(root), "Types")) { xml_element *item; for (item = xml_down(root); item; item = xml_next(item)) { if (!strcmp(xml_tag(item), "Override") && xml_att(item, "ContentType") && !strcmp(xml_att(item, "ContentType"), CONTENT_TYPE_CORE_PROPS) && xml_att(item, "PartName")) { fz_strlcpy(path, xml_att(item, "PartName"), 1024); } } } else code = fz_throw("couldn't parse part '[Content_Types].xml'"); xml_free_element(root); return code; }
static int xps_load_fixed_page(xps_context *ctx, xps_page *page) { xps_part *part; xml_element *root; char *width_att; char *height_att; part = xps_read_part(ctx, page->name); if (!part) return fz_rethrow(-1, "cannot read zip part '%s'", page->name); root = xml_parse_document(part->data, part->size); if (!root) return fz_rethrow(-1, "cannot parse xml part '%s'", page->name); xps_free_part(ctx, part); if (strcmp(xml_tag(root), "FixedPage")) return fz_throw("expected FixedPage element (found %s)", xml_tag(root)); width_att = xml_att(root, "Width"); if (!width_att) return fz_throw("FixedPage missing required attribute: Width"); height_att = xml_att(root, "Height"); if (!height_att) return fz_throw("FixedPage missing required attribute: Height"); page->width = atoi(width_att); page->height = atoi(height_att); page->root = root; return 0; }
static int xps_find_doc_props_path(xps_context *ctx, char path[1024]) { xml_element *root; int code = xps_open_and_parse(ctx, "/_rels/.rels", &root); if (code != fz_okay) return code; *path = '\0'; if (!strcmp(xml_tag(root), "Relationships")) { xml_element *item; for (item = xml_down(root); item; item = xml_next(item)) { if (!strcmp(xml_tag(item), "Relationship") && xml_att(item, "Type") && !strcmp(xml_att(item, "Type"), REL_CORE_PROPERTIES) && xml_att(item, "Target")) { xps_absolute_path(path, "", xml_att(item, "Target"), 1024); } } } else code = fz_error_make(ctx->ctx, "couldn't parse part '/_rels/.rels'"); xml_free_element(ctx->ctx, root); return code; }
static xps_resource * xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *source_att) { char part_name[1024]; char part_uri[1024]; xps_resource *dict; xps_part *part; xml_element *xml; char *s; /* 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); xml = xml_parse_document(doc->ctx, part->data, part->size); xps_free_part(doc, part); if (strcmp(xml_tag(xml), "ResourceDictionary")) { xml_free_element(doc->ctx, xml); fz_throw(doc->ctx, "expected ResourceDictionary element (found %s)", xml_tag(xml)); } fz_strlcpy(part_uri, part_name, sizeof part_uri); s = strrchr(part_uri, '/'); if (s) s[1] = 0; dict = xps_parse_resource_dictionary(doc, part_uri, xml); if (dict) dict->base_xml = xml; /* pass on ownership */ return dict; }
static int xps_parse_remote_resource_dictionary(xps_context *ctx, xps_resource **dictp, char *base_uri, char *source_att) { char part_name[1024]; char part_uri[1024]; xps_resource *dict; xps_part *part; xml_element *xml; char *s; int code; /* External resource dictionaries MUST NOT reference other resource dictionaries */ xps_absolute_path(part_name, base_uri, source_att, sizeof part_name); part = xps_read_part(ctx, part_name); if (!part) { return fz_throw("cannot find remote resource part '%s'", part_name); } xml = xml_parse_document(part->data, part->size); if (!xml) { xps_free_part(ctx, part); return fz_rethrow(-1, "cannot parse xml"); } if (strcmp(xml_tag(xml), "ResourceDictionary")) { xml_free_element(xml); xps_free_part(ctx, part); return fz_throw("expected ResourceDictionary element (found %s)", xml_tag(xml)); } fz_strlcpy(part_uri, part_name, sizeof part_uri); s = strrchr(part_uri, '/'); if (s) s[1] = 0; code = xps_parse_resource_dictionary(ctx, &dict, part_uri, xml); if (code) { xml_free_element(xml); xps_free_part(ctx, part); return fz_rethrow(code, "cannot parse remote resource dictionary: %s", part_uri); } dict->base_xml = xml; /* pass on ownership */ xps_free_part(ctx, part); *dictp = dict; return fz_okay; }
static void xps_parse_path_figure(fz_context *doc, fz_path *path, xml_element *root, int stroking) { xml_element *node; char *is_closed_att; char *start_point_att; char *is_filled_att; int is_closed = 0; int is_filled = 1; float start_x = 0; float start_y = 0; int skipped_stroke = 0; is_closed_att = xml_att(root, "IsClosed"); start_point_att = xml_att(root, "StartPoint"); is_filled_att = xml_att(root, "IsFilled"); if (is_closed_att) is_closed = !strcmp(is_closed_att, "true"); if (is_filled_att) is_filled = !strcmp(is_filled_att, "true"); if (start_point_att) xps_get_point(start_point_att, &start_x, &start_y); if (!stroking && !is_filled) /* not filled, when filling */ return; fz_moveto(doc, path, start_x, start_y); for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "ArcSegment")) xps_parse_arc_segment(doc, path, node, stroking, &skipped_stroke); if (!strcmp(xml_tag(node), "PolyBezierSegment")) xps_parse_poly_bezier_segment(doc, path, node, stroking, &skipped_stroke); if (!strcmp(xml_tag(node), "PolyLineSegment")) xps_parse_poly_line_segment(doc, path, node, stroking, &skipped_stroke); if (!strcmp(xml_tag(node), "PolyQuadraticBezierSegment")) xps_parse_poly_quadratic_bezier_segment(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... */ else fz_closepath(doc, path); /* no skipped segments, safe to closepath properly */ } }
void xps_parse_element(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, xml_element *node) { if (doc->cookie && doc->cookie->abort) return; if (!strcmp(xml_tag(node), "Path")) xps_parse_path(doc, ctm, base_uri, dict, node); if (!strcmp(xml_tag(node), "Glyphs")) xps_parse_glyphs(doc, ctm, base_uri, dict, node); if (!strcmp(xml_tag(node), "Canvas")) xps_parse_canvas(doc, ctm, area, base_uri, dict, node); /* skip unknown tags (like Foo.Resources and similar) */ }
static void xps_parse_metadata_imp(xps_context *ctx, xml_element *item) { while (item) { xps_parse_metadata_imp(ctx, xml_down(item)); if (!strcmp(xml_tag(item), "Relationship")) { char *target = xml_att(item, "Target"); char *type = xml_att(item, "Type"); if (target && type) { char tgtbuf[1024]; xps_absolute_path(tgtbuf, ctx->base_uri, target, sizeof tgtbuf); if (!strcmp(type, REL_START_PART)) ctx->start_part = fz_strdup(tgtbuf); } } if (!strcmp(xml_tag(item), "DocumentReference")) { char *source = xml_att(item, "Source"); if (source) { char srcbuf[1024]; xps_absolute_path(srcbuf, ctx->base_uri, source, sizeof srcbuf); xps_add_fixed_document(ctx, srcbuf); } } if (!strcmp(xml_tag(item), "PageContent")) { char *source = xml_att(item, "Source"); char *width_att = xml_att(item, "Width"); char *height_att = xml_att(item, "Height"); int width = width_att ? atoi(width_att) : 0; int height = height_att ? atoi(height_att) : 0; if (source) { char srcbuf[1024]; xps_absolute_path(srcbuf, ctx->base_uri, source, sizeof srcbuf); xps_add_fixed_page(ctx, srcbuf, width, height); } } item = xml_next(item); } }
void xps_parse_visual_brush(xps_context *ctx, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, xml_element *root) { xml_element *node; char *visual_uri; char *visual_att; xml_element *visual_tag = NULL; visual_att = xml_att(root, "Visual"); for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "VisualBrush.Visual")) visual_tag = xml_down(node); } visual_uri = base_uri; xps_resolve_resource_reference(ctx, dict, &visual_att, &visual_tag, &visual_uri); if (visual_tag) { xps_parse_tiling_brush(ctx, ctm, area, visual_uri, dict, root, xps_paint_visual_brush, visual_tag); } }
static fz_outline * xps_parse_document_structure(xps_context *ctx, xml_element *root) { xml_element *node; if (!strcmp(xml_tag(root), "DocumentStructure")) { node = xml_down(root); if (!strcmp(xml_tag(node), "DocumentStructure.Outline")) { node = xml_down(node); if (!strcmp(xml_tag(node), "DocumentOutline")) return xps_parse_document_outline(ctx, node); } } return NULL; }
void indentedtag(const char *name) { xstartline(); xml_tag(name); xindent(); xnewline(); }
static void xps_parse_outline_imp(xps_outline **outlinep, xml_element *item, char *base_uri) { int lastLevel = 0; for (; item; item = xml_next(item)) { char *description, *target; int level; char tgtbuf[1024]; xps_outline *outline; xps_parse_outline_imp(outlinep, xml_down(item), base_uri); if (strcmp(xml_tag(item), "OutlineEntry") != 0 || !(description = xml_att(item, "Description")) || !(target = xml_att(item, "OutlineTarget"))) continue; if (xml_att(item, "OutlineLevel")) level = atoi(xml_att(item, "OutlineLevel")); else level = lastLevel; xps_absolute_path(tgtbuf, base_uri, target, sizeof(tgtbuf)); outline = xps_new_outline(description, tgtbuf); if (!*outlinep) *outlinep = outline; else if (level > lastLevel) xps_get_insertion_point(*outlinep, lastLevel)->child = outline; else xps_get_insertion_point(*outlinep, level)->next = outline; lastLevel = level; } }
void xps_parse_brush(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, xml_element *node) { if (doc->cookie && doc->cookie->abort) return; /* SolidColorBrushes are handled in a special case and will never show up here */ if (!strcmp(xml_tag(node), "ImageBrush")) xps_parse_image_brush(doc, ctm, area, base_uri, dict, node); else if (!strcmp(xml_tag(node), "VisualBrush")) xps_parse_visual_brush(doc, ctm, area, base_uri, dict, node); else if (!strcmp(xml_tag(node), "LinearGradientBrush")) xps_parse_linear_gradient_brush(doc, ctm, area, base_uri, dict, node); else if (!strcmp(xml_tag(node), "RadialGradientBrush")) xps_parse_radial_gradient_brush(doc, ctm, area, base_uri, dict, node); else fz_warn(doc->ctx, "unknown brush tag: %s", xml_tag(node)); }
xml_element *Floor::xml(xml_document *document) { // new on 011102 xml_element *floor_element = create_xml_element(xml_tag(),document); if (previous_mouse != NULL && tt_dumping_background != NULL) { // new on 131202 previous_mouse->add_xml(floor_element,L"PreviousMouse",document); }; // folllowing new on 070103 - checked through all state variables if (body_cubby != NULL) { body_cubby->add_xml(floor_element,L"MainBox",document); if (room != NULL) { // only needed if in thought bubble xml_append_child(room->xml_path(document),floor_element); }; }; if (alternative_body_cubbies != NULL) { // new on 151204 xml_element *alternative_body_cubbies_element = create_xml_element(L"AlternativesForMyBox",document); alternative_body_cubbies->add_xml(alternative_body_cubbies_element,document); xml_append_child(alternative_body_cubbies_element,floor_element); // new on 161204 }; if (initial_robot != NULL) { initial_robot->add_xml(floor_element,L"InitialRobot",document); }; if (toolbox_status != TOOLBOX_CACHE_STATUS_UNINITIALIZED) { xml_set_attribute(floor_element,L"ToolBoxStatusCode",(int) toolbox_status); }; if (items != NULL) { // moved here so these don't generate include files if the above refers to them (or their parts) xml_element *on_floor_element = create_xml_element(L"OnFloor",document); xml_set_attribute(on_floor_element,L"Z",current_priority); // only need this if there are some items on the floor #if TT_DEBUG_ON if (tt_debug_mode == 160703) { tt_error_file() << "About to dump floor items." << endl; }; #endif items->add_xml(on_floor_element,document,NULL,TRUE); xml_append_child(on_floor_element,floor_element); // moved here on 190804 #if TT_DEBUG_ON if (tt_debug_mode == 160703) { tt_error_file() << "Done dumping floor items." << endl; }; #endif // following not needed as of 160703 so restored above // new on 120703 so that mice who might cause others to not dump as an include file are processed first // what about running robots?? -- ok since tt_running_robots is processed first - right? // items->add_xml(on_floor_element,document,NULL,TRUE,FALSE,first_to_be_dumped); //items->add_xml(on_floor_element,document,NULL,TRUE,FALSE,not_first_to_be_dumped); }; xml_set_attribute(floor_element,L"FloorID",floor_id); if (at_left_wall) { xml_set_attribute(floor_element,L"AtLeftWall",1); }; if (at_right_wall) { xml_set_attribute(floor_element,L"AtRightWall",1); }; if (at_front_wall) { xml_set_attribute(floor_element,L"AtFrontWall",1); }; // add_xml(floor_element,document); // new on 090404 -- this wasn't needed since all this containment stuff is now computed from sit_llx etc on load return(floor_element); };
xml_element * xps_lookup_alternate_content(xml_element *node) { for (node = xml_down(node); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "mc:Choice") && xml_att(node, "Requires")) { char list[64]; char *next = list, *item; fz_strlcpy(list, xml_att(node, "Requires"), sizeof(list)); while ((item = fz_strsep(&next, " \t\r\n")) && (!*item || !strcmp(item, "xps"))); if (!item) return xml_down(node); } else if (!strcmp(xml_tag(node), "mc:Fallback")) return xml_down(node); } return NULL; }
void nxml_doc(struct docstring *doc) { if (!doc->short_s) return; indentedtag_start("documentation"); xml_attr_loc(doc->loc); xml_tag_end(); xnewline(); xml_tag("short"); xqputs(doc->short_s); xml_pop(); xnewline(); if (doc->long_s) { xml_tag("long"); xqputs(doc->long_s); xml_pop(); xnewline(); } indentedtag_pop(); }
static void xps_parse_names_imp(xps_named_dest **destsp, xps_context *ctx, xps_document *doc, xml_element *item, char *base_uri, int page) { char tgtbuf[1024]; for (; item; item = xml_next(item)) { if (!strcmp(xml_tag(item), "PageContent") && xml_att(item, "Source") && page == 0) { int i; xps_page *page; xps_absolute_path(tgtbuf, base_uri, xml_att(item, "Source"), sizeof(tgtbuf)); for (page = ctx->first_page, i = 0; page; page = page->next, i++) { if (strcmp(page->name, tgtbuf) != 0) continue; xps_parse_names_imp(destsp, ctx, doc, xml_down(item), base_uri, i + 1); break; } } else if (!strcmp(xml_tag(item), "LinkTarget") && xml_att(item, "Name") && page != 0) { xps_named_dest *dest; fz_strlcpy(tgtbuf, doc->name, sizeof(tgtbuf)); fz_strlcat(tgtbuf, "#", sizeof(tgtbuf)); fz_strlcat(tgtbuf, xml_att(item, "Name"), sizeof(tgtbuf)); dest = xps_new_named_dest(tgtbuf, page); if (!*destsp) *destsp = dest; else { xps_named_dest *next; for (next = *destsp; next->next; next = next->next); next->next = dest; } } else xps_parse_names_imp(destsp, ctx, doc, xml_down(item), base_uri, page); } }
static PyObject* py_xml_tag(PyObject *self, PyObject *args) { int n; if (!PyArg_ParseTuple(args, "i:xml_tag", &n)) return NULL; char* val = new char[81]; int iok = xml_tag(n, val); if (iok < 0) return reportError(iok); PyObject* r = Py_BuildValue("s",val); delete val; return r; }
static int xps_read_and_process_document_outline(xps_outline **outlinep, xps_context *ctx, xps_document *doc) { char base_uri[1024]; xml_element *root; xml_element *item; int code = fz_okay; xps_rels_for_part(base_uri, doc->name, sizeof(base_uri)); code = xps_open_and_parse(ctx, base_uri, &root); if (code != fz_okay) return code; *strstr(base_uri, "/_rels/") = '\0'; for (item = root; item; item = xml_next(item)) { xml_element *relItem; if (strcmp(xml_tag(item), "Relationships") != 0) continue; for (relItem = xml_down(item); relItem; relItem = xml_next(relItem)) { char *target, *type; if (!strcmp(xml_tag(relItem), "Relationship") && (target = xml_att(relItem, "Target")) && (type = xml_att(relItem, "Type")) && !strcmp(type, REL_DOC_STRUCTURE)) { char tgtbuf[1024]; xps_absolute_path(tgtbuf, base_uri, target, sizeof(tgtbuf)); code = xps_parse_outline_structure(outlinep, ctx, tgtbuf); } } } xml_free_element(root); return code; }
void xps_parse_matrix_transform(xps_document *doc, xml_element *root, fz_matrix *matrix) { char *transform; *matrix = fz_identity; if (!strcmp(xml_tag(root), "MatrixTransform")) { transform = xml_att(root, "Matrix"); if (transform) xps_parse_render_transform(doc, transform, matrix); } }
static fz_outline * xps_parse_document_outline(xps_context *ctx, xml_element *root) { xml_element *node; fz_outline *head = NULL, *entry, *tail; int last_level = 1, this_level; for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "OutlineEntry")) { char *level = xml_att(node, "OutlineLevel"); char *target = xml_att(node, "OutlineTarget"); char *description = xml_att(node, "Description"); /* SumatraPDF: allow target-less outline entries */ if (!description) continue; entry = fz_malloc(ctx->ctx, sizeof *entry); entry->title = fz_strdup(ctx->ctx, description); entry->page = -1; /* SumatraPDF: extended outline actions */ entry->data = target ? fz_strdup(ctx->ctx, target) : NULL; if (target && !xps_is_external_uri(target)) entry->page = xps_find_link_target(ctx, target); entry->free_data = fz_free; entry->down = NULL; entry->next = NULL; this_level = level ? atoi(level) : 1; entry->is_open = this_level == 1; /* SumatraPDF: support expansion states */ if (!head) { head = entry; } else { tail = xps_find_last_outline_at_level(head, 1, this_level); if (this_level > last_level) tail->down = entry; else tail->next = entry; } last_level = this_level; } } return head; }
void xps_end_opacity(xps_document *doc, char *base_uri, xps_resource *dict, char *opacity_att, xml_element *opacity_mask_tag) { if (!opacity_att && !opacity_mask_tag) return; if (doc->opacity_top > 0) doc->opacity_top--; if (opacity_mask_tag) { if (strcmp(xml_tag(opacity_mask_tag), "SolidColorBrush")) fz_pop_clip(doc->dev); } }
void xps_begin_opacity(xps_document *doc, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, char *opacity_att, xml_element *opacity_mask_tag) { float opacity; if (!opacity_att && !opacity_mask_tag) return; opacity = 1; if (opacity_att) opacity = fz_atof(opacity_att); if (opacity_mask_tag && !strcmp(xml_tag(opacity_mask_tag), "SolidColorBrush")) { char *scb_opacity_att = xml_att(opacity_mask_tag, "Opacity"); char *scb_color_att = xml_att(opacity_mask_tag, "Color"); if (scb_opacity_att) opacity = opacity * fz_atof(scb_opacity_att); if (scb_color_att) { fz_colorspace *colorspace; float samples[32]; xps_parse_color(doc, base_uri, scb_color_att, &colorspace, samples); opacity = opacity * samples[0]; } opacity_mask_tag = NULL; } if (doc->opacity_top + 1 < nelem(doc->opacity)) { doc->opacity[doc->opacity_top + 1] = doc->opacity[doc->opacity_top] * opacity; doc->opacity_top++; } 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); } }
void xps_parse_fixed_page(xps_context *ctx, fz_matrix ctm, xps_page *page) { xml_element *node; xps_resource *dict; char base_uri[1024]; fz_rect area; char *s; int code; fz_strlcpy(base_uri, page->name, sizeof base_uri); s = strrchr(base_uri, '/'); if (s) s[1] = 0; dict = NULL; ctx->opacity_top = 0; ctx->opacity[0] = 1; if (!page->root) return; area = fz_transform_rect(fz_scale(page->width, page->height), fz_unit_rect); for (node = xml_down(page->root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "FixedPage.Resources") && xml_down(node)) { code = xps_parse_resource_dictionary(ctx, &dict, base_uri, xml_down(node)); if (code) fz_catch(code, "cannot load FixedPage.Resources"); } xps_parse_element(ctx, ctm, area, base_uri, dict, node); } if (dict) { xps_free_resource_dictionary(ctx, dict); } }
void xps_parse_canvas(xps_context *ctx, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, xml_element *root) { xps_resource *new_dict = NULL; xml_element *node; char *opacity_mask_uri; int code; char *transform_att; char *clip_att; char *opacity_att; char *opacity_mask_att; xml_element *transform_tag = NULL; xml_element *clip_tag = NULL; xml_element *opacity_mask_tag = NULL; fz_matrix transform; transform_att = xml_att(root, "RenderTransform"); clip_att = xml_att(root, "Clip"); opacity_att = xml_att(root, "Opacity"); opacity_mask_att = xml_att(root, "OpacityMask"); for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "Canvas.Resources") && xml_down(node)) { code = xps_parse_resource_dictionary(ctx, &new_dict, base_uri, xml_down(node)); if (code) fz_catch(code, "cannot load Canvas.Resources"); else { new_dict->parent = dict; dict = new_dict; } } if (!strcmp(xml_tag(node), "Canvas.RenderTransform")) transform_tag = xml_down(node); if (!strcmp(xml_tag(node), "Canvas.Clip")) clip_tag = xml_down(node); if (!strcmp(xml_tag(node), "Canvas.OpacityMask")) opacity_mask_tag = xml_down(node); } opacity_mask_uri = base_uri; xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL); xps_resolve_resource_reference(ctx, dict, &clip_att, &clip_tag, NULL); xps_resolve_resource_reference(ctx, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); transform = fz_identity; if (transform_att) xps_parse_render_transform(ctx, transform_att, &transform); if (transform_tag) xps_parse_matrix_transform(ctx, transform_tag, &transform); ctm = fz_concat(transform, ctm); if (clip_att || clip_tag) xps_clip(ctx, ctm, dict, clip_att, clip_tag); xps_begin_opacity(ctx, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); for (node = xml_down(root); node; node = xml_next(node)) { xps_parse_element(ctx, ctm, area, base_uri, dict, node); } xps_end_opacity(ctx, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (clip_att || clip_tag) fz_pop_clip(ctx->dev); if (new_dict) xps_free_resource_dictionary(ctx, new_dict); }
void xmlmethods(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[]) { int j, m, iok = 0; char* file, *key, *val, *nm; int job = getInt(prhs[1]); int i = getInt(prhs[2]); // Check for proper number of arguments if (!nargs_ok(job,nrhs-1)) { mexErrMsgTxt("Wrong number of inputs."); return; } else if (nlhs > 1) { mexErrMsgTxt("Too many output arguments"); } // options that do not return a value if (job < 20) { switch (job) { case 0: nm = getString(prhs[3]); iok = xml_new(nm); break; case 1: iok = xml_del(i); break; case 2: iok = xml_copy(i); break; case 4: file = getString(prhs[3]); iok = xml_build(i, file); break; case 5: key = getString(prhs[3]); val = getString(prhs[4]); iok = xml_addAttrib(i, key, val); break; case 6: key = getString(prhs[3]); iok = xml_child(i, key); break; case 7: m = getInt(prhs[3]); iok = xml_child_bynumber(i, m); break; case 8: key = getString(prhs[3]); iok = xml_findID(i, key); break; case 9: key = getString(prhs[3]); iok = xml_findByName(i, key); break; case 10: iok = xml_nChildren(i); break; case 11: key = getString(prhs[3]); val = getString(prhs[4]); iok = xml_addChild(i, key, val); break; case 12: key = getString(prhs[3]); j = getInt(prhs[4]); iok = xml_addChildNode(i, j); break; case 13: file = getString(prhs[3]); iok = xml_write(i, file); break; case 14: j = getInt(prhs[3]); iok = xml_removeChild(i, j); break; case 15: file = getString(prhs[3]); iok = xml_get_XML_File(file, 0); break; default: mexErrMsgTxt("unknown job parameter"); } plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double* h = mxGetPr(plhs[0]); *h = double(iok); if (iok < 0) { reportError(); } return; } // options that return strings char* v = (char*)mxCalloc(80, sizeof(char)); switch (job) { case 20: // return an attribute key = getString(prhs[3]); iok = xml_attrib(i, key, v); break; case 21: // return the value of the node iok = xml_value(i, v); break; case 22: iok = xml_tag(i, v); break; default: mexErrMsgTxt("unknown job parameter"); } if (iok < 0) { plhs[0] = mxCreateNumericMatrix(1,1,mxDOUBLE_CLASS,mxREAL); double* h = mxGetPr(plhs[0]); *h = double(iok); if (iok < 0) { reportError(); } } else { plhs[0] = mxCreateString(v); } }
void xps_parse_path(xps_document *doc, fz_matrix ctm, char *base_uri, xps_resource *dict, xml_element *root) { xml_element *node; char *fill_uri; char *stroke_uri; char *opacity_mask_uri; char *transform_att; char *clip_att; char *data_att; char *fill_att; char *stroke_att; char *opacity_att; char *opacity_mask_att; xml_element *transform_tag = NULL; xml_element *clip_tag = NULL; xml_element *data_tag = NULL; xml_element *fill_tag = NULL; xml_element *stroke_tag = NULL; xml_element *opacity_mask_tag = NULL; char *fill_opacity_att = NULL; char *stroke_opacity_att = NULL; char *stroke_dash_array_att; char *stroke_dash_cap_att; char *stroke_dash_offset_att; char *stroke_end_line_cap_att; char *stroke_start_line_cap_att; char *stroke_line_join_att; char *stroke_miter_limit_att; char *stroke_thickness_att; char *navigate_uri_att; fz_stroke_state stroke; fz_matrix transform; float samples[32]; fz_colorspace *colorspace; fz_path *path; fz_rect area; int fill_rule; /* * Extract attributes and extended attributes. */ transform_att = xml_att(root, "RenderTransform"); clip_att = xml_att(root, "Clip"); data_att = xml_att(root, "Data"); fill_att = xml_att(root, "Fill"); stroke_att = xml_att(root, "Stroke"); opacity_att = xml_att(root, "Opacity"); opacity_mask_att = xml_att(root, "OpacityMask"); stroke_dash_array_att = xml_att(root, "StrokeDashArray"); stroke_dash_cap_att = xml_att(root, "StrokeDashCap"); stroke_dash_offset_att = xml_att(root, "StrokeDashOffset"); stroke_end_line_cap_att = xml_att(root, "StrokeEndLineCap"); stroke_start_line_cap_att = xml_att(root, "StrokeStartLineCap"); stroke_line_join_att = xml_att(root, "StrokeLineJoin"); stroke_miter_limit_att = xml_att(root, "StrokeMiterLimit"); stroke_thickness_att = xml_att(root, "StrokeThickness"); navigate_uri_att = xml_att(root, "FixedPage.NavigateUri"); for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "Path.RenderTransform")) transform_tag = xml_down(node); if (!strcmp(xml_tag(node), "Path.OpacityMask")) opacity_mask_tag = xml_down(node); if (!strcmp(xml_tag(node), "Path.Clip")) clip_tag = xml_down(node); if (!strcmp(xml_tag(node), "Path.Fill")) fill_tag = xml_down(node); if (!strcmp(xml_tag(node), "Path.Stroke")) stroke_tag = xml_down(node); if (!strcmp(xml_tag(node), "Path.Data")) data_tag = xml_down(node); } fill_uri = base_uri; 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); /* * Act on the information we have gathered: */ if (!data_att && !data_tag) return; if (fill_tag && !strcmp(xml_tag(fill_tag), "SolidColorBrush")) { fill_opacity_att = xml_att(fill_tag, "Opacity"); fill_att = xml_att(fill_tag, "Color"); fill_tag = NULL; } if (stroke_tag && !strcmp(xml_tag(stroke_tag), "SolidColorBrush")) { stroke_opacity_att = xml_att(stroke_tag, "Opacity"); stroke_att = xml_att(stroke_tag, "Color"); stroke_tag = NULL; } 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); stroke.linejoin = FZ_LINEJOIN_MITER_XPS; if (stroke_line_join_att) { if (!strcmp(stroke_line_join_att, "Miter")) stroke.linejoin = FZ_LINEJOIN_MITER_XPS; if (!strcmp(stroke_line_join_att, "Round")) stroke.linejoin = FZ_LINEJOIN_ROUND; if (!strcmp(stroke_line_join_att, "Bevel")) stroke.linejoin = FZ_LINEJOIN_BEVEL; } stroke.miterlimit = 10; if (stroke_miter_limit_att) stroke.miterlimit = fz_atof(stroke_miter_limit_att); stroke.linewidth = 1; if (stroke_thickness_att) stroke.linewidth = fz_atof(stroke_thickness_att); stroke.dash_phase = 0; stroke.dash_len = 0; if (stroke_dash_array_att) { char *s = stroke_dash_array_att; if (stroke_dash_offset_att) stroke.dash_phase = fz_atof(stroke_dash_offset_att) * stroke.linewidth; while (*s && stroke.dash_len < nelem(stroke.dash_list)) { while (*s == ' ') s++; if (*s) /* needed in case of a space before the last quote */ stroke.dash_list[stroke.dash_len++] = fz_atof(s) * stroke.linewidth; while (*s && *s != ' ') s++; } } transform = fz_identity; if (transform_att) xps_parse_render_transform(doc, transform_att, &transform); if (transform_tag) xps_parse_matrix_transform(doc, transform_tag, &transform); ctm = fz_concat(transform, ctm); if (clip_att || clip_tag) xps_clip(doc, ctm, dict, clip_att, clip_tag); fill_rule = 0; if (data_att) path = xps_parse_abbreviated_geometry(doc, data_att, &fill_rule); else if (data_tag) path = xps_parse_path_geometry(doc, dict, data_tag, 0, &fill_rule); if (stroke_att || stroke_tag) area = fz_bound_path(doc->ctx, path, &stroke, ctm); else area = fz_bound_path(doc->ctx, path, NULL, ctm); if (navigate_uri_att) xps_add_link(doc, area, base_uri, navigate_uri_att); xps_begin_opacity(doc, ctm, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (fill_att) { xps_parse_color(doc, base_uri, fill_att, &colorspace, samples); if (fill_opacity_att) samples[0] = fz_atof(fill_opacity_att); xps_set_color(doc, colorspace, samples); fz_fill_path(doc->dev, path, fill_rule == 0, ctm, doc->colorspace, doc->color, doc->alpha); } if (fill_tag) { area = fz_bound_path(doc->ctx, path, NULL, ctm); fz_clip_path(doc->dev, path, NULL, fill_rule == 0, ctm); xps_parse_brush(doc, ctm, area, fill_uri, dict, fill_tag); fz_pop_clip(doc->dev); } if (stroke_att) { xps_parse_color(doc, base_uri, stroke_att, &colorspace, samples); if (stroke_opacity_att) samples[0] = fz_atof(stroke_opacity_att); xps_set_color(doc, colorspace, samples); fz_stroke_path(doc->dev, path, &stroke, ctm, doc->colorspace, doc->color, doc->alpha); } if (stroke_tag) { fz_clip_stroke_path(doc->dev, path, NULL, &stroke, ctm); xps_parse_brush(doc, ctm, area, stroke_uri, dict, stroke_tag); fz_pop_clip(doc->dev); } xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); fz_free_path(doc->ctx, path); path = NULL; if (clip_att || clip_tag) fz_pop_clip(doc->dev); }
fz_path * xps_parse_path_geometry(xps_document *doc, xps_resource *dict, xml_element *root, int stroking, int *fill_rule) { xml_element *node; char *figures_att; char *fill_rule_att; char *transform_att; xml_element *transform_tag = NULL; xml_element *figures_tag = NULL; /* only used by resource */ fz_matrix transform; fz_path *path; figures_att = xml_att(root, "Figures"); fill_rule_att = xml_att(root, "FillRule"); transform_att = xml_att(root, "Transform"); for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "PathGeometry.Transform")) transform_tag = 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); if (fill_rule_att) { if (!strcmp(fill_rule_att, "NonZero")) *fill_rule = 1; if (!strcmp(fill_rule_att, "EvenOdd")) *fill_rule = 0; } transform = fz_identity; if (transform_att) xps_parse_render_transform(doc, transform_att, &transform); if (transform_tag) xps_parse_matrix_transform(doc, transform_tag, &transform); if (figures_att) path = xps_parse_abbreviated_geometry(doc, figures_att, fill_rule); else path = fz_new_path(doc->ctx); if (figures_tag) xps_parse_path_figure(doc->ctx, path, figures_tag, stroking); for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "PathFigure")) xps_parse_path_figure(doc->ctx, path, node, stroking); } if (transform_att || transform_tag) fz_transform_path(doc->ctx, path, transform); return path; }
void xps_parse_tiling_brush(xps_context *ctx, fz_matrix ctm, fz_rect area, char *base_uri, xps_resource *dict, xml_element *root, void (*func)(xps_context*, fz_matrix, fz_rect, char*, xps_resource*, xml_element*, void*), void *user) { xml_element *node; struct closure c; char *opacity_att; char *transform_att; char *viewbox_att; char *viewport_att; char *tile_mode_att; char *viewbox_units_att; char *viewport_units_att; xml_element *transform_tag = NULL; fz_matrix transform; fz_rect viewbox; fz_rect viewport; float xstep, ystep; float xscale, yscale; int tile_mode; opacity_att = xml_att(root, "Opacity"); transform_att = xml_att(root, "Transform"); viewbox_att = xml_att(root, "Viewbox"); viewport_att = xml_att(root, "Viewport"); tile_mode_att = xml_att(root, "TileMode"); viewbox_units_att = xml_att(root, "ViewboxUnits"); viewport_units_att = xml_att(root, "ViewportUnits"); c.base_uri = base_uri; c.dict = dict; c.root = root; c.user = user; c.func = func; for (node = xml_down(root); node; node = xml_next(node)) { if (!strcmp(xml_tag(node), "ImageBrush.Transform")) transform_tag = xml_down(node); if (!strcmp(xml_tag(node), "VisualBrush.Transform")) transform_tag = xml_down(node); } xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL); transform = fz_identity; if (transform_att) xps_parse_render_transform(ctx, transform_att, &transform); if (transform_tag) xps_parse_matrix_transform(ctx, transform_tag, &transform); ctm = fz_concat(transform, ctm); viewbox = fz_unit_rect; if (viewbox_att) xps_parse_rectangle(ctx, viewbox_att, &viewbox); viewport = fz_unit_rect; if (viewport_att) xps_parse_rectangle(ctx, viewport_att, &viewport); /* some sanity checks on the viewport/viewbox size */ if (fabsf(viewport.x1 - viewport.x0) < 0.01f) return; if (fabsf(viewport.y1 - viewport.y0) < 0.01f) return; if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f) return; if (fabsf(viewbox.y1 - viewbox.y0) < 0.01f) return; xstep = viewbox.x1 - viewbox.x0; ystep = viewbox.y1 - viewbox.y0; xscale = (viewport.x1 - viewport.x0) / xstep; yscale = (viewport.y1 - viewport.y0) / ystep; tile_mode = TILE_NONE; if (tile_mode_att) { if (!strcmp(tile_mode_att, "None")) tile_mode = TILE_NONE; if (!strcmp(tile_mode_att, "Tile")) tile_mode = TILE_TILE; if (!strcmp(tile_mode_att, "FlipX")) tile_mode = TILE_FLIP_X; if (!strcmp(tile_mode_att, "FlipY")) tile_mode = TILE_FLIP_Y; if (!strcmp(tile_mode_att, "FlipXY")) tile_mode = TILE_FLIP_X_Y; } if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y) xstep *= 2; if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y) ystep *= 2; xps_begin_opacity(ctx, ctm, area, base_uri, dict, opacity_att, NULL); ctm = fz_concat(fz_translate(viewport.x0, viewport.y0), ctm); ctm = fz_concat(fz_scale(xscale, yscale), ctm); ctm = fz_concat(fz_translate(-viewbox.x0, -viewbox.y0), ctm); if (tile_mode != TILE_NONE) { int x0, y0, x1, y1; fz_matrix invctm = fz_invert_matrix(ctm); area = fz_transform_rect(invctm, area); x0 = floorf(area.x0 / xstep); y0 = floorf(area.y0 / ystep); x1 = ceilf(area.x1 / xstep); y1 = ceilf(area.y1 / ystep); #ifdef TILE if ((x1 - x0) * (y1 - y0) > 1) #else if (0) #endif { fz_rect bigview = viewbox; bigview.x1 = bigview.x0 + xstep; bigview.y1 = bigview.y0 + ystep; fz_begin_tile(ctx->dev, area, bigview, xstep, ystep, ctm); xps_paint_tiling_brush(ctx, ctm, viewbox, tile_mode, &c); fz_end_tile(ctx->dev); } else { int x, y; for (y = y0; y < y1; y++) { for (x = x0; x < x1; x++) { fz_matrix ttm = fz_concat(fz_translate(xstep * x, ystep * y), ctm); xps_paint_tiling_brush(ctx, ttm, viewbox, tile_mode, &c); } } } } else { xps_paint_tiling_brush(ctx, ctm, viewbox, tile_mode, &c); } xps_end_opacity(ctx, base_uri, dict, opacity_att, NULL); }