2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
|
|
|
/* groups_editor.cpp */
|
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 14:16:55 +02:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 02:10:30 +01:00
|
|
|
/*************************************************************************/
|
2019-01-01 12:53:14 +01:00
|
|
|
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md) */
|
2014-02-10 02:10:30 +01:00
|
|
|
/* */
|
|
|
|
/* 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. */
|
|
|
|
/*************************************************************************/
|
2018-01-05 00:50:27 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
#include "groups_editor.h"
|
2018-02-08 10:52:02 +01:00
|
|
|
#include "editor/scene_tree_editor.h"
|
2017-03-05 16:44:50 +01:00
|
|
|
#include "editor_node.h"
|
2019-12-24 08:17:23 +01:00
|
|
|
#include "editor_scale.h"
|
2015-11-26 18:59:04 +01:00
|
|
|
#include "scene/gui/box_container.h"
|
2014-02-10 02:10:30 +01:00
|
|
|
#include "scene/gui/label.h"
|
2016-07-08 01:49:43 +02:00
|
|
|
#include "scene/resources/packed_scene.h"
|
2017-01-16 08:04:19 +01:00
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
void GroupDialog::_group_selected() {
|
|
|
|
nodes_to_add->clear();
|
|
|
|
add_node_root = nodes_to_add->create_item();
|
|
|
|
|
|
|
|
nodes_to_remove->clear();
|
|
|
|
remove_node_root = nodes_to_remove->create_item();
|
|
|
|
|
|
|
|
if (!groups->is_anything_selected()) {
|
2019-08-29 02:24:57 +02:00
|
|
|
group_empty->hide();
|
2018-02-08 10:52:02 +01:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
selected_group = groups->get_selected()->get_text(0);
|
|
|
|
_load_nodes(scene_tree->get_edited_scene_root());
|
2019-08-29 02:24:57 +02:00
|
|
|
|
|
|
|
group_empty->set_visible(!remove_node_root->get_children());
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_load_nodes(Node *p_current) {
|
|
|
|
String item_name = p_current->get_name();
|
|
|
|
if (p_current != scene_tree->get_edited_scene_root()) {
|
2019-06-16 14:31:57 +02:00
|
|
|
item_name = String(p_current->get_parent()->get_name()) + "/" + item_name;
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
bool keep = true;
|
|
|
|
Node *root = scene_tree->get_edited_scene_root();
|
|
|
|
Node *owner = p_current->get_owner();
|
|
|
|
if (owner != root && p_current != root && !owner && !root->is_editable_instance(owner)) {
|
|
|
|
keep = false;
|
|
|
|
}
|
|
|
|
|
2019-07-01 12:59:42 +02:00
|
|
|
TreeItem *node = NULL;
|
2018-02-08 10:52:02 +01:00
|
|
|
NodePath path = scene_tree->get_edited_scene_root()->get_path_to(p_current);
|
|
|
|
if (keep && p_current->is_in_group(selected_group)) {
|
|
|
|
if (remove_filter->get_text().is_subsequence_ofi(String(p_current->get_name()))) {
|
|
|
|
node = nodes_to_remove->create_item(remove_node_root);
|
|
|
|
keep = true;
|
|
|
|
} else {
|
|
|
|
keep = false;
|
|
|
|
}
|
|
|
|
} else if (keep && add_filter->get_text().is_subsequence_ofi(String(p_current->get_name()))) {
|
|
|
|
node = nodes_to_add->create_item(add_node_root);
|
|
|
|
keep = true;
|
|
|
|
} else {
|
|
|
|
keep = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (keep) {
|
|
|
|
node->set_text(0, item_name);
|
|
|
|
node->set_metadata(0, path);
|
|
|
|
node->set_tooltip(0, path);
|
|
|
|
|
2018-09-02 23:40:51 +02:00
|
|
|
Ref<Texture> icon = EditorNode::get_singleton()->get_object_icon(p_current, "Node");
|
2018-02-08 10:52:02 +01:00
|
|
|
node->set_icon(0, icon);
|
|
|
|
|
|
|
|
if (!_can_edit(p_current, selected_group)) {
|
|
|
|
node->set_selectable(0, false);
|
|
|
|
node->set_custom_color(0, get_color("disabled_font_color", "Editor"));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < p_current->get_child_count(); i++) {
|
|
|
|
_load_nodes(p_current->get_child(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool GroupDialog::_can_edit(Node *p_node, String p_group) {
|
|
|
|
Node *n = p_node;
|
|
|
|
bool can_edit = true;
|
|
|
|
while (n) {
|
|
|
|
Ref<SceneState> ss = (n == EditorNode::get_singleton()->get_edited_scene()) ? n->get_scene_inherited_state() : n->get_scene_instance_state();
|
|
|
|
if (ss.is_valid()) {
|
|
|
|
int path = ss->find_node_by_path(n->get_path_to(p_node));
|
|
|
|
if (path != -1) {
|
|
|
|
if (ss->is_node_in_group(path, p_group)) {
|
|
|
|
can_edit = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
n = n->get_owner();
|
|
|
|
}
|
|
|
|
return can_edit;
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_add_pressed() {
|
|
|
|
TreeItem *selected = nodes_to_add->get_selected();
|
|
|
|
|
|
|
|
if (!selected) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->create_action(TTR("Add to Group"));
|
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
while (selected) {
|
|
|
|
Node *node = scene_tree->get_edited_scene_root()->get_node(selected->get_metadata(0));
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(node, "add_to_group", selected_group, true);
|
|
|
|
undo_redo->add_undo_method(node, "remove_from_group", selected_group);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
selected = nodes_to_add->get_next_selected(selected);
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "_group_selected");
|
|
|
|
undo_redo->add_undo_method(this, "_group_selected");
|
|
|
|
undo_redo->add_do_method(this, "emit_signal", "group_edited");
|
|
|
|
undo_redo->add_undo_method(this, "emit_signal", "group_edited");
|
|
|
|
|
|
|
|
// To force redraw of scene tree.
|
|
|
|
undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
undo_redo->add_undo_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
|
|
|
|
undo_redo->commit_action();
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_removed_pressed() {
|
|
|
|
TreeItem *selected = nodes_to_remove->get_selected();
|
|
|
|
|
|
|
|
if (!selected) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->create_action(TTR("Remove from Group"));
|
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
while (selected) {
|
|
|
|
Node *node = scene_tree->get_edited_scene_root()->get_node(selected->get_metadata(0));
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(node, "remove_from_group", selected_group);
|
|
|
|
undo_redo->add_undo_method(node, "add_to_group", selected_group, true);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
selected = nodes_to_add->get_next_selected(selected);
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "_group_selected");
|
|
|
|
undo_redo->add_undo_method(this, "_group_selected");
|
|
|
|
undo_redo->add_do_method(this, "emit_signal", "group_edited");
|
|
|
|
undo_redo->add_undo_method(this, "emit_signal", "group_edited");
|
|
|
|
|
|
|
|
// To force redraw of scene tree.
|
|
|
|
undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
undo_redo->add_undo_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
|
|
|
|
undo_redo->commit_action();
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_remove_filter_changed(const String &p_filter) {
|
|
|
|
_group_selected();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_add_filter_changed(const String &p_filter) {
|
|
|
|
_group_selected();
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
void GroupDialog::_add_group_pressed(const String &p_name) {
|
2018-02-08 10:52:02 +01:00
|
|
|
_add_group(add_group_text->get_text());
|
|
|
|
add_group_text->clear();
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
void GroupDialog::_add_group(String p_name) {
|
|
|
|
if (!is_visible()) {
|
|
|
|
return; // No need to edit the dialog if it's not being used.
|
|
|
|
}
|
|
|
|
|
|
|
|
String name = p_name.strip_edges();
|
|
|
|
if (name == "" || groups->search_item_text(name)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TreeItem *new_group = groups->create_item(groups_root);
|
|
|
|
new_group->set_text(0, name);
|
|
|
|
new_group->add_button(0, get_icon("Remove", "EditorIcons"), 0);
|
|
|
|
new_group->set_editable(0, true);
|
|
|
|
new_group->select(0);
|
|
|
|
groups->ensure_cursor_is_visible();
|
|
|
|
}
|
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
void GroupDialog::_group_renamed() {
|
|
|
|
TreeItem *renamed_group = groups->get_edited();
|
|
|
|
if (!renamed_group) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
String name = renamed_group->get_text(0).strip_edges();
|
|
|
|
for (TreeItem *E = groups_root->get_children(); E; E = E->get_next()) {
|
|
|
|
if (E != renamed_group && E->get_text(0) == name) {
|
|
|
|
renamed_group->set_text(0, selected_group);
|
|
|
|
error->set_text(TTR("Group name already exists."));
|
|
|
|
error->popup_centered();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (name == "") {
|
|
|
|
renamed_group->set_text(0, selected_group);
|
2018-12-13 14:16:20 +01:00
|
|
|
error->set_text(TTR("Invalid group name."));
|
2018-02-08 10:52:02 +01:00
|
|
|
error->popup_centered();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->create_action(TTR("Rename Group"));
|
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
List<Node *> nodes;
|
|
|
|
scene_tree->get_nodes_in_group(selected_group, &nodes);
|
|
|
|
bool removed_all = true;
|
|
|
|
for (List<Node *>::Element *E = nodes.front(); E; E = E->next()) {
|
|
|
|
Node *node = E->get();
|
|
|
|
if (_can_edit(node, selected_group)) {
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(node, "remove_from_group", selected_group);
|
|
|
|
undo_redo->add_undo_method(node, "remove_from_group", name);
|
|
|
|
undo_redo->add_do_method(node, "add_to_group", name, true);
|
|
|
|
undo_redo->add_undo_method(node, "add_to_group", selected_group, true);
|
2018-02-08 10:52:02 +01:00
|
|
|
} else {
|
|
|
|
removed_all = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!removed_all) {
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "_add_group", selected_group);
|
|
|
|
undo_redo->add_undo_method(this, "_delete_group_item", selected_group);
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "_rename_group_item", selected_group, renamed_group->get_text(0));
|
|
|
|
undo_redo->add_undo_method(this, "_rename_group_item", renamed_group->get_text(0), selected_group);
|
|
|
|
undo_redo->add_do_method(this, "_group_selected");
|
|
|
|
undo_redo->add_undo_method(this, "_group_selected");
|
|
|
|
undo_redo->add_do_method(this, "emit_signal", "group_edited");
|
|
|
|
undo_redo->add_undo_method(this, "emit_signal", "group_edited");
|
2018-02-08 10:52:02 +01:00
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->commit_action();
|
|
|
|
}
|
2018-02-08 10:52:02 +01:00
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
void GroupDialog::_rename_group_item(const String &p_old_name, const String &p_new_name) {
|
|
|
|
if (!is_visible()) {
|
|
|
|
return; // No need to edit the dialog if it's not being used.
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
selected_group = p_new_name;
|
|
|
|
|
|
|
|
for (TreeItem *E = groups_root->get_children(); E; E = E->get_next()) {
|
|
|
|
if (E->get_text(0) == p_old_name) {
|
|
|
|
E->set_text(0, p_new_name);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_load_groups(Node *p_current) {
|
|
|
|
List<Node::GroupInfo> gi;
|
|
|
|
p_current->get_groups(&gi);
|
|
|
|
|
|
|
|
for (List<Node::GroupInfo>::Element *E = gi.front(); E; E = E->next()) {
|
|
|
|
if (!E->get().persistent) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
_add_group(E->get().name);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (int i = 0; i < p_current->get_child_count(); i++) {
|
|
|
|
_load_groups(p_current->get_child(i));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_delete_group_pressed(Object *p_item, int p_column, int p_id) {
|
|
|
|
TreeItem *ti = Object::cast_to<TreeItem>(p_item);
|
|
|
|
if (!ti)
|
|
|
|
return;
|
|
|
|
|
|
|
|
String name = ti->get_text(0);
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->create_action(TTR("Delete Group"));
|
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
List<Node *> nodes;
|
|
|
|
scene_tree->get_nodes_in_group(name, &nodes);
|
|
|
|
bool removed_all = true;
|
|
|
|
for (List<Node *>::Element *E = nodes.front(); E; E = E->next()) {
|
|
|
|
if (_can_edit(E->get(), name)) {
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(E->get(), "remove_from_group", name);
|
|
|
|
undo_redo->add_undo_method(E->get(), "add_to_group", name, true);
|
2018-02-08 10:52:02 +01:00
|
|
|
} else {
|
|
|
|
removed_all = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (removed_all) {
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "_delete_group_item", name);
|
|
|
|
undo_redo->add_undo_method(this, "_add_group", name);
|
|
|
|
}
|
|
|
|
|
|
|
|
undo_redo->add_do_method(this, "_group_selected");
|
|
|
|
undo_redo->add_undo_method(this, "_group_selected");
|
|
|
|
undo_redo->add_do_method(this, "emit_signal", "group_edited");
|
|
|
|
undo_redo->add_undo_method(this, "emit_signal", "group_edited");
|
|
|
|
|
|
|
|
// To force redraw of scene tree.
|
|
|
|
undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
undo_redo->add_undo_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
|
|
|
|
undo_redo->commit_action();
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_delete_group_item(const String &p_name) {
|
|
|
|
if (!is_visible()) {
|
|
|
|
return; // No need to edit the dialog if it's not being used.
|
|
|
|
}
|
|
|
|
|
|
|
|
if (selected_group == p_name) {
|
|
|
|
add_filter->clear();
|
|
|
|
remove_filter->clear();
|
|
|
|
nodes_to_remove->clear();
|
|
|
|
nodes_to_add->clear();
|
|
|
|
groups->deselect_all();
|
|
|
|
selected_group = "";
|
|
|
|
}
|
|
|
|
|
|
|
|
for (TreeItem *E = groups_root->get_children(); E; E = E->get_next()) {
|
|
|
|
if (E->get_text(0) == p_name) {
|
|
|
|
groups_root->remove_child(E);
|
|
|
|
return;
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_notification(int p_what) {
|
|
|
|
switch (p_what) {
|
|
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
|
|
add_button->set_icon(get_icon("Forward", "EditorIcons"));
|
|
|
|
remove_button->set_icon(get_icon("Back", "EditorIcons"));
|
2018-05-18 02:45:12 +02:00
|
|
|
|
2018-08-11 12:04:19 +02:00
|
|
|
add_filter->set_right_icon(get_icon("Search", "EditorIcons"));
|
2018-07-26 13:45:38 +02:00
|
|
|
add_filter->set_clear_button_enabled(true);
|
2018-08-11 12:04:19 +02:00
|
|
|
remove_filter->set_right_icon(get_icon("Search", "EditorIcons"));
|
2018-07-26 13:45:38 +02:00
|
|
|
remove_filter->set_clear_button_enabled(true);
|
2018-02-08 10:52:02 +01:00
|
|
|
} break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::edit() {
|
2019-08-29 02:24:57 +02:00
|
|
|
popup_centered();
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
groups->clear();
|
|
|
|
groups_root = groups->create_item();
|
|
|
|
|
|
|
|
nodes_to_add->clear();
|
|
|
|
nodes_to_remove->clear();
|
|
|
|
|
|
|
|
add_group_text->clear();
|
|
|
|
add_filter->clear();
|
|
|
|
remove_filter->clear();
|
|
|
|
|
|
|
|
_load_groups(scene_tree->get_edited_scene_root());
|
|
|
|
}
|
|
|
|
|
|
|
|
void GroupDialog::_bind_methods() {
|
|
|
|
ClassDB::bind_method("_add_pressed", &GroupDialog::_add_pressed);
|
|
|
|
ClassDB::bind_method("_removed_pressed", &GroupDialog::_removed_pressed);
|
|
|
|
ClassDB::bind_method("_delete_group_pressed", &GroupDialog::_delete_group_pressed);
|
2019-08-29 02:24:57 +02:00
|
|
|
ClassDB::bind_method("_delete_group_item", &GroupDialog::_delete_group_item);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
ClassDB::bind_method("_group_selected", &GroupDialog::_group_selected);
|
|
|
|
ClassDB::bind_method("_add_group_pressed", &GroupDialog::_add_group_pressed);
|
2019-08-29 02:24:57 +02:00
|
|
|
ClassDB::bind_method("_add_group", &GroupDialog::_add_group);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
ClassDB::bind_method("_add_filter_changed", &GroupDialog::_add_filter_changed);
|
|
|
|
ClassDB::bind_method("_remove_filter_changed", &GroupDialog::_remove_filter_changed);
|
|
|
|
|
|
|
|
ClassDB::bind_method("_group_renamed", &GroupDialog::_group_renamed);
|
2019-08-29 02:24:57 +02:00
|
|
|
ClassDB::bind_method("_rename_group_item", &GroupDialog::_rename_group_item);
|
|
|
|
|
|
|
|
ADD_SIGNAL(MethodInfo("group_edited"));
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
GroupDialog::GroupDialog() {
|
2019-12-15 05:56:10 +01:00
|
|
|
set_custom_minimum_size(Size2(600, 400) * EDSCALE);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
scene_tree = SceneTree::get_singleton();
|
|
|
|
|
|
|
|
VBoxContainer *vbc = memnew(VBoxContainer);
|
|
|
|
add_child(vbc);
|
2019-08-29 02:24:57 +02:00
|
|
|
vbc->set_anchors_and_margins_preset(PRESET_WIDE, PRESET_MODE_KEEP_SIZE, 8 * EDSCALE);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
HBoxContainer *hbc = memnew(HBoxContainer);
|
|
|
|
vbc->add_child(hbc);
|
|
|
|
hbc->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
|
|
|
|
VBoxContainer *vbc_left = memnew(VBoxContainer);
|
|
|
|
hbc->add_child(vbc_left);
|
|
|
|
vbc_left->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
|
|
|
|
Label *group_title = memnew(Label);
|
|
|
|
group_title->set_text(TTR("Groups"));
|
|
|
|
vbc_left->add_child(group_title);
|
|
|
|
|
|
|
|
groups = memnew(Tree);
|
|
|
|
vbc_left->add_child(groups);
|
|
|
|
groups->set_hide_root(true);
|
|
|
|
groups->set_select_mode(Tree::SELECT_SINGLE);
|
|
|
|
groups->set_allow_reselect(true);
|
|
|
|
groups->set_allow_rmb_select(true);
|
2019-08-29 02:24:57 +02:00
|
|
|
groups->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
groups->add_constant_override("draw_guides", 1);
|
2018-02-08 10:52:02 +01:00
|
|
|
groups->connect("item_selected", this, "_group_selected");
|
|
|
|
groups->connect("button_pressed", this, "_delete_group_pressed");
|
|
|
|
groups->connect("item_edited", this, "_group_renamed");
|
|
|
|
|
|
|
|
HBoxContainer *chbc = memnew(HBoxContainer);
|
|
|
|
vbc_left->add_child(chbc);
|
|
|
|
chbc->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
|
|
|
|
add_group_text = memnew(LineEdit);
|
|
|
|
chbc->add_child(add_group_text);
|
|
|
|
add_group_text->set_h_size_flags(SIZE_EXPAND_FILL);
|
2019-08-29 02:24:57 +02:00
|
|
|
add_group_text->connect("text_entered", this, "_add_group_pressed");
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
Button *add_group_button = memnew(Button);
|
2019-12-21 07:57:15 +01:00
|
|
|
add_group_button->set_text(TTR("Add"));
|
2018-02-08 10:52:02 +01:00
|
|
|
chbc->add_child(add_group_button);
|
2019-08-29 02:24:57 +02:00
|
|
|
add_group_button->connect("pressed", this, "_add_group_pressed", varray(String()));
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
VBoxContainer *vbc_add = memnew(VBoxContainer);
|
|
|
|
hbc->add_child(vbc_add);
|
|
|
|
vbc_add->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
|
|
|
|
Label *out_of_group_title = memnew(Label);
|
2019-08-29 02:24:57 +02:00
|
|
|
out_of_group_title->set_text(TTR("Nodes Not in Group"));
|
2018-02-08 10:52:02 +01:00
|
|
|
vbc_add->add_child(out_of_group_title);
|
|
|
|
|
|
|
|
nodes_to_add = memnew(Tree);
|
|
|
|
vbc_add->add_child(nodes_to_add);
|
|
|
|
nodes_to_add->set_hide_root(true);
|
|
|
|
nodes_to_add->set_hide_folding(true);
|
|
|
|
nodes_to_add->set_select_mode(Tree::SELECT_MULTI);
|
2019-08-29 02:24:57 +02:00
|
|
|
nodes_to_add->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
nodes_to_add->add_constant_override("draw_guides", 1);
|
2018-02-08 10:52:02 +01:00
|
|
|
nodes_to_add->connect("item_selected", this, "_nodes_to_add_selected");
|
|
|
|
|
|
|
|
HBoxContainer *add_filter_hbc = memnew(HBoxContainer);
|
|
|
|
add_filter_hbc->add_constant_override("separate", 0);
|
|
|
|
vbc_add->add_child(add_filter_hbc);
|
|
|
|
|
|
|
|
add_filter = memnew(LineEdit);
|
|
|
|
add_filter->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
add_filter->set_placeholder(TTR("Filter nodes"));
|
|
|
|
add_filter_hbc->add_child(add_filter);
|
|
|
|
add_filter->connect("text_changed", this, "_add_filter_changed");
|
|
|
|
|
|
|
|
VBoxContainer *vbc_buttons = memnew(VBoxContainer);
|
|
|
|
hbc->add_child(vbc_buttons);
|
|
|
|
vbc_buttons->set_h_size_flags(SIZE_SHRINK_CENTER);
|
|
|
|
vbc_buttons->set_v_size_flags(SIZE_SHRINK_CENTER);
|
|
|
|
|
|
|
|
add_button = memnew(ToolButton);
|
|
|
|
add_button->set_text(TTR("Add"));
|
|
|
|
add_button->connect("pressed", this, "_add_pressed");
|
|
|
|
|
|
|
|
vbc_buttons->add_child(add_button);
|
|
|
|
vbc_buttons->add_spacer();
|
|
|
|
vbc_buttons->add_spacer();
|
|
|
|
vbc_buttons->add_spacer();
|
|
|
|
|
|
|
|
remove_button = memnew(ToolButton);
|
|
|
|
remove_button->set_text(TTR("Remove"));
|
|
|
|
remove_button->connect("pressed", this, "_removed_pressed");
|
|
|
|
|
|
|
|
vbc_buttons->add_child(remove_button);
|
|
|
|
|
|
|
|
VBoxContainer *vbc_remove = memnew(VBoxContainer);
|
|
|
|
hbc->add_child(vbc_remove);
|
|
|
|
vbc_remove->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
|
|
|
|
Label *in_group_title = memnew(Label);
|
|
|
|
in_group_title->set_text(TTR("Nodes in Group"));
|
|
|
|
vbc_remove->add_child(in_group_title);
|
|
|
|
|
|
|
|
nodes_to_remove = memnew(Tree);
|
|
|
|
vbc_remove->add_child(nodes_to_remove);
|
|
|
|
nodes_to_remove->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
nodes_to_remove->set_hide_root(true);
|
|
|
|
nodes_to_remove->set_hide_folding(true);
|
|
|
|
nodes_to_remove->set_select_mode(Tree::SELECT_MULTI);
|
2019-08-29 02:24:57 +02:00
|
|
|
nodes_to_remove->add_constant_override("draw_guides", 1);
|
2018-02-08 10:52:02 +01:00
|
|
|
nodes_to_remove->connect("item_selected", this, "_node_to_remove_selected");
|
|
|
|
|
|
|
|
HBoxContainer *remove_filter_hbc = memnew(HBoxContainer);
|
|
|
|
remove_filter_hbc->add_constant_override("separate", 0);
|
|
|
|
vbc_remove->add_child(remove_filter_hbc);
|
|
|
|
|
|
|
|
remove_filter = memnew(LineEdit);
|
|
|
|
remove_filter->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
remove_filter->set_placeholder(TTR("Filter nodes"));
|
|
|
|
remove_filter_hbc->add_child(remove_filter);
|
|
|
|
remove_filter->connect("text_changed", this, "_remove_filter_changed");
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
group_empty = memnew(Label());
|
|
|
|
group_empty->set_text(TTR("Empty groups will be automatically removed."));
|
|
|
|
group_empty->set_valign(Label::VALIGN_CENTER);
|
|
|
|
group_empty->set_align(Label::ALIGN_CENTER);
|
|
|
|
group_empty->set_autowrap(true);
|
2019-11-04 10:12:15 +01:00
|
|
|
group_empty->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
|
2019-08-29 02:24:57 +02:00
|
|
|
nodes_to_remove->add_child(group_empty);
|
|
|
|
group_empty->set_anchors_and_margins_preset(PRESET_WIDE, PRESET_MODE_KEEP_SIZE, 8 * EDSCALE);
|
|
|
|
|
|
|
|
set_title(TTR("Group Editor"));
|
2018-02-08 10:52:02 +01:00
|
|
|
set_as_toplevel(true);
|
2018-07-02 21:32:53 +02:00
|
|
|
set_resizable(true);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
error = memnew(ConfirmationDialog);
|
|
|
|
add_child(error);
|
|
|
|
error->get_ok()->set_text(TTR("Close"));
|
|
|
|
}
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void GroupsEditor::_add_group(const String &p_group) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2015-11-26 18:59:04 +01:00
|
|
|
if (!node)
|
|
|
|
return;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2015-11-26 18:59:04 +01:00
|
|
|
String name = group_name->get_text();
|
2017-03-05 16:44:50 +01:00
|
|
|
if (name.strip_edges() == "")
|
2015-11-26 18:59:04 +01:00
|
|
|
return;
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2015-11-26 18:59:04 +01:00
|
|
|
if (node->is_in_group(name))
|
2014-02-10 02:10:30 +01:00
|
|
|
return;
|
|
|
|
|
2016-05-04 03:25:37 +02:00
|
|
|
undo_redo->create_action(TTR("Add to Group"));
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
undo_redo->add_do_method(node, "add_to_group", name, true);
|
|
|
|
undo_redo->add_undo_method(node, "remove_from_group", name);
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "update_tree");
|
2017-03-05 16:44:50 +01:00
|
|
|
undo_redo->add_undo_method(this, "update_tree");
|
2019-08-29 02:24:57 +02:00
|
|
|
|
|
|
|
// To force redraw of scene tree.
|
|
|
|
undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
undo_redo->add_undo_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
undo_redo->commit_action();
|
2016-01-24 14:51:42 +01:00
|
|
|
|
|
|
|
group_name->clear();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2015-11-26 18:59:04 +01:00
|
|
|
void GroupsEditor::_remove_group(Object *p_item, int p_column, int p_id) {
|
2014-02-10 02:10:30 +01:00
|
|
|
|
|
|
|
if (!node)
|
|
|
|
return;
|
|
|
|
|
2017-08-24 22:58:51 +02:00
|
|
|
TreeItem *ti = Object::cast_to<TreeItem>(p_item);
|
2015-11-26 18:59:04 +01:00
|
|
|
if (!ti)
|
2014-02-10 02:10:30 +01:00
|
|
|
return;
|
2015-11-26 18:59:04 +01:00
|
|
|
|
|
|
|
String name = ti->get_text(0);
|
|
|
|
|
2016-05-04 03:25:37 +02:00
|
|
|
undo_redo->create_action(TTR("Remove from Group"));
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
undo_redo->add_do_method(node, "remove_from_group", name);
|
|
|
|
undo_redo->add_undo_method(node, "add_to_group", name, true);
|
2019-08-29 02:24:57 +02:00
|
|
|
undo_redo->add_do_method(this, "update_tree");
|
2017-03-05 16:44:50 +01:00
|
|
|
undo_redo->add_undo_method(this, "update_tree");
|
2019-08-29 02:24:57 +02:00
|
|
|
|
|
|
|
// To force redraw of scene tree.
|
|
|
|
undo_redo->add_do_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
|
|
|
undo_redo->add_undo_method(EditorNode::get_singleton()->get_scene_tree_dock()->get_tree_editor(), "update_tree");
|
2015-11-26 18:59:04 +01:00
|
|
|
|
|
|
|
undo_redo->commit_action();
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2015-11-26 18:59:04 +01:00
|
|
|
struct _GroupInfoComparator {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
bool operator()(const Node::GroupInfo &p_a, const Node::GroupInfo &p_b) const {
|
2015-11-26 18:59:04 +01:00
|
|
|
return p_a.name.operator String() < p_b.name.operator String();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void GroupsEditor::update_tree() {
|
|
|
|
|
|
|
|
tree->clear();
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
if (!node)
|
|
|
|
return;
|
2015-11-26 18:59:04 +01:00
|
|
|
|
|
|
|
List<Node::GroupInfo> groups;
|
2014-02-10 02:10:30 +01:00
|
|
|
node->get_groups(&groups);
|
2015-11-26 18:59:04 +01:00
|
|
|
groups.sort_custom<_GroupInfoComparator>();
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TreeItem *root = tree->create_item();
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
for (List<GroupInfo>::Element *E = groups.front(); E; E = E->next()) {
|
2015-11-26 18:59:04 +01:00
|
|
|
|
|
|
|
Node::GroupInfo gi = E->get();
|
|
|
|
if (!gi.persistent)
|
2014-02-10 02:10:30 +01:00
|
|
|
continue;
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2016-07-08 01:49:43 +02:00
|
|
|
Node *n = node;
|
2017-03-05 16:44:50 +01:00
|
|
|
bool can_be_deleted = true;
|
2016-07-08 01:49:43 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
while (n) {
|
2016-07-08 01:49:43 +02:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
Ref<SceneState> ss = (n == EditorNode::get_singleton()->get_edited_scene()) ? n->get_scene_inherited_state() : n->get_scene_instance_state();
|
2016-07-08 01:49:43 +02:00
|
|
|
|
|
|
|
if (ss.is_valid()) {
|
|
|
|
|
|
|
|
int path = ss->find_node_by_path(n->get_path_to(node));
|
2017-03-05 16:44:50 +01:00
|
|
|
if (path != -1) {
|
|
|
|
if (ss->is_node_in_group(path, gi.name)) {
|
|
|
|
can_be_deleted = false;
|
2016-07-08 01:49:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
n = n->get_owner();
|
2016-07-08 01:49:43 +02:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
TreeItem *item = tree->create_item(root);
|
2015-11-26 18:59:04 +01:00
|
|
|
item->set_text(0, gi.name);
|
2016-07-08 01:49:43 +02:00
|
|
|
if (can_be_deleted) {
|
|
|
|
item->add_button(0, get_icon("Remove", "EditorIcons"), 0);
|
|
|
|
} else {
|
2017-03-05 16:44:50 +01:00
|
|
|
item->set_selectable(0, false);
|
2016-07-08 01:49:43 +02:00
|
|
|
}
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
void GroupsEditor::set_current(Node *p_node) {
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
node = p_node;
|
2014-02-10 02:10:30 +01:00
|
|
|
update_tree();
|
|
|
|
}
|
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
void GroupsEditor::_show_group_dialog() {
|
|
|
|
|
2019-08-29 02:24:57 +02:00
|
|
|
group_dialog->edit();
|
|
|
|
group_dialog->set_undo_redo(undo_redo);
|
2018-02-08 10:52:02 +01:00
|
|
|
}
|
|
|
|
|
2014-02-10 02:10:30 +01:00
|
|
|
void GroupsEditor::_bind_methods() {
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
ClassDB::bind_method("_add_group", &GroupsEditor::_add_group);
|
|
|
|
ClassDB::bind_method("_remove_group", &GroupsEditor::_remove_group);
|
|
|
|
ClassDB::bind_method("update_tree", &GroupsEditor::update_tree);
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
ClassDB::bind_method("_show_group_dialog", &GroupsEditor::_show_group_dialog);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
GroupsEditor::GroupsEditor() {
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
node = NULL;
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2016-06-04 18:17:56 +02:00
|
|
|
VBoxContainer *vbc = this;
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2018-02-08 10:52:02 +01:00
|
|
|
group_dialog = memnew(GroupDialog);
|
|
|
|
group_dialog->set_as_toplevel(true);
|
|
|
|
add_child(group_dialog);
|
2019-08-29 02:24:57 +02:00
|
|
|
group_dialog->connect("group_edited", this, "update_tree");
|
2018-02-08 10:52:02 +01:00
|
|
|
|
|
|
|
Button *group_dialog_button = memnew(Button);
|
|
|
|
group_dialog_button->set_text(TTR("Manage Groups"));
|
|
|
|
vbc->add_child(group_dialog_button);
|
|
|
|
group_dialog_button->connect("pressed", this, "_show_group_dialog");
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
HBoxContainer *hbc = memnew(HBoxContainer);
|
2016-06-04 18:17:56 +02:00
|
|
|
vbc->add_child(hbc);
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
group_name = memnew(LineEdit);
|
2015-11-26 18:59:04 +01:00
|
|
|
group_name->set_h_size_flags(SIZE_EXPAND_FILL);
|
|
|
|
hbc->add_child(group_name);
|
2017-03-05 16:44:50 +01:00
|
|
|
group_name->connect("text_entered", this, "_add_group");
|
2015-11-26 18:59:04 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
add = memnew(Button);
|
2016-05-04 03:25:37 +02:00
|
|
|
add->set_text(TTR("Add"));
|
2015-11-26 18:59:04 +01:00
|
|
|
hbc->add_child(add);
|
2017-03-05 16:44:50 +01:00
|
|
|
add->connect("pressed", this, "_add_group", varray(String()));
|
2014-02-10 02:10:30 +01:00
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
tree = memnew(Tree);
|
2015-11-26 18:59:04 +01:00
|
|
|
tree->set_hide_root(true);
|
|
|
|
tree->set_v_size_flags(SIZE_EXPAND_FILL);
|
2016-06-04 18:17:56 +02:00
|
|
|
vbc->add_child(tree);
|
2017-03-05 16:44:50 +01:00
|
|
|
tree->connect("button_pressed", this, "_remove_group");
|
2019-08-29 02:24:57 +02:00
|
|
|
tree->add_constant_override("draw_guides", 1);
|
2017-03-05 16:44:50 +01:00
|
|
|
add_constant_override("separation", 3 * EDSCALE);
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|
|
|
|
|
2017-03-05 16:44:50 +01:00
|
|
|
GroupsEditor::~GroupsEditor() {
|
2014-02-10 02:10:30 +01:00
|
|
|
}
|