If you change the type of an existing node, it checks if you have
modified the initial value of their properties before overwriting
their values in the new node.
For example, if you created a `Label` and changed it to
`LineEdit`, the `mouse_filter` property was created as `Ignore`
for the original `Label` node, and was maintained after changing
it to `LineEdit` causing not to work as expected. Now it checks if
`Ignore` is the default value for `Label` nodes, and as it is, the
property value is left unchanged, maintaining the default value
for `LineEdit`, which is `Stop`.
Fix #13955 and alike.
(cherry picked from commit 8ea4ea0d53
)
2086 lines
67 KiB
C++
2086 lines
67 KiB
C++
/*************************************************************************/
|
|
/* scene_tree_dock.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */
|
|
/* */
|
|
/* 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 "core/io/resource_saver.h"
|
|
#include "core/os/keyboard.h"
|
|
#include "core/project_settings.h"
|
|
#include "editor/animation_editor.h"
|
|
#include "editor/editor_node.h"
|
|
#include "editor/editor_settings.h"
|
|
#include "editor/multi_node_edit.h"
|
|
#include "editor/plugins/animation_player_editor_plugin.h"
|
|
#include "editor/plugins/canvas_item_editor_plugin.h"
|
|
#include "editor/plugins/script_editor_plugin.h"
|
|
#include "editor/plugins/spatial_editor_plugin.h"
|
|
#include "editor/script_editor_debugger.h"
|
|
#include "scene/main/viewport.h"
|
|
#include "scene/resources/packed_scene.h"
|
|
|
|
void SceneTreeDock::_nodes_drag_begin() {
|
|
|
|
if (restore_script_editor_on_drag) {
|
|
EditorNode::get_singleton()->set_visible_editor(EditorNode::EDITOR_SCRIPT);
|
|
restore_script_editor_on_drag = false;
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_input(Ref<InputEvent> p_event) {
|
|
|
|
Ref<InputEventMouseButton> mb = p_event;
|
|
|
|
if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
|
|
restore_script_editor_on_drag = false; //lost chance
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_unhandled_key_input(Ref<InputEvent> p_event) {
|
|
|
|
if (get_viewport()->get_modal_stack_top())
|
|
return; //ignore because of modal window
|
|
|
|
if (get_focus_owner() && get_focus_owner()->is_text_field())
|
|
return;
|
|
|
|
if (!p_event->is_pressed() || p_event->is_echo())
|
|
return;
|
|
|
|
if (ED_IS_SHORTCUT("scene_tree/add_child_node", p_event)) {
|
|
_tool_selected(TOOL_NEW);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/instance_scene", p_event)) {
|
|
_tool_selected(TOOL_INSTANCE);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/change_node_type", p_event)) {
|
|
_tool_selected(TOOL_REPLACE);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/duplicate", p_event)) {
|
|
_tool_selected(TOOL_DUPLICATE);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/attach_script", p_event)) {
|
|
_tool_selected(TOOL_ATTACH_SCRIPT);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/clear_script", p_event)) {
|
|
_tool_selected(TOOL_CLEAR_SCRIPT);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/move_up", p_event)) {
|
|
_tool_selected(TOOL_MOVE_UP);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/move_down", p_event)) {
|
|
_tool_selected(TOOL_MOVE_DOWN);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/reparent", p_event)) {
|
|
_tool_selected(TOOL_REPARENT);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/merge_from_scene", p_event)) {
|
|
_tool_selected(TOOL_MERGE_FROM_SCENE);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/save_branch_as_scene", p_event)) {
|
|
_tool_selected(TOOL_NEW_SCENE_FROM);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/delete_no_confirm", p_event)) {
|
|
_tool_selected(TOOL_ERASE, true);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/copy_node_path", p_event)) {
|
|
_tool_selected(TOOL_COPY_NODE_PATH);
|
|
} else if (ED_IS_SHORTCUT("scene_tree/delete", p_event)) {
|
|
_tool_selected(TOOL_ERASE);
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::instance(const String &p_file) {
|
|
|
|
Node *parent = scene_tree->get_selected();
|
|
if (!parent || !edited_scene) {
|
|
|
|
current_option = -1;
|
|
accept->get_ok()->set_text(TTR("OK :("));
|
|
accept->set_text(TTR("No parent to instance a child at."));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
};
|
|
|
|
ERR_FAIL_COND(!parent);
|
|
|
|
Vector<String> scenes;
|
|
scenes.push_back(p_file);
|
|
_perform_instance_scenes(scenes, parent, -1);
|
|
}
|
|
|
|
void SceneTreeDock::instance_scenes(const Vector<String> &p_files, Node *p_parent) {
|
|
|
|
Node *parent = p_parent;
|
|
|
|
if (!parent) {
|
|
parent = scene_tree->get_selected();
|
|
}
|
|
|
|
if (!parent || !edited_scene) {
|
|
|
|
accept->get_ok()->set_text(TTR("OK"));
|
|
accept->set_text(TTR("No parent to instance the scenes at."));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
};
|
|
|
|
_perform_instance_scenes(p_files, parent, -1);
|
|
}
|
|
|
|
void SceneTreeDock::_perform_instance_scenes(const Vector<String> &p_files, Node *parent, int p_pos) {
|
|
|
|
ERR_FAIL_COND(!parent);
|
|
|
|
Vector<Node *> instances;
|
|
|
|
bool error = false;
|
|
|
|
for (int i = 0; i < p_files.size(); i++) {
|
|
|
|
Ref<PackedScene> sdata = ResourceLoader::load(p_files[i]);
|
|
if (!sdata.is_valid()) {
|
|
current_option = -1;
|
|
accept->get_ok()->set_text(TTR("Ugh"));
|
|
accept->set_text(vformat(TTR("Error loading scene from %s"), p_files[i]));
|
|
accept->popup_centered_minsize();
|
|
error = true;
|
|
break;
|
|
}
|
|
|
|
Node *instanced_scene = sdata->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
|
|
if (!instanced_scene) {
|
|
current_option = -1;
|
|
accept->get_ok()->set_text(TTR("Ugh"));
|
|
accept->set_text(vformat(TTR("Error instancing scene from %s"), p_files[i]));
|
|
accept->popup_centered_minsize();
|
|
error = true;
|
|
break;
|
|
}
|
|
|
|
if (edited_scene->get_filename() != "") {
|
|
|
|
if (_cyclical_dependency_exists(edited_scene->get_filename(), instanced_scene)) {
|
|
|
|
accept->get_ok()->set_text(TTR("Ok"));
|
|
accept->set_text(vformat(TTR("Cannot instance the scene '%s' because the current scene exists within one of its nodes."), p_files[i]));
|
|
accept->popup_centered_minsize();
|
|
error = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
instanced_scene->set_filename(ProjectSettings::get_singleton()->localize_path(p_files[i]));
|
|
|
|
instances.push_back(instanced_scene);
|
|
}
|
|
|
|
if (error) {
|
|
for (int i = 0; i < instances.size(); i++) {
|
|
memdelete(instances[i]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
editor_data->get_undo_redo().create_action(TTR("Instance Scene(s)"));
|
|
|
|
for (int i = 0; i < instances.size(); i++) {
|
|
|
|
Node *instanced_scene = instances[i];
|
|
|
|
editor_data->get_undo_redo().add_do_method(parent, "add_child", instanced_scene);
|
|
if (p_pos >= 0) {
|
|
editor_data->get_undo_redo().add_do_method(parent, "move_child", instanced_scene, p_pos + i);
|
|
}
|
|
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);
|
|
|
|
String new_name = parent->validate_child_name(instanced_scene);
|
|
ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
|
|
editor_data->get_undo_redo().add_do_method(sed, "live_debug_instance_node", edited_scene->get_path_to(parent), p_files[i], new_name);
|
|
editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(edited_scene->get_path_to(parent)) + "/" + new_name));
|
|
}
|
|
|
|
editor_data->get_undo_redo().commit_action();
|
|
}
|
|
|
|
void SceneTreeDock::_replace_with_branch_scene(const String &p_file, Node *base) {
|
|
Ref<PackedScene> sdata = ResourceLoader::load(p_file);
|
|
if (!sdata.is_valid()) {
|
|
accept->get_ok()->set_text(TTR("Ugh"));
|
|
accept->set_text(vformat(TTR("Error loading scene from %s"), p_file));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
}
|
|
|
|
Node *instanced_scene = sdata->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
|
|
if (!instanced_scene) {
|
|
accept->get_ok()->set_text(TTR("Ugh"));
|
|
accept->set_text(vformat(TTR("Error instancing scene from %s"), p_file));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
}
|
|
|
|
Node *parent = base->get_parent();
|
|
int pos = base->get_index();
|
|
parent->remove_child(base);
|
|
parent->add_child(instanced_scene);
|
|
parent->move_child(instanced_scene, pos);
|
|
instanced_scene->set_owner(edited_scene);
|
|
editor_selection->clear();
|
|
editor_selection->add_node(instanced_scene);
|
|
scene_tree->set_selected(instanced_scene);
|
|
|
|
// Delete the node as late as possible because before another one is selected
|
|
// an editor plugin could be referencing it to do something with it before
|
|
// switching to another (or to none); and since some steps of changing the
|
|
// editor state are deferred, the safest thing is to do this is as the last
|
|
// step of this function and also by enqueing instead of memdelete()-ing it here
|
|
base->queue_delete();
|
|
}
|
|
|
|
bool SceneTreeDock::_cyclical_dependency_exists(const String &p_target_scene_path, Node *p_desired_node) {
|
|
int childCount = p_desired_node->get_child_count();
|
|
|
|
if (p_desired_node->get_filename() == p_target_scene_path) {
|
|
return true;
|
|
}
|
|
|
|
for (int i = 0; i < childCount; i++) {
|
|
Node *child = p_desired_node->get_child(i);
|
|
|
|
if (_cyclical_dependency_exists(p_target_scene_path, child)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void SceneTreeDock::_tool_selected(int p_tool, bool p_confirm_override) {
|
|
|
|
current_option = p_tool;
|
|
|
|
switch (p_tool) {
|
|
|
|
case TOOL_NEW: {
|
|
|
|
String preferred = "";
|
|
Node *current_edited_scene_root = EditorNode::get_singleton()->get_edited_scene();
|
|
|
|
if (current_edited_scene_root) {
|
|
|
|
if (ClassDB::is_parent_class(current_edited_scene_root->get_class_name(), "Node2D"))
|
|
preferred = "Node2D";
|
|
else if (ClassDB::is_parent_class(current_edited_scene_root->get_class_name(), "Spatial"))
|
|
preferred = "Spatial";
|
|
}
|
|
create_dialog->set_preferred_search_result_type(preferred);
|
|
create_dialog->popup_create(true);
|
|
} break;
|
|
case TOOL_INSTANCE: {
|
|
|
|
Node *scene = edited_scene;
|
|
|
|
if (!scene) {
|
|
EditorNode::get_singleton()->new_inherited_scene();
|
|
break;
|
|
}
|
|
|
|
file->set_mode(EditorFileDialog::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->popup_centered_ratio();
|
|
|
|
} break;
|
|
case TOOL_REPLACE: {
|
|
|
|
create_dialog->popup_create(false, true);
|
|
} break;
|
|
case TOOL_ATTACH_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();
|
|
if (path == "") {
|
|
String root_path = editor_data->get_edited_scene_root()->get_filename();
|
|
if (root_path == "") {
|
|
path = "res://" + selected->get_name();
|
|
} else {
|
|
path = root_path.get_base_dir() + "/" + selected->get_name();
|
|
}
|
|
}
|
|
script_create_dialog->config(selected->get_class(), path);
|
|
script_create_dialog->popup_centered();
|
|
}
|
|
|
|
} break;
|
|
case TOOL_CLEAR_SCRIPT: {
|
|
Node *selected = scene_tree->get_selected();
|
|
if (!selected)
|
|
break;
|
|
|
|
Ref<Script> existing = selected->get_script();
|
|
if (existing.is_valid()) {
|
|
const RefPtr empty;
|
|
selected->set_script(empty);
|
|
_update_script_button();
|
|
}
|
|
|
|
} 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_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation can't be done on the tree root."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
if (!_validate_no_foreign())
|
|
break;
|
|
|
|
bool MOVING_DOWN = (p_tool == TOOL_MOVE_DOWN);
|
|
bool MOVING_UP = !MOVING_DOWN;
|
|
|
|
Node *common_parent = scene_tree->get_selected()->get_parent();
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
selection.sort_custom<Node::Comparator>(); // sort by index
|
|
if (MOVING_DOWN)
|
|
selection.invert();
|
|
|
|
int lowest_id = common_parent->get_child_count() - 1;
|
|
int highest_id = 0;
|
|
for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
|
|
int index = E->get()->get_index();
|
|
|
|
if (index > highest_id) highest_id = index;
|
|
if (index < lowest_id) lowest_id = index;
|
|
|
|
if (E->get()->get_parent() != common_parent)
|
|
common_parent = NULL;
|
|
}
|
|
|
|
if (!common_parent || (MOVING_DOWN && highest_id >= common_parent->get_child_count() - MOVING_DOWN) || (MOVING_UP && lowest_id == 0))
|
|
break; // one or more nodes can not be moved
|
|
|
|
if (selection.size() == 1) editor_data->get_undo_redo().create_action(TTR("Move Node In Parent"));
|
|
if (selection.size() > 1) editor_data->get_undo_redo().create_action(TTR("Move Nodes In Parent"));
|
|
|
|
for (int i = 0; i < selection.size(); i++) {
|
|
Node *top_node = selection[i];
|
|
Node *bottom_node = selection[selection.size() - 1 - i];
|
|
|
|
ERR_FAIL_COND(!top_node->get_parent());
|
|
ERR_FAIL_COND(!bottom_node->get_parent());
|
|
|
|
int bottom_node_pos = bottom_node->get_index();
|
|
int top_node_pos_next = top_node->get_index() + (MOVING_DOWN ? 1 : -1);
|
|
|
|
editor_data->get_undo_redo().add_do_method(top_node->get_parent(), "move_child", top_node, top_node_pos_next);
|
|
editor_data->get_undo_redo().add_undo_method(bottom_node->get_parent(), "move_child", bottom_node, bottom_node_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_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation can't be done on the tree root."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
if (!_validate_no_foreign())
|
|
break;
|
|
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
if (selection.size() == 0)
|
|
break;
|
|
|
|
editor_data->get_undo_redo().create_action(TTR("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<const Node *, Node *> duplimap;
|
|
Node *dup = node->duplicate_from_editor(duplimap);
|
|
|
|
ERR_CONTINUE(!dup);
|
|
|
|
if (selection.size() == 1)
|
|
dupsingle = dup;
|
|
|
|
dup->set_name(parent->validate_child_name(dup));
|
|
|
|
editor_data->get_undo_redo().add_do_method(parent, "add_child_below_node", node, 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);
|
|
|
|
ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
|
|
|
|
editor_data->get_undo_redo().add_do_method(sed, "live_debug_duplicate_node", edited_scene->get_path_to(node), dup->get_name());
|
|
editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(edited_scene->get_path_to(parent)) + "/" + dup->get_name()));
|
|
}
|
|
|
|
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;
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation can't be done on the tree root."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
if (!_validate_no_foreign())
|
|
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_MULTI_EDIT: {
|
|
|
|
Node *root = EditorNode::get_singleton()->get_edited_scene();
|
|
if (!root)
|
|
break;
|
|
Ref<MultiNodeEdit> mne = memnew(MultiNodeEdit);
|
|
for (const Map<Node *, Object *>::Element *E = EditorNode::get_singleton()->get_editor_selection()->get_selection().front(); E; E = E->next()) {
|
|
mne->add_node(root->get_path_to(E->key()));
|
|
}
|
|
|
|
EditorNode::get_singleton()->push_item(mne.ptr());
|
|
|
|
} break;
|
|
|
|
case TOOL_ERASE: {
|
|
|
|
List<Node *> remove_list = editor_selection->get_selected_node_list();
|
|
|
|
if (remove_list.empty())
|
|
return;
|
|
|
|
if (!_validate_no_foreign())
|
|
break;
|
|
|
|
if (p_confirm_override) {
|
|
_delete_confirm();
|
|
|
|
} else {
|
|
delete_dialog->set_text(TTR("Delete Node(s)?"));
|
|
delete_dialog->popup_centered_minsize();
|
|
}
|
|
|
|
} break;
|
|
case TOOL_MERGE_FROM_SCENE: {
|
|
|
|
EditorNode::get_singleton()->merge_from_scene();
|
|
} break;
|
|
case TOOL_NEW_SCENE_FROM: {
|
|
|
|
Node *scene = editor_data->get_edited_scene_root();
|
|
|
|
if (!scene) {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation can't be done without a scene."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
|
|
if (selection.size() != 1) {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation requires a single selected node."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
Node *tocopy = selection.front()->get();
|
|
|
|
if (tocopy == scene) {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("Can not perform with the root node."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
if (tocopy != editor_data->get_edited_scene_root() && tocopy->get_filename() != "") {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation can't be done on instanced scenes."));
|
|
accept->popup_centered_minsize();
|
|
break;
|
|
}
|
|
|
|
new_scene_from_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE);
|
|
|
|
List<String> extensions;
|
|
Ref<PackedScene> sd = memnew(PackedScene);
|
|
ResourceSaver::get_recognized_extensions(sd, &extensions);
|
|
new_scene_from_dialog->clear_filters();
|
|
for (int i = 0; i < extensions.size(); i++) {
|
|
new_scene_from_dialog->add_filter("*." + extensions[i] + " ; " + extensions[i].to_upper());
|
|
}
|
|
|
|
String existing;
|
|
if (extensions.size()) {
|
|
String root_name(tocopy->get_name());
|
|
existing = root_name + "." + extensions.front()->get().to_lower();
|
|
}
|
|
new_scene_from_dialog->set_current_path(existing);
|
|
|
|
new_scene_from_dialog->popup_centered_ratio();
|
|
new_scene_from_dialog->set_title(TTR("Save New Scene As.."));
|
|
} break;
|
|
case TOOL_COPY_NODE_PATH: {
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
Node *root = EditorNode::get_singleton()->get_edited_scene();
|
|
NodePath path = root->get_path().rel_path_to(node->get_path());
|
|
OS::get_singleton()->set_clipboard(path);
|
|
}
|
|
}
|
|
} break;
|
|
case TOOL_SCENE_EDITABLE_CHILDREN: {
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
bool editable = EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(node);
|
|
int editable_item_idx = menu->get_item_idx_from_text(TTR("Editable Children"));
|
|
int placeholder_item_idx = menu->get_item_idx_from_text(TTR("Load As Placeholder"));
|
|
editable = !editable;
|
|
|
|
EditorNode::get_singleton()->get_edited_scene()->set_editable_instance(node, editable);
|
|
|
|
menu->set_item_checked(editable_item_idx, editable);
|
|
if (editable) {
|
|
node->set_scene_instance_load_placeholder(false);
|
|
menu->set_item_checked(placeholder_item_idx, false);
|
|
}
|
|
scene_tree->update_tree();
|
|
}
|
|
}
|
|
} break;
|
|
case TOOL_SCENE_USE_PLACEHOLDER: {
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
bool placeholder = node->get_scene_instance_load_placeholder();
|
|
placeholder = !placeholder;
|
|
int editable_item_idx = menu->get_item_idx_from_text(TTR("Editable Children"));
|
|
int placeholder_item_idx = menu->get_item_idx_from_text(TTR("Load As 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(editable_item_idx, false);
|
|
menu->set_item_checked(placeholder_item_idx, placeholder);
|
|
scene_tree->update_tree();
|
|
}
|
|
}
|
|
} break;
|
|
case TOOL_SCENE_CLEAR_INSTANCING: {
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
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(TTR("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();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
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();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
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();
|
|
List<Node *>::Element *e = selection.front();
|
|
if (e) {
|
|
Node *node = e->get();
|
|
if (node) {
|
|
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) {
|
|
|
|
int idx = p_tool - EDIT_SUBRESOURCE_BASE;
|
|
|
|
ERR_FAIL_INDEX(idx, subresources.size());
|
|
|
|
Object *obj = ObjectDB::get_instance(subresources[idx]);
|
|
ERR_FAIL_COND(!obj);
|
|
|
|
editor->push_item(obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_notification(int p_what) {
|
|
|
|
switch (p_what) {
|
|
|
|
case NOTIFICATION_READY: {
|
|
|
|
if (!first_enter)
|
|
break;
|
|
first_enter = false;
|
|
|
|
CanvasItemEditorPlugin *canvas_item_plugin = Object::cast_to<CanvasItemEditorPlugin>(editor_data->get_editor("2D"));
|
|
if (canvas_item_plugin) {
|
|
canvas_item_plugin->get_canvas_item_editor()->connect("item_lock_status_changed", scene_tree, "_update_tree");
|
|
canvas_item_plugin->get_canvas_item_editor()->connect("item_group_status_changed", scene_tree, "_update_tree");
|
|
scene_tree->connect("node_changed", canvas_item_plugin->get_canvas_item_editor()->get_viewport_control(), "update");
|
|
}
|
|
|
|
SpatialEditorPlugin *spatial_editor_plugin = Object::cast_to<SpatialEditorPlugin>(editor_data->get_editor("3D"));
|
|
spatial_editor_plugin->get_spatial_editor()->connect("item_lock_status_changed", scene_tree, "_update_tree");
|
|
|
|
button_add->set_icon(get_icon("Add", "EditorIcons"));
|
|
button_instance->set_icon(get_icon("Instance", "EditorIcons"));
|
|
button_create_script->set_icon(get_icon("ScriptCreate", "EditorIcons"));
|
|
button_clear_script->set_icon(get_icon("ScriptRemove", "EditorIcons"));
|
|
|
|
filter->add_icon_override("right_icon", get_icon("Search", "EditorIcons"));
|
|
|
|
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;
|
|
case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: {
|
|
button_add->set_icon(get_icon("Add", "EditorIcons"));
|
|
button_instance->set_icon(get_icon("Instance", "EditorIcons"));
|
|
button_create_script->set_icon(get_icon("ScriptCreate", "EditorIcons"));
|
|
button_clear_script->set_icon(get_icon("ScriptRemove", "EditorIcons"));
|
|
|
|
filter->add_icon_override("right_icon", get_icon("Search", "EditorIcons"));
|
|
} 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);
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
if (ScriptEditor::get_singleton()->is_visible_in_tree()) {
|
|
restore_script_editor_on_drag = true;
|
|
}
|
|
|
|
editor->push_item(node);
|
|
}
|
|
|
|
void SceneTreeDock::_node_renamed() {
|
|
|
|
_node_selected();
|
|
}
|
|
|
|
void SceneTreeDock::_set_owners(Node *p_owner, const Array &p_nodes) {
|
|
|
|
for (int i = 0; i < p_nodes.size(); i++) {
|
|
|
|
Node *n = Object::cast_to<Node>(p_nodes[i]);
|
|
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("editors/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("editors/animation/autorename_animation_tracks", true)))
|
|
return;
|
|
|
|
if (!p_base) {
|
|
|
|
p_base = edited_scene;
|
|
}
|
|
|
|
if (!p_base)
|
|
return;
|
|
|
|
if (Object::cast_to<AnimationPlayer>(p_base)) {
|
|
|
|
AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(p_base);
|
|
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);
|
|
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);
|
|
}
|
|
|
|
bool SceneTreeDock::_validate_no_foreign() {
|
|
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
|
|
for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
|
|
|
|
if (E->get() != edited_scene && E->get()->get_owner() != edited_scene) {
|
|
|
|
accept->get_ok()->set_text(TTR("Makes Sense!"));
|
|
accept->set_text(TTR("Can't operate on nodes from a foreign scene!"));
|
|
accept->popup_centered_minsize();
|
|
return false;
|
|
}
|
|
|
|
if (edited_scene->get_scene_inherited_state().is_valid() && edited_scene->get_scene_inherited_state()->find_node_by_path(edited_scene->get_path_to(E->get())) >= 0) {
|
|
|
|
accept->get_ok()->set_text(TTR("Makes Sense!"));
|
|
accept->set_text(TTR("Can't operate on nodes the current scene inherits from!"));
|
|
accept->popup_centered_minsize();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void SceneTreeDock::_node_reparent(NodePath p_path, bool p_keep_global_xform) {
|
|
|
|
Node *new_parent = scene_root->get_node(p_path);
|
|
ERR_FAIL_COND(!new_parent);
|
|
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
|
|
if (selection.empty())
|
|
return; //nothing to reparent
|
|
|
|
Vector<Node *> nodes;
|
|
|
|
for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
|
|
nodes.push_back(E->get());
|
|
}
|
|
|
|
_do_reparent(new_parent, -1, nodes, p_keep_global_xform);
|
|
}
|
|
|
|
void SceneTreeDock::_do_reparent(Node *p_new_parent, int p_position_in_parent, Vector<Node *> p_nodes, bool p_keep_global_xform) {
|
|
|
|
Node *new_parent = p_new_parent;
|
|
ERR_FAIL_COND(!new_parent);
|
|
|
|
Node *validate = new_parent;
|
|
while (validate) {
|
|
|
|
if (p_nodes.find(validate) != -1) {
|
|
ERR_EXPLAIN("Selection changed at some point.. can't reparent");
|
|
ERR_FAIL();
|
|
return;
|
|
}
|
|
validate = validate->get_parent();
|
|
}
|
|
//ok all valid
|
|
|
|
if (p_nodes.size() == 0)
|
|
return; //nothing to reparent
|
|
|
|
//sort by tree order, so re-adding is easy
|
|
p_nodes.sort_custom<Node::Comparator>();
|
|
|
|
editor_data->get_undo_redo().create_action(TTR("Reparent Node"));
|
|
|
|
List<Pair<NodePath, NodePath> > path_renames;
|
|
Vector<StringName> former_names;
|
|
|
|
int inc = 0;
|
|
|
|
for (int ni = 0; ni < p_nodes.size(); ni++) {
|
|
|
|
//no undo for now, sorry
|
|
Node *node = p_nodes[ni];
|
|
|
|
fill_path_renames(node, new_parent, &path_renames);
|
|
former_names.push_back(node->get_name());
|
|
|
|
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());
|
|
}
|
|
|
|
if (new_parent == node->get_parent() && node->get_index() < p_position_in_parent + ni) {
|
|
//if child will generate a gap when moved, adjust
|
|
inc--;
|
|
}
|
|
|
|
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);
|
|
|
|
if (p_position_in_parent >= 0)
|
|
editor_data->get_undo_redo().add_do_method(new_parent, "move_child", node, p_position_in_parent + inc);
|
|
|
|
ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
|
|
String new_name = new_parent->validate_child_name(node);
|
|
editor_data->get_undo_redo().add_do_method(sed, "live_debug_reparent_node", edited_scene->get_path_to(node), edited_scene->get_path_to(new_parent), new_name, -1);
|
|
editor_data->get_undo_redo().add_undo_method(sed, "live_debug_reparent_node", NodePath(String(edited_scene->get_path_to(new_parent)) + "/" + new_name), edited_scene->get_path_to(node->get_parent()), node->get_name(), node->get_index());
|
|
|
|
if (p_keep_global_xform) {
|
|
if (Object::cast_to<Node2D>(node))
|
|
editor_data->get_undo_redo().add_do_method(node, "set_global_transform", Object::cast_to<Node2D>(node)->get_global_transform());
|
|
if (Object::cast_to<Spatial>(node))
|
|
editor_data->get_undo_redo().add_do_method(node, "set_global_transform", Object::cast_to<Spatial>(node)->get_global_transform());
|
|
if (Object::cast_to<Control>(node))
|
|
editor_data->get_undo_redo().add_do_method(node, "set_global_position", Object::cast_to<Control>(node)->get_global_position());
|
|
}
|
|
|
|
editor_data->get_undo_redo().add_do_method(this, "_set_owners", edited_scene, owners);
|
|
|
|
if (AnimationPlayerEditor::singleton->get_key_editor()->get_root() == node)
|
|
editor_data->get_undo_redo().add_do_method(AnimationPlayerEditor::singleton->get_key_editor(), "set_root", node);
|
|
|
|
editor_data->get_undo_redo().add_undo_method(new_parent, "remove_child", node);
|
|
editor_data->get_undo_redo().add_undo_method(node, "set_name", former_names[ni]);
|
|
|
|
inc++;
|
|
}
|
|
|
|
//add and move in a second step.. (so old order is preserved)
|
|
|
|
for (int ni = 0; ni < p_nodes.size(); ni++) {
|
|
|
|
Node *node = p_nodes[ni];
|
|
|
|
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 (AnimationPlayerEditor::singleton->get_key_editor()->get_root() == node)
|
|
editor_data->get_undo_redo().add_undo_method(AnimationPlayerEditor::singleton->get_key_editor(), "set_root", node);
|
|
|
|
if (p_keep_global_xform) {
|
|
if (Object::cast_to<Node2D>(node))
|
|
editor_data->get_undo_redo().add_undo_method(node, "set_transform", Object::cast_to<Node2D>(node)->get_transform());
|
|
if (Object::cast_to<Spatial>(node))
|
|
editor_data->get_undo_redo().add_undo_method(node, "set_transform", Object::cast_to<Spatial>(node)->get_transform());
|
|
if (Object::cast_to<Control>(node))
|
|
editor_data->get_undo_redo().add_undo_method(node, "set_position", Object::cast_to<Control>(node)->get_position());
|
|
}
|
|
}
|
|
|
|
perform_node_renames(NULL, &path_renames);
|
|
|
|
editor_data->get_undo_redo().commit_action();
|
|
}
|
|
|
|
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->());
|
|
_update_script_button();
|
|
}
|
|
|
|
void SceneTreeDock::_delete_confirm() {
|
|
|
|
List<Node *> remove_list = editor_selection->get_selected_node_list();
|
|
|
|
if (remove_list.empty())
|
|
return;
|
|
|
|
editor->get_editor_plugins_over()->make_visible(false);
|
|
|
|
editor_data->get_undo_redo().create_action(TTR("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_method(scene_tree, "update_tree");
|
|
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_tree() || !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_tree() || !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 (AnimationPlayerEditor::singleton->get_key_editor()->get_root() == n)
|
|
editor_data->get_undo_redo().add_undo_method(AnimationPlayerEditor::singleton->get_key_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_reference(n);
|
|
|
|
ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
|
|
editor_data->get_undo_redo().add_do_method(sed, "live_debug_remove_and_keep_node", edited_scene->get_path_to(n), n->get_instance_id());
|
|
editor_data->get_undo_redo().add_undo_method(sed, "live_debug_restore_node", n->get_instance_id(), edited_scene->get_path_to(n->get_parent()), n->get_index());
|
|
}
|
|
}
|
|
editor_data->get_undo_redo().commit_action();
|
|
|
|
// hack, force 2d editor viewport to refresh after deletion
|
|
if (CanvasItemEditor *editor = CanvasItemEditor::get_singleton())
|
|
editor->get_viewport_control()->update();
|
|
|
|
editor->push_item(NULL);
|
|
|
|
// Fixes the EditorHistory from still offering deleted notes
|
|
EditorHistory *editor_history = EditorNode::get_singleton()->get_editor_history();
|
|
editor_history->cleanup_history();
|
|
EditorNode::get_singleton()->call("_prepare_history");
|
|
}
|
|
|
|
void SceneTreeDock::_update_script_button() {
|
|
if (EditorNode::get_singleton()->get_editor_selection()->get_selection().size() == 1) {
|
|
if (EditorNode::get_singleton()->get_editor_selection()->get_selection().front()->key()->get_script().is_null()) {
|
|
button_create_script->show();
|
|
button_clear_script->hide();
|
|
} else {
|
|
button_create_script->hide();
|
|
button_clear_script->show();
|
|
}
|
|
} else {
|
|
button_create_script->hide();
|
|
button_clear_script->hide();
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_selection_changed() {
|
|
|
|
int selection_size = EditorNode::get_singleton()->get_editor_selection()->get_selection().size();
|
|
if (selection_size > 1) {
|
|
//automatically turn on multi-edit
|
|
_tool_selected(TOOL_MULTI_EDIT);
|
|
}
|
|
_update_script_button();
|
|
}
|
|
|
|
void SceneTreeDock::_create() {
|
|
|
|
if (current_option == TOOL_NEW) {
|
|
|
|
Node *parent = NULL;
|
|
|
|
if (edited_scene) {
|
|
// If root exists in edited scene
|
|
parent = scene_tree->get_selected();
|
|
if (!parent)
|
|
parent = edited_scene;
|
|
|
|
} else {
|
|
// If no root exist in edited scene
|
|
parent = scene_root;
|
|
ERR_FAIL_COND(!parent);
|
|
}
|
|
|
|
Object *c = create_dialog->instance_selected();
|
|
|
|
ERR_FAIL_COND(!c);
|
|
Node *child = Object::cast_to<Node>(c);
|
|
ERR_FAIL_COND(!child);
|
|
|
|
editor_data->get_undo_redo().create_action(TTR("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);
|
|
|
|
String new_name = parent->validate_child_name(child);
|
|
ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
|
|
editor_data->get_undo_redo().add_do_method(sed, "live_debug_create_node", edited_scene->get_path_to(parent), child->get_class(), new_name);
|
|
editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(edited_scene->get_path_to(parent)) + "/" + new_name));
|
|
|
|
} else {
|
|
|
|
editor_data->get_undo_redo().add_do_method(editor, "set_edited_scene", child);
|
|
editor_data->get_undo_redo().add_do_method(scene_tree, "update_tree");
|
|
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);
|
|
editor_selection->clear();
|
|
editor_selection->add_node(child);
|
|
if (Object::cast_to<Control>(c)) {
|
|
//make editor more comfortable, so some controls don't appear super shrunk
|
|
Control *ct = Object::cast_to<Control>(c);
|
|
|
|
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) {
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
ERR_FAIL_COND(selection.size() <= 0);
|
|
for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
|
|
Node *n = E->get();
|
|
ERR_FAIL_COND(!n);
|
|
|
|
Object *c = create_dialog->instance_selected();
|
|
|
|
ERR_FAIL_COND(!c);
|
|
Node *newnode = Object::cast_to<Node>(c);
|
|
ERR_FAIL_COND(!newnode);
|
|
|
|
Node *default_oldnode = Object::cast_to<Node>(ClassDB::instance(n->get_class()));
|
|
|
|
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;
|
|
if (E->get().name == "__meta__")
|
|
continue;
|
|
if (default_oldnode->get(E->get().name) != n->get(E->get().name)) {
|
|
newnode->set(E->get().name, n->get(E->get().name));
|
|
}
|
|
}
|
|
|
|
editor->push_item(NULL);
|
|
memdelete(default_oldnode);
|
|
|
|
//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();
|
|
|
|
List<Node *> to_erase;
|
|
for (int i = 0; i < n->get_child_count(); i++) {
|
|
if (n->get_child(i)->get_owner() == NULL && n->is_owned_by_parent()) {
|
|
to_erase.push_back(n->get_child(i));
|
|
}
|
|
}
|
|
n->replace_by(newnode, true);
|
|
|
|
if (n == edited_scene) {
|
|
edited_scene = newnode;
|
|
editor->set_edited_scene(newnode);
|
|
newnode->set_editable_instances(n->get_editable_instances());
|
|
}
|
|
|
|
//small hack to make collisionshapes and other kind of nodes to work
|
|
for (int i = 0; i < newnode->get_child_count(); i++) {
|
|
Node *c = newnode->get_child(i);
|
|
c->call("set_transform", c->call("get_transform"));
|
|
}
|
|
editor_data->get_undo_redo().clear_history();
|
|
newnode->set_name(newname);
|
|
|
|
editor->push_item(newnode);
|
|
|
|
memdelete(n);
|
|
|
|
while (to_erase.front()) {
|
|
memdelete(to_erase.front()->get());
|
|
to_erase.pop_front();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::set_edited_scene(Node *p_scene) {
|
|
|
|
edited_scene = p_scene;
|
|
}
|
|
|
|
void SceneTreeDock::set_selected(Node *p_node, bool p_emit_selected) {
|
|
|
|
scene_tree->set_selected(p_node, p_emit_selected);
|
|
}
|
|
|
|
void SceneTreeDock::import_subscene() {
|
|
|
|
import_subscene_dialog->popup_centered_ratio();
|
|
}
|
|
|
|
void SceneTreeDock::_import_subscene() {
|
|
|
|
Node *parent = scene_tree->get_selected();
|
|
if (!parent) {
|
|
parent = editor_data->get_edited_scene_root();
|
|
ERR_FAIL_COND(!parent);
|
|
}
|
|
|
|
import_subscene_dialog->move(parent, edited_scene);
|
|
editor_data->get_undo_redo().clear_history(); //no undo for now..
|
|
}
|
|
|
|
void SceneTreeDock::_new_scene_from(String p_file) {
|
|
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
|
|
if (selection.size() != 1) {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("This operation requires a single selected node."));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
}
|
|
|
|
Node *base = selection.front()->get();
|
|
|
|
Map<Node *, Node *> reown;
|
|
reown[editor_data->get_edited_scene_root()] = base;
|
|
Node *copy = base->duplicate_and_reown(reown);
|
|
if (copy) {
|
|
|
|
Ref<PackedScene> sdata = memnew(PackedScene);
|
|
Error err = sdata->pack(copy);
|
|
memdelete(copy);
|
|
|
|
if (err != OK) {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("Couldn't save new scene. Likely dependencies (instances) couldn't be satisfied."));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
}
|
|
|
|
int flg = 0;
|
|
if (EditorSettings::get_singleton()->get("filesystem/on_save/compress_binary_resources"))
|
|
flg |= ResourceSaver::FLAG_COMPRESS;
|
|
|
|
err = ResourceSaver::save(p_file, sdata, flg);
|
|
if (err != OK) {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("Error saving scene."));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
}
|
|
_replace_with_branch_scene(p_file, base);
|
|
} else {
|
|
accept->get_ok()->set_text(TTR("I see.."));
|
|
accept->set_text(TTR("Error duplicating scene to save it."));
|
|
accept->popup_centered_minsize();
|
|
return;
|
|
}
|
|
}
|
|
|
|
static bool _is_node_visible(Node *p_node) {
|
|
|
|
if (!p_node->get_owner())
|
|
return false;
|
|
if (p_node->get_owner() != EditorNode::get_singleton()->get_edited_scene() && !EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(p_node->get_owner()))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool _has_visible_children(Node *p_node) {
|
|
|
|
bool collapsed = p_node->is_displayed_folded();
|
|
if (collapsed)
|
|
return false;
|
|
|
|
for (int i = 0; i < p_node->get_child_count(); i++) {
|
|
|
|
Node *child = p_node->get_child(i);
|
|
if (!_is_node_visible(child))
|
|
continue;
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static Node *_find_last_visible(Node *p_node) {
|
|
|
|
Node *last = NULL;
|
|
|
|
bool collapsed = p_node->is_displayed_folded();
|
|
|
|
if (!collapsed) {
|
|
for (int i = 0; i < p_node->get_child_count(); i++) {
|
|
if (_is_node_visible(p_node->get_child(i))) {
|
|
last = p_node->get_child(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (last) {
|
|
Node *lastc = _find_last_visible(last);
|
|
if (lastc)
|
|
last = lastc;
|
|
|
|
} else {
|
|
last = p_node;
|
|
}
|
|
|
|
return last;
|
|
}
|
|
|
|
void SceneTreeDock::_normalize_drop(Node *&to_node, int &to_pos, int p_type) {
|
|
|
|
to_pos = -1;
|
|
|
|
if (p_type == -1) {
|
|
//drop at above selected node
|
|
if (to_node == EditorNode::get_singleton()->get_edited_scene()) {
|
|
to_node = NULL;
|
|
ERR_EXPLAIN("Cannot perform drop above the root node!");
|
|
ERR_FAIL();
|
|
}
|
|
|
|
to_pos = to_node->get_index();
|
|
to_node = to_node->get_parent();
|
|
|
|
} else if (p_type == 1) {
|
|
//drop at below selected node
|
|
if (to_node == EditorNode::get_singleton()->get_edited_scene()) {
|
|
//if at lower sibling of root node
|
|
to_pos = 0; //just insert at beginning of root node
|
|
return;
|
|
}
|
|
|
|
Node *lower_sibling = NULL;
|
|
|
|
if (_has_visible_children(to_node)) {
|
|
to_pos = 0;
|
|
} else {
|
|
for (int i = to_node->get_index() + 1; i < to_node->get_parent()->get_child_count(); i++) {
|
|
Node *c = to_node->get_parent()->get_child(i);
|
|
if (_is_node_visible(c)) {
|
|
lower_sibling = c;
|
|
break;
|
|
}
|
|
}
|
|
if (lower_sibling) {
|
|
to_pos = lower_sibling->get_index();
|
|
}
|
|
|
|
to_node = to_node->get_parent();
|
|
}
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_files_dropped(Vector<String> p_files, NodePath p_to, int p_type) {
|
|
|
|
Node *node = get_node(p_to);
|
|
ERR_FAIL_COND(!node);
|
|
|
|
int to_pos = -1;
|
|
_normalize_drop(node, to_pos, p_type);
|
|
_perform_instance_scenes(p_files, node, to_pos);
|
|
}
|
|
|
|
void SceneTreeDock::_script_dropped(String p_file, NodePath p_to) {
|
|
Ref<Script> scr = ResourceLoader::load(p_file);
|
|
ERR_FAIL_COND(!scr.is_valid());
|
|
Node *n = get_node(p_to);
|
|
if (n) {
|
|
n->set_script(scr.get_ref_ptr());
|
|
_update_script_button();
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_nodes_dragged(Array p_nodes, NodePath p_to, int p_type) {
|
|
|
|
Vector<Node *> nodes;
|
|
Node *to_node;
|
|
|
|
for (int i = 0; i < p_nodes.size(); i++) {
|
|
Node *n = get_node((p_nodes[i]));
|
|
if (n) {
|
|
nodes.push_back(n);
|
|
}
|
|
}
|
|
|
|
if (nodes.size() == 0)
|
|
return;
|
|
|
|
to_node = get_node(p_to);
|
|
if (!to_node)
|
|
return;
|
|
|
|
int to_pos = -1;
|
|
|
|
_normalize_drop(to_node, to_pos, p_type);
|
|
_do_reparent(to_node, to_pos, nodes, true);
|
|
}
|
|
|
|
void SceneTreeDock::_add_children_to_popup(Object *p_obj, int p_depth) {
|
|
|
|
if (p_depth > 8)
|
|
return;
|
|
|
|
List<PropertyInfo> pinfo;
|
|
p_obj->get_property_list(&pinfo);
|
|
for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
|
|
|
|
if (!(E->get().usage & PROPERTY_USAGE_EDITOR))
|
|
continue;
|
|
if (E->get().hint != PROPERTY_HINT_RESOURCE_TYPE)
|
|
continue;
|
|
|
|
Variant value = p_obj->get(E->get().name);
|
|
if (value.get_type() != Variant::OBJECT)
|
|
continue;
|
|
Object *obj = value;
|
|
if (!obj)
|
|
continue;
|
|
|
|
Ref<Texture> icon;
|
|
|
|
if (has_icon(obj->get_class(), "EditorIcons"))
|
|
icon = get_icon(obj->get_class(), "EditorIcons");
|
|
else
|
|
icon = get_icon("Object", "EditorIcons");
|
|
|
|
if (menu->get_item_count() == 0) {
|
|
menu->add_submenu_item(TTR("Sub-Resources"), "Sub-Resources");
|
|
}
|
|
int index = menu_subresources->get_item_count();
|
|
menu_subresources->add_icon_item(icon, E->get().name.capitalize(), EDIT_SUBRESOURCE_BASE + subresources.size());
|
|
menu_subresources->set_item_h_offset(index, p_depth * 10 * EDSCALE);
|
|
subresources.push_back(obj->get_instance_id());
|
|
|
|
_add_children_to_popup(obj, p_depth + 1);
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::_tree_rmb(const Vector2 &p_menu_pos) {
|
|
if (!EditorNode::get_singleton()->get_edited_scene()) {
|
|
|
|
menu->clear();
|
|
menu->add_icon_shortcut(get_icon("Add", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/add_child_node"), TOOL_NEW);
|
|
menu->add_icon_shortcut(get_icon("Instance", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/instance_scene"), TOOL_INSTANCE);
|
|
|
|
menu->set_size(Size2(1, 1));
|
|
menu->set_position(p_menu_pos);
|
|
menu->popup();
|
|
return;
|
|
}
|
|
|
|
List<Node *> selection = editor_selection->get_selected_node_list();
|
|
|
|
if (selection.size() == 0)
|
|
return;
|
|
|
|
menu->clear();
|
|
|
|
if (selection.size() == 1) {
|
|
|
|
subresources.clear();
|
|
menu_subresources->clear();
|
|
_add_children_to_popup(selection.front()->get(), 0);
|
|
if (menu->get_item_count() > 0)
|
|
menu->add_separator();
|
|
|
|
menu->add_icon_shortcut(get_icon("Add", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/add_child_node"), TOOL_NEW);
|
|
menu->add_icon_shortcut(get_icon("Instance", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/instance_scene"), TOOL_INSTANCE);
|
|
menu->add_separator();
|
|
menu->add_icon_shortcut(get_icon("ScriptCreate", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/attach_script"), TOOL_ATTACH_SCRIPT);
|
|
menu->add_icon_shortcut(get_icon("ScriptRemove", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/clear_script"), TOOL_CLEAR_SCRIPT);
|
|
menu->add_separator();
|
|
}
|
|
menu->add_icon_shortcut(get_icon("Reload", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/change_node_type"), TOOL_REPLACE);
|
|
menu->add_separator();
|
|
menu->add_icon_shortcut(get_icon("MoveUp", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/move_up"), TOOL_MOVE_UP);
|
|
menu->add_icon_shortcut(get_icon("MoveDown", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/move_down"), TOOL_MOVE_DOWN);
|
|
menu->add_icon_shortcut(get_icon("Duplicate", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/duplicate"), TOOL_DUPLICATE);
|
|
menu->add_icon_shortcut(get_icon("Reparent", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/reparent"), TOOL_REPARENT);
|
|
|
|
if (selection.size() == 1) {
|
|
menu->add_separator();
|
|
menu->add_icon_shortcut(get_icon("Blend", "EditorIcons"), ED_GET_SHORTCUT("scene_tree/merge_from_scene"), TOOL_MERGE_FROM_SCENE);
|
|
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() != "");
|
|
if (is_external) {
|
|
bool is_inherited = selection[0]->get_scene_inherited_state() != NULL;
|
|
bool is_top_level = selection[0]->get_owner() == NULL;
|
|
if (is_inherited && is_top_level) {
|
|
menu->add_separator();
|
|
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 if (!is_top_level) {
|
|
menu->add_separator();
|
|
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(menu->get_item_idx_from_text(TTR("Editable Children")), editable);
|
|
menu->set_item_checked(menu->get_item_idx_from_text(TTR("Load As Placeholder")), 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);
|
|
menu->set_size(Size2(1, 1));
|
|
menu->set_position(p_menu_pos);
|
|
menu->popup();
|
|
}
|
|
|
|
void SceneTreeDock::_filter_changed(const String &p_filter) {
|
|
|
|
scene_tree->set_filter(p_filter);
|
|
}
|
|
|
|
String SceneTreeDock::get_filter() {
|
|
|
|
return filter->get_text();
|
|
}
|
|
|
|
void SceneTreeDock::set_filter(const String &p_filter) {
|
|
|
|
filter->set_text(p_filter);
|
|
scene_tree->set_filter(p_filter);
|
|
}
|
|
|
|
void SceneTreeDock::_focus_node() {
|
|
|
|
Node *node = scene_tree->get_selected();
|
|
ERR_FAIL_COND(!node);
|
|
|
|
if (node->is_class("CanvasItem")) {
|
|
CanvasItemEditorPlugin *editor = Object::cast_to<CanvasItemEditorPlugin>(editor_data->get_editor("2D"));
|
|
editor->get_canvas_item_editor()->focus_selection();
|
|
} else {
|
|
SpatialEditorPlugin *editor = Object::cast_to<SpatialEditorPlugin>(editor_data->get_editor("3D"));
|
|
editor->get_spatial_editor()->get_editor_viewport(0)->focus_selection();
|
|
}
|
|
}
|
|
|
|
void SceneTreeDock::open_script_dialog(Node *p_for_node) {
|
|
|
|
scene_tree->set_selected(p_for_node, false);
|
|
_tool_selected(TOOL_ATTACH_SCRIPT);
|
|
}
|
|
|
|
void SceneTreeDock::add_remote_tree_editor(Control *p_remote) {
|
|
ERR_FAIL_COND(remote_tree != NULL);
|
|
add_child(p_remote);
|
|
remote_tree = p_remote;
|
|
remote_tree->hide();
|
|
}
|
|
|
|
void SceneTreeDock::show_remote_tree() {
|
|
|
|
_remote_tree_selected();
|
|
}
|
|
|
|
void SceneTreeDock::hide_remote_tree() {
|
|
|
|
_local_tree_selected();
|
|
}
|
|
|
|
void SceneTreeDock::show_tab_buttons() {
|
|
|
|
button_hb->show();
|
|
}
|
|
|
|
void SceneTreeDock::hide_tab_buttons() {
|
|
|
|
button_hb->hide();
|
|
}
|
|
|
|
void SceneTreeDock::_remote_tree_selected() {
|
|
|
|
scene_tree->hide();
|
|
if (remote_tree)
|
|
remote_tree->show();
|
|
edit_remote->set_pressed(true);
|
|
edit_local->set_pressed(false);
|
|
|
|
emit_signal("remote_tree_selected");
|
|
}
|
|
|
|
void SceneTreeDock::_local_tree_selected() {
|
|
|
|
scene_tree->show();
|
|
if (remote_tree)
|
|
remote_tree->hide();
|
|
edit_remote->set_pressed(false);
|
|
edit_local->set_pressed(true);
|
|
}
|
|
|
|
void SceneTreeDock::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("_tool_selected"), &SceneTreeDock::_tool_selected, DEFVAL(false));
|
|
ClassDB::bind_method(D_METHOD("_create"), &SceneTreeDock::_create);
|
|
ClassDB::bind_method(D_METHOD("_node_reparent"), &SceneTreeDock::_node_reparent);
|
|
ClassDB::bind_method(D_METHOD("_set_owners"), &SceneTreeDock::_set_owners);
|
|
ClassDB::bind_method(D_METHOD("_node_selected"), &SceneTreeDock::_node_selected);
|
|
ClassDB::bind_method(D_METHOD("_node_renamed"), &SceneTreeDock::_node_renamed);
|
|
ClassDB::bind_method(D_METHOD("_script_created"), &SceneTreeDock::_script_created);
|
|
ClassDB::bind_method(D_METHOD("_load_request"), &SceneTreeDock::_load_request);
|
|
ClassDB::bind_method(D_METHOD("_script_open_request"), &SceneTreeDock::_script_open_request);
|
|
ClassDB::bind_method(D_METHOD("_unhandled_key_input"), &SceneTreeDock::_unhandled_key_input);
|
|
ClassDB::bind_method(D_METHOD("_input"), &SceneTreeDock::_input);
|
|
ClassDB::bind_method(D_METHOD("_nodes_drag_begin"), &SceneTreeDock::_nodes_drag_begin);
|
|
ClassDB::bind_method(D_METHOD("_delete_confirm"), &SceneTreeDock::_delete_confirm);
|
|
ClassDB::bind_method(D_METHOD("_node_prerenamed"), &SceneTreeDock::_node_prerenamed);
|
|
ClassDB::bind_method(D_METHOD("_import_subscene"), &SceneTreeDock::_import_subscene);
|
|
ClassDB::bind_method(D_METHOD("_selection_changed"), &SceneTreeDock::_selection_changed);
|
|
ClassDB::bind_method(D_METHOD("_new_scene_from"), &SceneTreeDock::_new_scene_from);
|
|
ClassDB::bind_method(D_METHOD("_nodes_dragged"), &SceneTreeDock::_nodes_dragged);
|
|
ClassDB::bind_method(D_METHOD("_files_dropped"), &SceneTreeDock::_files_dropped);
|
|
ClassDB::bind_method(D_METHOD("_script_dropped"), &SceneTreeDock::_script_dropped);
|
|
ClassDB::bind_method(D_METHOD("_tree_rmb"), &SceneTreeDock::_tree_rmb);
|
|
ClassDB::bind_method(D_METHOD("_filter_changed"), &SceneTreeDock::_filter_changed);
|
|
ClassDB::bind_method(D_METHOD("_focus_node"), &SceneTreeDock::_focus_node);
|
|
ClassDB::bind_method(D_METHOD("_remote_tree_selected"), &SceneTreeDock::_remote_tree_selected);
|
|
ClassDB::bind_method(D_METHOD("_local_tree_selected"), &SceneTreeDock::_local_tree_selected);
|
|
|
|
ClassDB::bind_method(D_METHOD("instance"), &SceneTreeDock::instance);
|
|
|
|
ADD_SIGNAL(MethodInfo("remote_tree_selected"));
|
|
}
|
|
|
|
SceneTreeDock::SceneTreeDock(EditorNode *p_editor, Node *p_scene_root, EditorSelection *p_editor_selection, EditorData &p_editor_data) {
|
|
|
|
set_name("Scene");
|
|
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 *filter_hbc = memnew(HBoxContainer);
|
|
filter_hbc->add_constant_override("separate", 0);
|
|
ToolButton *tb;
|
|
|
|
ED_SHORTCUT("scene_tree/add_child_node", TTR("Add Child Node"), KEY_MASK_CMD | KEY_A);
|
|
ED_SHORTCUT("scene_tree/instance_scene", TTR("Instance Child Scene"));
|
|
ED_SHORTCUT("scene_tree/change_node_type", TTR("Change Type"));
|
|
ED_SHORTCUT("scene_tree/attach_script", TTR("Attach Script"));
|
|
ED_SHORTCUT("scene_tree/clear_script", TTR("Clear Script"));
|
|
ED_SHORTCUT("scene_tree/move_up", TTR("Move Up"), KEY_MASK_CMD | KEY_UP);
|
|
ED_SHORTCUT("scene_tree/move_down", TTR("Move Down"), KEY_MASK_CMD | KEY_DOWN);
|
|
ED_SHORTCUT("scene_tree/duplicate", TTR("Duplicate"), KEY_MASK_CMD | KEY_D);
|
|
ED_SHORTCUT("scene_tree/reparent", TTR("Reparent"));
|
|
ED_SHORTCUT("scene_tree/merge_from_scene", TTR("Merge From Scene"));
|
|
ED_SHORTCUT("scene_tree/save_branch_as_scene", TTR("Save Branch as Scene"));
|
|
ED_SHORTCUT("scene_tree/copy_node_path", TTR("Copy Node Path"), KEY_MASK_CMD | KEY_C);
|
|
ED_SHORTCUT("scene_tree/delete_no_confirm", TTR("Delete (No Confirm)"), KEY_MASK_SHIFT | KEY_DELETE);
|
|
ED_SHORTCUT("scene_tree/delete", TTR("Delete"), KEY_DELETE);
|
|
|
|
tb = memnew(ToolButton);
|
|
tb->connect("pressed", this, "_tool_selected", make_binds(TOOL_NEW, false));
|
|
tb->set_tooltip(TTR("Add/Create a New Node"));
|
|
tb->set_shortcut(ED_GET_SHORTCUT("scene_tree/add_child_node"));
|
|
filter_hbc->add_child(tb);
|
|
button_add = tb;
|
|
|
|
tb = memnew(ToolButton);
|
|
tb->connect("pressed", this, "_tool_selected", make_binds(TOOL_INSTANCE, false));
|
|
tb->set_tooltip(TTR("Instance a scene file as a Node. Creates an inherited scene if no root node exists."));
|
|
tb->set_shortcut(ED_GET_SHORTCUT("scene_tree/instance_scene"));
|
|
filter_hbc->add_child(tb);
|
|
button_instance = tb;
|
|
|
|
vbc->add_child(filter_hbc);
|
|
filter = memnew(LineEdit);
|
|
filter->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
filter->set_placeholder(TTR("Filter nodes"));
|
|
filter_hbc->add_child(filter);
|
|
filter->connect("text_changed", this, "_filter_changed");
|
|
|
|
tb = memnew(ToolButton);
|
|
tb->connect("pressed", this, "_tool_selected", make_binds(TOOL_ATTACH_SCRIPT, false));
|
|
tb->set_tooltip(TTR("Attach a new or existing script for the selected node."));
|
|
tb->set_shortcut(ED_GET_SHORTCUT("scene_tree/attach_script"));
|
|
filter_hbc->add_child(tb);
|
|
tb->hide();
|
|
button_create_script = tb;
|
|
|
|
tb = memnew(ToolButton);
|
|
tb->connect("pressed", this, "_tool_selected", make_binds(TOOL_CLEAR_SCRIPT, false));
|
|
tb->set_tooltip(TTR("Clear a script for the selected node."));
|
|
tb->set_shortcut(ED_GET_SHORTCUT("scene_tree/clear_script"));
|
|
filter_hbc->add_child(tb);
|
|
button_clear_script = tb;
|
|
tb->hide();
|
|
|
|
button_hb = memnew(HBoxContainer);
|
|
vbc->add_child(button_hb);
|
|
|
|
edit_remote = memnew(ToolButton);
|
|
button_hb->add_child(edit_remote);
|
|
edit_remote->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
edit_remote->set_text(TTR("Remote"));
|
|
edit_remote->set_toggle_mode(true);
|
|
edit_remote->connect("pressed", this, "_remote_tree_selected");
|
|
|
|
edit_local = memnew(ToolButton);
|
|
button_hb->add_child(edit_local);
|
|
edit_local->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
edit_local->set_text(TTR("Local"));
|
|
edit_local->set_toggle_mode(true);
|
|
edit_local->connect("pressed", this, "_local_tree_selected");
|
|
|
|
remote_tree = NULL;
|
|
button_hb->hide();
|
|
|
|
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("rmb_pressed", this, "_tree_rmb");
|
|
|
|
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->connect("nodes_rearranged", this, "_nodes_dragged");
|
|
scene_tree->connect("files_dropped", this, "_files_dropped");
|
|
scene_tree->connect("script_dropped", this, "_script_dropped");
|
|
scene_tree->connect("nodes_dragged", this, "_nodes_drag_begin");
|
|
|
|
scene_tree->get_scene_tree()->connect("item_double_clicked", this, "_focus_node");
|
|
|
|
scene_tree->set_undo_redo(&editor_data->get_undo_redo());
|
|
scene_tree->set_editor_selection(editor_selection);
|
|
|
|
create_dialog = memnew(CreateDialog);
|
|
create_dialog->set_base_type("Node");
|
|
add_child(create_dialog);
|
|
create_dialog->connect("create", this, "_create");
|
|
|
|
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(EditorFileDialog);
|
|
add_child(file);
|
|
file->connect("file_selected", this, "instance");
|
|
set_process_unhandled_key_input(true);
|
|
|
|
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");
|
|
|
|
new_scene_from_dialog = memnew(EditorFileDialog);
|
|
new_scene_from_dialog->set_mode(EditorFileDialog::MODE_SAVE_FILE);
|
|
add_child(new_scene_from_dialog);
|
|
new_scene_from_dialog->connect("file_selected", this, "_new_scene_from");
|
|
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
menu->connect("id_pressed", this, "_tool_selected");
|
|
menu_subresources = memnew(PopupMenu);
|
|
menu_subresources->set_name("Sub-Resources");
|
|
menu_subresources->connect("id_pressed", this, "_tool_selected");
|
|
menu->add_child(menu_subresources);
|
|
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);
|
|
|
|
set_process_input(true);
|
|
}
|