godot/editor/editor_data.cpp

949 lines
23 KiB
C++
Raw Normal View History

2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* editor_data.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2017 Godot Engine contributors (cf. AUTHORS.md) */
2014-02-10 01:10:30 +00: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. */
/*************************************************************************/
#include "editor_data.h"
#include "editor_node.h"
2014-02-10 01:10:30 +00:00
#include "editor_settings.h"
#include "io/resource_loader.h"
#include "os/dir_access.h"
#include "os/file_access.h"
#include "project_settings.h"
#include "scene/resources/packed_scene.h"
2014-02-10 01:10:30 +00:00
void EditorHistory::_cleanup_history() {
for (int i = 0; i < history.size(); i++) {
2014-02-10 01:10:30 +00:00
bool fail = false;
2014-02-10 01:10:30 +00:00
for (int j = 0; j < history[i].path.size(); j++) {
if (!history[i].path[j].ref.is_null())
2014-02-10 01:10:30 +00:00
continue;
if (ObjectDB::get_instance(history[i].path[j].object))
continue; //has isntance, try next
if (j <= history[i].level) {
2014-02-10 01:10:30 +00:00
//before or equal level, complete fail
fail = true;
2014-02-10 01:10:30 +00:00
} else {
//after level, clip
history[i].path.resize(j);
}
break;
}
if (fail) {
history.remove(i);
i--;
}
}
if (current >= history.size())
current = history.size() - 1;
2014-02-10 01:10:30 +00:00
}
void EditorHistory::_add_object(ObjectID p_object, const String &p_property, int p_level_change) {
2014-02-10 01:10:30 +00:00
Object *obj = ObjectDB::get_instance(p_object);
ERR_FAIL_COND(!obj);
Reference *r = Object::cast_to<Reference>(obj);
2014-02-10 01:10:30 +00:00
Obj o;
if (r)
o.ref = REF(r);
o.object = p_object;
o.property = p_property;
2014-02-10 01:10:30 +00:00
History h;
bool has_prev = current >= 0 && current < history.size();
2014-02-10 01:10:30 +00:00
if (has_prev) {
history.resize(current + 1); //clip history to next
2014-02-10 01:10:30 +00:00
}
if (p_property != "" && has_prev) {
2014-02-10 01:10:30 +00:00
//add a sub property
History &pr = history[current];
h = pr;
h.path.resize(h.level + 1);
2014-02-10 01:10:30 +00:00
h.path.push_back(o);
h.level++;
} else if (p_level_change != -1 && has_prev) {
2014-02-10 01:10:30 +00:00
//add a sub property
History &pr = history[current];
h = pr;
ERR_FAIL_INDEX(p_level_change, h.path.size());
h.level = p_level_change;
2014-02-10 01:10:30 +00:00
} else {
//add a new node
h.path.push_back(o);
h.level = 0;
2014-02-10 01:10:30 +00:00
}
history.push_back(h);
current++;
}
void EditorHistory::add_object(ObjectID p_object) {
_add_object(p_object, "", -1);
2014-02-10 01:10:30 +00:00
}
void EditorHistory::add_object(ObjectID p_object, const String &p_subprop) {
2014-02-10 01:10:30 +00:00
_add_object(p_object, p_subprop, -1);
2014-02-10 01:10:30 +00:00
}
void EditorHistory::add_object(ObjectID p_object, int p_relevel) {
2014-02-10 01:10:30 +00:00
_add_object(p_object, "", p_relevel);
2014-02-10 01:10:30 +00:00
}
int EditorHistory::get_history_len() {
return history.size();
}
int EditorHistory::get_history_pos() {
return current;
}
ObjectID EditorHistory::get_history_obj(int p_obj) const {
ERR_FAIL_INDEX_V(p_obj, history.size(), 0);
ERR_FAIL_INDEX_V(history[p_obj].level, history[p_obj].path.size(), 0);
return history[p_obj].path[history[p_obj].level].object;
}
2017-09-01 15:54:57 +00:00
bool EditorHistory::is_at_beginning() const {
return current <= 0;
}
bool EditorHistory::is_at_end() const {
return ((current + 1) >= history.size());
}
2014-02-10 01:10:30 +00:00
bool EditorHistory::next() {
_cleanup_history();
if ((current + 1) < history.size())
2014-02-10 01:10:30 +00:00
current++;
else
return false;
return true;
}
bool EditorHistory::previous() {
_cleanup_history();
if (current > 0)
2014-02-10 01:10:30 +00:00
current--;
else
return false;
return true;
}
ObjectID EditorHistory::get_current() {
if (current < 0 || current >= history.size())
2014-02-10 01:10:30 +00:00
return 0;
History &h = history[current];
2014-02-10 01:10:30 +00:00
Object *obj = ObjectDB::get_instance(h.path[h.level].object);
if (!obj)
return 0;
return obj->get_instance_id();
2014-02-10 01:10:30 +00:00
}
int EditorHistory::get_path_size() const {
if (current < 0 || current >= history.size())
2014-02-10 01:10:30 +00:00
return 0;
const History &h = history[current];
2014-02-10 01:10:30 +00:00
return h.path.size();
}
ObjectID EditorHistory::get_path_object(int p_index) const {
if (current < 0 || current >= history.size())
2014-02-10 01:10:30 +00:00
return 0;
const History &h = history[current];
2014-02-10 01:10:30 +00:00
ERR_FAIL_INDEX_V(p_index, h.path.size(), 0);
2014-02-10 01:10:30 +00:00
Object *obj = ObjectDB::get_instance(h.path[p_index].object);
if (!obj)
return 0;
return obj->get_instance_id();
2014-02-10 01:10:30 +00:00
}
String EditorHistory::get_path_property(int p_index) const {
if (current < 0 || current >= history.size())
2014-02-10 01:10:30 +00:00
return "";
const History &h = history[current];
2014-02-10 01:10:30 +00:00
ERR_FAIL_INDEX_V(p_index, h.path.size(), "");
2014-02-10 01:10:30 +00:00
return h.path[p_index].property;
}
void EditorHistory::clear() {
history.clear();
current = -1;
2014-02-10 01:10:30 +00:00
}
EditorHistory::EditorHistory() {
current = -1;
2014-02-10 01:10:30 +00:00
}
EditorPlugin *EditorData::get_editor(Object *p_object) {
2014-02-10 01:10:30 +00:00
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
if (editor_plugins[i]->has_main_screen() && editor_plugins[i]->handles(p_object))
return editor_plugins[i];
}
return NULL;
}
EditorPlugin *EditorData::get_subeditor(Object *p_object) {
2014-02-10 01:10:30 +00:00
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
if (!editor_plugins[i]->has_main_screen() && editor_plugins[i]->handles(p_object))
return editor_plugins[i];
}
return NULL;
}
Vector<EditorPlugin *> EditorData::get_subeditors(Object *p_object) {
Vector<EditorPlugin *> sub_plugins;
for (int i = 0; i < editor_plugins.size(); i++) {
if (!editor_plugins[i]->has_main_screen() && editor_plugins[i]->handles(p_object)) {
sub_plugins.push_back(editor_plugins[i]);
}
}
return sub_plugins;
}
EditorPlugin *EditorData::get_editor(String p_name) {
2016-03-08 23:00:52 +00:00
for (int i = 0; i < editor_plugins.size(); i++) {
2016-03-08 23:00:52 +00:00
if (editor_plugins[i]->get_name() == p_name)
2014-02-10 01:10:30 +00:00
return editor_plugins[i];
}
2016-03-08 23:00:52 +00:00
2014-02-10 01:10:30 +00:00
return NULL;
}
void EditorData::copy_object_params(Object *p_object) {
clipboard.clear();
List<PropertyInfo> pinfo;
p_object->get_property_list(&pinfo);
for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {
2014-02-10 01:10:30 +00:00
if (!(E->get().usage & PROPERTY_USAGE_EDITOR))
2014-02-10 01:10:30 +00:00
continue;
PropertyData pd;
pd.name = E->get().name;
pd.value = p_object->get(pd.name);
2014-02-10 01:10:30 +00:00
clipboard.push_back(pd);
}
}
void EditorData::get_editor_breakpoints(List<String> *p_breakpoints) {
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
editor_plugins[i]->get_breakpoints(p_breakpoints);
}
}
Dictionary EditorData::get_editor_states() const {
Dictionary metadata;
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
Dictionary state = editor_plugins[i]->get_state();
2014-02-10 01:10:30 +00:00
if (state.empty())
continue;
metadata[editor_plugins[i]->get_name()] = state;
2014-02-10 01:10:30 +00:00
}
return metadata;
}
Dictionary EditorData::get_scene_editor_states(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), Dictionary());
EditedScene es = edited_scene[p_idx];
return es.editor_states;
}
void EditorData::set_editor_states(const Dictionary &p_states) {
2014-02-10 01:10:30 +00:00
List<Variant> keys;
p_states.get_key_list(&keys);
List<Variant>::Element *E = keys.front();
for (; E; E = E->next()) {
2014-02-10 01:10:30 +00:00
String name = E->get();
int idx = -1;
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
if (editor_plugins[i]->get_name() == name) {
idx = i;
2014-02-10 01:10:30 +00:00
break;
}
}
if (idx == -1)
2014-02-10 01:10:30 +00:00
continue;
editor_plugins[idx]->set_state(p_states[name]);
}
}
void EditorData::notify_edited_scene_changed() {
for (int i = 0; i < editor_plugins.size(); i++) {
editor_plugins[i]->edited_scene_changed();
editor_plugins[i]->notify_scene_changed(get_edited_scene_root());
}
}
2014-02-10 01:10:30 +00:00
void EditorData::clear_editor_states() {
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
editor_plugins[i]->clear();
}
}
void EditorData::save_editor_external_data() {
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
editor_plugins[i]->save_external_data();
}
}
void EditorData::apply_changes_in_editors() {
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
editor_plugins[i]->apply_changes();
}
}
void EditorData::save_editor_global_states() {
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
editor_plugins[i]->save_global_state();
}
}
void EditorData::restore_editor_global_states() {
2014-02-10 01:10:30 +00:00
for (int i = 0; i < editor_plugins.size(); i++) {
2014-02-10 01:10:30 +00:00
editor_plugins[i]->restore_global_state();
}
}
void EditorData::paste_object_params(Object *p_object) {
for (List<PropertyData>::Element *E = clipboard.front(); E; E = E->next()) {
2014-02-10 01:10:30 +00:00
p_object->set(E->get().name, E->get().value);
2014-02-10 01:10:30 +00:00
}
}
UndoRedo &EditorData::get_undo_redo() {
return undo_redo;
}
void EditorData::remove_editor_plugin(EditorPlugin *p_plugin) {
p_plugin->undo_redo = NULL;
2014-02-10 01:10:30 +00:00
editor_plugins.erase(p_plugin);
}
void EditorData::add_editor_plugin(EditorPlugin *p_plugin) {
p_plugin->undo_redo = &undo_redo;
2014-02-10 01:10:30 +00:00
editor_plugins.push_back(p_plugin);
}
int EditorData::get_editor_plugin_count() const {
return editor_plugins.size();
}
EditorPlugin *EditorData::get_editor_plugin(int p_idx) {
ERR_FAIL_INDEX_V(p_idx, editor_plugins.size(), NULL);
return editor_plugins[p_idx];
}
2014-02-10 01:10:30 +00:00
void EditorData::add_custom_type(const String &p_type, const String &p_inherits, const Ref<Script> &p_script, const Ref<Texture> &p_icon) {
2014-02-10 01:10:30 +00:00
ERR_FAIL_COND(p_script.is_null());
CustomType ct;
ct.name = p_type;
ct.icon = p_icon;
ct.script = p_script;
2014-02-10 01:10:30 +00:00
if (!custom_types.has(p_inherits)) {
custom_types[p_inherits] = Vector<CustomType>();
2014-02-10 01:10:30 +00:00
}
custom_types[p_inherits].push_back(ct);
}
void EditorData::remove_custom_type(const String &p_type) {
2014-02-10 01:10:30 +00:00
for (Map<String, Vector<CustomType> >::Element *E = custom_types.front(); E; E = E->next()) {
2014-02-10 01:10:30 +00:00
for (int i = 0; i < E->get().size(); i++) {
if (E->get()[i].name == p_type) {
2014-02-10 01:10:30 +00:00
E->get().remove(i);
if (E->get().empty()) {
custom_types.erase(E->key());
}
return;
}
}
}
}
int EditorData::add_edited_scene(int p_at_pos) {
if (p_at_pos < 0)
p_at_pos = edited_scene.size();
EditedScene es;
es.root = NULL;
es.history_current = -1;
es.version = 0;
es.live_edit_root = NodePath(String("/root"));
if (p_at_pos == edited_scene.size())
edited_scene.push_back(es);
else
edited_scene.insert(p_at_pos, es);
if (current_edited_scene < 0)
current_edited_scene = 0;
return p_at_pos;
}
void EditorData::move_edited_scene_index(int p_idx, int p_to_idx) {
ERR_FAIL_INDEX(p_idx, edited_scene.size());
ERR_FAIL_INDEX(p_to_idx, edited_scene.size());
SWAP(edited_scene[p_idx], edited_scene[p_to_idx]);
}
void EditorData::remove_scene(int p_idx) {
ERR_FAIL_INDEX(p_idx, edited_scene.size());
if (edited_scene[p_idx].root) {
for (int i = 0; i < editor_plugins.size(); i++) {
editor_plugins[i]->notify_scene_closed(edited_scene[p_idx].root->get_filename());
}
memdelete(edited_scene[p_idx].root);
}
if (current_edited_scene > p_idx)
current_edited_scene--;
else if (current_edited_scene == p_idx && current_edited_scene > 0) {
current_edited_scene--;
}
edited_scene.remove(p_idx);
}
bool EditorData::_find_updated_instances(Node *p_root, Node *p_node, Set<String> &checked_paths) {
/*
if (p_root!=p_node && p_node->get_owner()!=p_root && !p_root->is_editable_instance(p_node->get_owner()))
return false;
*/
Ref<SceneState> ss;
if (p_node == p_root) {
ss = p_node->get_scene_inherited_state();
} else if (p_node->get_filename() != String()) {
ss = p_node->get_scene_instance_state();
}
if (ss.is_valid()) {
String path = ss->get_path();
if (!checked_paths.has(path)) {
uint64_t modified_time = FileAccess::get_modified_time(path);
if (modified_time != ss->get_last_modified_time()) {
return true; //external scene changed
}
checked_paths.insert(path);
}
}
for (int i = 0; i < p_node->get_child_count(); i++) {
bool found = _find_updated_instances(p_root, p_node->get_child(i), checked_paths);
if (found)
return true;
}
return false;
}
bool EditorData::check_and_update_scene(int p_idx) {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), false);
if (!edited_scene[p_idx].root)
return false;
Set<String> checked_scenes;
bool must_reload = _find_updated_instances(edited_scene[p_idx].root, edited_scene[p_idx].root, checked_scenes);
print_line("MUST RELOAD? " + itos(must_reload));
if (must_reload) {
Ref<PackedScene> pscene;
pscene.instance();
EditorProgress ep("update_scene", TTR("Updating Scene"), 2);
ep.step(TTR("Storing local changes.."), 0);
//pack first, so it stores diffs to previous version of saved scene
Error err = pscene->pack(edited_scene[p_idx].root);
ERR_FAIL_COND_V(err != OK, false);
ep.step(TTR("Updating scene.."), 1);
Node *new_scene = pscene->instance(PackedScene::GEN_EDIT_STATE_MAIN);
ERR_FAIL_COND_V(!new_scene, false);
//transfer selection
List<Node *> new_selection;
for (List<Node *>::Element *E = edited_scene[p_idx].selection.front(); E; E = E->next()) {
NodePath p = edited_scene[p_idx].root->get_path_to(E->get());
Node *new_node = new_scene->get_node(p);
if (new_node)
new_selection.push_back(new_node);
}
new_scene->set_filename(edited_scene[p_idx].root->get_filename());
memdelete(edited_scene[p_idx].root);
edited_scene[p_idx].root = new_scene;
edited_scene[p_idx].selection = new_selection;
return true;
}
return false;
}
int EditorData::get_edited_scene() const {
return current_edited_scene;
}
void EditorData::set_edited_scene(int p_idx) {
ERR_FAIL_INDEX(p_idx, edited_scene.size());
current_edited_scene = p_idx;
//swap
}
Node *EditorData::get_edited_scene_root(int p_idx) {
if (p_idx < 0) {
ERR_FAIL_INDEX_V(current_edited_scene, edited_scene.size(), NULL);
return edited_scene[current_edited_scene].root;
} else {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), NULL);
return edited_scene[p_idx].root;
}
}
void EditorData::set_edited_scene_root(Node *p_root) {
ERR_FAIL_INDEX(current_edited_scene, edited_scene.size());
edited_scene[current_edited_scene].root = p_root;
}
int EditorData::get_edited_scene_count() const {
return edited_scene.size();
}
Vector<EditorData::EditedScene> EditorData::get_edited_scenes() const {
Vector<EditedScene> out_edited_scenes_list = Vector<EditedScene>();
for (int i = 0; i < edited_scene.size(); i++) {
out_edited_scenes_list.push_back(edited_scene[i]);
}
return out_edited_scenes_list;
}
2017-08-12 16:52:50 +00:00
void EditorData::set_edited_scene_version(uint64_t version, int p_scene_idx) {
ERR_FAIL_INDEX(current_edited_scene, edited_scene.size());
2017-08-12 16:52:50 +00:00
if (p_scene_idx < 0) {
edited_scene[current_edited_scene].version = version;
} else {
2017-08-12 16:52:50 +00:00
ERR_FAIL_INDEX(p_scene_idx, edited_scene.size());
edited_scene[p_scene_idx].version = version;
}
}
uint64_t EditorData::get_edited_scene_version() const {
ERR_FAIL_INDEX_V(current_edited_scene, edited_scene.size(), 0);
return edited_scene[current_edited_scene].version;
}
uint64_t EditorData::get_scene_version(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), false);
return edited_scene[p_idx].version;
}
String EditorData::get_scene_type(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), String());
if (!edited_scene[p_idx].root)
return "";
return edited_scene[p_idx].root->get_class();
}
void EditorData::move_edited_scene_to_index(int p_idx) {
ERR_FAIL_INDEX(current_edited_scene, edited_scene.size());
ERR_FAIL_INDEX(p_idx, edited_scene.size());
EditedScene es = edited_scene[current_edited_scene];
edited_scene.remove(current_edited_scene);
edited_scene.insert(p_idx, es);
current_edited_scene = p_idx;
}
2015-07-26 13:44:10 +00:00
Ref<Script> EditorData::get_scene_root_script(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), Ref<Script>());
2015-07-26 13:44:10 +00:00
if (!edited_scene[p_idx].root)
return Ref<Script>();
Ref<Script> s = edited_scene[p_idx].root->get_script();
if (!s.is_valid() && edited_scene[p_idx].root->get_child_count()) {
2015-07-26 13:44:10 +00:00
Node *n = edited_scene[p_idx].root->get_child(0);
while (!s.is_valid() && n && n->get_filename() == String()) {
s = n->get_script();
n = n->get_parent();
2015-07-26 13:44:10 +00:00
}
}
return s;
}
String EditorData::get_scene_title(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), String());
if (!edited_scene[p_idx].root)
return "[empty]";
if (edited_scene[p_idx].root->get_filename() == "")
return "[unsaved]";
bool show_ext = EDITOR_DEF("interface/scene_tabs/show_extension", false);
String name = edited_scene[p_idx].root->get_filename().get_file();
if (!show_ext) {
name = name.get_basename();
}
return name;
}
String EditorData::get_scene_path(int p_idx) const {
ERR_FAIL_INDEX_V(p_idx, edited_scene.size(), String());
if (!edited_scene[p_idx].root)
return "";
return edited_scene[p_idx].root->get_filename();
}
void EditorData::set_edited_scene_live_edit_root(const NodePath &p_root) {
ERR_FAIL_INDEX(current_edited_scene, edited_scene.size());
edited_scene[current_edited_scene].live_edit_root = p_root;
}
NodePath EditorData::get_edited_scene_live_edit_root() {
ERR_FAIL_INDEX_V(current_edited_scene, edited_scene.size(), String());
return edited_scene[current_edited_scene].live_edit_root;
}
void EditorData::save_edited_scene_state(EditorSelection *p_selection, EditorHistory *p_history, const Dictionary &p_custom) {
ERR_FAIL_INDEX(current_edited_scene, edited_scene.size());
EditedScene &es = edited_scene[current_edited_scene];
es.selection = p_selection->get_selected_node_list();
es.history_current = p_history->current;
es.history_stored = p_history->history;
es.editor_states = get_editor_states();
es.custom_state = p_custom;
}
Dictionary EditorData::restore_edited_scene_state(EditorSelection *p_selection, EditorHistory *p_history) {
ERR_FAIL_INDEX_V(current_edited_scene, edited_scene.size(), Dictionary());
EditedScene &es = edited_scene[current_edited_scene];
p_history->current = es.history_current;
p_history->history = es.history_stored;
p_selection->clear();
for (List<Node *>::Element *E = es.selection.front(); E; E = E->next()) {
p_selection->add_node(E->get());
}
set_editor_states(es.editor_states);
return es.custom_state;
}
void EditorData::clear_edited_scenes() {
for (int i = 0; i < edited_scene.size(); i++) {
if (edited_scene[i].root) {
memdelete(edited_scene[i].root);
}
}
edited_scene.clear();
}
void EditorData::set_plugin_window_layout(Ref<ConfigFile> p_layout) {
for (int i = 0; i < editor_plugins.size(); i++) {
editor_plugins[i]->set_window_layout(p_layout);
}
}
void EditorData::get_plugin_window_layout(Ref<ConfigFile> p_layout) {
for (int i = 0; i < editor_plugins.size(); i++) {
editor_plugins[i]->get_window_layout(p_layout);
}
}
2014-02-10 01:10:30 +00:00
EditorData::EditorData() {
current_edited_scene = -1;
//load_imported_scenes_from_globals();
2014-02-10 01:10:30 +00:00
}
///////////
void EditorSelection::_node_removed(Node *p_node) {
if (!selection.has(p_node))
return;
Object *meta = selection[p_node];
if (meta)
memdelete(meta);
selection.erase(p_node);
changed = true;
nl_changed = true;
2014-02-10 01:10:30 +00:00
}
void EditorSelection::add_node(Node *p_node) {
ERR_FAIL_NULL(p_node);
ERR_FAIL_COND(!p_node->is_inside_tree());
2014-02-10 01:10:30 +00:00
if (selection.has(p_node))
return;
changed = true;
nl_changed = true;
Object *meta = NULL;
for (List<Object *>::Element *E = editor_plugins.front(); E; E = E->next()) {
2014-02-10 01:10:30 +00:00
meta = E->get()->call("_get_editor_data", p_node);
2014-02-10 01:10:30 +00:00
if (meta) {
break;
}
}
selection[p_node] = meta;
2014-02-10 01:10:30 +00:00
p_node->connect("tree_exited", this, "_node_removed", varray(p_node), CONNECT_ONESHOT);
2014-02-10 01:10:30 +00:00
//emit_signal("selection_changed");
}
void EditorSelection::remove_node(Node *p_node) {
ERR_FAIL_NULL(p_node);
2014-02-10 01:10:30 +00:00
if (!selection.has(p_node))
return;
changed = true;
nl_changed = true;
2014-02-10 01:10:30 +00:00
Object *meta = selection[p_node];
if (meta)
memdelete(meta);
selection.erase(p_node);
p_node->disconnect("tree_exited", this, "_node_removed");
2014-02-10 01:10:30 +00:00
//emit_signal("selection_changed");
}
bool EditorSelection::is_selected(Node *p_node) const {
2014-02-10 01:10:30 +00:00
return selection.has(p_node);
}
2016-09-10 20:50:20 +00:00
Array EditorSelection::_get_transformable_selected_nodes() {
Array ret;
for (List<Node *>::Element *E = selected_node_list.front(); E; E = E->next()) {
ret.push_back(E->get());
}
return ret;
}
2014-02-10 01:10:30 +00:00
2016-09-10 20:50:20 +00:00
Array EditorSelection::_get_selected_nodes() {
Array ret;
for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2016-09-10 20:50:20 +00:00
ret.push_back(E->key());
}
return ret;
}
2014-02-10 01:10:30 +00:00
void EditorSelection::_bind_methods() {
ClassDB::bind_method(D_METHOD("_node_removed"), &EditorSelection::_node_removed);
ClassDB::bind_method(D_METHOD("clear"), &EditorSelection::clear);
ClassDB::bind_method(D_METHOD("add_node", "node"), &EditorSelection::add_node);
ClassDB::bind_method(D_METHOD("remove_node", "node"), &EditorSelection::remove_node);
ClassDB::bind_method(D_METHOD("get_selected_nodes"), &EditorSelection::_get_selected_nodes);
ClassDB::bind_method(D_METHOD("get_transformable_selected_nodes"), &EditorSelection::_get_transformable_selected_nodes);
ADD_SIGNAL(MethodInfo("selection_changed"));
2014-02-10 01:10:30 +00:00
}
void EditorSelection::add_editor_plugin(Object *p_object) {
editor_plugins.push_back(p_object);
}
void EditorSelection::_update_nl() {
if (!nl_changed)
return;
selected_node_list.clear();
for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
2014-02-10 01:10:30 +00:00
Node *parent = E->key();
parent = parent->get_parent();
bool skip = false;
2014-02-10 01:10:30 +00:00
while (parent) {
if (selection.has(parent)) {
skip = true;
2014-02-10 01:10:30 +00:00
break;
}
parent = parent->get_parent();
2014-02-10 01:10:30 +00:00
}
if (skip)
continue;
selected_node_list.push_back(E->key());
}
nl_changed = true;
2014-02-10 01:10:30 +00:00
}
void EditorSelection::update() {
_update_nl();
if (!changed)
return;
changed = false;
emit_signal("selection_changed");
2014-02-10 01:10:30 +00:00
}
List<Node *> &EditorSelection::get_selected_node_list() {
2014-02-10 01:10:30 +00:00
if (changed)
update();
else
_update_nl();
return selected_node_list;
}
void EditorSelection::clear() {
while (!selection.empty()) {
2014-02-10 01:10:30 +00:00
remove_node(selection.front()->key());
}
changed = true;
nl_changed = true;
2014-02-10 01:10:30 +00:00
}
EditorSelection::EditorSelection() {
changed = false;
nl_changed = false;
2014-02-10 01:10:30 +00:00
}
EditorSelection::~EditorSelection() {
clear();
}