static void Text_Traverse(GF_Node *n, void *rs, Bool is_destroy)
{
DrawableContext *ctx;
M_Text *txt = (M_Text *) n;
TextStack *st = (TextStack *) gf_node_get_private(n);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
if (is_destroy) {
text_clean_paths(gf_sc_get_compositor(n), st);
drawable_del(st->graph);
gf_list_del(st->spans);
gf_free(st);
return;
}
if (!txt->string.count) return;
if (tr_state->text_split_mode) {
gf_node_dirty_clear(n, 0);
text_clean_paths(tr_state->visual->compositor, st);
build_text_split(st, txt, tr_state);
return;
}
text_check_changes(n, st, tr_state);
switch (tr_state->traversing_mode) {
case TRAVERSE_DRAW_2D:
text_draw_2d(n, tr_state);
return;
#ifndef GPAC_DISABLE_3D
case TRAVERSE_DRAW_3D:
text_draw_3d(tr_state, n, st);
return;
#endif
case TRAVERSE_PICK:
tr_state->text_parent = n;
gf_font_spans_pick(n, st->spans, tr_state, &st->bounds, 0, NULL);
tr_state->text_parent = NULL;
return;
case TRAVERSE_GET_BOUNDS:
tr_state->bounds = st->bounds;
return;
case TRAVERSE_GET_TEXT:
tr_state->text_parent = n;
gf_font_spans_get_selection(n, st->spans, tr_state);
tr_state->text_parent = NULL;
return;
case TRAVERSE_SORT:
break;
default:
return;
}
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) return;
#endif
ctx = drawable_init_context_mpeg4(st->graph, tr_state);
if (!ctx) return;
ctx->sub_path_index = tr_state->text_split_idx;
ctx->flags |= CTX_IS_TEXT;
if (!GF_COL_A(ctx->aspect.fill_color)) {
/*override line join*/
ctx->aspect.pen_props.join = GF_LINE_JOIN_MITER;
ctx->aspect.pen_props.cap = GF_LINE_CAP_FLAT;
}
/*if text selection mode, we must force redraw of the entire text span because we don't
if glyphs have been (un)selected*/
if (!tr_state->immediate_draw &&
/*text selection on*/
(tr_state->visual->compositor->text_selection
/*text sel release*/
|| (tr_state->visual->compositor->store_text_state==GF_SC_TSEL_RELEASED))
) {
GF_TextSpan *span;
u32 i = 0;
Bool unselect = (tr_state->visual->compositor->store_text_state==GF_SC_TSEL_RELEASED) ? 1 : 0;
while ((span = gf_list_enum(st->spans, &i))) {
if (span->flags & GF_TEXT_SPAN_SELECTED) {
if (unselect) span->flags &= ~GF_TEXT_SPAN_SELECTED;
ctx->flags |= CTX_APP_DIRTY;
}
}
}
if (ctx->sub_path_index) {
GF_TextSpan *span = (GF_TextSpan *)gf_list_get(st->spans, ctx->sub_path_index-1);
if (span) drawable_finalize_sort(ctx, tr_state, &span->bounds);
} else {
drawable_finalize_sort(ctx, tr_state, &st->bounds);
}
}
static void svg_traverse_textArea(GF_Node *node, void *rs, Bool is_destroy)
{
SVGPropertiesPointers backup_props;
u32 backup_flags;
GF_Matrix mx3d;
GF_Matrix2D backup_matrix;
DrawableContext *ctx = NULL;
GF_ChildNodeItem *child;
SVG_TextStack *st = (SVG_TextStack *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVG_Element *text = (SVG_Element *)node;
SVGAllAttributes atts;
if (is_destroy) {
drawable_del(st->drawable);
svg_reset_text_stack(st);
gf_list_del(st->spans);
gf_free(st);
return;
}
if (tr_state->traversing_mode==TRAVERSE_DRAW_2D) {
svg_text_draw_2d(st, tr_state);
return;
}
else if (tr_state->traversing_mode==TRAVERSE_GET_TEXT) {
tr_state->text_parent = node;
gf_font_spans_get_selection(node, st->spans, tr_state);
/*and browse children*/
child = ((GF_ParentNode *) text)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
case TAG_SVG_a:
gf_node_traverse(child->node, tr_state);
break;
}
child = child->next;
}
tr_state->text_parent = NULL;
return;
}
gf_svg_flatten_attributes(text, &atts);
if (!compositor_svg_traverse_base(node, &atts, tr_state, &backup_props, &backup_flags))
return;
tr_state->text_parent = node;
tr_state->in_svg_text_area++;
if (tr_state->traversing_mode==TRAVERSE_PICK) {
if (*tr_state->svg_props->pointer_events!=SVG_POINTEREVENTS_NONE) {
compositor_svg_apply_local_transformation(tr_state, &atts, &backup_matrix, &mx3d);
gf_font_spans_pick(node, st->spans, tr_state, &st->bounds, GF_TRUE, st->drawable);
/*and browse children*/
child = ((GF_ParentNode *) node)->children;
while (child) {
gf_node_traverse(child->node, tr_state);
child = child->next;
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx3d);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
tr_state->in_svg_text_area--;
tr_state->text_parent = NULL;
return;
}
compositor_svg_apply_local_transformation(tr_state, &atts, &backup_matrix, &mx3d);
if ( (st->prev_size != tr_state->svg_props->font_size->value) ||
(st->prev_flags != *tr_state->svg_props->font_style) ||
(st->prev_anchor != *tr_state->svg_props->text_anchor) ||
(gf_node_dirty_get(node) & (GF_SG_SVG_GEOMETRY_DIRTY | GF_SG_CHILD_DIRTY) )
|| tr_state->visual->compositor->reset_fonts
) {
u32 mode;
child = ((GF_ParentNode *) text)->children;
svg_reset_text_stack(st);
gf_node_dirty_clear(node, 0);
drawable_mark_modified(st->drawable, tr_state);
drawable_reset_path(st->drawable);
tr_state->max_length = (atts.width ? (atts.width->type == SVG_NUMBER_AUTO ? FIX_MAX : atts.width->value) : FIX_MAX);
tr_state->max_height = (atts.height ? (atts.height->type == SVG_NUMBER_AUTO ? FIX_MAX : atts.height->value) : FIX_MAX);
tr_state->base_x = (atts.x ? atts.x->value : 0);
tr_state->base_y = (atts.y ? atts.y->value : 0);
/*init the xml:space algo*/
tr_state->last_char_type = 0;
/*let it initialize from first font*/
tr_state->line_spacing = 0;
tr_state->text_end_x = 0;
tr_state->text_end_y = (tr_state->svg_props->line_increment->type == SVG_NUMBER_AUTO ? 0 : tr_state->svg_props->line_increment->value);
tr_state->x_anchors = gf_list_new();
if (tr_state->svg_props->font_size && (tr_state->svg_props->font_size->value <= tr_state->max_height)) {
Fixed remain;
u32 c, refresh_to_idx, prev_refresh;
/*switch to bounds mode, and recompute children*/
mode = tr_state->traversing_mode;
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
prev_refresh = tr_state->refresh_children_bounds;
tr_state->refresh_children_bounds = 0;
c = refresh_to_idx = 0;
child = ((GF_ParentNode *) text)->children;
while (child) {
c++;
switch (gf_node_get_tag(child->node)) {
case TAG_DOMText:
svg_traverse_dom_text_area(child->node, &atts, tr_state, st->spans);
break;
case TAG_SVG_tspan:
/*mark tspan as dirty to force rebuild*/
gf_node_dirty_set(child->node, 0, GF_FALSE);
gf_node_traverse(child->node, tr_state);
break;
case TAG_SVG_switch:
case TAG_SVG_a:
case TAG_SVG_tbreak:
gf_node_traverse(child->node, tr_state);
break;
default:
break;
}
if (tr_state->refresh_children_bounds) {
tr_state->refresh_children_bounds=0;
refresh_to_idx=c;
}
child=child->next;
}
st->prev_size = tr_state->svg_props->font_size->value;
st->prev_flags = *tr_state->svg_props->font_style;
st->prev_anchor = *tr_state->svg_props->text_anchor;
svg_text_area_reset_state(tr_state);
gf_list_del(tr_state->x_anchors);
tr_state->x_anchors = NULL;
remain = 0;
if (tr_state->refresh_children_bounds) {
refresh_to_idx = (u32) -1;
tr_state->base_shift = 0;
}
if (tr_state->svg_props->display_align) {
switch (*tr_state->svg_props->display_align) {
case SVG_DISPLAYALIGN_CENTER:
remain = (tr_state->max_height-tr_state->text_end_y) / 2;
break;
case SVG_DISPLAYALIGN_AFTER:
remain = tr_state->max_height - tr_state->text_end_y;
break;
default:
remain = 0;
break;
}
if (remain<0) remain=0;
if (remain) {
refresh_to_idx = (u32) -1;
tr_state->base_shift = remain;
svg_text_area_shift_bounds(st, tr_state);
}
}
if (refresh_to_idx) {
tr_state->refresh_children_bounds=1;
/*and retraverse in case of bounds adjustements*/
child = ((GF_ParentNode *) text)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_DOMText:
break;
case TAG_SVG_tspan:
case TAG_SVG_switch:
case TAG_SVG_a:
gf_node_traverse(child->node, tr_state);
break;
default:
break;
}
child=child->next;
refresh_to_idx--;
if (!refresh_to_idx) break;
}
tr_state->base_shift = 0;
}
tr_state->traversing_mode = mode;
tr_state->refresh_children_bounds = prev_refresh;
}
svg_update_bounds(st);
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (!compositor_svg_is_display_off(tr_state->svg_props))
tr_state->bounds = st->bounds;
} else if ( (tr_state->traversing_mode == TRAVERSE_SORT)
&& !compositor_svg_is_display_off(tr_state->svg_props)
&& (*(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN)
) {
ctx = drawable_init_context_svg(st->drawable, tr_state);
if (ctx) svg_finalize_sort(ctx, st, tr_state);
child = ((GF_ParentNode *) text)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_DOMText:
break;
case TAG_SVG_tspan:
case TAG_SVG_switch:
case TAG_SVG_a:
gf_node_traverse(child->node, tr_state);
break;
default:
break;
}
child = child->next;
}
}
tr_state->in_svg_text_area--;
tr_state->text_parent = NULL;
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx3d);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
static void svg_traverse_text(GF_Node *node, void *rs, Bool is_destroy)
{
SVGPropertiesPointers backup_props;
u32 backup_flags;
GF_Matrix2D backup_matrix;
GF_Matrix mx3d;
GF_ChildNodeItem *child;
DrawableContext *ctx;
SVG_TextStack *st = (SVG_TextStack *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVG_Element *text = (SVG_Element *)node;
SVGAllAttributes atts;
u32 i,imax;
Fixed * lw;
if (is_destroy) {
drawable_del(st->drawable);
svg_reset_text_stack(st);
gf_list_del(st->spans);
gf_free(st);
return;
}
if (tr_state->traversing_mode==TRAVERSE_DRAW_2D) {
svg_text_draw_2d(st, tr_state);
return;
}
else if (tr_state->traversing_mode==TRAVERSE_GET_TEXT) {
tr_state->text_parent = node;
gf_font_spans_get_selection(node, st->spans, tr_state);
/*and browse children*/
child = ((GF_ParentNode *) text)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
gf_node_traverse(child->node, tr_state);
break;
}
child = child->next;
}
tr_state->text_parent = NULL;
return;
}
gf_svg_flatten_attributes(text, &atts);
if (!compositor_svg_traverse_base(node, &atts, tr_state, &backup_props, &backup_flags))
return;
tr_state->in_svg_text++;
tr_state->text_parent = node;
if (tr_state->traversing_mode==TRAVERSE_PICK) {
compositor_svg_apply_local_transformation(tr_state, &atts, &backup_matrix, &mx3d);
if (*tr_state->svg_props->pointer_events!=SVG_POINTEREVENTS_NONE)
gf_font_spans_pick(node, st->spans, tr_state, &st->bounds, 1, st->drawable);
/*and browse children*/
child = ((GF_ParentNode *) text)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
gf_node_traverse(child->node, tr_state);
break;
}
child = child->next;
}
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx3d);
tr_state->svg_flags = backup_flags;
tr_state->text_parent = NULL;
tr_state->in_svg_text--;
return;
}
else if (tr_state->traversing_mode==TRAVERSE_GET_TEXT) {
gf_font_spans_get_selection(node, st->spans, tr_state);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
tr_state->text_parent = NULL;
tr_state->in_svg_text--;
return;
}
compositor_svg_apply_local_transformation(tr_state, &atts, &backup_matrix, &mx3d);
if ( (st->prev_size != tr_state->svg_props->font_size->value) ||
(st->prev_flags != *tr_state->svg_props->font_style) ||
(st->prev_anchor != *tr_state->svg_props->text_anchor) ||
(gf_node_dirty_get(node) & (GF_SG_SVG_GEOMETRY_DIRTY | GF_SG_CHILD_DIRTY) )
|| tr_state->visual->compositor->reset_fonts
) {
u32 mode;
child = ((GF_ParentNode *) text)->children;
svg_reset_text_stack(st);
tr_state->text_end_x = 0;
tr_state->text_end_y = 0;
/*init the xml:space algo*/
tr_state->last_char_type = 0;
/*initialize x and y counters - stored at the traverse level for handling tspan & co*/
if (atts.text_x) tr_state->count_x = gf_list_count(*atts.text_x);
else tr_state->count_x=0;
if (atts.text_y) tr_state->count_y = gf_list_count(*atts.text_y);
else tr_state->count_y=0;
if (atts.text_rotate) tr_state->count_rotate = gf_list_count(*atts.text_rotate);
else tr_state->count_rotate=0;
/*horizontal justifiers container*/
tr_state->x_anchors = gf_list_new();
/*compute length of all text blocks*/
while (child) {
svg_compute_text_width(child->node, &atts, tr_state);
child=child->next;
}
/*apply justification of all blocks*/
imax=gf_list_count(tr_state->x_anchors);
for (i=0; i<imax; i++) {
lw=gf_list_get(tr_state->x_anchors, i);
svg_apply_text_anchor(tr_state, lw);
}
/*re-initialize x and y counters for final compute*/
if (atts.text_x) tr_state->count_x = gf_list_count(*atts.text_x);
else tr_state->count_x=0;
if (atts.text_y) tr_state->count_y = gf_list_count(*atts.text_y);
else tr_state->count_y=0;
if (atts.text_rotate) tr_state->count_rotate = gf_list_count(*atts.text_rotate);
else tr_state->count_rotate=0;
tr_state->idx_rotate = 0;
tr_state->chunk_index = 0;
/*initialize current text position*/
if (!tr_state->text_end_x) {
SVG_Coordinate *xc = (atts.text_x ? (SVG_Coordinate *) gf_list_get(*atts.text_x, 0) : NULL);
tr_state->text_end_x = (xc ? xc->value : 0);
}
if (!tr_state->text_end_y) {
SVG_Coordinate *yc = (atts.text_y ? (SVG_Coordinate *) gf_list_get(*atts.text_y, 0) : NULL);
tr_state->text_end_y = (yc ? yc->value : 0);
}
/*pass x and y to children*/
tr_state->text_x = atts.text_x;
tr_state->text_y = atts.text_y;
tr_state->text_rotate = atts.text_rotate;
drawable_reset_path(st->drawable);
/*switch to bounds mode, and recompute children*/
mode = tr_state->traversing_mode;
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
tr_state->last_char_type = 0;
child = ((GF_ParentNode *) text)->children;
while (child) {
svg_traverse_text_block(child->node, &atts, tr_state, st->spans);
child = child->next;
}
tr_state->traversing_mode = mode;
gf_node_dirty_clear(node, 0);
drawable_mark_modified(st->drawable, tr_state);
st->prev_size = tr_state->svg_props->font_size->value;
st->prev_flags = *tr_state->svg_props->font_style;
st->prev_anchor = *tr_state->svg_props->text_anchor;
while (gf_list_count(tr_state->x_anchors)) {
Fixed *f = gf_list_last(tr_state->x_anchors);
gf_list_rem_last(tr_state->x_anchors);
gf_free(f);
}
gf_list_del(tr_state->x_anchors);
tr_state->x_anchors = NULL;
svg_update_bounds(st);
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (!compositor_svg_is_display_off(tr_state->svg_props))
tr_state->bounds = st->bounds;
} else if ((tr_state->traversing_mode == TRAVERSE_SORT)
&& !compositor_svg_is_display_off(tr_state->svg_props)
&& (*(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN)
) {
ctx = drawable_init_context_svg(st->drawable, tr_state);
if (ctx) svg_finalize_sort(ctx, st, tr_state);
/*and browse children*/
child = ((GF_ParentNode *) text)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
gf_node_traverse(child->node, tr_state);
break;
case TAG_SVG_switch:
gf_node_traverse(child->node, tr_state);
break;
}
child = child->next;
}
}
tr_state->in_svg_text--;
tr_state->text_parent = NULL;
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx3d);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
static void svg_traverse_tspan(GF_Node *node, void *rs, Bool is_destroy)
{
SVGPropertiesPointers backup_props;
u32 backup_flags;
GF_Matrix2D backup_matrix;
GF_Matrix mx3d;
DrawableContext *ctx;
SVG_TextStack *st = (SVG_TextStack *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVG_Element *tspan = (SVG_Element *)node;
SVGAllAttributes atts;
GF_ChildNodeItem *child;
if (is_destroy) {
drawable_del(st->drawable);
svg_reset_text_stack(st);
gf_list_del(st->spans);
gf_free(st);
return;
}
if (tr_state->traversing_mode==TRAVERSE_DRAW_2D) {
svg_text_draw_2d(st, tr_state);
return;
}
else if (tr_state->traversing_mode==TRAVERSE_GET_TEXT) {
gf_font_spans_get_selection(node, st->spans, tr_state);
/*and browse children*/
child = ((GF_ParentNode *) tspan)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
gf_node_traverse(child->node, tr_state);
break;
}
child = child->next;
}
return;
}
if (!tr_state->in_svg_text && !tr_state->in_svg_text_area) return;
gf_svg_flatten_attributes(tspan, &atts);
if (!compositor_svg_traverse_base(node, &atts, tr_state, &backup_props, &backup_flags))
return;
if (tr_state->traversing_mode==TRAVERSE_PICK) {
if (*tr_state->svg_props->pointer_events!=SVG_POINTEREVENTS_NONE)
gf_font_spans_pick(node, st->spans, tr_state, &st->bounds, GF_TRUE, st->drawable);
/*and browse children*/
child = ((GF_ParentNode *) tspan)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
gf_node_traverse(child->node, tr_state);
break;
}
child = child->next;
}
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
return;
}
compositor_svg_apply_local_transformation(tr_state, &atts, &backup_matrix, &mx3d);
if ( (st->prev_size != tr_state->svg_props->font_size->value) ||
(st->prev_flags != *tr_state->svg_props->font_style) ||
(st->prev_anchor != *tr_state->svg_props->text_anchor) ||
(gf_node_dirty_get(node) & (GF_SG_SVG_GEOMETRY_DIRTY | GF_SG_CHILD_DIRTY) )
) {
u32 mode;
/*tspan has been modified in the SORT stage, which means that an anim local to tspan has modified the node.
The result of the parent (text, textArea) will thus be wrong if we try to update the tspan. We therefore
keep the previous computed drawable, and invalidate the parent for next frame*/
if (tr_state->traversing_mode==TRAVERSE_SORT) {
gf_node_dirty_set(node, 0, GF_TRUE);
goto skip_changes;
}
/*switch to bounds mode, and recompute children*/
mode = tr_state->traversing_mode;
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
svg_reset_text_stack(st);
child = ((GF_ParentNode *) tspan)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_DOMText:
svg_traverse_domtext(child->node, &atts, tr_state, st->spans, NULL);
break;
case TAG_SVG_tspan:
gf_node_dirty_set(child->node, 0, GF_FALSE);
gf_node_traverse(child->node, tr_state);
break;
case TAG_SVG_switch:
case TAG_SVG_a:
case TAG_SVG_tbreak:
gf_node_traverse(child->node, tr_state);
break;
default:
break;
}
child = child->next;
}
tr_state->traversing_mode = mode;
gf_node_dirty_clear(node, 0);
drawable_mark_modified(st->drawable, tr_state);
st->prev_size = tr_state->svg_props->font_size->value;
st->prev_flags = *tr_state->svg_props->font_style;
st->prev_anchor = *tr_state->svg_props->text_anchor;
svg_update_bounds(st);
}
skip_changes:
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (tr_state->refresh_children_bounds) {
if (tr_state->base_shift)
svg_text_area_shift_bounds(st, tr_state);
else
svg_update_bounds(st);
child = ((GF_ParentNode *) tspan)->children;
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
case TAG_SVG_switch:
case TAG_SVG_a:
gf_node_traverse(child->node, tr_state);
break;
default:
break;
}
child = child->next;
}
}
if (!compositor_svg_is_display_off(tr_state->svg_props))
tr_state->bounds = st->bounds;
}
else if (
(tr_state->traversing_mode == TRAVERSE_SORT)
&& !compositor_svg_is_display_off(tr_state->svg_props)
&& ( *(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN)
) {
child = ((GF_ParentNode *) tspan)->children;
ctx = drawable_init_context_svg(st->drawable, tr_state);
if (ctx) svg_finalize_sort(ctx, st, tr_state);
while (child) {
switch (gf_node_get_tag(child->node)) {
case TAG_SVG_tspan:
case TAG_SVG_switch:
case TAG_SVG_a:
gf_node_traverse(child->node, tr_state);
break;
default:
break;
}
child = child->next;
}
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx3d);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
