diff options
Diffstat (limited to '')
| -rw-r--r-- | tools/editor/scene_tree_dock.cpp | 1211 |
1 files changed, 1211 insertions, 0 deletions
diff --git a/tools/editor/scene_tree_dock.cpp b/tools/editor/scene_tree_dock.cpp new file mode 100644 index 000000000..9a43cbfe5 --- /dev/null +++ b/tools/editor/scene_tree_dock.cpp @@ -0,0 +1,1211 @@ +/*************************************************************************/ +/* scene_tree_dock.cpp */ +/*************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* http://www.godotengine.org */ +/*************************************************************************/ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/*************************************************************************/ +#include "scene_tree_dock.h" +#include "editor_node.h" +#include "globals.h" +#include "os/keyboard.h" +#include "scene/resources/packed_scene.h" +#include "editor_settings.h" + + +void SceneTreeDock::_unhandled_key_input(InputEvent p_event) { + + + uint32_t sc = p_event.key.get_scancode_with_modifiers(); + if (!p_event.key.pressed || p_event.key.echo) + return; + + switch(sc) { + case KEY_MASK_CMD|KEY_A: { _tool_selected(TOOL_NEW); } break; + case KEY_MASK_CMD|KEY_D: { _tool_selected(TOOL_DUPLICATE); } break; + case KEY_MASK_CMD|KEY_UP: { _tool_selected(TOOL_MOVE_UP); } break; + case KEY_MASK_CMD|KEY_DOWN: { _tool_selected(TOOL_MOVE_DOWN); } break; + case KEY_DELETE: { _tool_selected(TOOL_ERASE); } break; + } +} + +Node* SceneTreeDock::instance(const String& p_file) { + + Node *parent = scene_tree->get_selected(); + if (!parent || !edited_scene) { + + current_option=-1; + //accept->get_cancel()->hide(); + accept->get_ok()->set_text("Ok :( "); + accept->set_text("No parent to instance a child at."); + accept->popup_centered(Size2(300,70)); + return NULL; + }; + + ERR_FAIL_COND_V(!parent,NULL); + + Node*instanced_scene=NULL; + Ref<PackedScene> sdata = ResourceLoader::load(p_file); + if (sdata.is_valid()) + instanced_scene=sdata->instance(); + + + if (!instanced_scene) { + + current_option=-1; + //accept->get_cancel()->hide(); + accept->get_ok()->set_text("Ugh"); + accept->set_text(String("Error loading scene from ")+p_file); + accept->popup_centered(Size2(300,70));; + return NULL; + } + + instanced_scene->generate_instance_state(); + instanced_scene->set_filename( Globals::get_singleton()->localize_path(p_file) ); + + editor_data->get_undo_redo().create_action("Instance Scene"); + editor_data->get_undo_redo().add_do_method(parent,"add_child",instanced_scene); + editor_data->get_undo_redo().add_do_method(instanced_scene,"set_owner",edited_scene); + editor_data->get_undo_redo().add_do_method(editor_selection,"clear"); + editor_data->get_undo_redo().add_do_method(editor_selection,"add_node",instanced_scene); + editor_data->get_undo_redo().add_do_reference(instanced_scene); + editor_data->get_undo_redo().add_undo_method(parent,"remove_child",instanced_scene); + editor_data->get_undo_redo().commit_action(); + + + return instanced_scene; + +} + +void SceneTreeDock::_tool_selected(int p_tool) { + + current_option=p_tool; + + switch(p_tool) { + + case TOOL_NEW: { + + create_dialog->popup_centered_ratio(); + } break; + case TOOL_INSTANCE: { + + Node *scene = edited_scene; + + if (!scene) { + + current_option=-1; + //confirmation->get_cancel()->hide(); + accept->get_ok()->set_text("I see.."); + accept->set_text("This operation can't be done without a tree root."); + accept->popup_centered(Size2(300,70));; + break; + } + + file->set_mode(FileDialog::MODE_OPEN_FILE); + List<String> extensions; + ResourceLoader::get_recognized_extensions_for_type("PackedScene",&extensions); + file->clear_filters(); + for(int i=0;i<extensions.size();i++) { + + file->add_filter("*."+extensions[i]+" ; "+extensions[i].to_upper()); + } + + //file->set_current_path(current_path); + file->popup_centered_ratio(); + + } break; + case TOOL_REPLACE: { + + create_dialog->popup_centered_ratio(); + } break; + case TOOL_CONNECT: { + + Node *current = scene_tree->get_selected(); + if (!current) + break; + + connect_dialog->popup_centered_ratio(); + connect_dialog->set_node(current); + + } break; + case TOOL_GROUP: { + + Node *current = scene_tree->get_selected(); + if (!current) + break; + groups_editor->set_current(current); + groups_editor->popup_centered_ratio(); + } break; + case TOOL_SCRIPT: { + + Node *selected = scene_tree->get_selected(); + if (!selected) + break; + + Ref<Script> existing = selected->get_script(); + if (existing.is_valid()) + editor->push_item(existing.ptr()); + else { + String path = selected->get_filename(); + script_create_dialog->config(selected->get_type(),path); + script_create_dialog->popup_centered(Size2(300,290)); + //script_create_dialog->popup_centered_minsize(); + + } + + } break; + case TOOL_MOVE_UP: + case TOOL_MOVE_DOWN: { + + if (!scene_tree->get_selected()) + break; + + if (scene_tree->get_selected()==edited_scene) { + + + current_option=-1; + //accept->get_cancel()->hide(); + accept->get_ok()->set_text("I see.."); + accept->set_text("This operation can't be done on the tree root."); + accept->popup_centered(Size2(300,70));; + break; + } + + + Node * node=scene_tree->get_selected(); + ERR_FAIL_COND(!node->get_parent()); + int current_pos = node->get_index(); + int next_pos = current_pos + ((p_tool==TOOL_MOVE_DOWN)?1:-1); + + if (next_pos< 0 || next_pos>=node->get_parent()->get_child_count()) + break; // invalid position + + editor_data->get_undo_redo().create_action("Move Node In Parent"); + editor_data->get_undo_redo().add_do_method(node->get_parent(),"move_child",node,next_pos); + editor_data->get_undo_redo().add_undo_method(node->get_parent(),"move_child",node,current_pos); + editor_data->get_undo_redo().commit_action(); + + } break; + case TOOL_DUPLICATE: { + + if (!edited_scene) + break; + + if (editor_selection->is_selected(edited_scene)) { + + + current_option=-1; + //accept->get_cancel()->hide(); + accept->get_ok()->set_text("I see.."); + accept->set_text("This operation can't be done on the tree root."); + accept->popup_centered(Size2(300,70));; + break; + } + + List<Node*> selection = editor_selection->get_selected_node_list(); + + List<Node*> reselect; + + editor_data->get_undo_redo().create_action("Duplicate Node(s)"); + editor_data->get_undo_redo().add_do_method(editor_selection,"clear"); + + Node *dupsingle=NULL; + + + for (List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Node *node = E->get(); + Node *parent = node->get_parent(); + + List<Node*> owned; + node->get_owned_by(node->get_owner(),&owned); + + Map<Node*,Node*> duplimap; + Node * dup = _duplicate(node,duplimap); + + ERR_CONTINUE(!dup); + + if (selection.size()==1) + dupsingle=dup; + + String name = node->get_name(); + + String nums; + for(int i=name.length()-1;i>=0;i--) { + CharType n=name[i]; + if (n>='0' && n<='9') { + nums=String::chr(name[i])+nums; + } else { + break; + } + } + + int num=nums.to_int(); + if (num<2) + num=2; + else + num++; + + name=name.substr(0,name.length()-nums.length()).strip_edges(); + String attempt=name+" "+itos(num); + + while(parent->has_node(attempt)) { + num++; + attempt=name+" "+itos(num); + } + + dup->set_name(attempt); + + editor_data->get_undo_redo().add_do_method(parent,"add_child",dup); + for (List<Node*>::Element *F=owned.front();F;F=F->next()) { + + if (!duplimap.has(F->get())) { + + continue; + } + Node *d=duplimap[F->get()]; + editor_data->get_undo_redo().add_do_method(d,"set_owner",node->get_owner()); + } + editor_data->get_undo_redo().add_do_method(editor_selection,"add_node",dup); + editor_data->get_undo_redo().add_undo_method(parent,"remove_child",dup); + editor_data->get_undo_redo().add_do_reference(dup); + + //parent->add_child(dup); + //reselect.push_back(dup); + } + + editor_data->get_undo_redo().commit_action(); + + if (dupsingle) + editor->push_item(dupsingle); + + + + + + } break; + case TOOL_REPARENT: { + + + if (!scene_tree->get_selected()) + break; + + if (editor_selection->is_selected(edited_scene)) { + + + current_option=-1; + //confirmation->get_cancel()->hide(); + accept->get_ok()->set_text("I see.."); + accept->set_text("This operation can't be done on the tree root."); + accept->popup_centered(Size2(300,70));; + break; + } + + List<Node*> nodes = editor_selection->get_selected_node_list(); + Set<Node*> nodeset; + for(List<Node*>::Element *E=nodes.front();E;E=E->next()) { + + nodeset.insert(E->get()); + } + reparent_dialog->popup_centered_ratio(); + reparent_dialog->set_current( nodeset ); + + } break; + case TOOL_ERASE: { + + List<Node*> remove_list = editor_selection->get_selected_node_list(); + + if (remove_list.empty()) + return; + + delete_dialog->set_text("Delete Node(s)?"); + delete_dialog->popup_centered(Size2(200,80)); + + + + } break; + + } + +} + +void SceneTreeDock::_notification(int p_what) { + + switch(p_what) { + + case NOTIFICATION_ENTER_SCENE: { + + static const char* button_names[TOOL_BUTTON_MAX]={ + "New", + "Add", + "Replace", + "Connect", + "Groups", + "Script", + "MoveUp", + "MoveDown", + "Duplicate", + "Reparent", + "Del", + }; + + for(int i=0;i<TOOL_BUTTON_MAX;i++) + tool_buttons[i]->set_icon(get_icon(button_names[i],"EditorIcons")); + + } break; + } +} + + +void SceneTreeDock::_load_request(const String& p_path) { + + editor->open_request(p_path); +} + +void SceneTreeDock::_script_open_request(const Ref<Script>& p_script) { + + editor->edit_resource(p_script); +} + +void SceneTreeDock::_node_selected() { + + + Node *node=scene_tree->get_selected(); + + if (!node) { + + editor->push_item(NULL); + return; + } + + editor->push_item(node); +} + +Node *SceneTreeDock::_duplicate(Node *p_node, Map<Node*,Node*> &duplimap) { + + Node *node=NULL; + + if (p_node->get_filename()!="") { //an instance + + Ref<PackedScene> sd = ResourceLoader::load( p_node->get_filename() ); + ERR_FAIL_COND_V(!sd.is_valid(),NULL); + node = sd->instance(); + ERR_FAIL_COND_V(!node,NULL); + node->generate_instance_state(); + } else { + Object *obj = ObjectTypeDB::instance(p_node->get_type()); + ERR_FAIL_COND_V(!obj,NULL); + node = obj->cast_to<Node>(); + if (!node) + memdelete(obj); + ERR_FAIL_COND_V(!node,NULL); + + } + + List<PropertyInfo> plist; + + p_node->get_property_list(&plist); + + for(List<PropertyInfo>::Element *E=plist.front();E;E=E->next()) { + + if (!(E->get().usage&PROPERTY_USAGE_STORAGE)) + continue; + String name = E->get().name; + node->set( name, p_node->get(name) ); + + } + + node->set_name(p_node->get_name()); + duplimap[p_node]=node; + + for(int i=0;i<p_node->get_child_count();i++) { + + Node *child = p_node->get_child(i); + if (p_node->get_owner()!=child->get_owner()) + continue; //don't bother with not in-scene nodes. + + Node *dup = _duplicate(child,duplimap); + if (!dup) { + memdelete(node); + return NULL; + } + + node->add_child(dup); + } + + return node; + +} + + +void SceneTreeDock::_set_owners(Node *p_owner, const Array& p_nodes) { + + for(int i=0;i<p_nodes.size();i++) { + + Object *obj=p_nodes[i]; + if (!obj) + continue; + + Node *n=obj->cast_to<Node>(); + if (!n) + continue; + n->set_owner(p_owner); + } +} + + +void SceneTreeDock::_fill_path_renames(Vector<StringName> base_path,Vector<StringName> new_base_path,Node * p_node, List<Pair<NodePath,NodePath> > *p_renames) { + + base_path.push_back(p_node->get_name()); + if (new_base_path.size()) + new_base_path.push_back(p_node->get_name()); + + NodePath from( base_path,true ); + NodePath to; + if (new_base_path.size()) + to=NodePath( new_base_path,true ); + + Pair<NodePath,NodePath> npp; + npp.first=from; + npp.second=to; + + p_renames->push_back(npp); + + for(int i=0;i<p_node->get_child_count();i++) { + + _fill_path_renames(base_path,new_base_path,p_node->get_child(i),p_renames); + } + + +} + +void SceneTreeDock::fill_path_renames(Node* p_node, Node *p_new_parent, List<Pair<NodePath,NodePath> > *p_renames) { + + if (!bool(EDITOR_DEF("animation/autorename_animation_tracks",true))) + return; + + + Vector<StringName> base_path; + Node *n = p_node->get_parent(); + while(n) { + base_path.push_back(n->get_name()); + n=n->get_parent(); + } + base_path.invert(); + + Vector<StringName> new_base_path; + if (p_new_parent) { + n = p_new_parent; + while(n) { + new_base_path.push_back(n->get_name()); + n=n->get_parent(); + } + + new_base_path.invert(); + } + + _fill_path_renames(base_path,new_base_path,p_node,p_renames); +} + +void SceneTreeDock::perform_node_renames(Node* p_base,List<Pair<NodePath,NodePath> > *p_renames, Map<Ref<Animation>, Set<int> > *r_rem_anims) { + + Map<Ref<Animation>, Set<int> > rem_anims; + + if (!r_rem_anims) + r_rem_anims=&rem_anims; + + if (!bool(EDITOR_DEF("animation/autorename_animation_tracks",true))) + return; + + if (!p_base) { + + p_base=edited_scene; + } + + if (!p_base) + return; + + + if (p_base->cast_to<AnimationPlayer>()) { + + AnimationPlayer *ap=p_base->cast_to<AnimationPlayer>(); + List<StringName> anims; + ap->get_animation_list(&anims); + Node *root = ap->get_node(ap->get_root()); + + + if (root) { + + + NodePath root_path=root->get_path(); + NodePath new_root_path=root_path; + + + for(List<Pair<NodePath,NodePath> >::Element* E=p_renames->front();E;E=E->next()) { + + if (E->get().first==root_path) { + new_root_path=E->get().second; + break; + } + } + + if (new_root_path!=NodePath()) { + //will not be erased + + for(List<StringName>::Element *E=anims.front();E;E=E->next()) { + + Ref<Animation> anim=ap->get_animation(E->get()); + if (!r_rem_anims->has(anim)) { + r_rem_anims->insert(anim,Set<int>()); + Set<int> &ran = r_rem_anims->find(anim)->get(); + for(int i=0;i<anim->get_track_count();i++) + ran.insert(i); + } + + Set<int> &ran = r_rem_anims->find(anim)->get(); + + if (anim.is_null()) + continue; + + for(int i=0;i<anim->get_track_count();i++) { + + NodePath track_np=anim->track_get_path(i); + Node *n = root->get_node(track_np); + if (!n) { + continue; + } + + NodePath old_np = n->get_path(); + + if (!ran.has(i)) + continue; //channel was removed + + for(List<Pair<NodePath,NodePath> >::Element* E=p_renames->front();E;E=E->next()) { + + if (E->get().first==old_np) { + + + if (E->get().second==NodePath()) { + //will be erased + + int idx=0; + Set<int>::Element *EI=ran.front(); + ERR_FAIL_COND(!EI); //bug + while(EI->get()!=i) { + idx++; + EI=EI->next(); + ERR_FAIL_COND(!EI); //another bug + + } + + editor_data->get_undo_redo().add_do_method(anim.ptr(),"remove_track",idx); + editor_data->get_undo_redo().add_undo_method(anim.ptr(),"add_track",anim->track_get_type(i),idx); + editor_data->get_undo_redo().add_undo_method(anim.ptr(),"track_set_path",idx,track_np); + editor_data->get_undo_redo().add_undo_method(anim.ptr(),"track_set_interpolation_type",idx,anim->track_get_interpolation_type(i)); + for(int j=0;j<anim->track_get_key_count(i);j++) { + + editor_data->get_undo_redo().add_undo_method(anim.ptr(),"track_insert_key",idx,anim->track_get_key_time(i,j),anim->track_get_key_value(i,j),anim->track_get_key_transition(i,j)); + } + + ran.erase(i); //byebye channel + + } else { + //will be renamed + NodePath rel_path = new_root_path.rel_path_to(E->get().second); + + NodePath new_path = NodePath( rel_path.get_names(), track_np.get_subnames(), false, track_np.get_property() ); + if (new_path==track_np) + continue; //bleh + editor_data->get_undo_redo().add_do_method(anim.ptr(),"track_set_path",i,new_path); + editor_data->get_undo_redo().add_undo_method(anim.ptr(),"track_set_path",i,track_np); + } + } + } + } + } + } + } + } + + + for(int i=0;i<p_base->get_child_count();i++) + perform_node_renames(p_base->get_child(i),p_renames,r_rem_anims); + +} + + +void SceneTreeDock::_node_prerenamed(Node* p_node, const String& p_new_name) { + + + List<Pair<NodePath,NodePath> > path_renames; + + Vector<StringName> base_path; + Node *n = p_node->get_parent(); + while(n) { + base_path.push_back(n->get_name()); + n=n->get_parent(); + } + base_path.invert(); + + + Vector<StringName> new_base_path=base_path; + base_path.push_back(p_node->get_name()); + + new_base_path.push_back(p_new_name); + + Pair<NodePath,NodePath> npp; + npp.first = NodePath(base_path,true); + npp.second = NodePath(new_base_path,true); + path_renames.push_back(npp); + + + for(int i=0;i<p_node->get_child_count();i++) + _fill_path_renames(base_path,new_base_path,p_node->get_child(i),&path_renames); + + perform_node_renames(NULL,&path_renames); + +} + +void SceneTreeDock::_node_reparent(NodePath p_path,bool p_node_only) { + + + Node *node = scene_tree->get_selected(); + ERR_FAIL_COND(!node); + ERR_FAIL_COND(node==edited_scene); + Node *new_parent = scene_root->get_node(p_path); + ERR_FAIL_COND(!new_parent); + + Node *validate=new_parent; + while(validate) { + + if (editor_selection->is_selected(validate)) { + ERR_EXPLAIN("Selection changed at some point.. can't reparent"); + ERR_FAIL(); + return; + } + validate=validate->get_parent(); + } + + //ok all valid + + List<Node*> selection = editor_selection->get_selected_node_list(); + + if (selection.empty()) + return; //nothing to reparent + + //sort by tree order, so re-adding is easy + selection.sort_custom<Node::Comparator>(); + + editor_data->get_undo_redo().create_action("Reparent Node"); + + List<Pair<NodePath,NodePath> > path_renames; + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + //no undo for now, sorry + Node *node = E->get(); + + fill_path_renames(node,new_parent,&path_renames); + + List<Node*> owned; + node->get_owned_by(node->get_owner(),&owned); + Array owners; + for(List<Node*>::Element *E=owned.front();E;E=E->next()) { + + owners.push_back(E->get()); + } + + + + editor_data->get_undo_redo().add_do_method(node->get_parent(),"remove_child",node); + editor_data->get_undo_redo().add_do_method(new_parent,"add_child",node); + editor_data->get_undo_redo().add_do_method(this,"_set_owners",edited_scene,owners); + + if (editor->get_animation_editor()->get_root()==node) + editor_data->get_undo_redo().add_do_method(editor->get_animation_editor(),"set_root",node); + + editor_data->get_undo_redo().add_undo_method(new_parent,"remove_child",node); + + } + + //add and move in a second step.. (so old order is preserved) + + + + for(List<Node*>::Element *E=selection.front();E;E=E->next()) { + + Node *node = E->get(); + + List<Node*> owned; + node->get_owned_by(node->get_owner(),&owned); + Array owners; + for(List<Node*>::Element *E=owned.front();E;E=E->next()) { + + owners.push_back(E->get()); + } + + int child_pos = node->get_position_in_parent(); + + editor_data->get_undo_redo().add_undo_method(node->get_parent(),"add_child",node); + editor_data->get_undo_redo().add_undo_method(node->get_parent(),"move_child",node,child_pos); + editor_data->get_undo_redo().add_undo_method(this,"_set_owners",edited_scene,owners); + if (editor->get_animation_editor()->get_root()==node) + editor_data->get_undo_redo().add_undo_method(editor->get_animation_editor(),"set_root",node); + + } + + perform_node_renames(NULL,&path_renames); + + editor_data->get_undo_redo().commit_action(); + //node->set_owner(owner); +} + + +void SceneTreeDock::_script_created(Ref<Script> p_script) { + + Node *selected = scene_tree->get_selected(); + if (!selected) + return; + selected->set_script(p_script.get_ref_ptr()); + editor->push_item(p_script.operator->()); + +} + + +void SceneTreeDock::_delete_confirm() { + + List<Node*> remove_list = editor_selection->get_selected_node_list(); + + if (remove_list.empty()) + return; + + + if (editor->get_editor_plugin_over()) + editor->get_editor_plugin_over()->make_visible(false); + + editor_data->get_undo_redo().create_action("Remove Node(s)"); + + bool entire_scene=false; + + for(List<Node*>::Element *E=remove_list.front();E;E=E->next()) { + + if (E->get()==edited_scene) { + entire_scene=true; + } + } + + if (entire_scene) { + + editor_data->get_undo_redo().add_do_method(editor,"set_edited_scene",(Object*)NULL); + editor_data->get_undo_redo().add_undo_method(editor,"set_edited_scene",edited_scene); + editor_data->get_undo_redo().add_undo_method(edited_scene,"set_owner",edited_scene->get_owner()); + editor_data->get_undo_redo().add_undo_reference(edited_scene); + + } else { + + remove_list.sort_custom<Node::Comparator>(); //sort nodes to keep positions + List<Pair<NodePath,NodePath> > path_renames; + + + //delete from animation + for(List<Node*>::Element *E=remove_list.front();E;E=E->next()) { + Node *n = E->get(); + if (!n->is_inside_scene() || !n->get_parent()) + continue; + + fill_path_renames(n,NULL,&path_renames); + + } + + perform_node_renames(NULL,&path_renames); + //delete for read + for(List<Node*>::Element *E=remove_list.front();E;E=E->next()) { + Node *n = E->get(); + if (!n->is_inside_scene() || !n->get_parent()) + continue; + + List<Node*> owned; + n->get_owned_by(n->get_owner(),&owned); + Array owners; + for(List<Node*>::Element *E=owned.front();E;E=E->next()) { + + owners.push_back(E->get()); + } + + + editor_data->get_undo_redo().add_do_method(n->get_parent(),"remove_child",n); + editor_data->get_undo_redo().add_undo_method(n->get_parent(),"add_child",n); + editor_data->get_undo_redo().add_undo_method(n->get_parent(),"move_child",n,n->get_index()); + if (editor->get_animation_editor()->get_root()==n) + editor_data->get_undo_redo().add_undo_method(editor->get_animation_editor(),"set_root",n); + editor_data->get_undo_redo().add_undo_method(this,"_set_owners",edited_scene,owners); + //editor_data->get_undo_redo().add_undo_method(n,"set_owner",n->get_owner()); + editor_data->get_undo_redo().add_undo_reference(n); + } + + + } + editor_data->get_undo_redo().commit_action(); + _update_tool_buttons(); + +} + +void SceneTreeDock::_update_tool_buttons() { + + Node *sel = scene_tree->get_selected(); + bool disable = !sel; + bool disable_root = disable || sel->get_parent()==scene_root; + + tool_buttons[TOOL_INSTANCE]->set_disabled(disable); + tool_buttons[TOOL_REPLACE]->set_disabled(disable); + tool_buttons[TOOL_CONNECT]->set_disabled(disable); + tool_buttons[TOOL_GROUP]->set_disabled(disable); + tool_buttons[TOOL_SCRIPT]->set_disabled(disable); + tool_buttons[TOOL_MOVE_UP]->set_disabled(disable_root); + tool_buttons[TOOL_MOVE_DOWN]->set_disabled(disable_root); + tool_buttons[TOOL_DUPLICATE]->set_disabled(disable_root); + tool_buttons[TOOL_REPARENT]->set_disabled(disable_root); + tool_buttons[TOOL_ERASE]->set_disabled(disable); + +} + +void SceneTreeDock::_create() { + + + if (current_option==TOOL_NEW) { + + Node *parent=NULL; + + + if (edited_scene) { + + parent = scene_tree->get_selected(); + ERR_FAIL_COND(!parent); + } else { + + parent = scene_root; + ERR_FAIL_COND(!parent); + + } + + Object *c = create_dialog->instance_selected(); + + ERR_FAIL_COND(!c); + Node *child=c->cast_to<Node>(); + ERR_FAIL_COND(!child); + + editor_data->get_undo_redo().create_action("Create Node"); + + if (edited_scene) { + editor_data->get_undo_redo().add_do_method(parent,"add_child",child); + editor_data->get_undo_redo().add_do_method(child,"set_owner",edited_scene); + editor_data->get_undo_redo().add_do_method(editor_selection,"clear"); + editor_data->get_undo_redo().add_do_method(editor_selection,"add_node",child); + editor_data->get_undo_redo().add_do_reference(child); + editor_data->get_undo_redo().add_undo_method(parent,"remove_child",child); + } else { + + editor_data->get_undo_redo().add_do_method(editor,"set_edited_scene",child); + editor_data->get_undo_redo().add_do_reference(child); + editor_data->get_undo_redo().add_undo_method(editor,"set_edited_scene",(Object*)NULL); + + } + + editor_data->get_undo_redo().commit_action(); + editor->push_item(c); + + if (c->cast_to<Control>()) { + //make editor more comfortable, so some controls don't appear super shrunk + Control *ct = c->cast_to<Control>(); + + Size2 ms = ct->get_minimum_size(); + if (ms.width<4) + ms.width=40; + if (ms.height<4) + ms.height=40; + ct->set_size(ms); + } + + + } else if (current_option==TOOL_REPLACE) { + Node * n = scene_tree->get_selected(); + ERR_FAIL_COND(!n); + + Object *c = create_dialog->instance_selected(); + + ERR_FAIL_COND(!c); + Node *newnode=c->cast_to<Node>(); + ERR_FAIL_COND(!newnode); + + List<PropertyInfo> pinfo; + n->get_property_list(&pinfo); + + for(List<PropertyInfo>::Element *E=pinfo.front();E;E=E->next()) { + if (!(E->get().usage&PROPERTY_USAGE_STORAGE)) + continue; + newnode->set(E->get().name,n->get(E->get().name)); + } + + editor->push_item(NULL); + + //reconnect signals + List<MethodInfo> sl; + + n->get_signal_list(&sl); + for (List<MethodInfo>::Element *E=sl.front();E;E=E->next()) { + + List<Object::Connection> cl; + n->get_signal_connection_list(E->get().name,&cl); + + for(List<Object::Connection>::Element *F=cl.front();F;F=F->next()) { + + Object::Connection &c=F->get(); + if (!(c.flags&Object::CONNECT_PERSIST)) + continue; + newnode->connect(c.signal,c.target,c.method,varray(),Object::CONNECT_PERSIST); + } + + } + + + String newname=n->get_name(); + n->replace_by(newnode,true); + + + if (n==edited_scene) { + edited_scene=newnode; + editor->set_edited_scene(newnode); + } + + + + + editor_data->get_undo_redo().clear_history(); + memdelete(n); + newnode->set_name(newname); + editor->push_item(newnode); + + _update_tool_buttons(); + + } + +} + + +void SceneTreeDock::set_edited_scene(Node* p_scene) { + + edited_scene=p_scene; +} + +void SceneTreeDock::set_selected(Node *p_node) { + + scene_tree->set_selected(p_node,false); + _update_tool_buttons(); +} + +void SceneTreeDock::import_subscene() { + + import_subscene_dialog->popup_centered_ratio(); +} + +void SceneTreeDock::_import_subscene() { + + Node* parent = scene_tree->get_selected(); + ERR_FAIL_COND(!parent); + + import_subscene_dialog->move(parent,edited_scene); + editor_data->get_undo_redo().clear_history(); //no undo for now.. + + +/* + editor_data->get_undo_redo().create_action("Import Subscene"); + editor_data->get_undo_redo().add_do_method(parent,"add_child",ss); + //editor_data->get_undo_redo().add_do_method(editor_selection,"clear"); + //editor_data->get_undo_redo().add_do_method(editor_selection,"add_node",child); + editor_data->get_undo_redo().add_do_reference(ss); + editor_data->get_undo_redo().add_undo_method(parent,"remove_child",ss); + editor_data->get_undo_redo().commit_action(); +*/ +} + +void SceneTreeDock::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("_tool_selected"),&SceneTreeDock::_tool_selected); + ObjectTypeDB::bind_method(_MD("_create"),&SceneTreeDock::_create); + //ObjectTypeDB::bind_method(_MD("_script_created"),&SceneTreeDock::_script_created); + ObjectTypeDB::bind_method(_MD("_node_reparent"),&SceneTreeDock::_node_reparent); + ObjectTypeDB::bind_method(_MD("_set_owners"),&SceneTreeDock::_set_owners); + ObjectTypeDB::bind_method(_MD("_node_selected"),&SceneTreeDock::_node_selected); + ObjectTypeDB::bind_method(_MD("_script_created"),&SceneTreeDock::_script_created); + ObjectTypeDB::bind_method(_MD("_load_request"),&SceneTreeDock::_load_request); + ObjectTypeDB::bind_method(_MD("_script_open_request"),&SceneTreeDock::_script_open_request); + ObjectTypeDB::bind_method(_MD("_unhandled_key_input"),&SceneTreeDock::_unhandled_key_input); + ObjectTypeDB::bind_method(_MD("_delete_confirm"),&SceneTreeDock::_delete_confirm); + ObjectTypeDB::bind_method(_MD("_node_prerenamed"),&SceneTreeDock::_node_prerenamed); + ObjectTypeDB::bind_method(_MD("_import_subscene"),&SceneTreeDock::_import_subscene); + + ObjectTypeDB::bind_method(_MD("instance"),&SceneTreeDock::instance); +} + + + +SceneTreeDock::SceneTreeDock(EditorNode *p_editor,Node *p_scene_root,EditorSelection *p_editor_selection,EditorData &p_editor_data) { + + editor=p_editor; + edited_scene=NULL; + editor_data=&p_editor_data; + editor_selection=p_editor_selection; + scene_root=p_scene_root; + + VBoxContainer *vbc = this; + + HBoxContainer *hbc_top = memnew( HBoxContainer ); + vbc->add_child(hbc_top); + + ToolButton *tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_NEW)); + tb->set_tooltip("Add/Create a New Node\n("+keycode_get_string(KEY_MASK_CMD|KEY_A)+")"); + hbc_top->add_child(tb); + tool_buttons[TOOL_NEW]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_INSTANCE)); + tb->set_tooltip("Instance a Node from scene file."); + hbc_top->add_child(tb); + tool_buttons[TOOL_INSTANCE]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_REPLACE)); + tb->set_tooltip("Replace a Node by Another Node Type"); + hbc_top->add_child(tb); + tool_buttons[TOOL_REPLACE]=tb; + + hbc_top->add_spacer(); + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_CONNECT)); + tb->set_tooltip("Edit the Node Connections"); + hbc_top->add_child(tb); + tool_buttons[TOOL_CONNECT]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_GROUP)); + tb->set_tooltip("Edit the Node Groups"); + hbc_top->add_child(tb); + tool_buttons[TOOL_GROUP]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_SCRIPT)); + tb->set_tooltip("Edit/Create the Node Script"); + hbc_top->add_child(tb); + tool_buttons[TOOL_SCRIPT]=tb; + + + scene_tree = memnew( SceneTreeEditor(false,true,true )); + vbc->add_child(scene_tree); + scene_tree->set_v_size_flags(SIZE_EXPAND|SIZE_FILL); + + scene_tree->connect("node_selected", this,"_node_selected",varray(),CONNECT_DEFERRED); + scene_tree->connect("node_renamed", this,"_node_renamed",varray(),CONNECT_DEFERRED); + scene_tree->connect("node_prerename", this,"_node_prerenamed"); + scene_tree->connect("open",this,"_load_request"); + scene_tree->connect("open_script",this,"_script_open_request"); + scene_tree->set_undo_redo(&editor_data->get_undo_redo()); + scene_tree->set_editor_selection(editor_selection); + + HBoxContainer *hbc_bottom = memnew( HBoxContainer ); + vbc->add_child(hbc_bottom); + + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_MOVE_UP)); + tb->set_tooltip("Move Node Up\n("+keycode_get_string(KEY_MASK_CMD|KEY_UP)+")"); + hbc_bottom->add_child(tb); + tool_buttons[TOOL_MOVE_UP]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_MOVE_DOWN)); + tb->set_tooltip("Move Node Down\n("+keycode_get_string(KEY_MASK_CMD|KEY_DOWN)+")"); + hbc_bottom->add_child(tb); + tool_buttons[TOOL_MOVE_DOWN]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_DUPLICATE)); + tb->set_tooltip("Duplicate Selected Node(s)\n("+keycode_get_string(KEY_MASK_CMD|KEY_D)+")"); + hbc_bottom->add_child(tb); + tool_buttons[TOOL_DUPLICATE]=tb; + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_REPARENT)); + tb->set_tooltip("Reparent Selected Node(s)"); + hbc_bottom->add_child(tb); + tool_buttons[TOOL_REPARENT]=tb; + + hbc_bottom->add_spacer(); + + tb = memnew( ToolButton ); + tb->connect("pressed",this,"_tool_selected",make_binds(TOOL_ERASE)); + tb->set_tooltip("Erase Selected Node(s)"); + hbc_bottom->add_child(tb); + tool_buttons[TOOL_ERASE]=tb; + + create_dialog = memnew( CreateDialog ); + create_dialog->set_base_type("Node"); + add_child(create_dialog); + create_dialog->connect("create",this,"_create"); + + groups_editor = memnew( GroupsEditor ); + add_child(groups_editor); + groups_editor->set_undo_redo(&editor_data->get_undo_redo()); + connect_dialog = memnew( ConnectionsDialog(p_editor) ); + add_child(connect_dialog); + connect_dialog->set_undoredo(&editor_data->get_undo_redo()); + script_create_dialog = memnew( ScriptCreateDialog ); + add_child(script_create_dialog); + script_create_dialog->connect("script_created",this,"_script_created"); + reparent_dialog = memnew( ReparentDialog ); + add_child(reparent_dialog); + reparent_dialog->connect("reparent",this,"_node_reparent"); + + accept = memnew( AcceptDialog ); + add_child(accept); + + file = memnew( FileDialog ); + add_child(file); + file->connect("file_selected",this,"instance"); + add_to_group("unhandled_key_input"); + + delete_dialog = memnew( ConfirmationDialog ); + add_child(delete_dialog); + delete_dialog->connect("confirmed",this,"_delete_confirm"); + import_subscene_dialog = memnew( EditorSubScene ); + add_child(import_subscene_dialog); + import_subscene_dialog->connect("subscene_selected",this,"_import_subscene"); + + + + +} |