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);
}
