static void svg_drawable_traverse(GF_Node *node, void *rs, Bool is_destroy,
void (*rebuild_path)(GF_Node *, Drawable *, SVGAllAttributes *),
Bool is_svg_rect, Bool is_svg_path)
{
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
DrawableContext *ctx;
SVGPropertiesPointers backup_props;
u32 backup_flags;
Drawable *drawable = (Drawable *)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVGAllAttributes all_atts;
if (is_destroy) {
#if USE_GF_PATH
/* The path is the same as the one in the SVG node, don't delete it here */
if (is_svg_path) drawable->path = NULL;
#endif
drawable_node_del(node);
return;
}
assert(tr_state->traversing_mode!=TRAVERSE_DRAW_2D);
if (tr_state->traversing_mode==TRAVERSE_PICK) {
svg_drawable_pick(node, drawable, tr_state);
return;
}
/*flatten attributes and apply animations + inheritance*/
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!compositor_svg_traverse_base(node, &all_atts, (GF_TraverseState *)rs, &backup_props, &backup_flags))
return;
/* Recreates the path (i.e the shape) only if the node is dirty */
if (gf_node_dirty_get(node) & GF_SG_SVG_GEOMETRY_DIRTY) {
/*the rebuild function is responsible for cleaning the path*/
rebuild_path(node, drawable, &all_atts);
gf_node_dirty_clear(node, GF_SG_SVG_GEOMETRY_DIRTY);
drawable_mark_modified(drawable, tr_state);
}
if (drawable->path) {
if (*(tr_state->svg_props->fill_rule)==GF_PATH_FILL_ZERO_NONZERO) {
if (!(drawable->path->flags & GF_PATH_FILL_ZERO_NONZERO)) {
drawable->path->flags |= GF_PATH_FILL_ZERO_NONZERO;
drawable_mark_modified(drawable, tr_state);
}
} else {
if (drawable->path->flags & GF_PATH_FILL_ZERO_NONZERO) {
drawable->path->flags &= ~GF_PATH_FILL_ZERO_NONZERO;
drawable_mark_modified(drawable, tr_state);
}
}
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (! compositor_svg_is_display_off(tr_state->svg_props)) {
DrawAspect2D asp;
gf_path_get_bounds(drawable->path, &tr_state->bounds);
if (!tr_state->ignore_strike) {
memset(&asp, 0, sizeof(DrawAspect2D));
drawable_get_aspect_2d_svg(node, &asp, tr_state);
if (asp.pen_props.width) {
StrikeInfo2D *si = drawable_get_strikeinfo(tr_state->visual->compositor, drawable, &asp, NULL, drawable->path, 0, NULL);
if (si && si->outline) {
gf_path_get_bounds(si->outline, &tr_state->bounds);
}
}
}
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, NULL);
if (!tr_state->abort_bounds_traverse)
gf_mx2d_apply_rect(&tr_state->transform, &tr_state->bounds);
gf_sc_get_nodes_bounds(node, NULL, tr_state, NULL);
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, NULL);
}
} else if (tr_state->traversing_mode == TRAVERSE_SORT) {
/*reset our flags - this may break reuse of nodes and change-detection in dirty-rect algo */
gf_node_dirty_clear(node, 0);
if (!compositor_svg_is_display_off(tr_state->svg_props) &&
( *(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN) ) {
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
ctx = drawable_init_context_svg(drawable, tr_state);
if (ctx) {
if (is_svg_rect) {
if (ctx->aspect.fill_texture && ctx->aspect.fill_texture->transparent) {}
else if (GF_COL_A(ctx->aspect.fill_color) != 0xFF) {}
else if (ctx->transform.m[1] || ctx->transform.m[3]) {}
else {
ctx->flags &= ~CTX_IS_TRANSPARENT;
if (!ctx->aspect.pen_props.width)
ctx->flags |= CTX_NO_ANTIALIAS;
}
}
if (all_atts.pathLength && all_atts.pathLength->type==SVG_NUMBER_VALUE)
ctx->aspect.pen_props.path_length = all_atts.pathLength->value;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!drawable->mesh) {
drawable->mesh = new_mesh();
if (drawable->path) mesh_from_path(drawable->mesh, drawable->path);
}
visual_3d_draw_from_context(ctx, tr_state);
ctx->drawable = NULL;
} else
#endif
{
drawable_finalize_sort(ctx, tr_state, NULL);
}
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
}
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
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;
}
/*
This is a crude draft implementation of filter. The main drawback is that we don't cache any data.
We should be able to check for changes in the sub-group or in the filter
*/
void svg_draw_filter(GF_Node *filter, GF_Node *node, GF_TraverseState *tr_state)
{
GF_IRect rc1, rc2;
#ifndef GPAC_DISABLE_3D
u32 type_3d;
#endif
u32 prev_flags;
GF_IRect txrc;
Fixed scale_x, scale_y, temp_x, temp_y;
DrawableContext *ctx, *child_ctx;
GF_SURFACE offscreen_surface, old_surf;
GF_Rect bounds, local_bounds, rc;
GF_Matrix2D backup;
SVGAllAttributes all_atts;
GF_FilterStack *st = gf_node_get_private(filter);
assert(tr_state->traversing_mode==TRAVERSE_SORT);
/*store the current transform matrix, create a new one for group_cache*/
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
gf_node_allow_cyclic_traverse(node);
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
tr_state->bounds.width = tr_state->bounds.height = 0;
gf_node_traverse(node, tr_state);
local_bounds = bounds = tr_state->bounds;
/*compute bounds in final coordinate system - this ensures that the cache has the correct anti aliasing*/
gf_mx2d_apply_rect(&backup, &bounds);
txrc = gf_rect_pixelize(&bounds);
if (txrc.width%2) txrc.width++;
if (txrc.height%2) txrc.height++;
bounds = gf_rect_ft(&txrc);
tr_state->traversing_mode = TRAVERSE_SORT;
gf_mx2d_copy(tr_state->transform, backup);
if (!bounds.width || !bounds.height) {
return;
}
/*create a context */
ctx = drawable_init_context_svg(st->drawable, tr_state);
if (!ctx) return;
/*setup texture */
st->txh.height = txrc.height;
st->txh.width = txrc.width;
st->txh.stride = txrc.width * 4;
st->txh.pixelformat = GF_PIXEL_ARGB;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) st->txh.pixelformat = GF_PIXEL_RGBA;
#endif
st->txh.transparent = 1;
if (st->txh.stride * st->txh.height > st->alloc_size) {
st->alloc_size = st->txh.stride * st->txh.height;
st->data = (u8*)gf_realloc(st->data, sizeof(u8) * st->alloc_size);
}
memset(st->data, 0x0, sizeof(char) * st->txh.stride * st->txh.height);
st->txh.data = (char *) st->data;
/*setup geometry (rectangle matching the bounds of the object)
Warning, we want to center the cached bitmap at the center of the screen (main visual)*/
gf_path_reset(st->drawable->path);
gf_path_add_rect_center(st->drawable->path,
bounds.x + bounds.width/2,
bounds.y - bounds.height/2,
bounds.width,
bounds.height);
old_surf = tr_state->visual->raster_surface;
offscreen_surface = tr_state->visual->compositor->rasterizer->surface_new(tr_state->visual->compositor->rasterizer, tr_state->visual->center_coords);
tr_state->visual->raster_surface = offscreen_surface;
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
/*attach the buffer to visual*/
tr_state->visual->compositor->rasterizer->surface_attach_to_buffer(offscreen_surface, st->txh.data,
st->txh.width,
st->txh.height,
0,
st->txh.stride,
st->txh.pixelformat);
prev_flags = tr_state->immediate_draw;
tr_state->immediate_draw = 1;
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->in_svg_filter = 1;
/*recompute the bounds with the final scaling used*/
scale_x = gf_divfix(bounds.width, local_bounds.width);
scale_y = gf_divfix(bounds.height, local_bounds.height);
gf_mx2d_init(tr_state->transform);
gf_mx2d_add_scale(&tr_state->transform, scale_x, scale_y);
rc = local_bounds;
gf_mx2d_apply_rect(&tr_state->transform, &rc);
/*centered the bitmap on the visual*/
if (tr_state->visual->center_coords) {
temp_x = -rc.x - rc.width/2;
temp_y = rc.height/2 - rc.y;
} else {
temp_x = -rc.x;
temp_y = rc.height - rc.y;
}
gf_mx2d_add_translation(&tr_state->transform, temp_x, temp_y);
rc1 = tr_state->visual->surf_rect;
rc2 = tr_state->visual->top_clipper;
tr_state->visual->surf_rect.width = st->txh.width;
tr_state->visual->surf_rect.height = st->txh.height;
if (tr_state->visual->center_coords) {
tr_state->visual->surf_rect.y = st->txh.height/2;
tr_state->visual->surf_rect.x = -1 * (s32) st->txh.width/2;
} else {
tr_state->visual->surf_rect.y = st->txh.height;
tr_state->visual->surf_rect.x = 0;
}
tr_state->visual->top_clipper = tr_state->visual->surf_rect;
#ifndef GPAC_DISABLE_3D
type_3d = tr_state->visual->type_3d;
tr_state->visual->type_3d=0;
#endif
if (prev_flags) gf_node_allow_cyclic_traverse(node);
gf_node_traverse(node, tr_state);
child_ctx = ctx->next;
while (child_ctx && child_ctx->drawable) {
drawable_reset_bounds(child_ctx->drawable, tr_state->visual);
child_ctx->drawable = NULL;
child_ctx = child_ctx->next;
}
tr_state->visual->cur_context = ctx;
/*restore state and destroy whatever needs to be cleaned*/
tr_state->in_svg_filter = 0;
tr_state->immediate_draw = prev_flags;
tr_state->visual->compositor->rasterizer->surface_delete(offscreen_surface);
tr_state->visual->raster_surface = old_surf;
tr_state->traversing_mode = TRAVERSE_SORT;
tr_state->visual->surf_rect = rc1;
tr_state->visual->top_clipper = rc2;
#ifndef GPAC_DISABLE_3D
tr_state->visual->type_3d = type_3d ;
#endif
/*update texture*/
st->txh.transparent = 1;
st->txh.flags |= GF_SR_TEXTURE_NO_GL_FLIP;
gf_sc_texture_set_data(&st->txh);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d)
gf_sc_texture_push_image(&st->txh, 0, 0);
else
#endif
gf_sc_texture_push_image(&st->txh, 0, 1);
ctx->flags |= CTX_NO_ANTIALIAS;
ctx->aspect.fill_color = 0;
ctx->aspect.line_color = 0xFF000000;
ctx->aspect.fill_texture = &st->txh;
ctx->flags |= CTX_TEXTURE_DIRTY;
/*get the filter region*/
bounds = local_bounds;
gf_svg_flatten_attributes((SVG_Element *)filter, &all_atts);
if (!all_atts.filterUnits || (*all_atts.filterUnits==SVG_GRADIENTUNITS_OBJECT)) {
Fixed v;
v = all_atts.x ? all_atts.x->value : INT2FIX(-10);
bounds.x += gf_mulfix(v, bounds.width);
v = all_atts.y ? all_atts.y->value : INT2FIX(-10);
bounds.y += gf_mulfix(v, bounds.height);
v = all_atts.width ? all_atts.width->value : INT2FIX(120);
bounds.width = gf_mulfix(v, bounds.width);
v = all_atts.height ? all_atts.height->value : INT2FIX(120);
bounds.height = gf_mulfix(v, bounds.height);
} else {
bounds.x = all_atts.x ? all_atts.x->value : 0;
bounds.y = all_atts.y ? all_atts.y->value : 0;
bounds.width = all_atts.width ? all_atts.x->value : bounds.width;
bounds.height = all_atts.x ? all_atts.x->value : 120;
}
gf_mx2d_apply_rect(&backup, &bounds);
svg_filter_apply(filter, &st->txh, &bounds);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!st->drawable->mesh) {
st->drawable->mesh = new_mesh();
mesh_from_path(st->drawable->mesh, st->drawable->path);
}
visual_3d_draw_from_context(tr_state->ctx, tr_state);
ctx->drawable = NULL;
return;
}
#endif
/*we computed the texture in final screen coordinate, so use the identity matrix for the context*/
gf_mx2d_init(tr_state->transform);
drawable_finalize_sort(ctx, tr_state, NULL);
gf_mx2d_copy(tr_state->transform, backup);
}
Bool group_cache_traverse(GF_Node *node, GroupCache *cache, GF_TraverseState *tr_state, Bool force_recompute, Bool is_mpeg4, Bool auto_fit_vp)
{
GF_Matrix2D backup;
DrawableContext *group_ctx = NULL;
GF_ChildNodeItem *l;
if (!cache) return 0;
/*do we need to recompute the cache*/
if (cache->force_recompute) {
force_recompute = 1;
cache->force_recompute = 0;
}
else if (gf_node_dirty_get(node) & GF_SG_CHILD_DIRTY) {
force_recompute = 1;
}
/*we need to redraw the group in an offscreen visual*/
if (force_recompute) {
GF_Matrix2D backup;
GF_IRect rc1, rc2;
u32 type_3d;
u32 prev_flags;
GF_Rect cache_bounds;
GF_SURFACE offscreen_surface, old_surf;
GF_Raster2D *r2d = tr_state->visual->compositor->rasterizer;
DrawableContext *child_ctx;
Fixed temp_x, temp_y, scale_x, scale_y;
GF_LOG(GF_LOG_INFO, GF_LOG_COMPOSE, ("[Compositor] Recomputing cache for subtree %s\n", gf_node_get_log_name(node)));
/*step 1 : store current state and indicate children should not be cached*/
tr_state->in_group_cache = 1;
prev_flags = tr_state->immediate_draw;
/*store the current transform matrix, create a new one for group_cache*/
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
type_3d = 0;
#ifndef GPAC_DISABLE_3D
/*force 2D rendering*/
type_3d = tr_state->visual->type_3d;
tr_state->visual->type_3d = 0;
#endif
/*step 2: collect the bounds of all children*/
tr_state->traversing_mode = TRAVERSE_GET_BOUNDS;
cache_bounds.width = cache_bounds.height = 0;
l = ((GF_ParentNode*)node)->children;
while (l) {
tr_state->bounds.width = tr_state->bounds.height = 0;
gf_node_traverse(l->node, tr_state);
l = l->next;
gf_rect_union(&cache_bounds, &tr_state->bounds);
}
tr_state->traversing_mode = TRAVERSE_SORT;
if (!cache_bounds.width || !cache_bounds.height) {
tr_state->in_group_cache = 0;
tr_state->immediate_draw = prev_flags;
gf_mx2d_copy(tr_state->transform, backup);
#ifndef GPAC_DISABLE_3D
tr_state->visual->type_3d = type_3d;
#endif
return 0;
}
/*step 3: insert a DrawableContext for this group in the display list*/
if (is_mpeg4) {
#ifndef GPAC_DISABLE_VRML
group_ctx = drawable_init_context_mpeg4(cache->drawable, tr_state);
#endif
} else {
#ifndef GPAC_DISABLE_SVG
group_ctx = drawable_init_context_svg(cache->drawable, tr_state);
#endif
}
if (!group_ctx) return 0;
/*step 4: now we have the bounds:
allocate the offscreen memory
create temp raster visual & attach to buffer
override the tr_state->visual->the_surface with the temp raster
add translation (shape is not always centered)
setup top clipers
*/
old_surf = tr_state->visual->raster_surface;
offscreen_surface = r2d->surface_new(r2d, tr_state->visual->center_coords); /*a new temp raster visual*/
tr_state->visual->raster_surface = offscreen_surface;
/*use current surface coordinate scaling to compute the cache*/
#ifdef GF_SR_USE_VIDEO_CACHE
scale_x = tr_state->visual->compositor->cache_scale * backup.m[0] / 100;
scale_y = tr_state->visual->compositor->cache_scale * backup.m[4] / 100;
#else
scale_x = backup.m[0];
scale_y = backup.m[4];
#endif
if (scale_x<0) scale_x = -scale_x;
if (scale_y<0) scale_y = -scale_y;
cache->scale = MAX(scale_x, scale_y);
tr_state->bounds = cache_bounds;
gf_mx2d_add_scale(&tr_state->transform, scale_x, scale_y);
gf_mx2d_apply_rect(&tr_state->transform, &cache_bounds);
rc1 = gf_rect_pixelize(&cache_bounds);
if (rc1.width % 2) rc1.width++;
if (rc1.height%2) rc1.height++;
/* Initialize the group cache with the scaled pixelized bounds for texture but the original bounds for path*/
group_cache_setup(cache, &tr_state->bounds, &rc1, tr_state->visual->compositor, type_3d);
/*attach the buffer to visual*/
r2d->surface_attach_to_buffer(offscreen_surface, cache->txh.data,
cache->txh.width,
cache->txh.height,
0,
cache->txh.stride,
cache->txh.pixelformat);
/*recompute the bounds with the final scaling used*/
scale_x = gf_divfix(INT2FIX(rc1.width), tr_state->bounds.width);
scale_y = gf_divfix(INT2FIX(rc1.height), tr_state->bounds.height);
gf_mx2d_init(tr_state->transform);
gf_mx2d_add_scale(&tr_state->transform, scale_x, scale_y);
cache_bounds = tr_state->bounds;
gf_mx2d_apply_rect(&tr_state->transform, &cache_bounds);
/*centered the bitmap on the visual*/
temp_x = -cache_bounds.x;
temp_y = -cache_bounds.y;
if (tr_state->visual->center_coords) {
temp_x -= cache_bounds.width/2;
temp_y += cache_bounds.height/2;
} else {
temp_y += cache_bounds.height;
}
gf_mx2d_add_translation(&tr_state->transform, temp_x, temp_y);
/*override top clippers*/
rc1 = tr_state->visual->surf_rect;
rc2 = tr_state->visual->top_clipper;
tr_state->visual->surf_rect.width = cache->txh.width;
tr_state->visual->surf_rect.height = cache->txh.height;
if (tr_state->visual->center_coords) {
tr_state->visual->surf_rect.y = cache->txh.height/2;
tr_state->visual->surf_rect.x = -1 * (s32) cache->txh.width/2;
} else {
tr_state->visual->surf_rect.y = cache->txh.height;
tr_state->visual->surf_rect.x = 0;
}
tr_state->visual->top_clipper = tr_state->visual->surf_rect;
/*step 5: traverse subtree in direct draw mode*/
tr_state->immediate_draw = 1;
group_ctx->flags &= ~CTX_NO_ANTIALIAS;
l = ((GF_ParentNode*)node)->children;
while (l) {
gf_node_traverse(l->node, tr_state);
l = l->next;
}
/*step 6: reset all contexts after the current group one*/
child_ctx = group_ctx->next;
while (child_ctx && child_ctx->drawable) {
drawable_reset_bounds(child_ctx->drawable, tr_state->visual);
child_ctx->drawable = NULL;
child_ctx = child_ctx->next;
}
/*and set ourselves as the last context on the main visual*/
tr_state->visual->cur_context = group_ctx;
/*restore state and destroy whatever needs to be cleaned*/
gf_mx2d_copy(tr_state->transform, backup);
tr_state->in_group_cache = 0;
tr_state->immediate_draw = prev_flags;
r2d->surface_delete(offscreen_surface);
tr_state->visual->raster_surface = old_surf;
tr_state->traversing_mode = TRAVERSE_SORT;
#ifndef GPAC_DISABLE_3D
tr_state->visual->type_3d = type_3d;
#endif
tr_state->visual->surf_rect = rc1;
tr_state->visual->top_clipper = rc2;
/*update texture*/
cache->txh.transparent = 1;
cache->txh.flags |= GF_SR_TEXTURE_NO_GL_FLIP;
gf_sc_texture_set_data(&cache->txh);
gf_sc_texture_push_image(&cache->txh, 0, type_3d ? 0 : 1);
cache->orig_vp = tr_state->vp_size;
}
/*just setup the context*/
else {
if (is_mpeg4) {
#ifndef GPAC_DISABLE_VRML
group_ctx = drawable_init_context_mpeg4(cache->drawable, tr_state);
#endif
} else {
#ifndef GPAC_DISABLE_SVG
group_ctx = drawable_init_context_svg(cache->drawable, tr_state);
#endif
}
}
if (!group_ctx) return 0;
group_ctx->flags |= CTX_NO_ANTIALIAS;
if (cache->opacity != FIX_ONE)
group_ctx->aspect.fill_color = GF_COL_ARGB_FIXED(cache->opacity, FIX_ONE, FIX_ONE, FIX_ONE);
else
group_ctx->aspect.fill_color = 0;
group_ctx->aspect.fill_texture = &cache->txh;
if (!cache->opacity) {
group_ctx->drawable = NULL;
return 0;
}
if (gf_node_dirty_get(node)) group_ctx->flags |= CTX_TEXTURE_DIRTY;
#ifdef CACHE_DEBUG_CENTER
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_init(tr_state->transform);
#else
gf_mx2d_copy(backup, tr_state->transform);
if (auto_fit_vp) {
if ((tr_state->vp_size.x != cache->orig_vp.x) || (tr_state->vp_size.y != cache->orig_vp.y)) {
GF_Matrix2D m;
gf_mx2d_init(m);
gf_mx2d_copy(backup, tr_state->transform);
gf_mx2d_add_scale(&m, gf_divfix(tr_state->vp_size.x, cache->orig_vp.x), gf_divfix(tr_state->vp_size.y, cache->orig_vp.y) );
gf_mx2d_pre_multiply(&tr_state->transform, &m);
} else {
auto_fit_vp = 0;
}
}
#endif
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!cache->drawable->mesh) {
cache->drawable->mesh = new_mesh();
mesh_from_path(cache->drawable->mesh, cache->drawable->path);
}
visual_3d_draw_from_context(group_ctx, tr_state);
group_ctx->drawable = NULL;
} else
#endif
drawable_finalize_sort(group_ctx, tr_state, NULL);
#ifndef CACHE_DEBUG_CENTER
if (auto_fit_vp)
#endif
{
gf_mx2d_copy(tr_state->transform, backup);
}
return (force_recompute==1);
}
static void svg_traverse_bitmap(GF_Node *node, void *rs, Bool is_destroy)
{
Fixed cx, cy, angle;
/*video stack is just an extension of image stack, type-casting is OK*/
SVG_video_stack *stack = (SVG_video_stack*)gf_node_get_private(node);
GF_TraverseState *tr_state = (GF_TraverseState *)rs;
SVGPropertiesPointers backup_props;
u32 backup_flags;
GF_Matrix2D backup_matrix;
GF_Matrix mx_3d;
DrawableContext *ctx;
SVGAllAttributes all_atts;
if (is_destroy) {
gf_sc_texture_destroy(&stack->txh);
gf_sg_mfurl_del(stack->txurl);
drawable_del(stack->graph);
if (stack->audio) {
gf_node_unregister(stack->audio, NULL);
}
gf_free(stack);
return;
}
/*TRAVERSE_DRAW is NEVER called in 3D mode*/
if (tr_state->traversing_mode==TRAVERSE_DRAW_2D) {
SVG_Draw_bitmap(tr_state);
return;
}
else if (tr_state->traversing_mode==TRAVERSE_PICK) {
svg_drawable_pick(node, stack->graph, tr_state);
return;
}
/*flatten attributes and apply animations + inheritance*/
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!compositor_svg_traverse_base(node, &all_atts, (GF_TraverseState *)rs, &backup_props, &backup_flags))
return;
if (gf_node_dirty_get(node) & GF_SG_SVG_XLINK_HREF_DIRTY) {
gf_term_get_mfurl_from_xlink(node, &stack->txurl);
stack->txh.width = stack->txh.height = 0;
/*remove associated audio if any*/
if (stack->audio) {
svg_audio_smil_evaluate_ex(NULL, 0, SMIL_TIMING_EVAL_REMOVE, stack->audio, stack->txh.owner);
gf_node_unregister(stack->audio, NULL);
stack->audio = NULL;
}
stack->audio_dirty = GF_TRUE;
if (stack->txurl.count) svg_play_texture(stack, &all_atts);
gf_node_dirty_clear(node, GF_SG_SVG_XLINK_HREF_DIRTY);
}
if (gf_node_dirty_get(node)) {
/*do not clear dirty state until the image is loaded*/
if (stack->txh.width) {
gf_node_dirty_clear(node, 0);
SVG_Build_Bitmap_Graph((SVG_video_stack*)gf_node_get_private(node), tr_state);
}
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
if (!compositor_svg_is_display_off(tr_state->svg_props)) {
gf_path_get_bounds(stack->graph->path, &tr_state->bounds);
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
if (svg_video_get_transform_behavior(tr_state, &all_atts, &cx, &cy, &angle)) {
GF_Matrix2D mx;
tr_state->bounds.width = INT2FIX(stack->txh.width);
tr_state->bounds.height = INT2FIX(stack->txh.height);
tr_state->bounds.x = cx - tr_state->bounds.width/2;
tr_state->bounds.y = cy + tr_state->bounds.height/2;
gf_mx2d_init(mx);
gf_mx2d_add_rotation(&mx, 0, 0, angle);
gf_mx2d_apply_rect(&mx, &tr_state->bounds);
} else {
gf_mx2d_apply_rect(&tr_state->transform, &tr_state->bounds);
}
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
} else if (tr_state->traversing_mode == TRAVERSE_SORT) {
if (!compositor_svg_is_display_off(tr_state->svg_props) && ( *(tr_state->svg_props->visibility) != SVG_VISIBILITY_HIDDEN) ) {
GF_Matrix mx_bck;
Bool restore_mx = GF_FALSE;
compositor_svg_apply_local_transformation(tr_state, &all_atts, &backup_matrix, &mx_3d);
ctx = drawable_init_context_svg(stack->graph, tr_state);
if (!ctx || !ctx->aspect.fill_texture ) return;
if (svg_video_get_transform_behavior(tr_state, &all_atts, &cx, &cy, &angle)) {
drawable_reset_path(stack->graph);
gf_path_add_rect_center(stack->graph->path, cx, cy, INT2FIX(stack->txh.width), INT2FIX(stack->txh.height));
gf_mx2d_copy(mx_bck, tr_state->transform);
restore_mx = GF_TRUE;
gf_mx2d_init(tr_state->transform);
gf_mx2d_add_rotation(&tr_state->transform, cx, cy, angle);
}
/*even if set this is not true*/
ctx->aspect.pen_props.width = 0;
ctx->flags |= CTX_NO_ANTIALIAS;
/*if rotation, transparent*/
ctx->flags &= ~CTX_IS_TRANSPARENT;
if (ctx->transform.m[1] || ctx->transform.m[3]) {
ctx->flags |= CTX_IS_TRANSPARENT;
ctx->flags &= ~CTX_NO_ANTIALIAS;
}
else if (ctx->aspect.fill_texture->transparent)
ctx->flags |= CTX_IS_TRANSPARENT;
else if (tr_state->svg_props->opacity && (tr_state->svg_props->opacity->type==SVG_NUMBER_VALUE) && (tr_state->svg_props->opacity->value!=FIX_ONE)) {
ctx->flags = CTX_IS_TRANSPARENT;
ctx->aspect.fill_color = GF_COL_ARGB(FIX2INT(0xFF * tr_state->svg_props->opacity->value), 0, 0, 0);
}
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (!stack->graph->mesh) {
stack->graph->mesh = new_mesh();
mesh_from_path(stack->graph->mesh, stack->graph->path);
}
compositor_3d_draw_bitmap(stack->graph, &ctx->aspect, tr_state, 0, 0, FIX_ONE, FIX_ONE);
ctx->drawable = NULL;
} else
#endif
{
drawable_finalize_sort(ctx, tr_state, NULL);
}
if (restore_mx) gf_mx2d_copy(tr_state->transform, mx_bck);
compositor_svg_restore_parent_transformation(tr_state, &backup_matrix, &mx_3d);
}
}
if (stack->audio) svg_traverse_audio_ex(stack->audio, rs, GF_FALSE, tr_state->svg_props);
memcpy(tr_state->svg_props, &backup_props, sizeof(SVGPropertiesPointers));
tr_state->svg_flags = backup_flags;
}
static void svg_traverse_svg(GF_Node *node, void *rs, Bool is_destroy)
{
Bool rootmost_svg, send_resize;
u32 viewport_color;
SVGsvgStack *stack;
GF_Matrix2D backup_matrix, vb_bck;
#ifndef GPAC_DISABLE_3D
GF_Matrix bck_mx;
#endif
Bool is_dirty;
GF_IRect top_clip;
SFVec2f prev_vp;
SVGPropertiesPointers backup_props, *prev_props;
u32 backup_flags;
Bool invalidate_flag;
u32 styling_size = sizeof(SVGPropertiesPointers);
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
SVGAllAttributes all_atts;
stack = gf_node_get_private(node);
if (is_destroy) {
if (stack->svg_props) {
gf_svg_properties_reset_pointers(stack->svg_props);
gf_free(stack->svg_props);
}
gf_sc_check_focus_upon_destroy(node);
if (stack->vp_fill) drawable_del(stack->vp_fill);
gf_free(stack);
return;
}
prev_props = tr_state->svg_props;
/*SVG props not set: we are either the root-most <svg> of the compositor
or an <svg> inside an <animation>*/
if (!tr_state->svg_props) {
tr_state->svg_props = stack->svg_props;
if (!tr_state->svg_props) return;
}
gf_svg_flatten_attributes((SVG_Element *)node, &all_atts);
if (!compositor_svg_traverse_base(node, &all_atts, tr_state, &backup_props, &backup_flags)) {
tr_state->svg_props = prev_props;
return;
}
/*enable or disable navigation*/
tr_state->visual->compositor->navigation_disabled = (all_atts.zoomAndPan && *all_atts.zoomAndPan == SVG_ZOOMANDPAN_DISABLE) ? 1 : 0;
if (compositor_svg_is_display_off(tr_state->svg_props)) {
memcpy(tr_state->svg_props, &backup_props, styling_size);
tr_state->svg_flags = backup_flags;
return;
}
top_clip = tr_state->visual->top_clipper;
gf_mx2d_copy(backup_matrix, tr_state->transform);
gf_mx2d_copy(vb_bck, tr_state->vb_transform);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) gf_mx_copy(bck_mx, tr_state->model_matrix);
#endif
invalidate_flag = tr_state->invalidate_all;
is_dirty = gf_node_dirty_get(node);
if (is_dirty & GF_SG_CHILD_DIRTY) drawable_reset_group_highlight(tr_state, node);
gf_node_dirty_clear(node, 0);
send_resize = 0;
if ((stack->parent_vp.x != tr_state->vp_size.x) || (stack->parent_vp.y != tr_state->vp_size.y)) {
is_dirty = 1;
send_resize = 1;
}
if (is_dirty || tr_state->visual->compositor->recompute_ar) {
svg_recompute_viewport_transformation(node, stack, tr_state, &all_atts);
}
gf_mx2d_copy(tr_state->vb_transform, stack->viewbox_mx);
rootmost_svg = (stack->root_svg && !tr_state->parent_anim_atts) ? 1 : 0;
if (tr_state->traversing_mode == TRAVERSE_SORT) {
SVG_Paint *vp_fill = NULL;
Fixed vp_opacity;
if (tr_state->parent_anim_atts) {
vp_fill = tr_state->parent_anim_atts->viewport_fill;
vp_opacity = tr_state->parent_anim_atts->viewport_fill_opacity ? tr_state->parent_anim_atts->viewport_fill_opacity->value : FIX_ONE;
} else {
vp_fill = tr_state->svg_props->viewport_fill;
vp_opacity = tr_state->svg_props->viewport_fill_opacity ? tr_state->svg_props->viewport_fill_opacity->value : FIX_ONE;
}
if (vp_fill && (vp_fill->type != SVG_PAINT_NONE) && vp_opacity) {
Bool col_dirty = 0;
viewport_color = GF_COL_ARGB_FIXED(vp_opacity, vp_fill->color.red, vp_fill->color.green, vp_fill->color.blue);
if (stack->prev_color != viewport_color) {
stack->prev_color = viewport_color;
col_dirty = 1;
}
if (!rootmost_svg) {
DrawableContext *ctx;
Fixed width = tr_state->parent_anim_atts->width->value;
Fixed height = tr_state->parent_anim_atts->height->value;
if (!stack->vp_fill) {
stack->vp_fill = drawable_new();
stack->vp_fill->node = node;
}
if ((width != stack->vp_fill->path->bbox.width) || (height != stack->vp_fill->path->bbox.height)) {
drawable_reset_path(stack->vp_fill);
gf_path_add_rect(stack->vp_fill->path, 0, 0, width, -height);
}
ctx = drawable_init_context_svg(stack->vp_fill, tr_state);
if (ctx) {
ctx->flags &= ~CTX_IS_TRANSPARENT;
ctx->aspect.pen_props.width = 0;
ctx->aspect.fill_color = viewport_color;
ctx->aspect.fill_texture = NULL;
if (col_dirty) ctx->flags |= CTX_APP_DIRTY;
drawable_finalize_sort(ctx, tr_state, NULL);
}
} else if (col_dirty) {
tr_state->visual->compositor->back_color = viewport_color;
/*invalidate the entire visual*/
tr_state->invalidate_all = 1;
}
}
}
if (!stack->root_svg && (all_atts.x || all_atts.y))
gf_mx2d_add_translation(&tr_state->vb_transform, all_atts.x->value, all_atts.y->value);
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (tr_state->traversing_mode==TRAVERSE_SORT) {
GF_Matrix tmp;
visual_3d_matrix_push(tr_state->visual);
gf_mx_from_mx2d(&tmp, &tr_state->vb_transform);
visual_3d_matrix_add(tr_state->visual, tmp.m);
} else {
gf_mx_add_matrix_2d(&tr_state->model_matrix, &tr_state->vb_transform);
}
} else
#endif
{
gf_mx2d_pre_multiply(&tr_state->transform, &tr_state->vb_transform);
}
/*store VP and move it to current VP (eg, the one used to compute the vb_transform)*/
prev_vp = tr_state->vp_size;
tr_state->vp_size = stack->vp;
/*the event may trigger scripts which may delete nodes / modify the scene. We therefore send the resize event
before traversing the scene*/
if (send_resize) {
GF_DOM_Event evt;
memset(&evt, 0, sizeof(GF_DOM_Event));
evt.bubbles = 1;
evt.type = GF_EVENT_RESIZE;
gf_dom_event_fire(node, &evt);
}
if ((stack->vp.x != prev_vp.x) || (stack->vp.y != prev_vp.y)) {
GF_Scene *scene = node->sgprivate->scenegraph->userpriv;
if (scene) {
GF_DOM_Event evt;
memset(&evt, 0, sizeof(GF_DOM_Event));
evt.bubbles = 0;
evt.screen_rect.width = stack->vpw;
evt.screen_rect.height = stack->vph;
evt.screen_rect.x = stack->dx;
evt.screen_rect.y = stack->dy;
evt.prev_translate.x = stack->vp.x;
evt.prev_translate.y = stack->vp.y;
evt.type = GF_EVENT_VP_RESIZE;
gf_scene_notify_event(scene, 0, NULL, &evt, GF_OK);
}
}
if (tr_state->traversing_mode == TRAVERSE_GET_BOUNDS) {
gf_sc_get_nodes_bounds(node, ((SVG_Element *)node)->children, tr_state, NULL);
} else {
compositor_svg_traverse_children(((SVG_Element *)node)->children, tr_state);
}
tr_state->vp_size = prev_vp;
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->type_3d) {
if (tr_state->traversing_mode==TRAVERSE_SORT) visual_3d_matrix_pop(tr_state->visual);
gf_mx_copy(tr_state->model_matrix, bck_mx);
}
#endif
gf_mx2d_copy(tr_state->transform, backup_matrix);
gf_mx2d_copy(tr_state->vb_transform, vb_bck);
memcpy(tr_state->svg_props, &backup_props, styling_size);
tr_state->svg_flags = backup_flags;
tr_state->visual->top_clipper = top_clip;
if (!stack->root_svg) {
tr_state->invalidate_all = invalidate_flag;
}
tr_state->svg_props = prev_props;
}