GF_EXPORT
Bool gf_inline_is_default_viewpoint(GF_Node *node)
{
const char *nname, *seg_name;
GF_SceneGraph *sg = gf_node_get_graph(node);
GF_Scene *scene = sg ? (GF_Scene *) gf_sg_get_private(sg) : NULL;
if (!scene) return 0;
nname = gf_node_get_name(node);
if (!nname) return 0;
/*check any viewpoint*/
seg_name = strrchr(scene->root_od->net_service->url, '#');
/*check the URL of the parent*/
if (!seg_name && scene->current_url) {
if (scene->current_url->count && scene->current_url->vals[0].url)
seg_name = strrchr(scene->current_url->vals[0].url, '#');
} else if (!seg_name && scene->root_od->mo && scene->root_od->mo->URLs.count && scene->root_od->mo->URLs.vals[0].url) {
seg_name = strrchr(scene->root_od->mo->URLs.vals[0].url, '#');
}
if (!seg_name) return 0;
seg_name += 1;
/*look for a media segment with this name - if none found, this is a viewpoint name*/
if (gf_odm_find_segment(scene->root_od, (char *) seg_name) != NULL) return 0;
return (!strcmp(nname, seg_name));
}
static void RenderSwitch(GF_Node *node, void *rs, Bool is_destroy)
{
GF_ChildNodeItem *l;
u32 i, count;
Bool prev_switch;
GF_ChildNodeItem *children;
s32 whichChoice;
GF_Node *child;
SwitchStack *st = (SwitchStack *)gf_node_get_private(node);
RenderEffect2D *eff;
eff = (RenderEffect2D *)rs;
if (is_destroy) {
free(st);
return;
}
if (gf_node_get_name(node)) {
node = node;
}
/*WARNING: X3D/MPEG4 NOT COMPATIBLE*/
if (gf_node_get_tag(node)==TAG_MPEG4_Switch) {
children = ((M_Switch *)node)->choice;
whichChoice = ((M_Switch *)node)->whichChoice;
} else {
children = ((X_Switch *)node)->children;
whichChoice = ((X_Switch *)node)->whichChoice;
}
count = gf_node_list_get_count(children);
prev_switch = eff->trav_flags;
/*check changes in choice field*/
if ((gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) || (st->last_switch != whichChoice) ) {
eff->trav_flags |= GF_SR_TRAV_SWITCHED_OFF;
i=0;
l = children;
while (l) {
// if ((s32) i!=whichChoice) gf_node_render(l->node, eff);
if ((s32) i == st->last_switch) gf_node_render(l->node, eff);
l = l->next;
i++;
}
eff->trav_flags &= ~GF_SR_TRAV_SWITCHED_OFF;
st->last_switch = whichChoice;
}
gf_node_dirty_clear(node, 0);
/*no need to check for sensors since a sensor is active for the whole parent group, that is for switch itself
CSQ: switch cannot be used to switch sensors, too bad...*/
eff->trav_flags = prev_switch;
if (whichChoice>=0) {
child = (GF_Node*)gf_node_list_get_child(children, whichChoice);
gf_node_render(child, eff);
}
}
// OnAddToTimeLine -- adds a node in the timeline (meaning creating a node ID and adding it to the dictionnary and the pool)
void V4StudioFrame::OnAddToTimeLine(wxCommandEvent &event) {
if (!m_pV4sm) return;
if (!m_selection) return; // don't add nothing
// if object has no node id then create one
if (! gf_node_get_id(m_selection) )
m_pV4sm->CreateIDandAddToPool(m_selection);
// Adds the node to the dictionnary
// m_pV4sm->AddToDictionnary(m_selection);
// calls timeline function to add the line
char c[50];
strcpy(c, gf_node_get_name(m_selection));
timeLine->AddLine( gf_node_get_id(m_selection), wxString(c) );
}
// HasDefParent -- checks if an ancestor of this node has an ID
GF_Node * V4SceneManager::HasDefParent(GF_Node * node) {
assert(node);
// also checks the node itself
int count = gf_node_get_parent_count(node);
GF_Node * parent;
// loops through all the parents and recurses
for (int i=0; i<count; i++) {
parent = gf_node_get_parent(node, i);
const char * name = gf_node_get_name(parent);
if (name) return parent;
parent = HasDefParent(parent);
if (parent) return parent;
}
return NULL;
}
// AddRecursive -- recursively adds items with an ID to the dictionnary
void V4SceneManager::AddRecursive(GF_Node * node, bool parentAdded) {
// skips empty nodes
if (!node) return;
// skips the dictionnary
const char * c = gf_node_get_name(node);
if ( (c != NULL) && (!strcmp(c, DICTNAME)) ) return;
// if node as an id adds it to the dictionnary and the node pool
u32 id = gf_node_get_id(node);
if (id) {
pools.Add(node);
// children of added node are not added to the dictionnary
if (!parentAdded) AddEffective(node);
parentAdded = true;
}
GF_FieldInfo field;
GF_ChildNodeItem * list;
int count = gf_node_get_field_count(node);
// tests all fields, if a field is a node then adds it and process its children recursively
for (int i=0; i<count; i++) {
gf_node_get_field(node, i, &field);
// single value node field
if (field.fieldType == GF_SG_VRML_SFNODE)
AddRecursive( * ((GF_Node **) field.far_ptr), parentAdded );
// multiple value node field
if (field.fieldType == GF_SG_VRML_MFNODE) {
list = *( (GF_ChildNodeItem **) field.far_ptr);
for (u32 j=0; j<gf_node_list_get_count(list); j++)
AddRecursive( (GF_Node *) gf_node_list_get_child(list, j), parentAdded );
}
}
}
GF_EXPORT
Bool gf_mo_get_visual_info(GF_MediaObject *mo, u32 *width, u32 *height, u32 *stride, u32 *pixel_ar, u32 *pixelFormat, Bool *is_flipped)
{
GF_CodecCapability cap;
if ((mo->type != GF_MEDIA_OBJECT_VIDEO) && (mo->type!=GF_MEDIA_OBJECT_TEXT)) return GF_FALSE;
if (width) {
cap.CapCode = GF_CODEC_WIDTH;
gf_codec_get_capability(mo->odm->codec, &cap);
*width = cap.cap.valueInt;
}
if (height) {
cap.CapCode = GF_CODEC_HEIGHT;
gf_codec_get_capability(mo->odm->codec, &cap);
*height = cap.cap.valueInt;
}
if (mo->type==GF_MEDIA_OBJECT_TEXT) return GF_TRUE;
if (is_flipped) {
cap.CapCode = GF_CODEC_FLIP;
cap.cap.valueInt = 0;
gf_codec_get_capability(mo->odm->codec, &cap);
*is_flipped = cap.cap.valueInt ? GF_TRUE : GF_FALSE;
}
if (stride) {
cap.CapCode = GF_CODEC_STRIDE;
gf_codec_get_capability(mo->odm->codec, &cap);
*stride = cap.cap.valueInt;
}
if (pixelFormat) {
cap.CapCode = GF_CODEC_PIXEL_FORMAT;
gf_codec_get_capability(mo->odm->codec, &cap);
*pixelFormat = cap.cap.valueInt;
if (mo->odm && mo->odm->parentscene->is_dynamic_scene) {
#ifndef GPAC_DISABLE_VRML
const char *name = gf_node_get_name(gf_event_target_get_node(gf_mo_event_target_get(mo, 0)));
if (name && !strcmp(name, "DYN_VIDEO")) {
const char *opt;
u32 r, g, b, a;
M_Background2D *back = (M_Background2D *) gf_sg_find_node_by_name(mo->odm->parentscene->graph, "DYN_BACK");
if (back) {
switch (cap.cap.valueInt) {
case GF_PIXEL_ARGB:
case GF_PIXEL_RGBA:
case GF_PIXEL_YUVA:
opt = gf_cfg_get_key(mo->odm->term->user->config, "Compositor", "BackColor");
if (!opt) {
gf_cfg_set_key(mo->odm->term->user->config, "Compositor", "BackColor", "FF999999");
opt = "FF999999";
}
sscanf(opt, "%02X%02X%02X%02X", &a, &r, &g, &b);
back->backColor.red = INT2FIX(r)/255;
back->backColor.green = INT2FIX(g)/255;
back->backColor.blue = INT2FIX(b)/255;
break;
default:
back->backColor.red = back->backColor.green = back->backColor.blue = 0;
break;
}
gf_node_dirty_set((GF_Node *)back, 0, GF_TRUE);
}
}
#endif
}
}
/*get PAR settings*/
if (pixel_ar) {
cap.CapCode = GF_CODEC_PAR;
gf_codec_get_capability(mo->odm->codec, &cap);
*pixel_ar = cap.cap.valueInt;
if (! (*pixel_ar & 0x0000FFFF)) *pixel_ar = 0;
if (! (*pixel_ar & 0xFFFF0000)) *pixel_ar = 0;
/**/
if (! *pixel_ar) {
GF_Channel *ch;
GF_NetworkCommand com;
com.base.command_type = GF_NET_CHAN_GET_PIXEL_AR;
ch = (GF_Channel *)gf_list_get(mo->odm->channels, 0);
if (!ch) return GF_FALSE;
com.base.on_channel = ch;
com.par.hSpacing = com.par.vSpacing = 0;
if (gf_term_service_command(ch->service, &com) == GF_OK) {
if ((com.par.hSpacing>65535) || (com.par.vSpacing>65535)) {
com.par.hSpacing>>=16;
com.par.vSpacing>>=16;
}
if (com.par.hSpacing|| com.par.vSpacing)
*pixel_ar = (com.par.hSpacing<<16) | com.par.vSpacing;
}
}
static void svg_parse_animation(GF_SceneGraph *sg, SVG_DeferedAnimation *anim)
{
GF_FieldInfo info;
u32 tag;
u8 anim_value_type = 0;
if (anim->resolve_stage==0) {
/* Stage 0: parsing the animation attribute values
for that we need to resolve the target first */
if (!anim->target)
anim->target = (SVG_Element *) gf_sg_find_node_by_name(sg, anim->target_id + 1);
if (!anim->target) {
/* the target is still not known stay in stage 0 */
return;
} else {
XMLRI *iri;
gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_XLINK_ATT_href, 1, 0, &info);
iri = (XMLRI *)info.far_ptr;
iri->type = XMLRI_ELEMENTID;
iri->target = anim->target;
gf_node_register_iri(sg, iri);
}
tag = gf_node_get_tag((GF_Node *)anim->animation_elt);
/* get the attribute name attribute if specified */
if (anim->type && (tag== TAG_SVG_animateTransform) ) {
gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_transform_type, 1, 0, &info);
gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->type, 0);
switch(*(SVG_TransformType *) info.far_ptr) {
case SVG_TRANSFORM_TRANSLATE:
anim_value_type = SVG_Transform_Translate_datatype;
break;
case SVG_TRANSFORM_SCALE:
anim_value_type = SVG_Transform_Scale_datatype;
break;
case SVG_TRANSFORM_ROTATE:
anim_value_type = SVG_Transform_Rotate_datatype;
break;
case SVG_TRANSFORM_SKEWX:
anim_value_type = SVG_Transform_SkewX_datatype;
break;
case SVG_TRANSFORM_SKEWY:
anim_value_type = SVG_Transform_SkewY_datatype;
break;
case SVG_TRANSFORM_MATRIX:
anim_value_type = SVG_Transform_datatype;
break;
default:
fprintf(stdout, "unknown datatype for animate transform");
return;
}
}
else if (gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_attributeName, 0, 0, &info) == GF_OK) {
gf_node_get_attribute_by_name((GF_Node *)anim->target, ((SMIL_AttributeName *)info.far_ptr)->name, 0, 1, 1, &info);
anim_value_type = info.fieldType;
} else {
if (tag == TAG_SVG_animateMotion) {
anim_value_type = SVG_Motion_datatype;
} else if (tag == TAG_SVG_discard) {
/* there is no value to parse in discard, we can jump to the next stage */
anim->resolve_stage = 1;
svg_parse_animation(sg, anim);
return;
} else {
fprintf(stdout, "Missing attributeName attribute on %s", gf_node_get_name((GF_Node *)anim->animation_elt));
return;
}
}
if (anim->to) {
gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_to, 1, 0, &info);
gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->to, anim_value_type);
}
if (anim->from) {
gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_from, 1, 0, &info);
gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->from, anim_value_type);
}
if (anim->by) {
gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_by, 1, 0, &info);
gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->by, anim_value_type);
}
if (anim->values) {
gf_node_get_attribute_by_tag((GF_Node *)anim->animation_elt, TAG_SVG_ATT_values, 1, 0, &info);
gf_svg_parse_attribute((GF_Node *)anim->animation_elt, &info, anim->values, anim_value_type);
}
anim->resolve_stage = 1;
}
}
void svg_drawable_3d_pick(Drawable *drawable, GF_TraverseState *tr_state, DrawAspect2D *asp)
{
SFVec3f local_pt, world_pt, vdiff;
SFVec3f hit_normal;
SFVec2f text_coords;
u32 i, count;
Fixed sqdist;
Bool node_is_over;
GF_Compositor *compositor;
GF_Matrix mx;
GF_Ray r;
compositor = tr_state->visual->compositor;
node_is_over = 0;
r = tr_state->ray;
gf_mx_copy(mx, tr_state->model_matrix);
gf_mx_inverse(&mx);
gf_mx_apply_ray(&mx, &r);
/*if we already have a hit point don't check anything below...*/
if (compositor->hit_square_dist && !compositor->grabbed_sensor && !tr_state->layer3d) {
GF_Plane p;
GF_BBox box;
SFVec3f hit = compositor->hit_world_point;
gf_mx_apply_vec(&mx, &hit);
p.normal = r.dir;
p.d = -1 * gf_vec_dot(p.normal, hit);
gf_bbox_from_rect(&box, &drawable->path->bbox);
if (gf_bbox_plane_relation(&box, &p) == GF_BBOX_FRONT) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] bounding box of node %s (DEF %s) below current hit point - skipping\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node)));
return;
}
}
node_is_over = 0;
if (compositor_get_2d_plane_intersection(&r, &local_pt)) {
node_is_over = svg_drawable_is_over(drawable, local_pt.x, local_pt.y, asp, tr_state, NULL);
}
if (!node_is_over) return;
hit_normal.x = hit_normal.y = 0; hit_normal.z = FIX_ONE;
text_coords.x = gf_divfix(local_pt.x, drawable->path->bbox.width) + FIX_ONE/2;
text_coords.y = gf_divfix(local_pt.y, drawable->path->bbox.height) + FIX_ONE/2;
/*check distance from user and keep the closest hitpoint*/
world_pt = local_pt;
gf_mx_apply_vec(&tr_state->model_matrix, &world_pt);
for (i=0; i<tr_state->num_clip_planes; i++) {
if (gf_plane_get_distance(&tr_state->clip_planes[i], &world_pt) < 0) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s (def %s) is not in clipper half space\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node)));
return;
}
}
gf_vec_diff(vdiff, world_pt, tr_state->ray.orig);
sqdist = gf_vec_lensq(vdiff);
if (compositor->hit_square_dist && (compositor->hit_square_dist+FIX_EPSILON<sqdist)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s (def %s) is farther (%g) than current pick (%g)\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node), FIX2FLT(sqdist), FIX2FLT(compositor->hit_square_dist)));
return;
}
compositor->hit_square_dist = sqdist;
/*also stack any VRML sensors present at the current level. If the event is not catched
by a listener in the SVG tree, the event will be forwarded to the VRML tree*/
gf_list_reset(compositor->sensors);
count = gf_list_count(tr_state->vrml_sensors);
for (i=0; i<count; i++) {
gf_list_add(compositor->sensors, gf_list_get(tr_state->vrml_sensors, i));
}
gf_mx_copy(compositor->hit_world_to_local, tr_state->model_matrix);
gf_mx_copy(compositor->hit_local_to_world, mx);
compositor->hit_local_point = local_pt;
compositor->hit_world_point = world_pt;
compositor->hit_world_ray = tr_state->ray;
compositor->hit_normal = hit_normal;
compositor->hit_texcoords = text_coords;
svg_clone_use_stack(compositor, tr_state);
/*not use in SVG patterns*/
compositor->hit_appear = NULL;
compositor->hit_node = drawable->node;
compositor->hit_text = NULL;
compositor->hit_use_dom_events = 1;
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Picking] node %s (def %s) is under mouse - hit %g %g %g\n", gf_node_get_class_name(drawable->node), gf_node_get_name(drawable->node),
FIX2FLT(world_pt.x), FIX2FLT(world_pt.y), FIX2FLT(world_pt.z)));
}
// GetName --
wxString V4Node::GetName() {
return wxString(gf_node_get_name(node));
}
static void svg2bifs_node_start(void *sax_cbck, const char *name, const char *name_space, const GF_XMLAttribute *attributes, u32 nb_attributes)
{
u32 i;
SVG_SANI_BIFS_Converter *converter = (SVG_SANI_BIFS_Converter *)sax_cbck;
SVGPropertiesPointers *backup_props;
char *id_string = NULL;
u32 tag = gf_svg_get_element_tag(name);
SVG_Element *elt = (SVG_Element*)gf_node_new(converter->svg_sg, tag);
if (!gf_sg_get_root_node(converter->svg_sg)) {
gf_node_register((GF_Node *)elt, NULL);
gf_sg_set_root_node(converter->svg_sg, (GF_Node *)elt);
} else {
gf_node_register((GF_Node *)elt, converter->svg_parent);
//gf_node_list_add_child(&((GF_ParentNode*)converter->svg_parent)->children, (GF_Node *)elt);
}
converter->svg_parent = (GF_Node *)elt;
// fprintf(stdout, "Converting %s\n", gf_node_get_class_name((GF_Node *)elt));
// if (converter->bifs_parent) fprintf(stdout, "%s\n", gf_node_get_class_name(converter->bifs_parent));
for (i=0; i<nb_attributes; i++) {
GF_XMLAttribute *att = (GF_XMLAttribute *)&attributes[i];
if (!att->value || !strlen(att->value)) continue;
if (!stricmp(att->name, "style")) {
gf_svg_parse_style((GF_Node *)elt, att->value);
} else if (!stricmp(att->name, "id") || !stricmp(att->name, "xml:id")) {
gf_svg_parse_element_id((GF_Node *)elt, att->value, 0);
id_string = att->value;
} else {
GF_FieldInfo info;
if (gf_node_get_field_by_name((GF_Node *)elt, att->name, &info)==GF_OK) {
gf_svg_parse_attribute((GF_Node *)elt, &info, att->value, 0);
} else {
fprintf(stdout, "Skipping attribute %s\n", att->name);
}
}
}
memset(&converter->all_atts, 0, sizeof(SVGAllAttributes));
gf_svg_flatten_attributes(elt, &converter->all_atts);
backup_props = gf_malloc(sizeof(SVGPropertiesPointers));
memcpy(backup_props, &converter->svg_props, sizeof(SVGPropertiesPointers));
gf_node_set_private((GF_Node *)elt, backup_props);
gf_svg_apply_inheritance(&converter->all_atts, &converter->svg_props);
if (!gf_sg_get_root_node(converter->bifs_sg)) {
if (tag == TAG_SVG_svg) {
GF_Node *node, *child;
converter->bifs_sg->usePixelMetrics = 1;
if (converter->all_atts.width && converter->all_atts.width->type == SVG_NUMBER_VALUE) {
converter->bifs_sg->width = FIX2INT(converter->all_atts.width->value);
} else {
converter->bifs_sg->width = 320;
}
if (converter->all_atts.height && converter->all_atts.height->type == SVG_NUMBER_VALUE) {
converter->bifs_sg->height = FIX2INT(converter->all_atts.height->value);
} else {
converter->bifs_sg->height = 200;
}
node = gf_node_new(converter->bifs_sg, TAG_MPEG4_OrderedGroup);
gf_node_register(node, NULL);
gf_sg_set_root_node(converter->bifs_sg, node);
/* SVG to BIFS coordinate transformation */
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Viewport);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
if (converter->all_atts.viewBox) {
M_Viewport *vp = (M_Viewport*)child;
vp->size.x = converter->all_atts.viewBox->width;
vp->size.y = converter->all_atts.viewBox->height;
vp->position.x = converter->all_atts.viewBox->x+converter->all_atts.viewBox->width/2;
vp->position.y = -(converter->all_atts.viewBox->y+converter->all_atts.viewBox->height/2);
} else {
M_Viewport *vp = (M_Viewport*)child;
vp->size.x = INT2FIX(converter->bifs_sg->width);
vp->size.y = INT2FIX(converter->bifs_sg->height);
vp->position.x = INT2FIX(converter->bifs_sg->width)/2;
vp->position.y = -INT2FIX(converter->bifs_sg->height)/2;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Background2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Background2D *b = (M_Background2D *)child;
b->backColor.red = FIX_ONE;
b->backColor.green = FIX_ONE;
b->backColor.blue = FIX_ONE;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
{
M_Transform2D *tr = (M_Transform2D *)node;
tr->scale.y = -FIX_ONE;
}
converter->bifs_parent = node;
}
} else {
GF_Node *node, *child;
node = converter->bifs_parent;
switch(tag) {
case TAG_SVG_g:
{
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
} else {
M_Group *g = (M_Group*)gf_node_new(converter->bifs_sg, TAG_MPEG4_Group);
gf_node_register((GF_Node *)g, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, (GF_Node *)g);
node = (GF_Node *)g;
converter->bifs_parent = node;
}
}
break;
case TAG_SVG_rect:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->all_atts.x || converter->all_atts.y) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
{
M_Transform2D *tr = (M_Transform2D *)node;
if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value + (converter->all_atts.width?converter->all_atts.width->value/2:0);
if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value + (converter->all_atts.height?converter->all_atts.height->value/2:0);
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_Rectangle);
gf_node_register(shape->geometry, (GF_Node *)shape);
{
M_Rectangle *rect = (M_Rectangle *)shape->geometry;
if (converter->all_atts.width) rect->size.x = converter->all_atts.width->value;
if (converter->all_atts.height) rect->size.y = converter->all_atts.height->value;
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_path:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->all_atts.x || converter->all_atts.y) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
{
M_Transform2D *tr = (M_Transform2D *)node;
if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value;
if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_XCurve2D);
gf_node_register(shape->geometry, (GF_Node *)shape);
if (converter->all_atts.d) {
M_Coordinate2D *c2d;
M_XCurve2D *xc = (M_XCurve2D *)shape->geometry;
u32 i, j, c;
xc->point = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D);
c2d = (M_Coordinate2D *)xc->point;
gf_node_register(xc->point, (GF_Node *)xc);
gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, converter->all_atts.d->n_points);
j= 0;
for (i = 0; i < converter->all_atts.d->n_points; i++) {
if (converter->all_atts.d->tags[i] != GF_PATH_CLOSE || i == converter->all_atts.d->n_points-1) {
c2d->point.vals[j] = converter->all_atts.d->points[i];
j++;
}
}
c2d->point.count = j;
gf_sg_vrml_mf_alloc(&xc->type, GF_SG_VRML_MFINT32, converter->all_atts.d->n_points);
c = 0;
j = 0;
xc->type.vals[0] = 0;
for (i = 1; i < converter->all_atts.d->n_points; i++) {
switch(converter->all_atts.d->tags[i]) {
case GF_PATH_CURVE_ON:
if (c < converter->all_atts.d->n_contours &&
i-1 == converter->all_atts.d->contours[c]) {
xc->type.vals[j] = 0;
c++;
} else {
xc->type.vals[j] = 1;
}
break;
case GF_PATH_CURVE_CUBIC:
xc->type.vals[j] = 2;
i+=2;
break;
case GF_PATH_CLOSE:
xc->type.vals[j] = 6;
break;
case GF_PATH_CURVE_CONIC:
xc->type.vals[j] = 7;
i++;
break;
}
j++;
}
xc->type.count = j;
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_polyline:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_IndexedFaceSet2D);
gf_node_register(shape->geometry, (GF_Node *)shape);
if (converter->all_atts.points) {
M_Coordinate2D *c2d;
M_IndexedFaceSet2D *ifs = (M_IndexedFaceSet2D *)shape->geometry;
u32 i;
ifs->coord = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D);
c2d = (M_Coordinate2D *)ifs->coord;
gf_node_register(ifs->coord, (GF_Node *)ifs);
gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, gf_list_count(*converter->all_atts.points));
for (i = 0; i < gf_list_count(*converter->all_atts.points); i++) {
SVG_Point *p = (SVG_Point *)gf_list_get(*converter->all_atts.points, i);
c2d->point.vals[i].x = p->x;
c2d->point.vals[i].y = p->y;
}
}
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_text:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Transform2D *tr = (M_Transform2D *)child;
if (converter->all_atts.text_x) tr->translation.x = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_x, 0))->value;
if (converter->all_atts.text_y) tr->translation.y = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_y, 0))->value;
tr->scale.y = -FIX_ONE;
}
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_FontStyle *fs;
M_Text *text;
M_Shape *shape = (M_Shape *)node;
text = (M_Text *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Text);
shape->geometry = (GF_Node *)text;
converter->bifs_text_node = shape->geometry;
gf_node_register(shape->geometry, (GF_Node *)shape);
fs = (M_FontStyle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_XFontStyle);
gf_node_register((GF_Node *)fs, (GF_Node*)text);
text->fontStyle = (GF_Node *)fs;
gf_sg_vrml_mf_alloc(&fs->family, GF_SG_VRML_MFSTRING, 1);
fs->family.vals[0] = strdup(converter->svg_props.font_family->value);
fs->size = converter->svg_props.font_size->value;
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_ellipse:
case TAG_SVG_circle:
{
Bool is_parent_set = 0;
if (converter->all_atts.transform) {
node = add_transform(converter, node);
converter->bifs_parent = node;
is_parent_set = 1;
}
if (converter->all_atts.cx || converter->all_atts.cy) {
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
{
M_Transform2D *tr = (M_Transform2D *)child;
if (converter->all_atts.cx) tr->translation.x = converter->all_atts.cx->value;
if (converter->all_atts.cy) tr->translation.y = converter->all_atts.cy->value;
}
node = child;
child = NULL;
if (!is_parent_set) {
converter->bifs_parent = node;
is_parent_set = 1;
}
}
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
if (!is_parent_set) converter->bifs_parent = node;
{
M_Shape *shape = (M_Shape *)node;
if (tag == TAG_SVG_ellipse) {
M_Ellipse *e = (M_Ellipse *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Ellipse);
shape->geometry = (GF_Node *)e;
e->radius.x = converter->all_atts.rx->value;
e->radius.y = converter->all_atts.ry->value;
} else {
M_Circle *c = (M_Circle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Circle);
shape->geometry = (GF_Node *)c;
c->radius = converter->all_atts.r->value;
}
gf_node_register(shape->geometry, (GF_Node *)shape);
shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg);
gf_node_register(shape->appearance, (GF_Node *)shape);
}
}
break;
case TAG_SVG_defs:
{
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Switch);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
{
M_Switch *sw = (M_Switch *)node;
sw->whichChoice = -1;
}
converter->bifs_parent = node;
}
break;
case TAG_SVG_solidColor:
{
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
converter->bifs_parent = node;
}
break;
default:
{
fprintf(stdout, "Warning: element %s not supported \n", gf_node_get_class_name((GF_Node *)elt));
child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D);
gf_node_register(child, node);
gf_node_list_add_child(&((GF_ParentNode*)node)->children, child);
node = child;
child = NULL;
converter->bifs_parent = node;
}
break;
}
if (id_string)
gf_node_set_id(converter->bifs_parent, gf_node_get_id((GF_Node *)elt), gf_node_get_name((GF_Node *)elt));
}
}
void V4StudioTree::AddNodesToItem(wxTreeItemId parentItemId, GF_Node * node, s32 fieldIndex, s32 position)
{
GF_FieldInfo field;
u32 count, i, j;
char *name;
if (!node) return;
// displays the name and the defname it exists
u32 s = strlen(gf_node_get_class_name(node));
if (gf_node_get_name(node)) {
s += strlen(gf_node_get_name(node));
name = new char[s+4];
strcpy(name, gf_node_get_class_name(node));
strcat(name, " - ");
strcat(name, gf_node_get_name(node));
} else {
name = new char[s+1];
strcpy(name, gf_node_get_class_name(node));
}
GF_Node * parent = NULL;
V4StudioTreeItemData *parentItemData = (V4StudioTreeItemData *)GetItemData(parentItemId);
if (parentItemData != NULL) parent = parentItemData->GetNode();
V4StudioTreeItemData * currentItemData = new V4StudioTreeItemData(node, parent, fieldIndex, position);
wxTreeItemId nodeItemId;
if (position == -1) nodeItemId = AppendItem(parentItemId, wxString(name), -1, -1, currentItemData);
else nodeItemId = InsertItem(parentItemId, position, wxString(name), -1, -1, currentItemData);
delete [] name;
name = NULL;
count = gf_node_get_field_count(node);
for (i=0;i<count; i++) {
gf_node_get_field(node, i, &field);
if (field.eventType == GF_SG_EVENT_IN || field.eventType == GF_SG_EVENT_OUT) continue;
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
if (* (GF_Node **) field.far_ptr) {
AddNodesToItem(nodeItemId, * (GF_Node **) field.far_ptr, i, -1);
}
break;
case GF_SG_VRML_MFNODE:
{
GF_List *nodes = (* (GF_List **) field.far_ptr); // list of children
u32 nbNodes = gf_list_count(nodes);
u8 skipped = 0; // counts nodes not added
for (j=0; j< nbNodes; j++) {
// gets a pointer to the current child
GF_Node *child = (GF_Node *)gf_list_get(nodes, j);
// prevents the dictionnary from being added to the graph
const char * c = gf_node_get_name(child);
if ( (c != NULL) && !strcmp(c,DICTNAME) ) {
skipped++;
continue;
}
// recursively adds children
AddNodesToItem(nodeItemId, child, i, j-skipped);
}
}
break;
default:
break;
}
}
Expand(nodeItemId);
}
/* Returns:
0 if no rendering traversal is required,
1 if a rendering traversal is required!!!,
-1 if the time node is a discard which has been deleted!! */
s32 gf_smil_timing_notify_time(SMIL_Timing_RTI *rti, Double scene_time)
{
Fixed simple_time;
s32 ret = 0;
GF_DOM_Event evt;
SMILTimingAttributesPointers *timingp = rti->timingp;
if (!timingp) return 0;
if (rti->scene_time == scene_time) return 0;
rti->scene_time = scene_time;
rti->cycle_number++;
/* for fraction events, we indicate that the scene needs redraw */
if (rti->evaluate_status == SMIL_TIMING_EVAL_FRACTION)
return 1;
if (rti->evaluate_status == SMIL_TIMING_EVAL_DISCARD) {
/* TODO: FIX ME discarding should send a begin event ? */
/* -1 is a special case when the discard is evaluated */
if (gf_smil_discard(rti, FLT2FIX(rti->scene_time))) return -1;
else return 0;
}
gf_node_register(rti->timed_elt, NULL);
waiting_to_begin:
if (rti->status == SMIL_STATUS_WAITING_TO_BEGIN) {
if (rti->current_interval && scene_time >= rti->current_interval->begin) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SMIL Timing ] Time %f - Timed element %s - Activating\n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_name((GF_Node *)rti->timed_elt)));
rti->status = SMIL_STATUS_ACTIVE;
memset(&evt, 0, sizeof(evt));
evt.type = GF_EVENT_BEGIN_EVENT;
evt.smil_event_time = rti->current_interval->begin;
gf_dom_event_fire((GF_Node *)rti->timed_elt, NULL, &evt);
if (rti->timed_elt->sgprivate->tag==TAG_SVG_conditional) {
SVG_Element *e = (SVG_Element *)rti->timed_elt;
/*activate conditional*/
if (e->children) gf_node_render(e->children->node, NULL);
rti->status = SMIL_STATUS_DONE;
} else {
gf_smil_reorder_anim(rti);
}
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SMIL Timing ] Time %f - Timed element %s - Evaluating (Not starting)\n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_name((GF_Node *)rti->timed_elt)));
ret = -2;
goto exit;
}
}
if (rti->status == SMIL_STATUS_ACTIVE) {
u32 cur_id;
if (rti->current_interval->active_duration >= 0
&& scene_time >= (rti->current_interval->begin + rti->current_interval->active_duration)) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SMIL Timing ] Time %f - Timed element %s - Stopping \n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_name((GF_Node *)rti->timed_elt)));
memset(&evt, 0, sizeof(evt));
evt.type = GF_EVENT_END_EVENT;
evt.smil_event_time = rti->current_interval->begin + rti->current_interval->active_duration;
gf_dom_event_fire((GF_Node *)rti->timed_elt, NULL, &evt);
ret = rti->postpone;
if (timingp->fill && *timingp->fill == SMIL_FILL_FREEZE) {
rti->status = SMIL_STATUS_FROZEN;
rti->first_frozen = rti->cycle_number;
rti->evaluate_status = SMIL_TIMING_EVAL_FREEZE;
if (!rti->postpone) {
Fixed simple_time = gf_smil_timing_get_normalized_simple_time(rti, scene_time);
rti->evaluate(rti, simple_time, rti->evaluate_status);
}
} else {
rti->status = SMIL_STATUS_DONE;
rti->first_frozen = rti->cycle_number;
rti->evaluate_status = SMIL_TIMING_EVAL_REMOVE;
if (!rti->postpone) {
Fixed simple_time = gf_smil_timing_get_normalized_simple_time(rti, scene_time);
rti->evaluate(rti, simple_time, rti->evaluate_status);
}
}
}
/*special case for unspecified simpleDur with animations (not with media timed elements)*/
else if (0 && rti->postpone
&& (rti->current_interval->simple_duration==-1)
&& (rti->current_interval->active_duration<=0)
) {
ret = 1;
rti->status = SMIL_STATUS_FROZEN;
rti->first_frozen = rti->cycle_number;
rti->evaluate_status = SMIL_TIMING_EVAL_FREEZE;
} else { // the animation is still active
if (!timingp->restart || *timingp->restart == SMIL_RESTART_ALWAYS) {
s32 interval_index;
interval_index = gf_smil_timing_find_interval_index(rti, scene_time);
if (interval_index >= 0 &&
interval_index != rti->current_interval_index) {
/* intervals are different, use the new one */
rti->current_interval_index = interval_index;
rti->current_interval = (SMIL_Interval*)gf_list_get(rti->intervals, rti->current_interval_index);
/* reinserting the new timed elements at its proper place in the list
of timed elements in the scenegraph */
gf_smil_reorder_timing(rti);
/* if this is animation, reinserting the animation in the list of animations
that targets this attribute, so that it is the last one */
gf_smil_reorder_anim(rti);
memset(&evt, 0, sizeof(evt));
evt.type = GF_EVENT_BEGIN_EVENT;
evt.smil_event_time = rti->current_interval->begin;
gf_dom_event_fire((GF_Node *)rti->timed_elt, NULL, &evt);
}
}
ret = rti->postpone;
cur_id = rti->current_interval->nb_iterations;
simple_time = gf_smil_timing_get_normalized_simple_time(rti, scene_time);
if (cur_id < rti->current_interval->nb_iterations) {
memset(&evt, 0, sizeof(evt));
evt.type = GF_EVENT_REPEAT_EVENT;
evt.smil_event_time = rti->current_interval->begin + rti->current_interval->nb_iterations*rti->current_interval->simple_duration;
evt.detail = rti->current_interval->nb_iterations;
gf_dom_event_fire((GF_Node *)rti->timed_elt, NULL, &evt);
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SMIL Timing ] Time %f - Timed element %s - Repeating\n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_name((GF_Node *)rti->timed_elt)));
rti->evaluate_status = SMIL_TIMING_EVAL_REPEAT;
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SMIL Timing ] Time %f - Timed element %s - Updating\n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_name((GF_Node *)rti->timed_elt)));
rti->evaluate_status = SMIL_TIMING_EVAL_UPDATE;
}
if (!rti->postpone) {
rti->evaluate(rti, simple_time, rti->evaluate_status);
}
}
}
if ((rti->status == SMIL_STATUS_DONE) || (rti->status == SMIL_STATUS_FROZEN)) {
if (!timingp->restart || *timingp->restart != SMIL_RESTART_NEVER) {
/* Check changes in begin or end attributes */
s32 interval_index;
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SMIL Timing ] Time %f - Timed element %s - Checking for restart\n", gf_node_get_scene_time((GF_Node *)rti->timed_elt), gf_node_get_name((GF_Node *)rti->timed_elt)));
interval_index = gf_smil_timing_find_interval_index(rti, scene_time);
if (interval_index >= 0 && interval_index != rti->current_interval_index) {
/* intervals are different, use the new one */
rti->current_interval_index = interval_index;
rti->current_interval = (SMIL_Interval*)gf_list_get(rti->intervals, rti->current_interval_index);
/* reinserting the new timed elements at its proper place in the list
of timed elements in the scenegraph */
gf_smil_reorder_timing(rti);
rti->status = SMIL_STATUS_WAITING_TO_BEGIN;
rti->evaluate_status = SMIL_TIMING_EVAL_NONE;
goto waiting_to_begin;
}
} else if ((rti->status == SMIL_STATUS_DONE) &&
timingp->restart && (*timingp->restart == SMIL_RESTART_NEVER)) {
/* the timed element is done and cannot restart, we don't need to evaluate it anymore */
GF_SceneGraph * sg = rti->timed_elt->sgprivate->scenegraph;
while (sg->parent_scene) sg = sg->parent_scene;
gf_list_del_item(sg->smil_timed_elements, rti);
}
}
exit:
gf_node_unregister(rti->timed_elt, NULL);
return ret;
}
static Bool gf_smil_discard(SMIL_Timing_RTI *rti, Fixed scene_time)
{
u32 nb_inst;
SMIL_Time *begin;
SMILTimingAttributesPointers *timingp = rti->timingp;
GF_Node *target;
u32 tag = gf_node_get_tag(rti->timed_elt);
if (!timingp) return 0;
if ((tag>=GF_NODE_RANGE_FIRST_SVG) && (tag<=GF_NODE_RANGE_LAST_SVG)) {
target = ((SVGTimedAnimBaseElement *)rti->timed_elt)->xlinkp->href->target;
}
#ifdef GPAC_ENABLE_SVG_SA
else if ((tag>=GF_NODE_RANGE_FIRST_SVG_SA) && (tag<=GF_NODE_RANGE_LAST_SVG_SA)) {
target = ((SVG_SA_Element *)rti->timed_elt)->xlinkp->href->target;
}
#endif
#ifdef GPAC_ENABLE_SVG_SANI
else if ((tag>=GF_NODE_RANGE_FIRST_SVG_SANI) && (tag<=GF_NODE_RANGE_LAST_SVG_SANI)) {
target = ((SVG_SANI_Element *)rti->timed_elt)->xlinkp->href->target;
}
#endif
else {
return 0;
}
begin = (timingp->begin ? (SMIL_Time *)gf_list_get(*timingp->begin, 0) : NULL);
if (!begin) return 0;
if (!GF_SMIL_TIME_IS_CLOCK(begin->type) ) return 0;
if (!target) return 0;
if (begin->clock > scene_time) return 0;
GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[SVG Composer] discarding element %s at time %f\n", gf_node_get_name(target), scene_time));
/*this takes care of cases where discard is a child of its target*/
gf_node_register(rti->timed_elt, NULL);
nb_inst = gf_node_get_num_instances(rti->timed_elt);
gf_node_replace(target, NULL, 0);
if (nb_inst == gf_node_get_num_instances(rti->timed_elt)) {
gf_node_unregister(rti->timed_elt, NULL);
/*after this the stack may be free'd*/
gf_node_replace(rti->timed_elt, NULL, 0);
} else {
gf_node_unregister(rti->timed_elt, NULL);
}
return 1;
}
static void svg_a_handle_event(GF_Node *handler, GF_DOM_Event *event, GF_Node *observer)
{
GF_Compositor *compositor;
GF_Event evt;
SVG_Element *a;
SVGAllAttributes all_atts;
if (event->event_phase & GF_DOM_EVENT_PHASE_PREVENT) return;
assert(gf_node_get_tag((GF_Node*)event->currentTarget->ptr)==TAG_SVG_a);
a = (SVG_Element *) event->currentTarget->ptr;
gf_svg_flatten_attributes(a, &all_atts);
compositor = (GF_Compositor *)gf_node_get_private((GF_Node *)handler);
if (!compositor->user->EventProc) return;
if (!all_atts.xlink_href) return;
if (event->type==GF_EVENT_MOUSEOVER) {
evt.type = GF_EVENT_NAVIGATE_INFO;
if (all_atts.xlink_title) evt.navigate.to_url = *all_atts.xlink_title;
else if (all_atts.xlink_href->string) evt.navigate.to_url = all_atts.xlink_href->string;
else {
evt.navigate.to_url = gf_node_get_name(all_atts.xlink_href->target);
if (!evt.navigate.to_url) evt.navigate.to_url = "document internal link";
}
gf_term_send_event(compositor->term, &evt);
return;
}
evt.type = GF_EVENT_NAVIGATE;
if (all_atts.xlink_href->type == XMLRI_STRING) {
evt.navigate.to_url = gf_term_resolve_xlink(handler, all_atts.xlink_href->string);
if (evt.navigate.to_url) {
if (all_atts.target) {
evt.navigate.parameters = (const char **) &all_atts.target;
evt.navigate.param_count = 1;
} else {
evt.navigate.parameters = NULL;
evt.navigate.param_count = 0;
}
if (evt.navigate.to_url[0] != '#') {
if (compositor->term) {
gf_scene_process_anchor(handler, &evt);
} else {
gf_term_send_event(compositor->term, &evt);
}
gf_free((char *)evt.navigate.to_url);
return;
}
all_atts.xlink_href->target = gf_sg_find_node_by_name(gf_node_get_graph(handler), (char *) evt.navigate.to_url+1);
if (all_atts.xlink_href->target) {
all_atts.xlink_href->type = XMLRI_ELEMENTID;
gf_free((char *)evt.navigate.to_url);
} else {
svg_a_set_view(handler, compositor, evt.navigate.to_url + 1);
gf_free((char *)evt.navigate.to_url);
return;
}
}
}
if (!all_atts.xlink_href->target) {
return;
}
/*this is a time event*/
if (is_timing_target(all_atts.xlink_href->target)) {
gf_smil_timing_insert_clock(all_atts.xlink_href->target, 0, gf_node_get_scene_time((GF_Node *)handler) );
}
/*this is an implicit SVGView event*/
else {
svg_a_set_view(handler, compositor, gf_node_get_name(all_atts.xlink_href->target));
}
}
static void TraverseSwitch(GF_Node *node, void *rs, Bool is_destroy)
{
GF_ChildNodeItem *l;
u32 i, count;
Bool prev_switch;
GF_ChildNodeItem *children;
s32 whichChoice;
GF_Node *child;
SwitchStack *st = (SwitchStack *)gf_node_get_private(node);
GF_TraverseState *tr_state;
tr_state = (GF_TraverseState *)rs;
children = NULL;
/* souchay : be sure to be initialized, -1 seems reasonable since we check if (whichChoice>=0) */
whichChoice = -1;
if (is_destroy) {
gf_sc_check_focus_upon_destroy(node);
gf_free(st);
return;
}
if (gf_node_get_name(node)) {
node = node;
}
/*WARNING: X3D/MPEG4 NOT COMPATIBLE*/
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_Switch:
children = ((M_Switch *)node)->choice;
whichChoice = ((M_Switch *)node)->whichChoice;
break;
#ifndef GPAC_DISABLE_X3D
case TAG_X3D_Switch:
children = ((X_Switch *)node)->children;
whichChoice = ((X_Switch *)node)->whichChoice;
break;
#endif
}
if (tr_state->traversing_mode!=TRAVERSE_GET_BOUNDS) {
count = gf_node_list_get_count(children);
prev_switch = tr_state->switched_off;
/*check changes in choice field*/
if ((gf_node_dirty_get(node) & GF_SG_NODE_DIRTY) || (st->last_switch != whichChoice) ) {
tr_state->switched_off = 1;
i=0;
l = children;
while (l) {
// if ((s32) i!=whichChoice) gf_node_traverse(l->node, tr_state);
if ((s32) i == st->last_switch) gf_node_traverse(l->node, tr_state);
l = l->next;
i++;
}
tr_state->switched_off = 0;
st->last_switch = whichChoice;
}
gf_node_dirty_clear(node, 0);
/*no need to check for sensors since a sensor is active for the whole parent group, that is for switch itself
CSQ: switch cannot be used to switch sensors, too bad...*/
tr_state->switched_off = prev_switch;
}
if (!children) return;
if (whichChoice==-2) {
#ifndef GPAC_DISABLE_3D
if (tr_state->visual->autostereo_type) {
u32 idx;
u32 count = gf_node_list_get_count(children);
/*this should be a bit more subtle (reusing views if missing, ...)...*/
idx = tr_state->visual->current_view % count;
child = (GF_Node*)gf_node_list_get_child(children, idx);
gf_node_traverse(child, tr_state);
return;
} else
#endif //GPAC_DISABLE_3D
{
/*fallback to first view*/
whichChoice=0;
}
}
if (whichChoice>=0) {
child = (GF_Node*)gf_node_list_get_child(children, whichChoice);
gf_node_traverse(child, tr_state);
}
}
