// 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_Node *CloneNodeForEditing(GF_SceneGraph *inScene, GF_Node *orig) //, GF_Node *cloned_parent)
{
u32 i, j, count;
GF_Node *node, *child, *tmp;
GF_List *list, *list2;
GF_FieldInfo field_orig, field;
/*this is not a mistake*/
if (!orig) return NULL;
/*check for DEF/USE
if (orig->sgprivate->NodeID) {
node = gf_sg_find_node(inScene, orig->sgprivate->NodeID);
//node already created, USE
if (node) {
gf_node_register(node, cloned_parent);
return node;
}
}
*/
/*create a node*/
/*
if (orig->sgprivate->tag == TAG_MPEG4_ProtoNode) {
proto_node = ((GF_ProtoInstance *)orig)->proto_interface;
//create the instance but don't load the code -c we MUST wait for ISed routes to be cloned before
node = gf_sg_proto_create_node(inScene, proto_node, (GF_ProtoInstance *) orig);
} else {
*/
node = gf_node_new(inScene, gf_node_get_tag(orig));
// }
count = gf_node_get_field_count(orig);
/*copy each field*/
for (i=0; i<count; i++) {
gf_node_get_field(orig, i, &field_orig);
/*get target ptr*/
gf_node_get_field(node, i, &field);
assert(field.eventType==field_orig.eventType);
assert(field.fieldType==field_orig.fieldType);
/*duplicate it*/
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
child = CloneNodeForEditing(inScene, (GF_Node *) (* ((GF_Node **) field_orig.far_ptr)));//, node);
*((GF_Node **) field.far_ptr) = child;
break;
case GF_SG_VRML_MFNODE:
list = *( (GF_List **) field_orig.far_ptr);
list2 = *( (GF_List **) field.far_ptr);
for (j=0; j<gf_list_count(list); j++) {
tmp = (GF_Node *)gf_list_get(list, j);
child = CloneNodeForEditing(inScene, tmp);//, node);
gf_list_add(list2, child);
}
break;
default:
gf_sg_vrml_field_copy(field.far_ptr, field_orig.far_ptr, field.fieldType);
break;
}
}
/*register node
if (orig->sgprivate->NodeID) {
Node_SetID(node, orig->sgprivate->NodeID);
gf_node_register(node, cloned_parent);
}*/
/*init node before creating ISed routes so the eventIn handler are in place*/
if (gf_node_get_tag(node) != TAG_ProtoNode) gf_node_init(node);
return node;
}
static GF_Err StatNodeGraph(GF_StatManager *st, GF_Node *n)
{
GF_Node *clone;
GF_FieldInfo field;
if (!n) return GF_OK;
StatNode(st->stats, n, StatIsUSE(st, n), 0, NULL);
if (n->sgprivate->tag != TAG_ProtoNode) {
clone = gf_node_new(n->sgprivate->scenegraph, n->sgprivate->tag);
} else {
#ifndef GPAC_DISABLE_VRML
clone = gf_sg_proto_create_node(n->sgprivate->scenegraph, ((GF_ProtoInstance *)n)->proto_interface, NULL);
#else
clone = NULL;
#endif
}
if (!clone) return GF_OK;
gf_node_register(clone, NULL);
#ifndef GPAC_DISABLE_SVG
if ((n->sgprivate->tag>= GF_NODE_RANGE_FIRST_SVG) && (n->sgprivate->tag<= GF_NODE_RANGE_LAST_SVG)) {
GF_ChildNodeItem *list = ((SVG_Element *)n)->children;
GF_DOMAttribute *atts = ((GF_DOMNode*)n)->attributes;
while (atts) {
field.far_ptr = atts->data;
field.fieldType = atts->data_type;
field.fieldIndex = atts->tag;
field.name = NULL;
StatSVGAttribute(st->stats, &field);
atts = atts->next;
}
while (list) {
StatNodeGraph(st, list->node);
list = list->next;
}
} else
#endif
if (n->sgprivate->tag == TAG_DOMText) {
} else if (n->sgprivate->tag == TAG_DOMFullNode) {
}
#ifndef GPAC_DISABLE_VRML
else if (n->sgprivate->tag<= GF_NODE_RANGE_LAST_X3D) {
GF_Node *child;
GF_ChildNodeItem *list;
u32 i, count;
GF_FieldInfo clone_field;
count = gf_node_get_field_count(n);
for (i=0; i<count; i++) {
gf_node_get_field(n, i, &field);
if (field.eventType==GF_SG_EVENT_IN) continue;
if (field.eventType==GF_SG_EVENT_OUT) continue;
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
child = *((GF_Node **)field.far_ptr);
StatNodeGraph(st, child);
break;
case GF_SG_VRML_MFNODE:
list = *((GF_ChildNodeItem **)field.far_ptr);
while (list) {
StatNodeGraph(st, list->node);
list = list->next;
}
break;
default:
gf_node_get_field(clone, i, &clone_field);
if (!gf_sg_vrml_field_equal(clone_field.far_ptr, field.far_ptr, field.fieldType)) {
StatField(st->stats, &field);
}
break;
}
}
}
#endif
gf_node_unregister(clone, NULL);
return GF_OK;
}
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);
}
