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