asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Clicking on subscene icon will open it

Browse source 
All options are moved into RMB menu
This commit is contained in:
Jakub Grzesik 2017-06-30 18:17:33 +02:00
parent e63c64e256
commit 80716a8bf4
4 changed files with 144 additions and 176 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

130
editor/scene_tree_dock.cpp
View file

@ -658,7 +658,91 @@ void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
}
}
} break;
case TOOL_SCENE_EDITABLE_CHILDREN: {
List<Node *> selection = editor_selection->get_selected_node_list();
if (List<Node *>::Element *e = selection.front()) {
if (Node *node = e->get()) {
bool editable = EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(node);
editable = !editable;
EditorNode::get_singleton()->get_edited_scene()->set_editable_instance(node, editable);
menu->set_item_checked(18, editable);
if (editable) {
node->set_scene_instance_load_placeholder(false);
menu->set_item_checked(19, false);
}
scene_tree->update_tree();
}
}
} break;
case TOOL_SCENE_USE_PLACEHOLDER: {
List<Node *> selection = editor_selection->get_selected_node_list();
if (List<Node *>::Element *e = selection.front()) {
if (Node *node = e->get()) {
bool placeholder = node->get_scene_instance_load_placeholder();
placeholder = !placeholder;
if (placeholder)
EditorNode::get_singleton()->get_edited_scene()->set_editable_instance(node, false);
node->set_scene_instance_load_placeholder(placeholder);
menu->set_item_checked(18, false);
menu->set_item_checked(19, placeholder);
scene_tree->update_tree();
}
}
} break;
case TOOL_SCENE_CLEAR_INSTANCING: {
List<Node *> selection = editor_selection->get_selected_node_list();
if (List<Node *>::Element *e = selection.front()) {
if (Node *node = e->get()) {
Node *root = EditorNode::get_singleton()->get_edited_scene();
UndoRedo *undo_redo = &editor_data->get_undo_redo();
if (!root)
break;
ERR_FAIL_COND(node->get_filename() == String());
undo_redo->create_action("Discard Instancing");
undo_redo->add_do_method(node, "set_filename", "");
undo_redo->add_undo_method(node, "set_filename", node->get_filename());
_node_replace_owner(node, node, root);
undo_redo->add_do_method(scene_tree, "update_tree");
undo_redo->add_undo_method(scene_tree, "update_tree");
undo_redo->commit_action();
}
}
} break;
case TOOL_SCENE_OPEN: {
List<Node *> selection = editor_selection->get_selected_node_list();
if (List<Node *>::Element *e = selection.front()) {
if (Node *node = e->get()) {
scene_tree->emit_signal("open", node->get_filename());
}
}
} break;
case TOOL_SCENE_CLEAR_INHERITANCE: {
clear_inherit_confirm->popup_centered_minsize();
} break;
case TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM: {
List<Node *> selection = editor_selection->get_selected_node_list();
if (List<Node *>::Element *e = selection.front()) {
if (Node *node = e->get()) {
node->set_scene_inherited_state(Ref<SceneState>());
scene_tree->update_tree();
EditorNode::get_singleton()->get_property_editor()->update_tree();
}
}
} break;
case TOOL_SCENE_OPEN_INHERITED: {
List<Node *> selection = editor_selection->get_selected_node_list();
if (List<Node *>::Element *e = selection.front()) {
if (Node *node = e->get()) {
if (node && node->get_scene_inherited_state().is_valid()) {
scene_tree->emit_signal("open", node->get_scene_inherited_state()->get_path());
}
}
}
} break;
default: {
if (p_tool >= EDIT_SUBRESOURCE_BASE) {
@ -702,6 +786,29 @@ void SceneTreeDock::_notification(int p_what) {
EditorNode::get_singleton()->get_editor_selection()->connect("selection_changed", this, "_selection_changed");
} break;
case NOTIFICATION_ENTER_TREE: {
clear_inherit_confirm->connect("confirmed", this, "_tool_selected", varray(TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM));
} break;
case NOTIFICATION_EXIT_TREE: {
clear_inherit_confirm->disconnect("confirmed", this, "_tool_selected");
} break;
}
}
void SceneTreeDock::_node_replace_owner(Node *p_base, Node *p_node, Node *p_root) {
if (p_base != p_node) {
if (p_node->get_owner() == p_base) {
UndoRedo *undo_redo = &editor_data->get_undo_redo();
undo_redo->add_do_method(p_node, "set_owner", p_root);
undo_redo->add_undo_method(p_node, "set_owner", p_base);
}
}
for (int i = 0; i < p_node->get_child_count(); i++) {
_node_replace_owner(p_base, p_node->get_child(i), p_root);
}
}
@ -1769,6 +1876,24 @@ void SceneTreeDock::_tree_rmb(const Vector2 &p_menu_pos) {
menu->add_icon_shortcut(get_icon("CreateNewSceneFrom", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/save_branch_as_scene"), TOOL_NEW_SCENE_FROM);
menu->add_separator();
menu->add_icon_shortcut(get_icon("CopyNodePath", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/copy_node_path"), TOOL_COPY_NODE_PATH);
bool is_external = (selection[0]->get_filename() != "") && (selection[0]->get_owner() != selection[0]);
if (is_external) {
bool is_inherited = selection[0]->get_scene_inherited_state() != NULL;
menu->add_separator();
if (is_inherited) {
menu->add_item(TTR("Clear Inheritance"), TOOL_SCENE_CLEAR_INHERITANCE);
menu->add_icon_item(get_icon("Load", "EditorIcons"), TTR("Open in Editor"), TOOL_SCENE_OPEN_INHERITED);
} else {
bool editable = EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(selection[0]);
bool placeholder = selection[0]->get_scene_instance_load_placeholder();
menu->add_check_item(TTR("Editable Children"), TOOL_SCENE_EDITABLE_CHILDREN);
menu->add_check_item(TTR("Load As Placeholder"), TOOL_SCENE_USE_PLACEHOLDER);
menu->add_item(TTR("Discard Instancing"), TOOL_SCENE_CLEAR_INSTANCING);
menu->add_icon_item(get_icon("Load", "EditorIcons"), TTR("Open in Editor"), TOOL_SCENE_OPEN);
menu->set_item_checked(18, editable);
menu->set_item_checked(19, placeholder);
}
}
}
menu->add_separator();
menu->add_icon_shortcut(get_icon("Remove", "EditorIcons"), ED_SHORTCUT("scene_tree/delete", TTR("Delete Node(s)"), KEY_DELETE), TOOL_ERASE);
@ -1978,6 +2103,11 @@ SceneTreeDock::SceneTreeDock(EditorNode *p_editor, Node *p_scene_root, EditorSel
first_enter = true;
restore_script_editor_on_drag = false;
clear_inherit_confirm = memnew(ConfirmationDialog);
clear_inherit_confirm->set_text(TTR("Clear Inheritance? (No Undo!)"));
clear_inherit_confirm->get_ok()->set_text(TTR("Clear!"));
add_child(clear_inherit_confirm);
vbc->add_constant_override("separation", 4);
set_process_input(true);
}

11
editor/scene_tree_dock.h
View file

@ -70,7 +70,14 @@ class SceneTreeDock : public VBoxContainer {
TOOL_MULTI_EDIT,
TOOL_ERASE,
TOOL_COPY_NODE_PATH,
TOOL_BUTTON_MAX
TOOL_BUTTON_MAX,
TOOL_SCENE_EDITABLE_CHILDREN,
TOOL_SCENE_USE_PLACEHOLDER,
TOOL_SCENE_CLEAR_INSTANCING,
TOOL_SCENE_OPEN,
TOOL_SCENE_CLEAR_INHERITANCE,
TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM,
TOOL_SCENE_OPEN_INHERITED
};
enum {
@ -112,6 +119,7 @@ class SceneTreeDock : public VBoxContainer {
TextureRect *filter_icon;
PopupMenu *menu;
ConfirmationDialog *clear_inherit_confirm;
bool first_enter;
@ -127,6 +135,7 @@ class SceneTreeDock : public VBoxContainer {
void _do_reparent(Node *p_new_parent, int p_position_in_parent, Vector<Node *> p_nodes, bool p_keep_global_xform);
void _set_owners(Node *p_owner, const Array &p_nodes);
void _node_replace_owner(Node *p_base, Node *p_node, Node *p_root);
void _load_request(const String &p_path);
void _script_open_request(const Ref<Script> &p_script);

165
editor/scene_tree_editor.cpp
View file

@ -44,110 +44,6 @@ Node *SceneTreeEditor::get_scene_node() {
return get_tree()->get_edited_scene_root();
}
void SceneTreeEditor::_subscene_option(int p_idx) {
Object *obj = ObjectDB::get_instance(instance_node);
if (!obj)
return;
Node *node = obj->cast_to<Node>();
if (!node)
return;
switch (p_idx) {
case SCENE_MENU_EDITABLE_CHILDREN: {
bool editable = EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(node);
editable = !editable;
//node->set_instance_children_editable(editable);
EditorNode::get_singleton()->get_edited_scene()->set_editable_instance(node, editable);
instance_menu->set_item_checked(0, editable);
if (editable) {
node->set_scene_instance_load_placeholder(false);
instance_menu->set_item_checked(1, false);
}
_update_tree();
} break;
case SCENE_MENU_USE_PLACEHOLDER: {
bool placeholder = node->get_scene_instance_load_placeholder();
placeholder = !placeholder;
//node->set_instance_children_editable(editable);
if (placeholder) {
EditorNode::get_singleton()->get_edited_scene()->set_editable_instance(node, false);
}
node->set_scene_instance_load_placeholder(placeholder);
instance_menu->set_item_checked(0, false);
instance_menu->set_item_checked(1, placeholder);
_update_tree();
} break;
case SCENE_MENU_OPEN: {
emit_signal("open", node->get_filename());
} break;
case SCENE_MENU_CLEAR_INHERITANCE: {
clear_inherit_confirm->popup_centered_minsize();
} break;
case SCENE_MENU_CLEAR_INSTANCING: {
Node *root = EditorNode::get_singleton()->get_edited_scene();
if (!root)
break;
ERR_FAIL_COND(node->get_filename() == String());
undo_redo->create_action("Discard Instancing");
undo_redo->add_do_method(node, "set_filename", "");
undo_redo->add_undo_method(node, "set_filename", node->get_filename());
_node_replace_owner(node, node, root);
undo_redo->add_do_method(this, "update_tree");
undo_redo->add_undo_method(this, "update_tree");
undo_redo->commit_action();
} break;
case SCENE_MENU_OPEN_INHERITED: {
if (node && node->get_scene_inherited_state().is_valid()) {
emit_signal("open", node->get_scene_inherited_state()->get_path());
}
} break;
case SCENE_MENU_CLEAR_INHERITANCE_CONFIRM: {
if (node && node->get_scene_inherited_state().is_valid()) {
node->set_scene_inherited_state(Ref<SceneState>());
update_tree();
EditorNode::get_singleton()->get_property_editor()->update_tree();
}
} break;
}
}
void SceneTreeEditor::_node_replace_owner(Node *p_base, Node *p_node, Node *p_root) {
if (p_base != p_node) {
if (p_node->get_owner() == p_base) {
undo_redo->add_do_method(p_node, "set_owner", p_root);
undo_redo->add_undo_method(p_node, "set_owner", p_base);
}
}
for (int i = 0; i < p_node->get_child_count(); i++) {
_node_replace_owner(p_base, p_node->get_child(i), p_root);
}
}
void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_id) {
TreeItem *item = p_item->cast_to<TreeItem>();
@ -159,38 +55,13 @@ void SceneTreeEditor::_cell_button_pressed(Object *p_item, int p_column, int p_i
ERR_FAIL_COND(!n);
if (p_id == BUTTON_SUBSCENE) {
//open scene request
Rect2 item_rect = tree->get_item_rect(item, 0);
item_rect.position.y -= tree->get_scroll().y;
item_rect.position += tree->get_global_position();
if (n == get_scene_node()) {
inheritance_menu->set_position(item_rect.position + Vector2(0, item_rect.size.y));
inheritance_menu->set_size(Vector2(item_rect.size.x, 0));
inheritance_menu->popup();
instance_node = n->get_instance_ID();
} else {
instance_menu->set_position(item_rect.position + Vector2(0, item_rect.size.y));
instance_menu->set_size(Vector2(item_rect.size.x, 0));
if (EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(n))
instance_menu->set_item_checked(0, true);
else
instance_menu->set_item_checked(0, false);
if (n->get_owner() == get_scene_node()) {
instance_menu->set_item_checked(1, n->get_scene_instance_load_placeholder());
instance_menu->set_item_disabled(1, false);
} else {
instance_menu->set_item_checked(1, false);
instance_menu->set_item_disabled(1, true);
if (n && n->get_scene_inherited_state().is_valid()) {
emit_signal("open", n->get_scene_inherited_state()->get_path());
}
instance_menu->popup();
instance_node = n->get_instance_ID();
} else {
emit_signal("open", n->get_filename());
}
//emit_signal("open",n->get_filename());
} else if (p_id == BUTTON_SCRIPT) {
RefPtr script = n->get_script();
if (!script.is_null())
@ -633,10 +504,7 @@ void SceneTreeEditor::_notification(int p_what) {
get_tree()->connect("node_removed", this, "_node_removed");
get_tree()->connect("node_configuration_warning_changed", this, "_warning_changed");
instance_menu->set_item_icon(5, get_icon("Load", "EditorIcons"));
tree->connect("item_collapsed", this, "_cell_collapsed");
inheritance_menu->set_item_icon(2, get_icon("Load", "EditorIcons"));
clear_inherit_confirm->connect("confirmed", this, "_subscene_option", varray(SCENE_MENU_CLEAR_INHERITANCE_CONFIRM));
EditorSettings::get_singleton()->connect("settings_changed", this, "_editor_settings_changed");
@ -649,7 +517,6 @@ void SceneTreeEditor::_notification(int p_what) {
get_tree()->disconnect("tree_changed", this, "_tree_changed");
get_tree()->disconnect("node_removed", this, "_node_removed");
tree->disconnect("item_collapsed", this, "_cell_collapsed");
clear_inherit_confirm->disconnect("confirmed", this, "_subscene_option");
get_tree()->disconnect("node_configuration_warning_changed", this, "_warning_changed");
EditorSettings::get_singleton()->disconnect("settings_changed", this, "_editor_settings_changed");
}
@ -1059,7 +926,6 @@ void SceneTreeEditor::_bind_methods() {
ClassDB::bind_method("_selection_changed", &SceneTreeEditor::_selection_changed);
ClassDB::bind_method("_cell_button_pressed", &SceneTreeEditor::_cell_button_pressed);
ClassDB::bind_method("_cell_collapsed", &SceneTreeEditor::_cell_collapsed);
ClassDB::bind_method("_subscene_option", &SceneTreeEditor::_subscene_option);
ClassDB::bind_method("_rmb_select", &SceneTreeEditor::_rmb_select);
ClassDB::bind_method("_warning_changed", &SceneTreeEditor::_warning_changed);
@ -1145,29 +1011,6 @@ SceneTreeEditor::SceneTreeEditor(bool p_label, bool p_can_rename, bool p_can_ope
updating_tree = false;
blocked = 0;
instance_menu = memnew(PopupMenu);
instance_menu->add_check_item(TTR("Editable Children"), SCENE_MENU_EDITABLE_CHILDREN);
instance_menu->add_check_item(TTR("Load As Placeholder"), SCENE_MENU_USE_PLACEHOLDER);
instance_menu->add_separator();
instance_menu->add_item(TTR("Discard Instancing"), SCENE_MENU_CLEAR_INSTANCING);
instance_menu->add_separator();
instance_menu->add_item(TTR("Open in Editor"), SCENE_MENU_OPEN);
instance_menu->connect("id_pressed", this, "_subscene_option");
add_child(instance_menu);
inheritance_menu = memnew(PopupMenu);
inheritance_menu->add_item(TTR("Clear Inheritance"), SCENE_MENU_CLEAR_INHERITANCE);
inheritance_menu->add_separator();
inheritance_menu->add_item(TTR("Open in Editor"), SCENE_MENU_OPEN_INHERITED);
inheritance_menu->connect("id_pressed", this, "_subscene_option");
add_child(inheritance_menu);
clear_inherit_confirm = memnew(ConfirmationDialog);
clear_inherit_confirm->set_text(TTR("Clear Inheritance? (No Undo!)"));
clear_inherit_confirm->get_ok()->set_text(TTR("Clear!"));
add_child(clear_inherit_confirm);
update_timer = memnew(Timer);
update_timer->connect("timeout", this, "_update_tree");
update_timer->set_one_shot(true);

14
editor/scene_tree_editor.h
View file

@ -56,27 +56,14 @@ class SceneTreeEditor : public Control {
BUTTON_GROUPS = 7,
};
enum {
SCENE_MENU_EDITABLE_CHILDREN,
SCENE_MENU_USE_PLACEHOLDER,
SCENE_MENU_OPEN,
SCENE_MENU_CLEAR_INHERITANCE,
SCENE_MENU_OPEN_INHERITED,
SCENE_MENU_CLEAR_INHERITANCE_CONFIRM,
SCENE_MENU_CLEAR_INSTANCING,
};
Tree *tree;
Node *selected;
PopupMenu *instance_menu;
PopupMenu *inheritance_menu;
ObjectID instance_node;
String filter;
AcceptDialog *error;
AcceptDialog *warning;
ConfirmationDialog *clear_inherit_confirm;
int blocked;
@ -119,7 +106,6 @@ class SceneTreeEditor : public Control {
void _node_script_changed(Node *p_node);
void _node_visibility_changed(Node *p_node);
void _update_visibility_color(Node *p_node, TreeItem *p_item);
void _subscene_option(int p_idx);
void _node_replace_owner(Node *p_base, Node *p_node, Node *p_root);