godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/tools/editor/editor_data.cpp

916 lines
20 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* editor_data.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
Update copyright to 2016 in headers
2016-01-01 13:50:53 +00:00
/* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur. */
GODOT IS OPEN SOURCE
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 "globals.h"
#include "editor_settings.h"
#include "os/dir_access.h"
#include "io/resource_loader.h"
-scenes are properly reloaded when a dependency changes, fixes #2896 (it's clevery done so local changes to scenes are kept even if unsaved)
2015-12-13 23:39:01 +00:00
#include "scene/resources/packed_scene.h"
#include "os/file_access.h"
#include "editor_node.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void EditorHistory::_cleanup_history() {
for(int i=0;i<history.size();i++) {
bool fail=false;
for(int j=0;j<history[i].path.size();j++) {
Multiple, simultaneous node editing spuport!! ..but will you be brave enough to try it? :)
2015-08-25 03:08:45 +00:00
if (!history[i].path[j].ref.is_null())
GODOT IS OPEN SOURCE
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) {
//before or equal level, complete fail
fail=true;
} else {
//after level, clip
history[i].path.resize(j);
}
break;
}
if (fail) {
history.remove(i);
i--;
}
}
if (current>=history.size())
current=history.size()-1;
}
void EditorHistory::_add_object(ObjectID p_object,const String& p_property,int p_level_change) {
Object *obj = ObjectDB::get_instance(p_object);
ERR_FAIL_COND(!obj);
Multiple, simultaneous node editing spuport!! ..but will you be brave enough to try it? :)
2015-08-25 03:08:45 +00:00
Reference *r = obj->cast_to<Reference>();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Obj o;
if (r)
Multiple, simultaneous node editing spuport!! ..but will you be brave enough to try it? :)
2015-08-25 03:08:45 +00:00
o.ref=REF(r);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
o.object=p_object;
o.property=p_property;
History h;
bool has_prev = current>=0 && current<history.size();
if (has_prev) {
history.resize(current+1); //clip history to next
}
if (p_property!="" && has_prev) {
//add a sub property
History &pr = history[current];
h=pr;
h.path.resize(h.level+1);
h.path.push_back(o);
h.level++;
} else if (p_level_change!=-1 && has_prev) {
//add a sub property
History &pr = history[current];
h=pr;
ERR_FAIL_INDEX(p_level_change,h.path.size());
h.level=p_level_change;
} else {
//add a new node
h.path.push_back(o);
h.level=0;
}
history.push_back(h);
current++;
}
void EditorHistory::add_object(ObjectID p_object) {
_add_object(p_object,"",-1);
}
void EditorHistory::add_object(ObjectID p_object,const String& p_subprop) {
_add_object(p_object,p_subprop,-1);
}
void EditorHistory::add_object(ObjectID p_object,int p_relevel){
_add_object(p_object,"",p_relevel);
}
-removed resources dock, good bye old friend
2015-09-01 03:49:47 +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;
}
bool EditorHistory::is_at_begining() const {
return current<=0;
}
bool EditorHistory::is_at_end() const {
return ((current+1)>=history.size());
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
bool EditorHistory::next() {
_cleanup_history();
if ((current+1)<history.size())
current++;
else
return false;
return true;
}
bool EditorHistory::previous() {
_cleanup_history();
if (current>0)
current--;
else
return false;
return true;
}
ObjectID EditorHistory::get_current() {
if (current<0 || current >=history.size())
return 0;
History &h=history[current];
Object *obj = ObjectDB::get_instance(h.path[h.level].object);
if (!obj)
return 0;
return obj->get_instance_ID();
}
int EditorHistory::get_path_size() const {
if (current<0 || current >=history.size())
return 0;
const History &h=history[current];
return h.path.size();
}
ObjectID EditorHistory::get_path_object(int p_index) const {
if (current<0 || current >=history.size())
return 0;
const History &h=history[current];
ERR_FAIL_INDEX_V(p_index,h.path.size(),0);
Object *obj = ObjectDB::get_instance(h.path[p_index].object);
if (!obj)
return 0;
return obj->get_instance_ID();
}
String EditorHistory::get_path_property(int p_index) const {
if (current<0 || current >=history.size())
return "";
const History &h=history[current];
ERR_FAIL_INDEX_V(p_index,h.path.size(),"");
return h.path[p_index].property;
}
void EditorHistory::clear() {
history.clear();
current=-1;
}
EditorHistory::EditorHistory() {
current=-1;
}
EditorPlugin* EditorData::get_editor(Object *p_object) {
for (int i=0;i<editor_plugins.size();i++) {
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) {
for (int i=0;i<editor_plugins.size();i++) {
if (!editor_plugins[i]->has_main_screen() && editor_plugins[i]->handles(p_object))
return editor_plugins[i];
}
return NULL;
}
EditorPlugin* EditorData::get_editor(String p_name) {
for(int i=0;i<editor_plugins.size();i++) {
if (editor_plugins[i]->get_name()==p_name)
return editor_plugins[i];
}
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()) {
if (!(E->get().usage&PROPERTY_USAGE_EDITOR))
continue;
PropertyData pd;
pd.name=E->get().name;
pd.value=p_object->get(pd.name);
clipboard.push_back(pd);
}
}
void EditorData::get_editor_breakpoints(List<String> *p_breakpoints) {
for(int i=0;i<editor_plugins.size();i++) {
editor_plugins[i]->get_breakpoints(p_breakpoints);
}
}
Dictionary EditorData::get_editor_states() const {
Dictionary metadata;
for(int i=0;i<editor_plugins.size();i++) {
Dictionary state=editor_plugins[i]->get_state();
if (state.empty())
continue;
metadata[editor_plugins[i]->get_name()]=state;
}
return metadata;
}
void EditorData::set_editor_states(const Dictionary& p_states) {
List<Variant> keys;
p_states.get_key_list(&keys);
List<Variant>::Element *E=keys.front();
for(;E;E=E->next()) {
String name = E->get();
int idx=-1;
for(int i=0;i<editor_plugins.size();i++) {
if (editor_plugins[i]->get_name()==name) {
idx=i;
break;
}
}
if (idx==-1)
continue;
editor_plugins[idx]->set_state(p_states[name]);
}
}
-ability to change scripts in external editor and still have properties reloaded in godot UI, fixes #3003
2015-12-09 12:08:41 +00:00
void EditorData::notify_edited_scene_changed() {
for(int i=0;i<editor_plugins.size();i++) {
editor_plugins[i]->edited_scene_changed();
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
void EditorData::clear_editor_states() {
for(int i=0;i<editor_plugins.size();i++) {
editor_plugins[i]->clear();
}
}
void EditorData::save_editor_external_data() {
for(int i=0;i<editor_plugins.size();i++) {
editor_plugins[i]->save_external_data();
}
}
void EditorData::apply_changes_in_editors() {
for(int i=0;i<editor_plugins.size();i++) {
editor_plugins[i]->apply_changes();
}
}
void EditorData::save_editor_global_states() {
for(int i=0;i<editor_plugins.size();i++) {
editor_plugins[i]->save_global_state();
}
}
void EditorData::restore_editor_global_states(){
for(int i=0;i<editor_plugins.size();i++) {
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()) {
p_object->set( E->get().name, E->get().value);
}
}
UndoRedo &EditorData::get_undo_redo() {
return undo_redo;
}
void EditorData::remove_editor_plugin(EditorPlugin *p_plugin) {
p_plugin->undo_redo=NULL;
editor_plugins.erase(p_plugin);
}
void EditorData::add_editor_plugin(EditorPlugin *p_plugin) {
p_plugin->undo_redo=&undo_redo;
editor_plugins.push_back(p_plugin);
}
void EditorData::add_custom_type(const String& p_type, const String& p_inherits,const Ref<Script>& p_script,const Ref<Texture>& p_icon ) {
ERR_FAIL_COND(p_script.is_null());
CustomType ct;
ct.name=p_type;
ct.icon=p_icon;
ct.script=p_script;
if (!custom_types.has(p_inherits)) {
custom_types[p_inherits]=Vector<CustomType>();
}
custom_types[p_inherits].push_back(ct);
}
void EditorData::remove_custom_type(const String& p_type){
for (Map<String,Vector<CustomType> >::Element *E=custom_types.front();E;E=E->next()) {
for(int i=0;i<E->get().size();i++) {
if (E->get()[i].name==p_type) {
E->get().remove(i);
if (E->get().empty()) {
custom_types.erase(E->key());
}
return;
}
}
}
}
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 03:03:19 +00:00
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;
Live edit WORK IN PROGRESS 1) press the heart while the game is running 2) select a scene to live edit from the opened scenes 3) edit/add/remove nodes or resources, change their properties, etc. 4) watch changes reflected in running game, in all places this scene is edited 5) It's not perfect obviously, but the aim of it is to try to reflect your changes as best as possible in the running game.
2015-08-02 15:29:37 +00:00
es.live_edit_root=NodePath(String("/root"));
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 03:03:19 +00:00
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)
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);
}
-scenes are properly reloaded when a dependency changes, fixes #2896 (it's clevery done so local changes to scenes are kept even if unsaved)
2015-12-13 23:39:01 +00:00
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);
if (must_reload) {
Ref<PackedScene> pscene;
pscene.instance();
EditorProgress ep("update_scene","Updating Scene",2);
ep.step("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("Updating scene..",1);
Node *new_scene = pscene->instance(true);
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;
}
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 03:03:19 +00:00
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(){
ERR_FAIL_INDEX_V(current_edited_scene,edited_scene.size(),NULL);
return edited_scene[current_edited_scene].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();
}
void EditorData::set_edited_scene_version(uint64_t version) {
ERR_FAIL_INDEX(current_edited_scene,edited_scene.size());
edited_scene[current_edited_scene].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;
}
-added icons for root node types on tabs
2015-07-24 17:18:02 +00:00
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_type();
}
QOL, script buttons in scene tabs
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>());
if (!edited_scene[p_idx].root)
return Ref<Script>();
Ref<Script> s=edited_scene[p_idx].root->get_script();
-added hints to sprite v/hframes, fixes truncation problem -removed an error being printed often unnecesarly about missing child
2015-08-29 16:02:56 +00:00
if (!s.is_valid() && edited_scene[p_idx].root->get_child_count()) {
QOL, script buttons in scene tabs
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();
}
}
return s;
}
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 03:03:19 +00:00
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]";
return edited_scene[p_idx].root->get_filename().get_file();
}
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();
}
Live edit WORK IN PROGRESS 1) press the heart while the game is running 2) select a scene to live edit from the opened scenes 3) edit/add/remove nodes or resources, change their properties, etc. 4) watch changes reflected in running game, in all places this scene is edited 5) It's not perfect obviously, but the aim of it is to try to reflect your changes as best as possible in the running game.
2015-08-02 15:29:37 +00:00
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;
}
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 03:03:19 +00:00
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::set_edited_scene_import_metadata(Ref<ResourceImportMetadata> p_mdata) {
ERR_FAIL_INDEX(current_edited_scene,edited_scene.size());
edited_scene[current_edited_scene].medatata=p_mdata;
}
Ref<ResourceImportMetadata> EditorData::get_edited_scene_import_metadata() const{
ERR_FAIL_INDEX_V(current_edited_scene,edited_scene.size(),Ref<ResourceImportMetadata>());
return edited_scene[current_edited_scene].medatata;
}
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);
}
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
EditorData::EditorData() {
Multiple scene editing *POTENTIALLY UNSTABLE* -ability to edit multiple scenes at the same time -resource internal IDs are now persistent, this makes multiple scene editing possible but maaaaay result in file corruption bugs (tested and could not find anything but possibility exists because core code changed, report immediately if you find this). -properly save settings, layout, etc when edited -script editing is independent from scene editing now -show a yellow box when a script belongs to the scene
2015-06-22 03:03:19 +00:00
current_edited_scene=-1;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
// load_imported_scenes_from_globals();
}
///////////
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;
}
void EditorSelection::add_node(Node *p_node) {
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()) {
meta = E->get()->call("_get_editor_data",p_node);
if (meta) {
break;
}
}
selection[p_node]=meta;
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 00:20:42 +00:00
p_node->connect("exit_tree",this,"_node_removed",varray(p_node),CONNECT_ONESHOT);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//emit_signal("selection_changed");
}
void EditorSelection::remove_node(Node *p_node) {
if (!selection.has(p_node))
return;
changed=true;
nl_changed=true;
Object *meta = selection[p_node];
if (meta)
memdelete(meta);
selection.erase(p_node);
SceneMainLoop -> SceneTree -=-=-=-=-=-=-=-=-=-=-=-=-=- *YOUR SOURCE MIGHT NOT WORK* For mor information on fix: https://github.com/okamstudio/godot/wiki/devel_scene_tree Other stuff: -Shower of bullets demo -Fixes all around
2014-11-06 00:20:42 +00:00
p_node->disconnect("exit_tree",this,"_node_removed");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
//emit_signal("selection_changed");
}
bool EditorSelection::is_selected(Node * p_node) const {
return selection.has(p_node);
}
void EditorSelection::_bind_methods() {
ObjectTypeDB::bind_method(_MD("_node_removed"),&EditorSelection::_node_removed);
ObjectTypeDB::bind_method(_MD("clear"),&EditorSelection::clear);
ObjectTypeDB::bind_method(_MD("add_node"),&EditorSelection::add_node);
ADD_SIGNAL( MethodInfo("selection_changed") );
}
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()) {
Node *parent = E->key();
parent=parent->get_parent();
bool skip=false;
while (parent) {
if (selection.has(parent)) {
skip=true;
break;
}
parent=parent->get_parent();
}
if (skip)
continue;
selected_node_list.push_back(E->key());
}
nl_changed=true;
}
void EditorSelection::update() {
_update_nl();
if (!changed)
return;
emit_signal("selection_changed");
changed=false;
}
List<Node*>& EditorSelection::get_selected_node_list() {
if (changed)
update();
else
_update_nl();
return selected_node_list;
}
void EditorSelection::clear() {
while( !selection.empty() ) {
remove_node(selection.front()->key());
}
changed=true;
nl_changed=true;
}
EditorSelection::EditorSelection() {
changed=false;
nl_changed=false;
}
EditorSelection::~EditorSelection() {
clear();
}