2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* scene_tree_dock.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
/*************************************************************************/
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 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 "scene_tree_dock.h"
2017-01-16 08:04:19 +01:00
2020-11-07 23:33:38 +01:00
# include "core/config/project_settings.h"
2020-04-28 15:19:37 +02:00
# include "core/input/input.h"
2017-03-05 16:44:50 +01:00
# include "core/io/resource_saver.h"
2021-04-27 17:43:49 +02:00
# include "core/object/message_queue.h"
2017-08-26 17:46:49 +02:00
# include "core/os/keyboard.h"
2020-02-07 02:52:05 +01:00
# include "editor/debugger/editor_debugger_node.h"
2019-12-24 08:17:23 +01:00
# include "editor/editor_feature_profile.h"
2017-08-26 17:46:49 +02:00
# include "editor/editor_node.h"
2019-12-24 08:17:23 +01:00
# include "editor/editor_scale.h"
2017-08-26 17:46:49 +02:00
# include "editor/editor_settings.h"
# include "editor/multi_node_edit.h"
2017-03-05 16:44:50 +01:00
# include "editor/plugins/animation_player_editor_plugin.h"
# include "editor/plugins/canvas_item_editor_plugin.h"
2020-03-27 08:44:44 +01:00
# include "editor/plugins/node_3d_editor_plugin.h"
2017-03-05 16:44:50 +01:00
# include "editor/plugins/script_editor_plugin.h"
2020-03-04 02:51:12 +01:00
# include "scene/main/window.h"
2014-02-10 02:10:30 +01:00
# include "scene/resources/packed_scene.h"
2020-03-03 14:36:29 +01:00
# include "servers/display_server.h"
2020-03-27 19:21:27 +01:00
# include "servers/rendering_server.h"
2016-05-11 16:46:08 +02:00
2016-08-03 16:28:20 +02:00
void SceneTreeDock : : _nodes_drag_begin ( ) {
if ( restore_script_editor_on_drag ) {
EditorNode : : get_singleton ( ) - > set_visible_editor ( EditorNode : : EDITOR_SCRIPT ) ;
2017-03-05 16:44:50 +01:00
restore_script_editor_on_drag = false ;
2016-08-03 16:28:20 +02:00
}
}
2018-10-17 07:03:22 +02:00
void SceneTreeDock : : _quick_open ( ) {
2021-06-18 00:03:09 +02:00
instantiate_scenes ( quick_open - > get_selected_files ( ) , scene_tree - > get_selected ( ) ) ;
2018-10-17 07:03:22 +02:00
}
2017-05-20 17:38:03 +02:00
void SceneTreeDock : : _input ( Ref < InputEvent > p_event ) {
2021-04-05 08:52:21 +02:00
ERR_FAIL_COND ( p_event . is_null ( ) ) ;
2017-05-20 17:38:03 +02:00
Ref < InputEventMouseButton > mb = p_event ;
2021-01-08 04:37:37 +01:00
if ( mb . is_valid ( ) & & ! mb - > is_pressed ( ) & & mb - > get_button_index ( ) = = MOUSE_BUTTON_LEFT ) {
2017-03-05 16:44:50 +01:00
restore_script_editor_on_drag = false ; //lost chance
2016-08-03 16:28:20 +02:00
}
}
2016-05-11 16:46:08 +02:00
2017-05-20 17:38:03 +02:00
void SceneTreeDock : : _unhandled_key_input ( Ref < InputEvent > p_event ) {
2021-04-05 08:52:21 +02:00
ERR_FAIL_COND ( p_event . is_null ( ) ) ;
2020-05-14 16:41:43 +02:00
if ( get_focus_owner ( ) & & get_focus_owner ( ) - > is_text_field ( ) ) {
2018-02-04 01:58:51 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-02-04 01:58:51 +01:00
2020-05-14 16:41:43 +02:00
if ( ! p_event - > is_pressed ( ) | | p_event - > is_echo ( ) ) {
2014-02-10 02:10:30 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2018-01-21 07:12:25 +01:00
if ( ED_IS_SHORTCUT ( " scene_tree/batch_rename " , p_event ) ) {
_tool_selected ( TOOL_BATCH_RENAME ) ;
2018-05-11 07:48:14 +02:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/rename " , p_event ) ) {
_tool_selected ( TOOL_RENAME ) ;
2018-01-21 07:12:25 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/add_child_node " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_NEW ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/instance_scene " , p_event ) ) {
2021-06-18 00:03:09 +02:00
_tool_selected ( TOOL_INSTANTIATE ) ;
2018-07-07 16:51:18 +02:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/expand_collapse_all " , p_event ) ) {
_tool_selected ( TOOL_EXPAND_COLLAPSE ) ;
2020-01-07 17:43:21 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/cut_node " , p_event ) ) {
_tool_selected ( TOOL_CUT ) ;
} else if ( ED_IS_SHORTCUT ( " scene_tree/copy_node " , p_event ) ) {
_tool_selected ( TOOL_COPY ) ;
} else if ( ED_IS_SHORTCUT ( " scene_tree/paste_node " , p_event ) ) {
_tool_selected ( TOOL_PASTE ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/change_node_type " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_REPLACE ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/duplicate " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_DUPLICATE ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/attach_script " , p_event ) ) {
2016-11-09 17:29:15 +01:00
_tool_selected ( TOOL_ATTACH_SCRIPT ) ;
2020-05-09 18:59:19 +02:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/detach_script " , p_event ) ) {
_tool_selected ( TOOL_DETACH_SCRIPT ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/move_up " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_MOVE_UP ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/move_down " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_MOVE_DOWN ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/reparent " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_REPARENT ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/save_branch_as_scene " , p_event ) ) {
2016-06-19 21:33:42 +02:00
_tool_selected ( TOOL_NEW_SCENE_FROM ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/delete_no_confirm " , p_event ) ) {
2016-06-12 17:47:29 +02:00
_tool_selected ( TOOL_ERASE , true ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/copy_node_path " , p_event ) ) {
2017-01-15 11:56:30 +01:00
_tool_selected ( TOOL_COPY_NODE_PATH ) ;
2017-03-05 16:44:50 +01:00
} else if ( ED_IS_SHORTCUT ( " scene_tree/delete " , p_event ) ) {
2016-06-12 17:47:29 +02:00
_tool_selected ( TOOL_ERASE ) ;
2020-09-16 02:44:38 +02:00
} else {
return ;
2014-02-10 02:10:30 +01:00
}
2020-09-16 02:44:38 +02:00
// Tool selection was successful, accept the event to stop propagation.
accept_event ( ) ;
2014-02-10 02:10:30 +01:00
}
2021-06-18 00:03:09 +02:00
void SceneTreeDock : : instantiate ( const String & p_file ) {
2016-05-12 01:57:52 +02:00
Vector < String > scenes ;
scenes . push_back ( p_file ) ;
2021-06-18 00:03:09 +02:00
instantiate_scenes ( scenes , scene_tree - > get_selected ( ) ) ;
2016-05-12 01:57:52 +02:00
}
2014-02-10 02:10:30 +01:00
2021-06-18 00:03:09 +02:00
void SceneTreeDock : : instantiate_scenes ( const Vector < String > & p_files , Node * p_parent ) {
2016-07-20 19:09:03 +02:00
Node * parent = p_parent ;
if ( ! parent ) {
parent = scene_tree - > get_selected ( ) ;
}
2021-04-04 05:20:18 +02:00
if ( ! parent ) {
parent = edited_scene ;
}
if ( ! parent ) {
2021-01-15 20:13:09 +01:00
if ( p_files . size ( ) = = 1 ) {
2021-06-18 00:03:09 +02:00
accept - > set_text ( TTR ( " No parent to instantiate a child at. " ) ) ;
2021-01-15 20:13:09 +01:00
} else {
2021-06-18 00:03:09 +02:00
accept - > set_text ( TTR ( " No parent to instantiate the scenes at. " ) ) ;
2021-01-15 20:13:09 +01:00
}
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2016-07-20 19:09:03 +02:00
return ;
} ;
2021-06-18 00:03:09 +02:00
_perform_instantiate_scenes ( p_files , parent , - 1 ) ;
2016-07-20 19:09:03 +02:00
}
2021-06-18 00:03:09 +02:00
void SceneTreeDock : : _perform_instantiate_scenes ( const Vector < String > & p_files , Node * parent , int p_pos ) {
2016-05-12 01:57:52 +02:00
ERR_FAIL_COND ( ! parent ) ;
2015-01-20 15:05:22 +01:00
2017-03-05 16:44:50 +01:00
Vector < Node * > instances ;
2016-05-12 01:57:52 +02:00
2017-03-05 16:44:50 +01:00
bool error = false ;
2016-05-12 01:57:52 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < p_files . size ( ) ; i + + ) {
2016-05-12 01:57:52 +02:00
Ref < PackedScene > sdata = ResourceLoader : : load ( p_files [ i ] ) ;
if ( ! sdata . is_valid ( ) ) {
2017-03-05 16:44:50 +01:00
current_option = - 1 ;
accept - > set_text ( vformat ( TTR ( " Error loading scene from %s " ) , p_files [ i ] ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2017-03-05 16:44:50 +01:00
error = true ;
2016-05-12 01:57:52 +02:00
break ;
}
2021-06-18 00:03:09 +02:00
Node * instantiated_scene = sdata - > instantiate ( PackedScene : : GEN_EDIT_STATE_INSTANCE ) ;
if ( ! instantiated_scene ) {
2017-03-05 16:44:50 +01:00
current_option = - 1 ;
accept - > set_text ( vformat ( TTR ( " Error instancing scene from %s " ) , p_files [ i ] ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2017-03-05 16:44:50 +01:00
error = true ;
2016-05-12 01:57:52 +02:00
break ;
}
2017-03-05 16:44:50 +01:00
if ( edited_scene - > get_filename ( ) ! = " " ) {
2021-06-18 00:03:09 +02:00
if ( _cyclical_dependency_exists ( edited_scene - > get_filename ( ) , instantiated_scene ) ) {
2017-03-05 16:44:50 +01:00
accept - > set_text ( vformat ( TTR ( " Cannot instance the scene '%s' because the current scene exists within one of its nodes. " ) , p_files [ i ] ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2017-03-05 16:44:50 +01:00
error = true ;
2016-05-12 01:57:52 +02:00
break ;
}
2015-01-20 15:05:22 +01:00
}
2016-05-12 01:57:52 +02:00
2021-06-18 00:03:09 +02:00
instantiated_scene - > set_filename ( ProjectSettings : : get_singleton ( ) - > localize_path ( p_files [ i ] ) ) ;
2016-05-12 01:57:52 +02:00
2021-06-18 00:03:09 +02:00
instances . push_back ( instantiated_scene ) ;
2014-02-10 02:10:30 +01:00
}
2016-05-12 01:57:52 +02:00
if ( error ) {
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < instances . size ( ) ; i + + ) {
2016-05-12 01:57:52 +02:00
memdelete ( instances [ i ] ) ;
}
return ;
}
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Instance Scene(s) " ) ) ;
2015-08-02 17:29:37 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < instances . size ( ) ; i + + ) {
2021-06-18 00:03:09 +02:00
Node * instantiated_scene = instances [ i ] ;
2015-08-02 17:29:37 +02:00
2021-06-18 00:03:09 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( parent , " add_child " , instantiated_scene ) ;
2017-03-05 16:44:50 +01:00
if ( p_pos > = 0 ) {
2021-06-18 00:03:09 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( parent , " move_child " , instantiated_scene , p_pos + i ) ;
2016-05-12 01:57:52 +02:00
}
2021-06-18 00:03:09 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( instantiated_scene , " set_owner " , edited_scene ) ;
2017-03-05 16:44:50 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( editor_selection , " clear " ) ;
2021-06-18 00:03:09 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( editor_selection , " add_node " , instantiated_scene ) ;
editor_data - > get_undo_redo ( ) . add_do_reference ( instantiated_scene ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( parent , " remove_child " , instantiated_scene ) ;
2014-02-10 02:10:30 +01:00
2021-06-18 00:03:09 +02:00
String new_name = parent - > validate_child_name ( instantiated_scene ) ;
2020-02-07 02:52:05 +01:00
EditorDebuggerNode * ed = EditorDebuggerNode : : get_singleton ( ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( ed , " live_debug_instance_node " , edited_scene - > get_path_to ( parent ) , p_files [ i ] , new_name ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( ed , " live_debug_remove_node " , NodePath ( String ( edited_scene - > get_path_to ( parent ) ) . plus_file ( new_name ) ) ) ;
2016-05-12 01:57:52 +02:00
}
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2021-01-05 14:14:45 +01:00
editor - > push_item ( instances [ instances . size ( ) - 1 ] ) ;
2020-08-25 01:32:58 +02:00
for ( int i = 0 ; i < instances . size ( ) ; i + + ) {
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " node_created " ) , instances [ i ] ) ;
2020-08-25 01:32:58 +02:00
}
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _replace_with_branch_scene ( const String & p_file , Node * base ) {
2016-10-11 16:54:46 +02:00
Ref < PackedScene > sdata = ResourceLoader : : load ( p_file ) ;
if ( ! sdata . is_valid ( ) ) {
2017-03-05 16:44:50 +01:00
accept - > set_text ( vformat ( TTR ( " Error loading scene from %s " ) , p_file ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2016-10-11 16:54:46 +02:00
return ;
}
2021-06-18 00:03:09 +02:00
Node * instantiated_scene = sdata - > instantiate ( PackedScene : : GEN_EDIT_STATE_INSTANCE ) ;
if ( ! instantiated_scene ) {
2017-03-05 16:44:50 +01:00
accept - > set_text ( vformat ( TTR ( " Error instancing scene from %s " ) , p_file ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2016-10-11 16:54:46 +02:00
return ;
}
2019-09-25 09:06:05 +02:00
UndoRedo * undo_redo = editor - > get_undo_redo ( ) ;
undo_redo - > create_action ( TTR ( " Replace with Branch Scene " ) ) ;
2016-10-11 16:54:46 +02:00
Node * parent = base - > get_parent ( ) ;
int pos = base - > get_index ( ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_do_method ( parent , " remove_child " , base ) ;
2021-06-18 00:03:09 +02:00
undo_redo - > add_undo_method ( parent , " remove_child " , instantiated_scene ) ;
undo_redo - > add_do_method ( parent , " add_child " , instantiated_scene ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_undo_method ( parent , " add_child " , base ) ;
2021-06-18 00:03:09 +02:00
undo_redo - > add_do_method ( parent , " move_child " , instantiated_scene , pos ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_undo_method ( parent , " move_child " , base , pos ) ;
List < Node * > owned ;
base - > get_owned_by ( base - > get_owner ( ) , & owned ) ;
Array owners ;
2021-07-16 05:45:57 +02:00
for ( Node * F : owned ) {
owners . push_back ( F ) ;
2019-09-25 09:06:05 +02:00
}
2021-06-18 00:03:09 +02:00
undo_redo - > add_do_method ( instantiated_scene , " set_owner " , edited_scene ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_undo_method ( this , " _set_owners " , edited_scene , owners ) ;
undo_redo - > add_do_method ( editor_selection , " clear " ) ;
undo_redo - > add_undo_method ( editor_selection , " clear " ) ;
2021-06-18 00:03:09 +02:00
undo_redo - > add_do_method ( editor_selection , " add_node " , instantiated_scene ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_undo_method ( editor_selection , " add_node " , base ) ;
2021-06-18 00:03:09 +02:00
undo_redo - > add_do_property ( scene_tree , " set_selected " , instantiated_scene ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_undo_property ( scene_tree , " set_selected " , base ) ;
2021-06-18 00:03:09 +02:00
undo_redo - > add_do_reference ( instantiated_scene ) ;
2019-09-25 09:06:05 +02:00
undo_redo - > add_undo_reference ( base ) ;
undo_redo - > commit_action ( ) ;
2016-10-11 16:54:46 +02:00
}
2017-03-05 16:44:50 +01:00
bool SceneTreeDock : : _cyclical_dependency_exists ( const String & p_target_scene_path , Node * p_desired_node ) {
2015-01-19 21:47:50 +01:00
int childCount = p_desired_node - > get_child_count ( ) ;
2019-03-14 06:04:16 +01:00
if ( _track_inherit ( p_target_scene_path , p_desired_node ) ) {
2015-01-19 21:47:50 +01:00
return true ;
}
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < childCount ; i + + ) {
Node * child = p_desired_node - > get_child ( i ) ;
2015-01-19 21:47:50 +01:00
2017-03-05 16:44:50 +01:00
if ( _cyclical_dependency_exists ( p_target_scene_path , child ) ) {
2015-01-19 21:47:50 +01:00
return true ;
}
}
return false ;
}
2019-03-14 06:04:16 +01:00
bool SceneTreeDock : : _track_inherit ( const String & p_target_scene_path , Node * p_desired_node ) {
Node * p = p_desired_node ;
bool result = false ;
Vector < Node * > instances ;
while ( true ) {
if ( p - > get_filename ( ) = = p_target_scene_path ) {
result = true ;
break ;
}
Ref < SceneState > ss = p - > get_scene_inherited_state ( ) ;
if ( ss . is_valid ( ) ) {
String path = ss - > get_path ( ) ;
Ref < PackedScene > data = ResourceLoader : : load ( path ) ;
if ( data . is_valid ( ) ) {
2021-06-18 00:03:09 +02:00
p = data - > instantiate ( PackedScene : : GEN_EDIT_STATE_INSTANCE ) ;
2020-05-14 16:41:43 +02:00
if ( ! p ) {
2019-07-23 09:14:31 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2019-03-14 06:04:16 +01:00
instances . push_back ( p ) ;
2020-05-14 16:41:43 +02:00
} else {
2019-03-14 06:04:16 +01:00
break ;
2020-05-14 16:41:43 +02:00
}
} else {
2019-03-14 06:04:16 +01:00
break ;
2020-05-14 16:41:43 +02:00
}
2019-03-14 06:04:16 +01:00
}
for ( int i = 0 ; i < instances . size ( ) ; i + + ) {
memdelete ( instances [ i ] ) ;
}
return result ;
}
2014-05-09 12:50:48 +02:00
void SceneTreeDock : : _tool_selected ( int p_tool , bool p_confirm_override ) {
2017-03-05 16:44:50 +01:00
current_option = p_tool ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
switch ( p_tool ) {
2018-01-21 07:12:25 +01:00
case TOOL_BATCH_RENAME : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2019-11-01 13:03:57 +01:00
if ( editor_selection - > get_selected_node_list ( ) . size ( ) > 1 ) {
2018-01-21 07:12:25 +01:00
rename_dialog - > popup_centered ( ) ;
}
} break ;
2018-05-11 07:48:14 +02:00
case TOOL_RENAME : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2018-05-11 07:48:14 +02:00
Tree * tree = scene_tree - > get_scene_tree ( ) ;
if ( tree - > is_anything_selected ( ) ) {
tree - > grab_focus ( ) ;
tree - > edit_selected ( ) ;
}
} break ;
2018-09-12 20:47:12 +02:00
case TOOL_NEW :
case TOOL_REPARENT_TO_NEW_NODE : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-09-29 20:57:31 +02:00
2021-07-08 00:52:49 +02:00
if ( reset_create_dialog & & ! p_confirm_override ) {
2020-08-25 01:32:58 +02:00
create_dialog - > set_base_type ( " Node " ) ;
reset_create_dialog = false ;
}
2020-06-29 18:23:49 +02:00
// Prefer nodes that inherit from the current scene root.
Node * current_edited_scene_root = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) ;
2017-09-29 20:57:31 +02:00
if ( current_edited_scene_root ) {
2020-07-01 22:57:08 +02:00
String root_class = current_edited_scene_root - > get_class_name ( ) ;
static Vector < String > preferred_types ;
2020-12-15 13:04:21 +01:00
if ( preferred_types . is_empty ( ) ) {
2020-07-01 22:57:08 +02:00
preferred_types . push_back ( " Control " ) ;
preferred_types . push_back ( " Node2D " ) ;
preferred_types . push_back ( " Node3D " ) ;
}
2020-06-29 18:23:49 +02:00
2020-07-01 22:57:08 +02:00
for ( int i = 0 ; i < preferred_types . size ( ) ; i + + ) {
2020-06-29 18:23:49 +02:00
if ( ClassDB : : is_parent_class ( root_class , preferred_types [ i ] ) ) {
create_dialog - > set_preferred_search_result_type ( preferred_types [ i ] ) ;
break ;
}
2020-05-14 16:41:43 +02:00
}
2017-09-29 20:57:31 +02:00
}
2020-06-29 18:23:49 +02:00
2017-03-16 21:58:45 +01:00
create_dialog - > popup_create ( true ) ;
2020-08-25 01:32:58 +02:00
if ( ! p_confirm_override ) {
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " add_node_used " ) ) ;
2020-08-25 01:32:58 +02:00
}
2014-02-10 02:10:30 +01:00
} break ;
2021-06-18 00:03:09 +02:00
case TOOL_INSTANTIATE : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2014-02-10 02:10:30 +01:00
Node * scene = edited_scene ;
if ( ! scene ) {
2016-05-16 17:23:40 +02:00
EditorNode : : get_singleton ( ) - > new_inherited_scene ( ) ;
2017-11-25 06:03:43 +01:00
break ;
2014-02-10 02:10:30 +01:00
}
2018-10-17 07:03:22 +02:00
quick_open - > popup_dialog ( " PackedScene " , true ) ;
2021-06-18 00:03:09 +02:00
quick_open - > set_title ( TTR ( " Instantiate Child Scene " ) ) ;
2020-08-25 01:32:58 +02:00
if ( ! p_confirm_override ) {
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " add_node_used " ) ) ;
2020-08-25 01:32:58 +02:00
}
2018-07-07 16:51:18 +02:00
} break ;
case TOOL_EXPAND_COLLAPSE : {
2020-05-14 16:41:43 +02:00
if ( ! scene_tree - > get_selected ( ) ) {
2018-07-07 16:51:18 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2018-07-07 16:51:18 +02:00
Tree * tree = scene_tree - > get_scene_tree ( ) ;
TreeItem * selected_item = tree - > get_selected ( ) ;
2020-05-14 16:41:43 +02:00
if ( ! selected_item ) {
2018-07-07 16:51:18 +02:00
selected_item = tree - > get_root ( ) ;
2020-05-14 16:41:43 +02:00
}
2018-07-07 16:51:18 +02:00
bool collapsed = _is_collapsed_recursive ( selected_item ) ;
_set_collapsed_recursive ( selected_item , ! collapsed ) ;
tree - > ensure_cursor_is_visible ( ) ;
2014-02-10 02:10:30 +01:00
} break ;
2020-01-07 17:43:21 +01:00
case TOOL_CUT :
case TOOL_COPY : {
if ( ! edited_scene | | ! _validate_no_foreign ( ) ) {
break ;
}
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
if ( selection . size ( ) = = 0 ) {
break ;
}
if ( ! node_clipboard . is_empty ( ) ) {
_clear_clipboard ( ) ;
}
2021-02-12 17:36:37 +01:00
clipboard_source_scene = editor - > get_edited_scene ( ) - > get_filename ( ) ;
2020-01-07 17:43:21 +01:00
selection . sort_custom < Node : : Comparator > ( ) ;
2021-07-16 05:45:57 +02:00
for ( Node * node : selection ) {
2020-01-07 17:43:21 +01:00
Map < const Node * , Node * > duplimap ;
Node * dup = node - > duplicate_from_editor ( duplimap ) ;
ERR_CONTINUE ( ! dup ) ;
node_clipboard . push_back ( dup ) ;
}
if ( p_tool = = TOOL_CUT ) {
_delete_confirm ( true ) ;
}
} break ;
case TOOL_PASTE : {
if ( node_clipboard . is_empty ( ) | | ! edited_scene ) {
break ;
}
bool has_cycle = false ;
if ( edited_scene - > get_filename ( ) ! = String ( ) ) {
2021-07-16 05:45:57 +02:00
for ( Node * E : node_clipboard ) {
if ( edited_scene - > get_filename ( ) = = E - > get_filename ( ) ) {
2020-01-07 17:43:21 +01:00
has_cycle = true ;
break ;
}
}
}
if ( has_cycle ) {
current_option = - 1 ;
accept - > set_text ( TTR ( " Can't paste root node into the same scene. " ) ) ;
accept - > popup_centered ( ) ;
break ;
}
Node * paste_parent = edited_scene ;
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
if ( selection . size ( ) > 0 ) {
paste_parent = selection . back ( ) - > get ( ) ;
}
Node * owner = paste_parent - > get_owner ( ) ;
if ( ! owner ) {
owner = paste_parent ;
}
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Paste Node(s) " ) ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( editor_selection , " clear " ) ;
2021-02-12 17:36:37 +01:00
Map < RES , RES > resource_remap ;
String target_scene = editor - > get_edited_scene ( ) - > get_filename ( ) ;
if ( target_scene ! = clipboard_source_scene ) {
if ( ! clipboard_resource_remap . has ( target_scene ) ) {
Map < RES , RES > remap ;
2021-07-16 05:45:57 +02:00
for ( Node * E : node_clipboard ) {
_create_remap_for_node ( E , remap ) ;
2021-02-12 17:36:37 +01:00
}
clipboard_resource_remap [ target_scene ] = remap ;
}
resource_remap = clipboard_resource_remap [ target_scene ] ;
}
2021-07-16 05:45:57 +02:00
for ( Node * node : node_clipboard ) {
2020-01-07 17:43:21 +01:00
Map < const Node * , Node * > duplimap ;
2021-02-12 17:36:37 +01:00
Node * dup = node - > duplicate_from_editor ( duplimap , resource_remap ) ;
2020-01-07 17:43:21 +01:00
ERR_CONTINUE ( ! dup ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( paste_parent , " add_child " , dup ) ;
for ( Map < const Node * , Node * > : : Element * E2 = duplimap . front ( ) ; E2 ; E2 = E2 - > next ( ) ) {
Node * d = E2 - > value ( ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( d , " set_owner " , owner ) ;
}
editor_data - > get_undo_redo ( ) . add_do_method ( dup , " set_owner " , owner ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( editor_selection , " add_node " , dup ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( paste_parent , " remove_child " , dup ) ;
editor_data - > get_undo_redo ( ) . add_do_reference ( dup ) ;
if ( node_clipboard . size ( ) = = 1 ) {
editor_data - > get_undo_redo ( ) . add_do_method ( editor , " push_item " , dup ) ;
}
}
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
} break ;
2014-02-10 02:10:30 +01:00
case TOOL_REPLACE : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2019-07-14 16:47:24 +02:00
2021-02-22 20:18:14 +01:00
if ( ! _validate_no_foreign ( ) ) {
break ;
}
if ( ! _validate_no_instance ( ) ) {
break ;
}
2021-07-20 16:47:57 +02:00
if ( reset_create_dialog ) {
create_dialog - > set_base_type ( " Node " ) ;
reset_create_dialog = false ;
}
2019-07-14 16:47:24 +02:00
Node * selected = scene_tree - > get_selected ( ) ;
2020-12-15 13:04:21 +01:00
if ( ! selected & & ! editor_selection - > get_selected_node_list ( ) . is_empty ( ) ) {
2019-08-09 16:31:31 +02:00
selected = editor_selection - > get_selected_node_list ( ) . front ( ) - > get ( ) ;
2020-05-14 16:41:43 +02:00
}
2019-08-09 16:31:31 +02:00
2020-05-14 16:41:43 +02:00
if ( selected ) {
2019-07-14 16:47:24 +02:00
create_dialog - > popup_create ( false , true , selected - > get_class ( ) ) ;
2020-05-14 16:41:43 +02:00
}
2019-07-14 16:47:24 +02:00
2014-02-10 02:10:30 +01:00
} break ;
2019-10-21 06:57:10 +02:00
case TOOL_EXTEND_SCRIPT : {
attach_script_to_selected ( true ) ;
} break ;
2016-11-09 17:29:15 +01:00
case TOOL_ATTACH_SCRIPT : {
2019-10-21 06:57:10 +02:00
attach_script_to_selected ( false ) ;
2016-10-31 15:45:20 +01:00
} break ;
2020-05-09 18:59:19 +02:00
case TOOL_DETACH_SCRIPT : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_script_editing ) {
break ;
}
2019-03-06 07:11:02 +01:00
Array selection = editor_selection - > get_selected_nodes ( ) ;
2018-03-07 20:08:13 +01:00
2020-12-15 13:04:21 +01:00
if ( selection . is_empty ( ) ) {
2018-03-07 20:08:13 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-03-07 20:08:13 +01:00
2020-05-09 18:59:19 +02:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Detach Script " ) ) ;
2020-04-02 01:20:12 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( editor , " push_item " , ( Script * ) nullptr ) ;
2018-03-07 20:08:13 +01:00
2019-03-06 07:11:02 +01:00
for ( int i = 0 ; i < selection . size ( ) ; i + + ) {
Node * n = Object : : cast_to < Node > ( selection [ i ] ) ;
Ref < Script > existing = n - > get_script ( ) ;
2019-07-19 21:21:30 +02:00
Ref < Script > empty = EditorNode : : get_singleton ( ) - > get_object_custom_type_base ( n ) ;
if ( existing ! = empty ) {
2019-03-06 07:11:02 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( n , " set_script " , empty ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( n , " set_script " , existing ) ;
2018-03-07 20:08:13 +01:00
}
2016-10-31 15:45:20 +01:00
}
2018-03-07 20:08:13 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( this , " _update_script_button " ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( this , " _update_script_button " ) ;
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2014-02-10 02:10:30 +01:00
} break ;
case TOOL_MOVE_UP :
case TOOL_MOVE_DOWN : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2020-05-14 16:41:43 +02:00
if ( ! scene_tree - > get_selected ( ) ) {
2014-02-10 02:10:30 +01:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
if ( scene_tree - > get_selected ( ) = = edited_scene ) {
current_option = - 1 ;
2016-05-21 01:18:35 +02:00
accept - > set_text ( TTR ( " This operation can't be done on the tree root. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2014-02-10 02:10:30 +01:00
break ;
}
2020-05-14 16:41:43 +02:00
if ( ! _validate_no_foreign ( ) ) {
2014-09-03 04:13:40 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-09-03 04:13:40 +02:00
2014-12-18 03:38:24 +01:00
bool MOVING_DOWN = ( p_tool = = TOOL_MOVE_DOWN ) ;
bool MOVING_UP = ! MOVING_DOWN ;
2014-12-18 05:46:03 +01:00
Node * common_parent = scene_tree - > get_selected ( ) - > get_parent ( ) ;
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
selection . sort_custom < Node : : Comparator > ( ) ; // sort by index
2020-05-14 16:41:43 +02:00
if ( MOVING_DOWN ) {
2021-03-14 08:21:32 +01:00
selection . reverse ( ) ;
2020-05-14 16:41:43 +02:00
}
2014-12-18 03:38:24 +01:00
2014-12-18 05:46:03 +01:00
int lowest_id = common_parent - > get_child_count ( ) - 1 ;
int highest_id = 0 ;
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
int index = E - > get_index ( ) ;
2014-12-18 03:38:24 +01:00
2020-05-14 16:41:43 +02:00
if ( index > highest_id ) {
2020-05-10 12:56:01 +02:00
highest_id = index ;
2020-05-14 16:41:43 +02:00
}
if ( index < lowest_id ) {
2020-05-10 12:56:01 +02:00
lowest_id = index ;
2020-05-14 16:41:43 +02:00
}
2014-12-18 05:46:03 +01:00
2021-07-16 05:45:57 +02:00
if ( E - > get_parent ( ) ! = common_parent ) {
2020-04-02 01:20:12 +02:00
common_parent = nullptr ;
2020-05-14 16:41:43 +02:00
}
2014-12-18 03:38:24 +01:00
}
2020-05-14 16:41:43 +02:00
if ( ! common_parent | | ( MOVING_DOWN & & highest_id > = common_parent - > get_child_count ( ) - MOVING_DOWN ) | | ( MOVING_UP & & lowest_id = = 0 ) ) {
2014-12-18 05:46:03 +01:00
break ; // one or more nodes can not be moved
2020-05-14 16:41:43 +02:00
}
2014-12-18 03:38:24 +01:00
2020-05-14 16:41:43 +02:00
if ( selection . size ( ) = = 1 ) {
2020-05-10 12:56:01 +02:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Move Node In Parent " ) ) ;
2020-05-14 16:41:43 +02:00
}
if ( selection . size ( ) > 1 ) {
2020-05-10 12:56:01 +02:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Move Nodes In Parent " ) ) ;
2020-05-14 16:41:43 +02:00
}
2014-12-18 05:52:27 +01:00
2014-12-18 03:38:24 +01:00
for ( int i = 0 ; i < selection . size ( ) ; i + + ) {
Node * top_node = selection [ i ] ;
Node * bottom_node = selection [ selection . size ( ) - 1 - i ] ;
2016-01-18 00:03:57 +01:00
2014-12-18 03:38:24 +01:00
ERR_FAIL_COND ( ! top_node - > get_parent ( ) ) ;
ERR_FAIL_COND ( ! bottom_node - > get_parent ( ) ) ;
int bottom_node_pos = bottom_node - > get_index ( ) ;
2016-07-06 19:04:21 +02:00
int top_node_pos_next = top_node - > get_index ( ) + ( MOVING_DOWN ? 1 : - 1 ) ;
2014-12-18 03:38:24 +01:00
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 ) ;
}
2014-12-18 05:52:27 +01:00
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2014-02-10 02:10:30 +01:00
} break ;
case TOOL_DUPLICATE : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2020-05-14 16:41:43 +02:00
if ( ! edited_scene ) {
2014-02-10 02:10:30 +01:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
if ( editor_selection - > is_selected ( edited_scene ) ) {
2017-03-05 16:44:50 +01:00
current_option = - 1 ;
2016-05-21 01:18:35 +02:00
accept - > set_text ( TTR ( " This operation can't be done on the tree root. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2014-02-10 02:10:30 +01:00
break ;
}
2020-05-14 16:41:43 +02:00
if ( ! _validate_no_foreign ( ) ) {
2014-09-03 04:13:40 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-09-03 04:13:40 +02:00
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2020-05-14 16:41:43 +02:00
if ( selection . size ( ) = = 0 ) {
2016-11-04 16:52:53 +01:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2016-05-04 03:25:37 +02:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Duplicate Node(s) " ) ) ;
2017-03-05 16:44:50 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( editor_selection , " clear " ) ;
2014-02-10 02:10:30 +01:00
2020-04-02 01:20:12 +02:00
Node * dupsingle = nullptr ;
2014-02-10 02:10:30 +01:00
2019-07-06 14:51:24 +02:00
selection . sort_custom < Node : : Comparator > ( ) ;
2020-05-01 10:45:55 +02:00
Node * add_below_node = selection . back ( ) - > get ( ) ;
2021-07-16 05:45:57 +02:00
for ( Node * node : selection ) {
2014-02-10 02:10:30 +01:00
Node * parent = node - > get_parent ( ) ;
2017-03-05 16:44:50 +01:00
List < Node * > owned ;
node - > get_owned_by ( node - > get_owner ( ) , & owned ) ;
2014-02-10 02:10:30 +01:00
2017-11-19 14:32:10 +01:00
Map < const Node * , Node * > duplimap ;
Node * dup = node - > duplicate_from_editor ( duplimap ) ;
2014-02-10 02:10:30 +01:00
ERR_CONTINUE ( ! dup ) ;
2020-05-14 16:41:43 +02:00
if ( selection . size ( ) = = 1 ) {
2017-03-05 16:44:50 +01:00
dupsingle = dup ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2016-10-07 20:25:29 +02:00
dup - > set_name ( parent - > validate_child_name ( dup ) ) ;
2014-02-10 02:10:30 +01:00
2020-05-12 08:12:08 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( add_below_node , " add_sibling " , dup ) ;
2021-07-16 05:45:57 +02:00
for ( Node * F : owned ) {
if ( ! duplimap . has ( F ) ) {
2014-02-10 02:10:30 +01:00
continue ;
}
2021-07-16 05:45:57 +02:00
Node * d = duplimap [ F ] ;
2020-05-01 10:45:55 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( d , " set_owner " , node - > get_owner ( ) ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
editor_data - > get_undo_redo ( ) . add_do_reference ( dup ) ;
2020-02-07 02:52:05 +01:00
EditorDebuggerNode * ed = EditorDebuggerNode : : get_singleton ( ) ;
2015-08-02 17:29:37 +02:00
2020-02-07 02:52:05 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( ed , " live_debug_duplicate_node " , edited_scene - > get_path_to ( node ) , dup - > get_name ( ) ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( ed , " live_debug_remove_node " , NodePath ( String ( edited_scene - > get_path_to ( parent ) ) . plus_file ( dup - > get_name ( ) ) ) ) ;
2020-05-01 10:45:55 +02:00
add_below_node = dup ;
2014-02-10 02:10:30 +01:00
}
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2020-05-14 16:41:43 +02:00
if ( dupsingle ) {
2014-02-10 02:10:30 +01:00
editor - > push_item ( dupsingle ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
} break ;
case TOOL_REPARENT : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2020-05-14 16:41:43 +02:00
if ( ! scene_tree - > get_selected ( ) ) {
2014-02-10 02:10:30 +01:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
if ( editor_selection - > is_selected ( edited_scene ) ) {
2017-03-05 16:44:50 +01:00
current_option = - 1 ;
2016-05-21 01:18:35 +02:00
accept - > set_text ( TTR ( " This operation can't be done on the tree root. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2014-02-10 02:10:30 +01:00
break ;
}
2020-05-14 16:41:43 +02:00
if ( ! _validate_no_foreign ( ) ) {
2014-09-03 04:13:40 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-09-03 04:13:40 +02:00
2017-03-05 16:44:50 +01:00
List < Node * > nodes = editor_selection - > get_selected_node_list ( ) ;
Set < Node * > nodeset ;
2021-07-16 05:45:57 +02:00
for ( Node * E : nodes ) {
nodeset . insert ( E ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
reparent_dialog - > set_current ( nodeset ) ;
2020-07-11 18:45:19 +02:00
reparent_dialog - > popup_centered_clamped ( Size2 ( 350 , 700 ) * EDSCALE ) ;
2015-08-25 05:08:45 +02:00
} break ;
2018-07-16 04:52:57 +02:00
case TOOL_MAKE_ROOT : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2018-07-16 04:52:57 +02:00
List < Node * > nodes = editor_selection - > get_selected_node_list ( ) ;
ERR_FAIL_COND ( nodes . size ( ) ! = 1 ) ;
Node * node = nodes . front ( ) - > get ( ) ;
Node * root = get_tree ( ) - > get_edited_scene_root ( ) ;
2020-05-14 16:41:43 +02:00
if ( node = = root ) {
2018-07-16 04:52:57 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-07-16 04:52:57 +02:00
2019-01-17 19:20:48 +01:00
//check that from node to root, all owners are right
2019-01-22 17:49:03 +01:00
if ( root - > get_scene_inherited_state ( ) . is_valid ( ) ) {
accept - > set_text ( TTR ( " Can't reparent nodes in inherited scenes, order of nodes can't change. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2019-01-22 17:49:03 +01:00
return ;
}
2019-01-17 19:20:48 +01:00
if ( node - > get_owner ( ) ! = root ) {
accept - > set_text ( TTR ( " Node must belong to the edited scene to become root. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2019-01-17 19:20:48 +01:00
return ;
}
if ( node - > get_filename ( ) ! = String ( ) ) {
accept - > set_text ( TTR ( " Instantiated scenes can't become root " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2019-01-17 19:20:48 +01:00
return ;
}
2019-02-21 20:41:01 +01:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Make node as Root " ) ) ;
2018-07-16 04:52:57 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( node - > get_parent ( ) , " remove_child " , node ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( editor , " set_edited_scene " , node ) ;
2019-09-28 14:17:07 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( node , " add_child " , root ) ;
2018-07-16 04:52:57 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( node , " set_filename " , root - > get_filename ( ) ) ;
2018-09-30 00:04:18 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( root , " set_filename " , String ( ) ) ;
2020-04-02 01:20:12 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( node , " set_owner " , ( Object * ) nullptr ) ;
2018-10-11 00:45:44 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( root , " set_owner " , node ) ;
2018-09-30 00:04:18 +02:00
_node_replace_owner ( root , root , node , MODE_DO ) ;
2018-07-16 04:52:57 +02:00
2018-09-30 00:04:18 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( root , " set_filename " , root - > get_filename ( ) ) ;
2018-07-16 04:52:57 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node , " set_filename " , String ( ) ) ;
2018-09-30 00:04:18 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node , " remove_child " , root ) ;
2018-07-16 04:52:57 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( editor , " set_edited_scene " , root ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( node - > get_parent ( ) , " add_child " , node ) ;
2019-09-28 14:17:07 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node - > get_parent ( ) , " move_child " , node , node - > get_index ( ) ) ;
2020-04-02 01:20:12 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( root , " set_owner " , ( Object * ) nullptr ) ;
2018-10-11 00:45:44 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node , " set_owner " , root ) ;
2018-09-30 00:04:18 +02:00
_node_replace_owner ( root , root , root , MODE_UNDO ) ;
2018-07-16 04:52:57 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( scene_tree , " update_tree " ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( scene_tree , " update_tree " ) ;
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
} break ;
2015-08-25 05:08:45 +02:00
case TOOL_MULTI_EDIT : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-03-05 16:44:50 +01:00
Node * root = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) ;
2020-05-14 16:41:43 +02:00
if ( ! root ) {
2015-08-25 05:08:45 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2017-03-05 16:44:50 +01:00
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 ( ) ) {
2015-08-25 05:08:45 +02:00
mne - > add_node ( root - > get_path_to ( E - > key ( ) ) ) ;
}
EditorNode : : get_singleton ( ) - > push_item ( mne . ptr ( ) ) ;
2014-02-10 02:10:30 +01:00
} break ;
2016-06-12 04:00:06 +02:00
2014-02-10 02:10:30 +01:00
case TOOL_ERASE : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-03-05 16:44:50 +01:00
List < Node * > remove_list = editor_selection - > get_selected_node_list ( ) ;
2014-02-10 02:10:30 +01:00
2020-12-15 13:04:21 +01:00
if ( remove_list . is_empty ( ) ) {
2014-02-10 02:10:30 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2020-05-14 16:41:43 +02:00
if ( ! _validate_no_foreign ( ) ) {
2014-09-03 04:13:40 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2014-09-03 04:13:40 +02:00
2014-05-09 12:50:48 +02:00
if ( p_confirm_override ) {
_delete_confirm ( ) ;
} else {
2020-06-29 17:11:04 +02:00
String msg ;
if ( remove_list . size ( ) > 1 ) {
bool any_children = false ;
for ( int i = 0 ; ! any_children & & i < remove_list . size ( ) ; i + + ) {
any_children = remove_list [ i ] - > get_child_count ( ) > 0 ;
}
msg = vformat ( any_children ? TTR ( " Delete %d nodes and any children? " ) : TTR ( " Delete %d nodes? " ) , remove_list . size ( ) ) ;
2019-09-03 23:14:59 +02:00
} else {
2020-06-29 17:11:04 +02:00
Node * node = remove_list [ 0 ] ;
if ( node = = editor_data - > get_edited_scene_root ( ) ) {
msg = vformat ( TTR ( " Delete the root node \" %s \" ? " ) , node - > get_name ( ) ) ;
} else if ( node - > get_filename ( ) = = " " & & node - > get_child_count ( ) > 0 ) {
2021-06-18 00:03:09 +02:00
// Display this message only for non-instantiated scenes
2020-06-29 17:11:04 +02:00
msg = vformat ( TTR ( " Delete node \" %s \" and its children? " ) , node - > get_name ( ) ) ;
} else {
msg = vformat ( TTR ( " Delete node \" %s \" ? " ) , node - > get_name ( ) ) ;
}
2019-09-03 23:14:59 +02:00
}
2020-06-29 17:11:04 +02:00
delete_dialog - > set_text ( msg ) ;
2019-09-03 23:14:59 +02:00
// Resize the dialog to its minimum size.
// This prevents the dialog from being too wide after displaying
// a deletion confirmation for a node with a long name.
delete_dialog - > set_size ( Size2 ( ) ) ;
2020-03-06 18:00:16 +01:00
delete_dialog - > popup_centered ( ) ;
2014-05-09 12:50:48 +02:00
}
2014-02-10 02:10:30 +01:00
2015-11-27 21:42:48 +01:00
} break ;
case TOOL_NEW_SCENE_FROM : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2015-11-27 21:42:48 +01:00
Node * scene = editor_data - > get_edited_scene_root ( ) ;
2014-02-10 02:10:30 +01:00
2015-11-27 21:42:48 +01:00
if ( ! scene ) {
2021-03-09 15:30:56 +01:00
accept - > set_text ( TTR ( " Saving the branch as a scene requires having a scene open in the editor. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
break ;
}
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2015-11-27 21:42:48 +01:00
2017-03-05 16:44:50 +01:00
if ( selection . size ( ) ! = 1 ) {
2021-03-09 15:30:56 +01:00
accept - > set_text ( vformat ( TTR ( " Saving the branch as a scene requires selecting only one node, but you have selected %d nodes. " ) , selection . size ( ) ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
break ;
}
Node * tocopy = selection . front ( ) - > get ( ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
if ( tocopy = = scene ) {
2021-06-18 00:03:09 +02:00
accept - > set_text ( TTR ( " Can't save the root node branch as an instantiated scene. \n To create an editable copy of the current scene, duplicate it using the FileSystem dock context menu \n or create an inherited scene using Scene > New Inherited Scene... instead. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2017-01-29 20:27:14 +01:00
break ;
}
2017-03-05 16:44:50 +01:00
if ( tocopy ! = editor_data - > get_edited_scene_root ( ) & & tocopy - > get_filename ( ) ! = " " ) {
2021-06-18 00:03:09 +02:00
accept - > set_text ( TTR ( " Can't save the branch of an already instantiated scene. \n To create a variation of a scene, you can make an inherited scene based on the instantiated scene using Scene > New Inherited Scene... instead. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
break ;
}
2020-03-06 18:00:16 +01:00
new_scene_from_dialog - > set_file_mode ( EditorFileDialog : : FILE_MODE_SAVE_FILE ) ;
2015-11-27 21:42:48 +01:00
List < String > extensions ;
2017-03-05 16:44:50 +01:00
Ref < PackedScene > sd = memnew ( PackedScene ) ;
ResourceSaver : : get_recognized_extensions ( sd , & extensions ) ;
2015-11-27 21:42:48 +01:00
new_scene_from_dialog - > clear_filters ( ) ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < extensions . size ( ) ; i + + ) {
new_scene_from_dialog - > add_filter ( " *. " + extensions [ i ] + " ; " + extensions [ i ] . to_upper ( ) ) ;
2015-11-27 21:42:48 +01:00
}
String existing ;
if ( extensions . size ( ) ) {
2016-05-23 15:27:58 +02:00
String root_name ( tocopy - > get_name ( ) ) ;
2017-03-05 16:44:50 +01:00
existing = root_name + " . " + extensions . front ( ) - > get ( ) . to_lower ( ) ;
2015-11-27 21:42:48 +01:00
}
new_scene_from_dialog - > set_current_path ( existing ) ;
2018-04-22 19:36:01 +02:00
new_scene_from_dialog - > set_title ( TTR ( " Save New Scene As... " ) ) ;
2020-07-11 18:45:19 +02:00
new_scene_from_dialog - > popup_file_dialog ( ) ;
2014-02-10 02:10:30 +01:00
} break ;
2017-03-05 16:44:50 +01:00
case TOOL_COPY_NODE_PATH : {
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
2017-01-15 11:56:30 +01:00
Node * root = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) ;
NodePath path = root - > get_path ( ) . rel_path_to ( node - > get_path ( ) ) ;
2020-03-03 14:36:29 +01:00
DisplayServer : : get_singleton ( ) - > clipboard_set ( path ) ;
2017-01-15 11:56:30 +01:00
}
}
} break ;
2018-10-03 11:25:18 +02:00
case TOOL_OPEN_DOCUMENTATION : {
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
for ( int i = 0 ; i < selection . size ( ) ; i + + ) {
ScriptEditor : : get_singleton ( ) - > goto_help ( " class_name: " + selection [ i ] - > get_class ( ) ) ;
}
EditorNode : : get_singleton ( ) - > set_visible_editor ( EditorNode : : EDITOR_SCRIPT ) ;
} break ;
2017-06-30 18:17:33 +02:00
case TOOL_SCENE_EDITABLE_CHILDREN : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-06-30 18:17:33 +02:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
2017-06-30 18:17:33 +02:00
bool editable = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > is_editable_instance ( node ) ;
if ( editable ) {
2018-09-13 00:49:12 +02:00
editable_instance_remove_dialog - > set_text ( TTR ( " Disabling \" editable_instance \" will cause all properties of the node to be reverted to their default. " ) ) ;
2020-03-06 18:00:16 +01:00
editable_instance_remove_dialog - > popup_centered ( ) ;
2018-09-13 00:49:12 +02:00
break ;
2017-06-30 18:17:33 +02:00
}
2019-05-14 02:11:06 +02:00
_toggle_editable_children ( node ) ;
2017-06-30 18:17:33 +02:00
}
}
} break ;
case TOOL_SCENE_USE_PLACEHOLDER : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-06-30 18:17:33 +02:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
2019-09-04 21:02:26 +02:00
bool editable = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > is_editable_instance ( node ) ;
2017-06-30 18:17:33 +02:00
bool placeholder = node - > get_scene_instance_load_placeholder ( ) ;
2019-09-04 21:02:26 +02:00
// Fire confirmation dialog when children are editable.
if ( editable & & ! placeholder ) {
placeholder_editable_instance_remove_dialog - > set_text ( TTR ( " Enabling \" Load As Placeholder \" will disable \" Editable Children \" and cause all properties of the node to be reverted to their default. " ) ) ;
2020-03-06 18:00:16 +01:00
placeholder_editable_instance_remove_dialog - > popup_centered ( ) ;
2019-09-04 21:02:26 +02:00
break ;
}
2017-06-30 18:17:33 +02:00
placeholder = ! placeholder ;
2019-09-04 21:02:26 +02:00
2020-05-14 16:41:43 +02:00
if ( placeholder ) {
2017-06-30 18:17:33 +02:00
EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > set_editable_instance ( node , false ) ;
2020-05-14 16:41:43 +02:00
}
2017-06-30 18:17:33 +02:00
node - > set_scene_instance_load_placeholder ( placeholder ) ;
scene_tree - > update_tree ( ) ;
}
}
} break ;
2018-06-23 13:03:05 +02:00
case TOOL_SCENE_MAKE_LOCAL : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-06-30 18:17:33 +02:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
2017-06-30 18:17:33 +02:00
Node * root = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) ;
UndoRedo * undo_redo = & editor_data - > get_undo_redo ( ) ;
2020-05-14 16:41:43 +02:00
if ( ! root ) {
2017-06-30 18:17:33 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2017-06-30 18:17:33 +02:00
ERR_FAIL_COND ( node - > get_filename ( ) = = String ( ) ) ;
2018-06-23 13:03:05 +02:00
undo_redo - > create_action ( TTR ( " Make Local " ) ) ;
2017-06-30 18:17:33 +02:00
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 ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
2021-07-17 23:22:52 +02:00
scene_tree - > emit_signal ( SNAME ( " open " ) , node - > get_filename ( ) ) ;
2017-06-30 18:17:33 +02:00
}
}
} break ;
case TOOL_SCENE_CLEAR_INHERITANCE : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2020-03-06 18:00:16 +01:00
clear_inherit_confirm - > popup_centered ( ) ;
2017-06-30 18:17:33 +02:00
} break ;
case TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM : {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_editing ) {
break ;
}
2017-06-30 18:17:33 +02:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
2017-06-30 18:17:33 +02:00
node - > set_scene_inherited_state ( Ref < SceneState > ( ) ) ;
scene_tree - > update_tree ( ) ;
2018-05-15 22:12:35 +02:00
EditorNode : : get_singleton ( ) - > get_inspector ( ) - > update_tree ( ) ;
2017-06-30 18:17:33 +02:00
}
}
} break ;
case TOOL_SCENE_OPEN_INHERITED : {
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2017-09-06 23:50:18 +02:00
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
2019-04-08 11:03:37 +02:00
if ( node & & node - > get_scene_inherited_state ( ) . is_valid ( ) ) {
2021-07-17 23:22:52 +02:00
scene_tree - > emit_signal ( SNAME ( " open " ) , node - > get_scene_inherited_state ( ) - > get_path ( ) ) ;
2017-06-30 18:17:33 +02:00
}
}
} break ;
2018-07-16 04:11:29 +02:00
case TOOL_CREATE_2D_SCENE :
case TOOL_CREATE_3D_SCENE :
2018-07-25 05:48:24 +02:00
case TOOL_CREATE_USER_INTERFACE :
case TOOL_CREATE_FAVORITE : {
2020-04-02 01:20:12 +02:00
Node * new_node = nullptr ;
2018-07-29 20:09:42 +02:00
2018-07-25 05:48:24 +02:00
if ( TOOL_CREATE_FAVORITE = = p_tool ) {
String name = selected_favorite_root . get_slicec ( ' ' , 0 ) ;
if ( ScriptServer : : is_global_class ( name ) ) {
2021-06-18 00:03:09 +02:00
new_node = Object : : cast_to < Node > ( ClassDB : : instantiate ( ScriptServer : : get_global_class_native_base ( name ) ) ) ;
2018-07-25 05:48:24 +02:00
Ref < Script > script = ResourceLoader : : load ( ScriptServer : : get_global_class_path ( name ) , " Script " ) ;
if ( new_node & & script . is_valid ( ) ) {
2020-02-13 20:03:10 +01:00
new_node - > set_script ( script ) ;
2018-07-25 05:48:24 +02:00
new_node - > set_name ( name ) ;
}
} else {
2021-06-18 00:03:09 +02:00
new_node = Object : : cast_to < Node > ( ClassDB : : instantiate ( selected_favorite_root ) ) ;
2018-07-25 05:48:24 +02:00
}
2019-08-15 04:57:49 +02:00
2018-07-25 05:48:24 +02:00
if ( ! new_node ) {
new_node = memnew ( Node ) ;
2019-11-06 17:03:04 +01:00
ERR_PRINT ( " Creating root from favorite ' " + selected_favorite_root + " ' failed. Creating 'Node' instead. " ) ;
2018-07-25 05:48:24 +02:00
}
} else {
switch ( p_tool ) {
2020-05-10 13:00:47 +02:00
case TOOL_CREATE_2D_SCENE :
new_node = memnew ( Node2D ) ;
break ;
case TOOL_CREATE_3D_SCENE :
new_node = memnew ( Node3D ) ;
break ;
2018-07-25 05:48:24 +02:00
case TOOL_CREATE_USER_INTERFACE : {
Control * node = memnew ( Control ) ;
2020-12-22 17:24:29 +01:00
node - > set_anchors_and_offsets_preset ( PRESET_WIDE ) ; //more useful for resizable UIs.
2018-07-25 05:48:24 +02:00
new_node = node ;
} break ;
}
2018-07-16 04:11:29 +02:00
}
2021-07-07 01:59:46 +02:00
add_root_node ( new_node ) ;
2018-07-16 04:11:29 +02:00
2018-09-20 10:44:58 +02:00
editor - > edit_node ( new_node ) ;
2018-10-04 02:36:58 +02:00
editor_selection - > clear ( ) ;
editor_selection - > add_node ( new_node ) ;
2018-09-20 10:44:58 +02:00
2018-07-16 04:11:29 +02:00
} break ;
2017-06-05 05:12:19 +02:00
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 ) ;
}
}
2014-02-10 02:10:30 +01:00
}
}
2021-07-16 16:27:59 +02:00
void SceneTreeDock : : _property_selected ( int p_idx ) {
ERR_FAIL_NULL ( property_drop_node ) ;
_perform_property_drop ( property_drop_node , menu_properties - > get_item_metadata ( p_idx ) , ResourceLoader : : load ( resource_drop_path ) ) ;
property_drop_node = nullptr ;
}
void SceneTreeDock : : _perform_property_drop ( Node * p_node , String p_property , RES p_res ) {
editor_data - > get_undo_redo ( ) . create_action ( vformat ( TTR ( " Set %s " ) , p_property ) ) ;
editor_data - > get_undo_redo ( ) . add_do_property ( p_node , p_property , p_res ) ;
editor_data - > get_undo_redo ( ) . add_undo_property ( p_node , p_property , p_node - > get ( p_property ) ) ;
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
}
2021-07-07 01:59:46 +02:00
void SceneTreeDock : : add_root_node ( Node * p_node ) {
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " New Scene Root " ) ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( editor , " set_edited_scene " , p_node ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( scene_tree , " update_tree " ) ;
editor_data - > get_undo_redo ( ) . add_do_reference ( p_node ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( editor , " set_edited_scene " , ( Object * ) nullptr ) ;
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
}
2018-07-07 16:51:18 +02:00
void SceneTreeDock : : _node_collapsed ( Object * p_obj ) {
TreeItem * ti = Object : : cast_to < TreeItem > ( p_obj ) ;
2020-05-14 16:41:43 +02:00
if ( ! ti ) {
2018-07-07 16:51:18 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-07-07 16:51:18 +02:00
2020-04-28 15:19:37 +02:00
if ( Input : : get_singleton ( ) - > is_key_pressed ( KEY_SHIFT ) ) {
2018-07-07 16:51:18 +02:00
_set_collapsed_recursive ( ti , ti - > is_collapsed ( ) ) ;
}
}
2014-02-10 02:10:30 +01:00
void SceneTreeDock : : _notification ( int p_what ) {
2017-03-05 16:44:50 +01:00
switch ( p_what ) {
2015-06-14 07:13:47 +02:00
case NOTIFICATION_READY : {
2020-05-14 16:41:43 +02:00
if ( ! first_enter ) {
2015-06-14 07:13:47 +02:00
break ;
2020-05-14 16:41:43 +02:00
}
2017-03-05 16:44:50 +01:00
first_enter = false ;
2014-02-10 02:10:30 +01:00
2020-02-21 18:28:45 +01:00
EditorFeatureProfileManager : : get_singleton ( ) - > connect ( " current_feature_profile_changed " , callable_mp ( this , & SceneTreeDock : : _feature_profile_changed ) ) ;
2019-04-09 00:18:03 +02:00
2017-08-24 22:58:51 +02:00
CanvasItemEditorPlugin * canvas_item_plugin = Object : : cast_to < CanvasItemEditorPlugin > ( editor_data - > get_editor ( " 2D " ) ) ;
2015-06-14 07:13:47 +02:00
if ( canvas_item_plugin ) {
2020-12-05 22:01:27 +01:00
canvas_item_plugin - > get_canvas_item_editor ( ) - > connect ( " item_lock_status_changed " , Callable ( scene_tree , " _update_tree " ) ) ;
canvas_item_plugin - > get_canvas_item_editor ( ) - > connect ( " item_group_status_changed " , Callable ( scene_tree , " _update_tree " ) ) ;
2020-02-21 23:26:13 +01:00
scene_tree - > connect ( " node_changed " , callable_mp ( ( CanvasItem * ) canvas_item_plugin - > get_canvas_item_editor ( ) - > get_viewport_control ( ) , & CanvasItem : : update ) ) ;
2015-06-14 07:13:47 +02:00
}
2017-10-23 21:21:15 +02:00
2020-03-26 22:49:16 +01:00
Node3DEditorPlugin * spatial_editor_plugin = Object : : cast_to < Node3DEditorPlugin > ( editor_data - > get_editor ( " 3D " ) ) ;
2020-12-05 22:01:27 +01:00
spatial_editor_plugin - > get_spatial_editor ( ) - > connect ( " item_lock_status_changed " , Callable ( scene_tree , " _update_tree " ) ) ;
spatial_editor_plugin - > get_spatial_editor ( ) - > connect ( " item_group_status_changed " , Callable ( scene_tree , " _update_tree " ) ) ;
2017-10-23 21:21:15 +02:00
2021-07-17 23:22:52 +02:00
button_add - > set_icon ( get_theme_icon ( SNAME ( " Add " ) , SNAME ( " EditorIcons " ) ) ) ;
button_instance - > set_icon ( get_theme_icon ( SNAME ( " Instance " ) , SNAME ( " EditorIcons " ) ) ) ;
button_create_script - > set_icon ( get_theme_icon ( SNAME ( " ScriptCreate " ) , SNAME ( " EditorIcons " ) ) ) ;
button_detach_script - > set_icon ( get_theme_icon ( SNAME ( " ScriptRemove " ) , SNAME ( " EditorIcons " ) ) ) ;
2016-08-08 00:22:33 +02:00
2021-07-17 23:22:52 +02:00
filter - > set_right_icon ( get_theme_icon ( SNAME ( " Search " ) , SNAME ( " EditorIcons " ) ) ) ;
2018-07-26 13:45:38 +02:00
filter - > set_clear_button_enabled ( true ) ;
2017-01-23 05:40:43 +01:00
2018-07-25 05:48:24 +02:00
// create_root_dialog
HBoxContainer * top_row = memnew ( HBoxContainer ) ;
top_row - > set_name ( " NodeShortcutsTopRow " ) ;
top_row - > set_h_size_flags ( SIZE_EXPAND_FILL ) ;
2021-07-08 15:29:15 +02:00
Label * l = memnew ( Label ( TTR ( " Create Root Node: " ) ) ) ;
l - > set_theme_type_variation ( " HeaderSmall " ) ;
top_row - > add_child ( l ) ;
2018-07-25 05:48:24 +02:00
top_row - > add_spacer ( ) ;
2018-07-16 04:11:29 +02:00
2020-06-19 20:49:04 +02:00
Button * node_shortcuts_toggle = memnew ( Button ) ;
node_shortcuts_toggle - > set_flat ( true ) ;
2018-07-25 05:48:24 +02:00
node_shortcuts_toggle - > set_name ( " NodeShortcutsToggle " ) ;
2021-07-17 23:22:52 +02:00
node_shortcuts_toggle - > set_icon ( get_theme_icon ( SNAME ( " Favorites " ) , SNAME ( " EditorIcons " ) ) ) ;
2018-07-25 05:48:24 +02:00
node_shortcuts_toggle - > set_toggle_mode ( true ) ;
2020-04-21 20:02:36 +02:00
node_shortcuts_toggle - > set_tooltip ( TTR ( " Switch to Favorite Nodes " ) ) ;
2018-07-25 05:48:24 +02:00
node_shortcuts_toggle - > set_pressed ( EDITOR_GET ( " _use_favorites_root_selection " ) ) ;
2020-12-22 17:24:29 +01:00
node_shortcuts_toggle - > set_anchors_and_offsets_preset ( Control : : PRESET_CENTER_RIGHT ) ;
2020-02-21 18:28:45 +01:00
node_shortcuts_toggle - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _update_create_root_dialog ) ) ;
2018-07-25 05:48:24 +02:00
top_row - > add_child ( node_shortcuts_toggle ) ;
create_root_dialog - > add_child ( top_row ) ;
VBoxContainer * node_shortcuts = memnew ( VBoxContainer ) ;
node_shortcuts - > set_name ( " NodeShortcuts " ) ;
2018-07-16 04:11:29 +02:00
2018-07-25 05:48:24 +02:00
VBoxContainer * beginner_node_shortcuts = memnew ( VBoxContainer ) ;
beginner_node_shortcuts - > set_name ( " BeginnerNodeShortcuts " ) ;
node_shortcuts - > add_child ( beginner_node_shortcuts ) ;
2020-09-17 04:33:19 +02:00
button_2d = memnew ( Button ) ;
2018-07-25 05:48:24 +02:00
beginner_node_shortcuts - > add_child ( button_2d ) ;
2018-07-16 04:11:29 +02:00
button_2d - > set_text ( TTR ( " 2D Scene " ) ) ;
2021-07-17 23:22:52 +02:00
button_2d - > set_icon ( get_theme_icon ( SNAME ( " Node2D " ) , SNAME ( " EditorIcons " ) ) ) ;
2020-02-21 18:28:45 +01:00
button_2d - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_CREATE_2D_SCENE , false ) ) ;
2020-03-12 13:37:40 +01:00
2019-11-10 16:58:56 +01:00
button_3d = memnew ( Button ) ;
2018-07-25 05:48:24 +02:00
beginner_node_shortcuts - > add_child ( button_3d ) ;
2018-07-16 04:11:29 +02:00
button_3d - > set_text ( TTR ( " 3D Scene " ) ) ;
2021-07-17 23:22:52 +02:00
button_3d - > set_icon ( get_theme_icon ( SNAME ( " Node3D " ) , SNAME ( " EditorIcons " ) ) ) ;
2020-02-21 18:28:45 +01:00
button_3d - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_CREATE_3D_SCENE , false ) ) ;
2018-07-16 04:11:29 +02:00
2020-09-17 04:33:19 +02:00
button_ui = memnew ( Button ) ;
2018-07-25 05:48:24 +02:00
beginner_node_shortcuts - > add_child ( button_ui ) ;
2018-07-16 04:11:29 +02:00
button_ui - > set_text ( TTR ( " User Interface " ) ) ;
2021-07-17 23:22:52 +02:00
button_ui - > set_icon ( get_theme_icon ( SNAME ( " Control " ) , SNAME ( " EditorIcons " ) ) ) ;
2020-02-21 18:28:45 +01:00
button_ui - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_CREATE_USER_INTERFACE , false ) ) ;
2018-07-16 04:11:29 +02:00
2018-07-25 05:48:24 +02:00
VBoxContainer * favorite_node_shortcuts = memnew ( VBoxContainer ) ;
favorite_node_shortcuts - > set_name ( " FavoriteNodeShortcuts " ) ;
node_shortcuts - > add_child ( favorite_node_shortcuts ) ;
2020-09-17 04:33:19 +02:00
button_custom = memnew ( Button ) ;
2018-07-25 05:48:24 +02:00
node_shortcuts - > add_child ( button_custom ) ;
2019-03-12 16:12:14 +01:00
button_custom - > set_text ( TTR ( " Other Node " ) ) ;
2021-07-17 23:22:52 +02:00
button_custom - > set_icon ( get_theme_icon ( SNAME ( " Add " ) , SNAME ( " EditorIcons " ) ) ) ;
2020-10-09 23:41:53 +02:00
button_custom - > connect ( " pressed " , callable_bind ( callable_mp ( this , & SceneTreeDock : : _tool_selected ) , TOOL_NEW , false ) ) ;
2018-07-16 04:11:29 +02:00
2018-07-25 05:48:24 +02:00
node_shortcuts - > add_spacer ( ) ;
create_root_dialog - > add_child ( node_shortcuts ) ;
_update_create_root_dialog ( ) ;
2014-02-10 02:10:30 +01:00
} break ;
2017-06-30 18:17:33 +02:00
case NOTIFICATION_ENTER_TREE : {
2020-03-03 10:46:03 +01:00
clear_inherit_confirm - > connect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_SCENE_CLEAR_INHERITANCE_CONFIRM , false ) ) ;
2017-06-30 18:17:33 +02:00
} break ;
case NOTIFICATION_EXIT_TREE : {
2020-02-21 18:28:45 +01:00
clear_inherit_confirm - > disconnect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) ) ;
2017-06-30 18:17:33 +02:00
} break ;
2017-08-30 01:03:13 +02:00
case EditorSettings : : NOTIFICATION_EDITOR_SETTINGS_CHANGED : {
2021-07-17 23:22:52 +02:00
button_add - > set_icon ( get_theme_icon ( SNAME ( " Add " ) , SNAME ( " EditorIcons " ) ) ) ;
button_instance - > set_icon ( get_theme_icon ( SNAME ( " Instance " ) , SNAME ( " EditorIcons " ) ) ) ;
button_create_script - > set_icon ( get_theme_icon ( SNAME ( " ScriptCreate " ) , SNAME ( " EditorIcons " ) ) ) ;
button_detach_script - > set_icon ( get_theme_icon ( SNAME ( " ScriptRemove " ) , SNAME ( " EditorIcons " ) ) ) ;
button_2d - > set_icon ( get_theme_icon ( SNAME ( " Node2D " ) , SNAME ( " EditorIcons " ) ) ) ;
button_3d - > set_icon ( get_theme_icon ( SNAME ( " Node3D " ) , SNAME ( " EditorIcons " ) ) ) ;
button_ui - > set_icon ( get_theme_icon ( SNAME ( " Control " ) , SNAME ( " EditorIcons " ) ) ) ;
button_custom - > set_icon ( get_theme_icon ( SNAME ( " Add " ) , SNAME ( " EditorIcons " ) ) ) ;
filter - > set_right_icon ( get_theme_icon ( SNAME ( " Search " ) , SNAME ( " EditorIcons " ) ) ) ;
2018-07-26 13:45:38 +02:00
filter - > set_clear_button_enabled ( true ) ;
2017-08-30 01:03:13 +02:00
} break ;
2018-07-16 04:11:29 +02:00
case NOTIFICATION_PROCESS : {
2020-04-02 01:20:12 +02:00
bool show_create_root = bool ( EDITOR_GET ( " interface/editors/show_scene_tree_root_selection " ) ) & & get_tree ( ) - > get_edited_scene_root ( ) = = nullptr ;
2018-07-16 04:11:29 +02:00
2019-05-30 02:20:59 +02:00
if ( show_create_root ! = create_root_dialog - > is_visible_in_tree ( ) & & ! remote_tree - > is_visible ( ) ) {
2018-07-16 04:11:29 +02:00
if ( show_create_root ) {
create_root_dialog - > show ( ) ;
scene_tree - > hide ( ) ;
} else {
create_root_dialog - > hide ( ) ;
scene_tree - > show ( ) ;
}
}
} break ;
2017-06-30 18:17:33 +02:00
}
}
2018-07-16 04:52:57 +02:00
void SceneTreeDock : : _node_replace_owner ( Node * p_base , Node * p_node , Node * p_root , ReplaceOwnerMode p_mode ) {
2018-10-11 00:45:44 +02:00
if ( p_node - > get_owner ( ) = = p_base & & p_node ! = p_root ) {
2018-09-30 00:04:18 +02:00
UndoRedo * undo_redo = & editor_data - > get_undo_redo ( ) ;
switch ( p_mode ) {
case MODE_BIDI : {
undo_redo - > add_do_method ( p_node , " set_owner " , p_root ) ;
undo_redo - > add_undo_method ( p_node , " set_owner " , p_base ) ;
2018-07-16 04:52:57 +02:00
2018-09-30 00:04:18 +02:00
} break ;
case MODE_DO : {
undo_redo - > add_do_method ( p_node , " set_owner " , p_root ) ;
2018-07-16 04:52:57 +02:00
2018-09-30 00:04:18 +02:00
} break ;
case MODE_UNDO : {
undo_redo - > add_undo_method ( p_node , " set_owner " , p_root ) ;
2018-07-16 04:52:57 +02:00
2018-09-30 00:04:18 +02:00
} break ;
2017-06-30 18:17:33 +02:00
}
}
for ( int i = 0 ; i < p_node - > get_child_count ( ) ; i + + ) {
2018-07-16 04:52:57 +02:00
_node_replace_owner ( p_base , p_node - > get_child ( i ) , p_root , p_mode ) ;
2014-02-10 02:10:30 +01:00
}
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _load_request ( const String & p_path ) {
2014-02-10 02:10:30 +01:00
editor - > open_request ( p_path ) ;
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _script_open_request ( const Ref < Script > & p_script ) {
2014-02-10 02:10:30 +01:00
editor - > edit_resource ( p_script ) ;
}
void SceneTreeDock : : _node_selected ( ) {
2017-03-05 16:44:50 +01:00
Node * node = scene_tree - > get_selected ( ) ;
2014-02-10 02:10:30 +01:00
if ( ! node ) {
return ;
}
2017-01-13 14:45:50 +01:00
if ( ScriptEditor : : get_singleton ( ) - > is_visible_in_tree ( ) ) {
2017-03-05 16:44:50 +01:00
restore_script_editor_on_drag = true ;
2016-08-03 16:28:20 +02:00
}
2014-02-10 02:10:30 +01:00
editor - > push_item ( node ) ;
}
2014-09-21 17:56:19 +02:00
void SceneTreeDock : : _node_renamed ( ) {
_node_selected ( ) ;
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _set_owners ( Node * p_owner , const Array & p_nodes ) {
for ( int i = 0 ; i < p_nodes . size ( ) ; i + + ) {
2017-08-24 22:58:51 +02:00
Node * n = Object : : cast_to < Node > ( p_nodes [ i ] ) ;
2020-05-14 16:41:43 +02:00
if ( ! n ) {
2014-02-10 02:10:30 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
n - > set_owner ( p_owner ) ;
}
}
2021-07-09 20:21:27 +02:00
void SceneTreeDock : : _fill_path_renames ( Vector < StringName > base_path , Vector < StringName > new_base_path , Node * p_node , Map < Node * , NodePath > * p_renames ) {
2014-02-10 02:10:30 +01:00
base_path . push_back ( p_node - > get_name ( ) ) ;
2020-05-14 16:41:43 +02:00
if ( new_base_path . size ( ) ) {
2014-02-10 02:10:30 +01:00
new_base_path . push_back ( p_node - > get_name ( ) ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2021-07-09 20:21:27 +02:00
NodePath new_path ;
2020-05-14 16:41:43 +02:00
if ( new_base_path . size ( ) ) {
2021-07-09 20:21:27 +02:00
new_path = NodePath ( new_base_path , true ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2021-07-09 20:21:27 +02:00
p_renames - > insert ( p_node , new_path ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2014-02-10 02:10:30 +01:00
}
}
2021-07-09 20:21:27 +02:00
void SceneTreeDock : : fill_path_renames ( Node * p_node , Node * p_new_parent , Map < Node * , NodePath > * p_renames ) {
2014-02-10 02:10:30 +01:00
Vector < StringName > base_path ;
Node * n = p_node - > get_parent ( ) ;
2017-03-05 16:44:50 +01:00
while ( n ) {
2014-02-10 02:10:30 +01:00
base_path . push_back ( n - > get_name ( ) ) ;
2017-03-05 16:44:50 +01:00
n = n - > get_parent ( ) ;
2014-02-10 02:10:30 +01:00
}
2021-03-14 08:21:32 +01:00
base_path . reverse ( ) ;
2014-02-10 02:10:30 +01:00
Vector < StringName > new_base_path ;
if ( p_new_parent ) {
n = p_new_parent ;
2017-03-05 16:44:50 +01:00
while ( n ) {
2014-02-10 02:10:30 +01:00
new_base_path . push_back ( n - > get_name ( ) ) ;
2017-03-05 16:44:50 +01:00
n = n - > get_parent ( ) ;
2014-02-10 02:10:30 +01:00
}
2021-03-14 08:21:32 +01:00
new_base_path . reverse ( ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
_fill_path_renames ( base_path , new_base_path , p_node , p_renames ) ;
2014-02-10 02:10:30 +01:00
}
2021-07-09 20:21:27 +02:00
bool SceneTreeDock : : _update_node_path ( Node * p_root_node , NodePath & r_node_path , Map < Node * , NodePath > * p_renames ) const {
Node * target_node = p_root_node - > get_node_or_null ( r_node_path ) ;
ERR_FAIL_NULL_V_MSG ( target_node , false , " Found invalid node path ' " + String ( r_node_path ) + " ' on node ' " + String ( scene_root - > get_path_to ( p_root_node ) ) + " ' " ) ;
2021-06-21 21:09:00 +02:00
2021-07-09 20:21:27 +02:00
// Try to find the target node in modified node paths.
Map < Node * , NodePath > : : Element * found_node_path = p_renames - > find ( target_node ) ;
if ( found_node_path ) {
Map < Node * , NodePath > : : Element * found_root_path = p_renames - > find ( p_root_node ) ;
NodePath root_path_new = found_root_path ? found_root_path - > get ( ) : p_root_node - > get_path ( ) ;
r_node_path = root_path_new . rel_path_to ( found_node_path - > get ( ) ) ;
2021-06-21 21:09:00 +02:00
2021-07-09 20:21:27 +02:00
return true ;
}
2021-06-21 21:09:00 +02:00
2021-07-09 20:21:27 +02:00
// Update the path if the base node has changed and has not been deleted.
Map < Node * , NodePath > : : Element * found_root_path = p_renames - > find ( p_root_node ) ;
if ( found_root_path ) {
NodePath root_path_new = found_root_path - > get ( ) ;
if ( ! root_path_new . is_empty ( ) ) {
NodePath old_abs_path = NodePath ( String ( p_root_node - > get_path ( ) ) . plus_file ( r_node_path ) ) ;
old_abs_path . simplify ( ) ;
r_node_path = root_path_new . rel_path_to ( old_abs_path ) ;
2021-06-21 21:09:00 +02:00
}
2021-07-09 20:21:27 +02:00
return true ;
2021-06-21 21:09:00 +02:00
}
return false ;
}
2021-07-09 20:21:27 +02:00
bool SceneTreeDock : : _check_node_path_recursive ( Node * p_root_node , Variant & r_variant , Map < Node * , NodePath > * p_renames ) const {
2021-06-30 20:50:40 +02:00
switch ( r_variant . get_type ( ) ) {
2021-06-21 21:09:00 +02:00
case Variant : : NODE_PATH : {
2021-06-30 20:50:40 +02:00
NodePath node_path = r_variant ;
2021-07-09 20:21:27 +02:00
if ( ! node_path . is_empty ( ) & & _update_node_path ( p_root_node , node_path , p_renames ) ) {
2021-06-30 20:50:40 +02:00
r_variant = node_path ;
2021-06-21 21:09:00 +02:00
return true ;
}
} break ;
case Variant : : ARRAY : {
2021-06-30 20:50:40 +02:00
Array a = r_variant ;
2021-06-21 21:09:00 +02:00
bool updated = false ;
for ( int i = 0 ; i < a . size ( ) ; i + + ) {
Variant value = a [ i ] ;
2021-07-09 20:21:27 +02:00
if ( _check_node_path_recursive ( p_root_node , value , p_renames ) ) {
2021-06-21 21:09:00 +02:00
if ( ! updated ) {
a = a . duplicate ( ) ; // Need to duplicate for undo-redo to work.
updated = true ;
}
a [ i ] = value ;
}
}
if ( updated ) {
2021-06-30 20:50:40 +02:00
r_variant = a ;
2021-06-21 21:09:00 +02:00
return true ;
}
} break ;
case Variant : : DICTIONARY : {
2021-06-30 20:50:40 +02:00
Dictionary d = r_variant ;
2021-06-21 21:09:00 +02:00
bool updated = false ;
for ( int i = 0 ; i < d . size ( ) ; i + + ) {
Variant value = d . get_value_at_index ( i ) ;
2021-07-09 20:21:27 +02:00
if ( _check_node_path_recursive ( p_root_node , value , p_renames ) ) {
2021-06-21 21:09:00 +02:00
if ( ! updated ) {
d = d . duplicate ( ) ; // Need to duplicate for undo-redo to work.
updated = true ;
}
d [ d . get_key_at_index ( i ) ] = value ;
}
}
if ( updated ) {
2021-06-30 20:50:40 +02:00
r_variant = d ;
2021-06-21 21:09:00 +02:00
return true ;
}
} break ;
default : {
}
}
return false ;
}
2021-07-09 20:21:27 +02:00
void SceneTreeDock : : perform_node_renames ( Node * p_base , Map < Node * , NodePath > * p_renames , Map < Ref < Animation > , Set < int > > * r_rem_anims ) {
2020-03-17 07:33:00 +01:00
Map < Ref < Animation > , Set < int > > rem_anims ;
2020-05-14 16:41:43 +02:00
if ( ! r_rem_anims ) {
2017-03-05 16:44:50 +01:00
r_rem_anims = & rem_anims ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
if ( ! p_base ) {
2017-03-05 16:44:50 +01:00
p_base = edited_scene ;
2014-02-10 02:10:30 +01:00
}
2020-05-14 16:41:43 +02:00
if ( ! p_base ) {
2014-02-10 02:10:30 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2021-07-09 20:21:27 +02:00
// No renaming if base node is deleted.
Map < Node * , NodePath > : : Element * found_base_path = p_renames - > find ( p_base ) ;
if ( found_base_path & & found_base_path - > get ( ) . is_empty ( ) ) {
return ;
}
2021-06-21 21:09:00 +02:00
// Renaming node paths used in node properties.
List < PropertyInfo > properties ;
p_base - > get_property_list ( & properties ) ;
2020-09-24 18:14:21 +02:00
2021-07-24 15:46:25 +02:00
for ( const PropertyInfo & E : properties ) {
2021-07-16 05:45:57 +02:00
if ( ! ( E . usage & ( PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_EDITOR ) ) ) {
2021-06-21 21:09:00 +02:00
continue ;
}
2021-07-16 05:45:57 +02:00
String propertyname = E . name ;
2021-06-21 21:09:00 +02:00
Variant old_variant = p_base - > get ( propertyname ) ;
Variant updated_variant = old_variant ;
2021-07-09 20:21:27 +02:00
if ( _check_node_path_recursive ( p_base , updated_variant , p_renames ) ) {
2021-06-21 21:09:00 +02:00
editor_data - > get_undo_redo ( ) . add_do_property ( p_base , propertyname , updated_variant ) ;
editor_data - > get_undo_redo ( ) . add_undo_property ( p_base , propertyname , old_variant ) ;
p_base - > set ( propertyname , updated_variant ) ;
2018-03-23 10:44:39 +01:00
}
}
bool autorename_animation_tracks = bool ( EDITOR_DEF ( " editors/animation/autorename_animation_tracks " , true ) ) ;
if ( autorename_animation_tracks & & Object : : cast_to < AnimationPlayer > ( p_base ) ) {
2017-08-24 22:58:51 +02:00
AnimationPlayer * ap = Object : : cast_to < AnimationPlayer > ( p_base ) ;
2014-02-10 02:10:30 +01:00
List < StringName > anims ;
ap - > get_animation_list ( & anims ) ;
Node * root = ap - > get_node ( ap - > get_root ( ) ) ;
if ( root ) {
2021-07-09 20:21:27 +02:00
Map < Node * , NodePath > : : Element * found_root_path = p_renames - > find ( root ) ;
NodePath new_root_path = found_root_path ? found_root_path - > get ( ) : root - > get_path ( ) ;
if ( ! new_root_path . is_empty ( ) ) { // No renaming if root node is deleted.
2021-07-24 15:46:25 +02:00
for ( const StringName & E : anims ) {
2021-07-16 05:45:57 +02:00
Ref < Animation > anim = ap - > get_animation ( E ) ;
2014-02-10 02:10:30 +01:00
if ( ! r_rem_anims - > has ( anim ) ) {
2017-03-05 16:44:50 +01:00
r_rem_anims - > insert ( anim , Set < int > ( ) ) ;
2014-02-10 02:10:30 +01:00
Set < int > & ran = r_rem_anims - > find ( anim ) - > get ( ) ;
2020-05-14 16:41:43 +02:00
for ( int i = 0 ; i < anim - > get_track_count ( ) ; i + + ) {
2014-02-10 02:10:30 +01:00
ran . insert ( i ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
}
Set < int > & ran = r_rem_anims - > find ( anim ) - > get ( ) ;
2020-05-14 16:41:43 +02:00
if ( anim . is_null ( ) ) {
2014-02-10 02:10:30 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < anim - > get_track_count ( ) ; i + + ) {
NodePath track_np = anim - > track_get_path ( i ) ;
2014-02-10 02:10:30 +01:00
Node * n = root - > get_node ( track_np ) ;
if ( ! n ) {
continue ;
}
2020-05-14 16:41:43 +02:00
if ( ! ran . has ( i ) ) {
2014-02-10 02:10:30 +01:00
continue ; //channel was removed
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2021-07-09 20:21:27 +02:00
Map < Node * , NodePath > : : Element * found_path = p_renames - > find ( n ) ;
if ( found_path ) {
if ( found_path - > get ( ) = = 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 ( found_path - > get ( ) ) ;
NodePath new_path = NodePath ( rel_path . get_names ( ) , track_np . get_subnames ( ) , false ) ;
if ( new_path = = track_np ) {
continue ; //bleh
2014-02-10 02:10:30 +01:00
}
2021-07-09 20:21:27 +02:00
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 ) ;
2014-02-10 02:10:30 +01:00
}
}
}
}
}
}
}
2020-05-14 16:41:43 +02:00
for ( int i = 0 ; i < p_base - > get_child_count ( ) ; i + + ) {
2017-03-05 16:44:50 +01:00
perform_node_renames ( p_base - > get_child ( i ) , p_renames , r_rem_anims ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _node_prerenamed ( Node * p_node , const String & p_new_name ) {
2021-07-09 20:21:27 +02:00
Map < Node * , NodePath > path_renames ;
2014-02-10 02:10:30 +01:00
Vector < StringName > base_path ;
Node * n = p_node - > get_parent ( ) ;
2017-03-05 16:44:50 +01:00
while ( n ) {
2014-02-10 02:10:30 +01:00
base_path . push_back ( n - > get_name ( ) ) ;
2017-03-05 16:44:50 +01:00
n = n - > get_parent ( ) ;
2014-02-10 02:10:30 +01:00
}
2021-03-14 08:21:32 +01:00
base_path . reverse ( ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
Vector < StringName > new_base_path = base_path ;
2014-02-10 02:10:30 +01:00
base_path . push_back ( p_node - > get_name ( ) ) ;
new_base_path . push_back ( p_new_name ) ;
2021-07-09 20:21:27 +02:00
NodePath new_path ( new_base_path , true ) ;
path_renames [ p_node ] = new_path ;
2014-02-10 02:10:30 +01:00
2020-05-14 16:41:43 +02:00
for ( int i = 0 ; i < p_node - > get_child_count ( ) ; i + + ) {
2017-03-05 16:44:50 +01:00
_fill_path_renames ( base_path , new_base_path , p_node - > get_child ( i ) , & path_renames ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2020-04-02 01:20:12 +02:00
perform_node_renames ( nullptr , & path_renames ) ;
2014-02-10 02:10:30 +01:00
}
2014-09-03 04:13:40 +02:00
bool SceneTreeDock : : _validate_no_foreign ( ) {
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2014-09-03 04:13:40 +02:00
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
if ( E ! = edited_scene & & E - > get_owner ( ) ! = edited_scene ) {
2016-05-04 03:25:37 +02:00
accept - > set_text ( TTR ( " Can't operate on nodes from a foreign scene! " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2014-09-03 04:13:40 +02:00
return false ;
}
2015-10-10 14:09:09 +02:00
2018-10-23 21:55:25 +02:00
// When edited_scene inherits from another one the root Node will be the parent Scene,
// we don't want to consider that Node a foreign one otherwise we would not be able to
2019-09-15 02:07:55 +02:00
// delete it.
2021-07-16 05:45:57 +02:00
if ( edited_scene - > get_scene_inherited_state ( ) . is_valid ( ) & & edited_scene = = E ) {
2018-10-23 21:55:25 +02:00
continue ;
}
2021-07-16 05:45:57 +02:00
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 ) ) > = 0 ) {
2016-05-04 03:25:37 +02:00
accept - > set_text ( TTR ( " Can't operate on nodes the current scene inherits from! " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-10-10 14:09:09 +02:00
return false ;
}
2014-09-03 04:13:40 +02:00
}
return true ;
}
2021-02-22 20:18:14 +01:00
bool SceneTreeDock : : _validate_no_instance ( ) {
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
if ( E ! = edited_scene & & E - > get_filename ( ) ! = " " ) {
2021-06-18 00:03:09 +02:00
accept - > set_text ( TTR ( " This operation can't be done on instantiated scenes. " ) ) ;
2021-02-22 20:18:14 +01:00
accept - > popup_centered ( ) ;
return false ;
}
}
return true ;
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _node_reparent ( NodePath p_path , bool p_keep_global_xform ) {
2014-02-10 02:10:30 +01:00
Node * new_parent = scene_root - > get_node ( p_path ) ;
ERR_FAIL_COND ( ! new_parent ) ;
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2016-05-11 16:46:08 +02:00
2020-12-15 13:04:21 +01:00
if ( selection . is_empty ( ) ) {
2019-09-15 02:07:55 +02:00
return ; // Nothing to reparent.
2020-05-14 16:41:43 +02:00
}
2016-05-11 16:46:08 +02:00
2017-03-05 16:44:50 +01:00
Vector < Node * > nodes ;
2016-05-11 16:46:08 +02:00
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
nodes . push_back ( E ) ;
2016-05-11 16:46:08 +02:00
}
2017-03-05 16:44:50 +01:00
_do_reparent ( new_parent , - 1 , nodes , p_keep_global_xform ) ;
2016-05-11 16:46:08 +02:00
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _do_reparent ( Node * p_new_parent , int p_position_in_parent , Vector < Node * > p_nodes , bool p_keep_global_xform ) {
2016-05-11 16:46:08 +02:00
Node * new_parent = p_new_parent ;
ERR_FAIL_COND ( ! new_parent ) ;
2020-05-14 16:41:43 +02:00
if ( p_nodes . size ( ) = = 0 ) {
2019-09-15 02:07:55 +02:00
return ; // Nothing to reparent.
2020-05-14 16:41:43 +02:00
}
2019-09-15 02:07:55 +02:00
2019-09-22 12:44:59 +02:00
p_nodes . sort_custom < Node : : Comparator > ( ) ; //Makes result reliable.
bool no_change = true ;
2019-09-15 02:07:55 +02:00
for ( int ni = 0 ; ni < p_nodes . size ( ) ; ni + + ) {
2020-05-14 16:41:43 +02:00
if ( p_nodes [ ni ] = = p_new_parent ) {
2019-09-15 02:07:55 +02:00
return ; // Attempt to reparent to itself.
2020-05-14 16:41:43 +02:00
}
2019-09-15 02:07:55 +02:00
2020-05-14 16:41:43 +02:00
if ( p_nodes [ ni ] - > get_parent ( ) ! = p_new_parent | | p_position_in_parent + ni ! = p_nodes [ ni ] - > get_index ( ) ) {
2019-09-22 12:44:59 +02:00
no_change = false ;
2020-05-14 16:41:43 +02:00
}
2019-09-15 02:07:55 +02:00
}
2020-05-14 16:41:43 +02:00
if ( no_change ) {
2019-09-22 12:44:59 +02:00
return ; // Position and parent didn't change.
2020-05-14 16:41:43 +02:00
}
2019-09-15 02:07:55 +02:00
2017-03-05 16:44:50 +01:00
Node * validate = new_parent ;
while ( validate ) {
2019-09-15 02:07:55 +02:00
ERR_FAIL_COND_MSG ( p_nodes . find ( validate ) ! = - 1 , " Selection changed at some point. Can't reparent. " ) ;
2017-03-05 16:44:50 +01:00
validate = validate - > get_parent ( ) ;
2014-02-10 02:10:30 +01:00
}
2019-09-15 02:07:55 +02:00
// Sort by tree order, so re-adding is easy.
2016-05-11 16:46:08 +02:00
p_nodes . sort_custom < Node : : Comparator > ( ) ;
2014-02-10 02:10:30 +01:00
2016-05-04 03:25:37 +02:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Reparent Node " ) ) ;
2014-02-10 02:10:30 +01:00
2021-07-09 20:21:27 +02:00
Map < Node * , NodePath > path_renames ;
2016-10-08 20:37:05 +02:00
Vector < StringName > former_names ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
int inc = 0 ;
2016-07-01 04:19:44 +02:00
2017-03-05 16:44:50 +01:00
for ( int ni = 0 ; ni < p_nodes . size ( ) ; ni + + ) {
2019-09-15 02:07:55 +02:00
// No undo implemented for this yet.
2016-05-11 16:46:08 +02:00
Node * node = p_nodes [ ni ] ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
fill_path_renames ( node , new_parent , & path_renames ) ;
2016-10-08 20:37:05 +02:00
former_names . push_back ( node - > get_name ( ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
List < Node * > owned ;
node - > get_owned_by ( node - > get_owner ( ) , & owned ) ;
2014-02-10 02:10:30 +01:00
Array owners ;
2021-07-16 05:45:57 +02:00
for ( Node * E : owned ) {
owners . push_back ( E ) ;
2014-02-10 02:10:30 +01:00
}
2020-05-14 16:41:43 +02:00
if ( new_parent = = node - > get_parent ( ) & & node - > get_index ( ) < p_position_in_parent + ni ) {
2019-09-15 02:07:55 +02:00
inc - - ; // If the child will generate a gap when moved, adjust.
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2015-08-02 17:29:37 +02:00
2020-05-14 16:41:43 +02:00
if ( p_position_in_parent > = 0 ) {
2017-03-05 16:44:50 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( new_parent , " move_child " , node , p_position_in_parent + inc ) ;
2020-05-14 16:41:43 +02:00
}
2016-05-11 16:46:08 +02:00
2020-02-07 02:52:05 +01:00
EditorDebuggerNode * ed = EditorDebuggerNode : : get_singleton ( ) ;
2018-03-23 10:44:39 +01:00
String old_name = former_names [ ni ] ;
2016-10-07 20:25:29 +02:00
String new_name = new_parent - > validate_child_name ( node ) ;
2018-03-23 10:44:39 +01:00
2019-09-15 02:07:55 +02:00
// Name was modified, fix the path renames.
2018-03-23 10:44:39 +01:00
if ( old_name . casecmp_to ( new_name ) ! = 0 ) {
2019-09-15 02:07:55 +02:00
// Fix the to name to have the new name.
2021-07-09 20:21:27 +02:00
Map < Node * , NodePath > : : Element * found_path = path_renames . find ( node ) ;
if ( found_path ) {
NodePath old_new_name = found_path - > get ( ) ;
2018-03-23 10:44:39 +01:00
2021-07-09 20:21:27 +02:00
Vector < StringName > unfixed_new_names = old_new_name . get_names ( ) ;
Vector < StringName > fixed_new_names ;
2018-03-23 10:44:39 +01:00
2021-07-09 20:21:27 +02:00
// Get last name and replace with fixed new name.
for ( int a = 0 ; a < ( unfixed_new_names . size ( ) - 1 ) ; a + + ) {
fixed_new_names . push_back ( unfixed_new_names [ a ] ) ;
}
fixed_new_names . push_back ( new_name ) ;
2018-03-23 10:44:39 +01:00
2021-07-09 20:21:27 +02:00
NodePath fixed_node_path = NodePath ( fixed_new_names , true ) ;
path_renames [ node ] = fixed_node_path ;
} else {
ERR_PRINT ( " Internal error. Can't find renamed path for node ' " + node - > get_path ( ) + " ' " ) ;
}
2018-03-23 10:44:39 +01:00
}
2020-02-07 02:52:05 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( ed , " live_debug_reparent_node " , edited_scene - > get_path_to ( node ) , edited_scene - > get_path_to ( new_parent ) , new_name , p_position_in_parent + inc ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( ed , " live_debug_reparent_node " , NodePath ( String ( edited_scene - > get_path_to ( new_parent ) ) . plus_file ( new_name ) ) , edited_scene - > get_path_to ( node - > get_parent ( ) ) , node - > get_name ( ) , node - > get_index ( ) ) ;
2015-08-02 17:29:37 +02:00
2016-01-02 15:57:47 +01:00
if ( p_keep_global_xform ) {
2020-05-14 16:41:43 +02:00
if ( Object : : cast_to < Node2D > ( node ) ) {
2017-08-24 22:58:51 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( node , " set_global_transform " , Object : : cast_to < Node2D > ( node ) - > get_global_transform ( ) ) ;
2020-05-14 16:41:43 +02:00
}
if ( Object : : cast_to < Node3D > ( node ) ) {
2020-03-26 22:49:16 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( node , " set_global_transform " , Object : : cast_to < Node3D > ( node ) - > get_global_transform ( ) ) ;
2020-05-14 16:41:43 +02:00
}
if ( Object : : cast_to < Control > ( node ) ) {
2017-08-24 22:58:51 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( node , " set_global_position " , Object : : cast_to < Control > ( node ) - > get_global_position ( ) ) ;
2020-05-14 16:41:43 +02:00
}
2016-01-02 15:57:47 +01:00
}
2015-08-02 17:29:37 +02:00
2017-03-05 16:44:50 +01:00
editor_data - > get_undo_redo ( ) . add_do_method ( this , " _set_owners " , edited_scene , owners ) ;
2014-02-10 02:10:30 +01:00
2020-05-14 16:41:43 +02:00
if ( AnimationPlayerEditor : : singleton - > get_track_editor ( ) - > get_root ( ) = = node ) {
2018-06-07 17:46:14 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( AnimationPlayerEditor : : singleton - > get_track_editor ( ) , " set_root " , node ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ] ) ;
2014-02-10 02:10:30 +01:00
2016-07-01 04:19:44 +02:00
inc + + ;
2014-02-10 02:10:30 +01:00
}
2019-09-15 02:07:55 +02:00
// Add and move in a second step (so old order is preserved).
2017-03-05 16:44:50 +01:00
for ( int ni = 0 ; ni < p_nodes . size ( ) ; ni + + ) {
2016-05-11 16:46:08 +02:00
Node * node = p_nodes [ ni ] ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
List < Node * > owned ;
node - > get_owned_by ( node - > get_owner ( ) , & owned ) ;
2014-02-10 02:10:30 +01:00
Array owners ;
2021-07-16 05:45:57 +02:00
for ( Node * E : owned ) {
owners . push_back ( E ) ;
2014-02-10 02:10:30 +01:00
}
2020-04-06 01:06:10 +02:00
int child_pos = node - > get_index ( ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
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 ) ;
2020-05-14 16:41:43 +02:00
if ( AnimationPlayerEditor : : singleton - > get_track_editor ( ) - > get_root ( ) = = node ) {
2018-06-07 17:46:14 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( AnimationPlayerEditor : : singleton - > get_track_editor ( ) , " set_root " , node ) ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2016-01-02 15:57:47 +01:00
if ( p_keep_global_xform ) {
2020-05-14 16:41:43 +02:00
if ( Object : : cast_to < Node2D > ( node ) ) {
2017-08-24 22:58:51 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node , " set_transform " , Object : : cast_to < Node2D > ( node ) - > get_transform ( ) ) ;
2020-05-14 16:41:43 +02:00
}
if ( Object : : cast_to < Node3D > ( node ) ) {
2020-03-26 22:49:16 +01:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node , " set_transform " , Object : : cast_to < Node3D > ( node ) - > get_transform ( ) ) ;
2020-05-14 16:41:43 +02:00
}
if ( Object : : cast_to < Control > ( node ) ) {
2017-08-24 22:58:51 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( node , " set_position " , Object : : cast_to < Control > ( node ) - > get_position ( ) ) ;
2020-05-14 16:41:43 +02:00
}
2016-01-02 15:57:47 +01:00
}
2014-02-10 02:10:30 +01:00
}
2020-04-02 01:20:12 +02:00
perform_node_renames ( nullptr , & path_renames ) ;
2014-02-10 02:10:30 +01:00
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
}
2018-07-07 16:51:18 +02:00
bool SceneTreeDock : : _is_collapsed_recursive ( TreeItem * p_item ) const {
bool is_branch_collapsed = false ;
List < TreeItem * > needs_check ;
needs_check . push_back ( p_item ) ;
2020-12-15 13:04:21 +01:00
while ( ! needs_check . is_empty ( ) ) {
2018-07-07 16:51:18 +02:00
TreeItem * item = needs_check . back ( ) - > get ( ) ;
needs_check . pop_back ( ) ;
2021-03-07 21:07:30 +01:00
TreeItem * child = item - > get_first_child ( ) ;
2018-07-07 16:51:18 +02:00
is_branch_collapsed = item - > is_collapsed ( ) & & child ;
if ( is_branch_collapsed ) {
break ;
}
while ( child ) {
needs_check . push_back ( child ) ;
child = child - > get_next ( ) ;
}
}
return is_branch_collapsed ;
}
void SceneTreeDock : : _set_collapsed_recursive ( TreeItem * p_item , bool p_collapsed ) {
List < TreeItem * > to_collapse ;
to_collapse . push_back ( p_item ) ;
2020-12-15 13:04:21 +01:00
while ( ! to_collapse . is_empty ( ) ) {
2018-07-07 16:51:18 +02:00
TreeItem * item = to_collapse . back ( ) - > get ( ) ;
to_collapse . pop_back ( ) ;
item - > set_collapsed ( p_collapsed ) ;
2021-03-07 21:07:30 +01:00
TreeItem * child = item - > get_first_child ( ) ;
2018-07-07 16:51:18 +02:00
while ( child ) {
to_collapse . push_back ( child ) ;
child = child - > get_next ( ) ;
}
}
}
2014-02-10 02:10:30 +01:00
void SceneTreeDock : : _script_created ( Ref < Script > p_script ) {
2018-03-07 20:08:13 +01:00
List < Node * > selected = editor_selection - > get_selected_node_list ( ) ;
2020-12-15 13:04:21 +01:00
if ( selected . is_empty ( ) ) {
2014-02-10 02:10:30 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-03-07 20:08:13 +01:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Attach Script " ) ) ;
2021-07-16 05:45:57 +02:00
for ( Node * E : selected ) {
Ref < Script > existing = E - > get_script ( ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( E , " set_script " , p_script ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( E , " set_script " , existing ) ;
2019-05-14 03:58:41 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( this , " _update_script_button " ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( this , " _update_script_button " ) ;
2018-03-07 20:08:13 +01:00
}
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2018-07-25 21:43:17 +02:00
editor - > push_item ( p_script . operator - > ( ) ) ;
2018-10-25 20:33:16 +02:00
_update_script_button ( ) ;
2014-02-10 02:10:30 +01:00
}
2019-06-30 05:19:45 +02:00
void SceneTreeDock : : _script_creation_closed ( ) {
2020-02-21 18:28:45 +01:00
script_create_dialog - > disconnect ( " script_created " , callable_mp ( this , & SceneTreeDock : : _script_created ) ) ;
2020-10-26 23:26:44 +01:00
script_create_dialog - > disconnect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _script_creation_closed ) ) ;
script_create_dialog - > disconnect ( " cancelled " , callable_mp ( this , & SceneTreeDock : : _script_creation_closed ) ) ;
2019-06-30 05:19:45 +02:00
}
2019-05-14 02:11:06 +02:00
void SceneTreeDock : : _toggle_editable_children_from_selection ( ) {
2018-09-13 00:49:12 +02:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
List < Node * > : : Element * e = selection . front ( ) ;
2019-05-14 02:11:06 +02:00
if ( e ) {
_toggle_editable_children ( e - > get ( ) ) ;
}
}
2018-09-13 00:49:12 +02:00
2019-09-04 21:02:26 +02:00
void SceneTreeDock : : _toggle_placeholder_from_selection ( ) {
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
List < Node * > : : Element * e = selection . front ( ) ;
if ( e ) {
Node * node = e - > get ( ) ;
if ( node ) {
_toggle_editable_children ( node ) ;
bool placeholder = node - > get_scene_instance_load_placeholder ( ) ;
placeholder = ! placeholder ;
node - > set_scene_instance_load_placeholder ( placeholder ) ;
scene_tree - > update_tree ( ) ;
}
}
}
2019-05-14 02:11:06 +02:00
void SceneTreeDock : : _toggle_editable_children ( Node * p_node ) {
if ( p_node ) {
bool editable = ! EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > is_editable_instance ( p_node ) ;
EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > set_editable_instance ( p_node , editable ) ;
2020-05-14 16:41:43 +02:00
if ( editable ) {
2019-05-14 02:11:06 +02:00
p_node - > set_scene_instance_load_placeholder ( false ) ;
2020-05-14 16:41:43 +02:00
}
2018-09-13 00:49:12 +02:00
2020-03-26 22:49:16 +01:00
Node3DEditor : : get_singleton ( ) - > update_all_gizmos ( p_node ) ;
2018-09-13 00:49:12 +02:00
2019-05-14 02:11:06 +02:00
scene_tree - > update_tree ( ) ;
2018-09-13 00:49:12 +02:00
}
}
2020-01-07 17:43:21 +01:00
void SceneTreeDock : : _delete_confirm ( bool p_cut ) {
2017-03-05 16:44:50 +01:00
List < Node * > remove_list = editor_selection - > get_selected_node_list ( ) ;
2014-02-10 02:10:30 +01:00
2020-12-15 13:04:21 +01:00
if ( remove_list . is_empty ( ) ) {
2014-02-10 02:10:30 +01:00
return ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2016-03-30 01:02:53 +02:00
editor - > get_editor_plugins_over ( ) - > make_visible ( false ) ;
2014-02-10 02:10:30 +01:00
2020-01-07 17:43:21 +01:00
if ( p_cut ) {
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Cut Node(s) " ) ) ;
} else {
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Remove Node(s) " ) ) ;
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
bool entire_scene = false ;
2014-02-10 02:10:30 +01:00
2021-07-16 05:45:57 +02:00
for ( Node * E : remove_list ) {
if ( E = = edited_scene ) {
2017-03-05 16:44:50 +01:00
entire_scene = true ;
2014-02-10 02:10:30 +01:00
}
}
if ( entire_scene ) {
2020-04-02 01:20:12 +02:00
editor_data - > get_undo_redo ( ) . add_do_method ( editor , " set_edited_scene " , ( Object * ) nullptr ) ;
2017-03-05 16:44:50 +01:00
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 ( ) ) ;
2017-11-12 17:12:53 +01:00
editor_data - > get_undo_redo ( ) . add_undo_method ( scene_tree , " update_tree " ) ;
2014-02-10 02:10:30 +01:00
editor_data - > get_undo_redo ( ) . add_undo_reference ( edited_scene ) ;
} else {
remove_list . sort_custom < Node : : Comparator > ( ) ; //sort nodes to keep positions
2021-07-09 20:21:27 +02:00
Map < Node * , NodePath > path_renames ;
2014-02-10 02:10:30 +01:00
//delete from animation
2021-07-16 05:45:57 +02:00
for ( Node * n : remove_list ) {
2020-05-14 16:41:43 +02:00
if ( ! n - > is_inside_tree ( ) | | ! n - > get_parent ( ) ) {
2014-02-10 02:10:30 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2020-04-02 01:20:12 +02:00
fill_path_renames ( n , nullptr , & path_renames ) ;
2014-02-10 02:10:30 +01:00
}
2020-04-02 01:20:12 +02:00
perform_node_renames ( nullptr , & path_renames ) ;
2014-02-10 02:10:30 +01:00
//delete for read
2021-07-16 05:45:57 +02:00
for ( Node * n : remove_list ) {
2020-05-14 16:41:43 +02:00
if ( ! n - > is_inside_tree ( ) | | ! n - > get_parent ( ) ) {
2014-02-10 02:10:30 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
List < Node * > owned ;
n - > get_owned_by ( n - > get_owner ( ) , & owned ) ;
2014-02-10 02:10:30 +01:00
Array owners ;
2021-07-16 05:45:57 +02:00
for ( Node * F : owned ) {
owners . push_back ( F ) ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
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 ( ) ) ;
2020-05-14 16:41:43 +02:00
if ( AnimationPlayerEditor : : singleton - > get_track_editor ( ) - > get_root ( ) = = n ) {
2018-06-07 17:46:14 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( AnimationPlayerEditor : : singleton - > get_track_editor ( ) , " set_root " , n ) ;
2020-05-14 16:41:43 +02:00
}
2017-03-05 16:44:50 +01:00
editor_data - > get_undo_redo ( ) . add_undo_method ( this , " _set_owners " , edited_scene , owners ) ;
2014-02-10 02:10:30 +01:00
editor_data - > get_undo_redo ( ) . add_undo_reference ( n ) ;
2015-08-02 17:29:37 +02:00
2020-02-07 02:52:05 +01:00
EditorDebuggerNode * ed = EditorDebuggerNode : : get_singleton ( ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( ed , " live_debug_remove_and_keep_node " , edited_scene - > get_path_to ( n ) , n - > get_instance_id ( ) ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( ed , " live_debug_restore_node " , n - > get_instance_id ( ) , edited_scene - > get_path_to ( n - > get_parent ( ) ) , n - > get_index ( ) ) ;
2014-02-10 02:10:30 +01:00
}
}
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2017-11-08 03:10:31 +01:00
// hack, force 2d editor viewport to refresh after deletion
2020-05-14 16:41:43 +02:00
if ( CanvasItemEditor * editor = CanvasItemEditor : : get_singleton ( ) ) {
2017-11-08 03:10:31 +01:00
editor - > get_viewport_control ( ) - > update ( ) ;
2020-05-14 16:41:43 +02:00
}
2017-11-08 03:10:31 +01:00
2020-04-02 01:20:12 +02:00
editor - > push_item ( nullptr ) ;
2018-01-08 06:50:51 +01:00
// Fixes the EditorHistory from still offering deleted notes
EditorHistory * editor_history = EditorNode : : get_singleton ( ) - > get_editor_history ( ) ;
editor_history - > cleanup_history ( ) ;
2018-10-01 12:15:22 +02:00
EditorNode : : get_singleton ( ) - > get_inspector_dock ( ) - > call ( " _prepare_history " ) ;
2016-05-17 23:27:15 +02:00
}
2015-08-25 05:08:45 +02:00
2018-01-11 21:58:17 +01:00
void SceneTreeDock : : _update_script_button ( ) {
2019-04-09 00:18:03 +02:00
if ( ! profile_allow_script_editing ) {
button_create_script - > hide ( ) ;
2020-05-09 18:59:19 +02:00
button_detach_script - > hide ( ) ;
2019-04-09 00:18:03 +02:00
} else if ( EditorNode : : get_singleton ( ) - > get_editor_selection ( ) - > get_selection ( ) . size ( ) = = 0 ) {
2019-01-02 11:40:23 +01:00
button_create_script - > hide ( ) ;
2020-05-09 18:59:19 +02:00
button_detach_script - > hide ( ) ;
2019-01-02 11:40:23 +01:00
} else if ( EditorNode : : get_singleton ( ) - > get_editor_selection ( ) - > get_selection ( ) . size ( ) = = 1 ) {
2018-10-19 16:04:07 +02:00
Node * n = EditorNode : : get_singleton ( ) - > get_editor_selection ( ) - > get_selected_node_list ( ) [ 0 ] ;
if ( n - > get_script ( ) . is_null ( ) ) {
2018-10-25 20:33:16 +02:00
button_create_script - > show ( ) ;
2020-05-09 18:59:19 +02:00
button_detach_script - > hide ( ) ;
2018-10-19 16:04:07 +02:00
} else {
2018-10-25 20:33:16 +02:00
button_create_script - > hide ( ) ;
2020-05-09 18:59:19 +02:00
button_detach_script - > show ( ) ;
2018-10-19 16:04:07 +02:00
}
2016-08-08 00:22:33 +02:00
} else {
2019-03-06 05:19:34 +01:00
button_create_script - > hide ( ) ;
2019-03-06 07:11:02 +01:00
Array selection = editor_selection - > get_selected_nodes ( ) ;
for ( int i = 0 ; i < selection . size ( ) ; i + + ) {
Node * n = Object : : cast_to < Node > ( selection [ i ] ) ;
2019-01-02 11:40:23 +01:00
if ( ! n - > get_script ( ) . is_null ( ) ) {
2020-05-09 18:59:19 +02:00
button_detach_script - > show ( ) ;
2019-01-02 11:40:23 +01:00
return ;
}
}
2020-05-09 18:59:19 +02:00
button_detach_script - > hide ( ) ;
2016-08-08 00:22:33 +02:00
}
2015-08-25 05:08:45 +02:00
}
2018-01-11 21:58:17 +01:00
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 ) ;
2019-10-18 20:00:09 +02:00
} else if ( selection_size = = 0 ) {
2020-04-02 01:20:12 +02:00
editor - > push_item ( nullptr ) ;
2018-01-11 21:58:17 +01:00
}
2019-10-18 20:00:09 +02:00
2018-01-11 21:58:17 +01:00
_update_script_button ( ) ;
}
2018-09-12 20:47:12 +02:00
void SceneTreeDock : : _do_create ( Node * p_parent ) {
2021-01-06 20:25:05 +01:00
Variant c = create_dialog - > instance_selected ( ) ;
2018-09-12 20:47:12 +02:00
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 ( p_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 ( p_parent , " remove_child " , child ) ;
String new_name = p_parent - > validate_child_name ( child ) ;
2020-02-07 02:52:05 +01:00
EditorDebuggerNode * ed = EditorDebuggerNode : : get_singleton ( ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( ed , " live_debug_create_node " , edited_scene - > get_path_to ( p_parent ) , child - > get_class ( ) , new_name ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( ed , " live_debug_remove_node " , NodePath ( String ( edited_scene - > get_path_to ( p_parent ) ) . plus_file ( new_name ) ) ) ;
2018-09-12 20:47:12 +02:00
} 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 ) ;
2020-04-02 01:20:12 +02:00
editor_data - > get_undo_redo ( ) . add_undo_method ( editor , " set_edited_scene " , ( Object * ) nullptr ) ;
2018-09-12 20:47:12 +02:00
}
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 ( ) ;
2020-05-14 16:41:43 +02:00
if ( ms . width < 4 ) {
2018-09-12 20:47:12 +02:00
ms . width = 40 ;
2020-05-14 16:41:43 +02:00
}
if ( ms . height < 4 ) {
2018-09-12 20:47:12 +02:00
ms . height = 40 ;
2020-05-14 16:41:43 +02:00
}
2020-09-03 13:22:16 +02:00
if ( ct - > is_layout_rtl ( ) ) {
ct - > set_position ( ct - > get_position ( ) - Vector2 ( ms . x , 0 ) ) ;
}
2018-09-12 20:47:12 +02:00
ct - > set_size ( ms ) ;
}
2020-08-25 01:32:58 +02:00
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " node_created " ) , c ) ;
2018-09-12 20:47:12 +02:00
}
2014-02-10 02:10:30 +01:00
void SceneTreeDock : : _create ( ) {
2017-03-05 16:44:50 +01:00
if ( current_option = = TOOL_NEW ) {
2020-04-02 01:20:12 +02:00
Node * parent = nullptr ;
2014-02-10 02:10:30 +01:00
if ( edited_scene ) {
2015-03-31 20:26:38 +02:00
// If root exists in edited scene
2014-02-10 02:10:30 +01:00
parent = scene_tree - > get_selected ( ) ;
2020-05-14 16:41:43 +02:00
if ( ! parent ) {
2015-03-31 20:26:38 +02:00
parent = edited_scene ;
2020-05-14 16:41:43 +02:00
}
2014-02-10 02:10:30 +01:00
2015-03-31 20:26:38 +02:00
} else {
// If no root exist in edited scene
2014-02-10 02:10:30 +01:00
parent = scene_root ;
ERR_FAIL_COND ( ! parent ) ;
}
2018-09-12 20:47:12 +02:00
_do_create ( parent ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
} else if ( current_option = = TOOL_REPLACE ) {
2017-12-15 04:01:25 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
ERR_FAIL_COND ( selection . size ( ) < = 0 ) ;
2019-08-09 16:31:31 +02:00
UndoRedo * ur = EditorNode : : get_singleton ( ) - > get_undo_redo ( ) ;
ur - > create_action ( TTR ( " Change type of node(s) " ) ) ;
2021-07-16 05:45:57 +02:00
for ( Node * n : selection ) {
2017-12-15 04:01:25 +01:00
ERR_FAIL_COND ( ! n ) ;
2014-02-10 02:10:30 +01:00
2021-01-06 20:25:05 +01:00
Variant c = create_dialog - > instance_selected ( ) ;
2014-02-10 02:10:30 +01:00
2017-12-15 04:01:25 +01:00
ERR_FAIL_COND ( ! c ) ;
Node * newnode = Object : : cast_to < Node > ( c ) ;
ERR_FAIL_COND ( ! newnode ) ;
2014-02-10 02:10:30 +01:00
2019-08-09 16:31:31 +02:00
ur - > add_do_method ( this , " replace_node " , n , newnode , true , false ) ;
ur - > add_do_reference ( newnode ) ;
ur - > add_undo_method ( this , " replace_node " , newnode , n , false , false ) ;
ur - > add_undo_reference ( n ) ;
2018-02-21 13:38:21 +01:00
}
2019-08-09 16:31:31 +02:00
ur - > commit_action ( ) ;
2018-09-12 20:47:12 +02:00
} else if ( current_option = = TOOL_REPARENT_TO_NEW_NODE ) {
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
ERR_FAIL_COND ( selection . size ( ) < = 0 ) ;
// Find top level node in selection
bool only_one_top_node = true ;
Node * first = selection . front ( ) - > get ( ) ;
ERR_FAIL_COND ( ! first ) ;
int smaller_path_to_top = first - > get_path_to ( scene_root ) . get_name_count ( ) ;
Node * top_node = first ;
for ( List < Node * > : : Element * E = selection . front ( ) - > next ( ) ; E ; E = E - > next ( ) ) {
Node * n = E - > get ( ) ;
ERR_FAIL_COND ( ! n ) ;
int path_length = n - > get_path_to ( scene_root ) . get_name_count ( ) ;
if ( top_node ! = n ) {
if ( smaller_path_to_top > path_length ) {
top_node = n ;
smaller_path_to_top = path_length ;
only_one_top_node = true ;
} else if ( smaller_path_to_top = = path_length ) {
2020-05-14 16:41:43 +02:00
if ( only_one_top_node & & top_node - > get_parent ( ) ! = n - > get_parent ( ) ) {
2018-09-12 20:47:12 +02:00
only_one_top_node = false ;
2020-05-14 16:41:43 +02:00
}
2018-09-12 20:47:12 +02:00
}
}
}
2020-04-02 01:20:12 +02:00
Node * parent = nullptr ;
2020-05-14 16:41:43 +02:00
if ( only_one_top_node ) {
2018-09-12 20:47:12 +02:00
parent = top_node - > get_parent ( ) ;
2020-05-14 16:41:43 +02:00
} else {
2018-09-12 20:47:12 +02:00
parent = top_node - > get_parent ( ) - > get_parent ( ) ;
2020-05-14 16:41:43 +02:00
}
2018-09-12 20:47:12 +02:00
_do_create ( parent ) ;
Vector < Node * > nodes ;
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
nodes . push_back ( E ) ;
2018-09-12 20:47:12 +02:00
}
// This works because editor_selection was cleared and populated with last created node in _do_create()
Node * last_created = editor_selection - > get_selected_node_list ( ) . front ( ) - > get ( ) ;
_do_reparent ( last_created , - 1 , nodes , true ) ;
2018-02-21 13:38:21 +01:00
}
2019-04-10 17:01:42 +02:00
2021-07-17 23:22:52 +02:00
scene_tree - > get_scene_tree ( ) - > call_deferred ( SNAME ( " grab_focus " ) ) ;
2018-02-21 13:38:21 +01:00
}
2014-02-10 02:10:30 +01:00
2019-04-23 21:10:44 +02:00
void SceneTreeDock : : replace_node ( Node * p_node , Node * p_by_node , bool p_keep_properties , bool p_remove_old ) {
2018-02-21 13:38:21 +01:00
Node * n = p_node ;
Node * newnode = p_by_node ;
2014-02-10 02:10:30 +01:00
2019-01-14 17:41:54 +01:00
if ( p_keep_properties ) {
2021-06-18 00:03:09 +02:00
Node * default_oldnode = Object : : cast_to < Node > ( ClassDB : : instantiate ( n - > get_class ( ) ) ) ;
2019-01-14 17:41:54 +01:00
List < PropertyInfo > pinfo ;
n - > get_property_list ( & pinfo ) ;
2021-07-24 15:46:25 +02:00
for ( const PropertyInfo & E : pinfo ) {
2021-07-16 05:45:57 +02:00
if ( ! ( E . usage & PROPERTY_USAGE_STORAGE ) ) {
2019-01-14 17:41:54 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2020-05-18 16:38:48 +02:00
2021-07-16 05:45:57 +02:00
if ( E . name = = " __meta__ " ) {
Dictionary metadata = n - > get ( E . name ) ;
2020-10-18 20:22:54 +02:00
if ( metadata . has ( " _editor_description_ " ) ) {
newnode - > set_meta ( " _editor_description_ " , metadata [ " _editor_description_ " ] ) ;
}
if ( Object : : cast_to < CanvasItem > ( newnode ) | | Object : : cast_to < Node3D > ( newnode ) ) {
2020-05-18 16:38:48 +02:00
if ( metadata . has ( " _edit_group_ " ) & & metadata [ " _edit_group_ " ] ) {
newnode - > set_meta ( " _edit_group_ " , true ) ;
}
if ( metadata . has ( " _edit_lock_ " ) & & metadata [ " _edit_lock_ " ] ) {
newnode - > set_meta ( " _edit_lock_ " , true ) ;
}
}
2019-01-14 17:41:54 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2020-05-18 16:38:48 +02:00
2021-07-16 05:45:57 +02:00
if ( default_oldnode - > get ( E . name ) ! = n - > get ( E . name ) ) {
newnode - > set ( E . name , n - > get ( E . name ) ) ;
2019-01-14 17:41:54 +01:00
}
2018-03-09 19:05:04 +01:00
}
2019-01-14 17:41:54 +01:00
memdelete ( default_oldnode ) ;
2018-02-21 13:38:21 +01:00
}
2014-02-10 02:10:30 +01:00
2020-04-02 01:20:12 +02:00
editor - > push_item ( nullptr ) ;
2014-02-10 02:10:30 +01:00
2018-02-21 13:38:21 +01:00
//reconnect signals
List < MethodInfo > sl ;
2014-02-10 02:10:30 +01:00
2018-02-21 13:38:21 +01:00
n - > get_signal_list ( & sl ) ;
2021-07-24 15:46:25 +02:00
for ( const MethodInfo & E : sl ) {
2018-02-21 13:38:21 +01:00
List < Object : : Connection > cl ;
2021-07-16 05:45:57 +02:00
n - > get_signal_connection_list ( E . name , & cl ) ;
2016-06-21 03:57:07 +02:00
2021-07-24 15:46:25 +02:00
for ( const Object : : Connection & c : cl ) {
2020-05-14 16:41:43 +02:00
if ( ! ( c . flags & Object : : CONNECT_PERSIST ) ) {
2018-02-21 13:38:21 +01:00
continue ;
2020-05-14 16:41:43 +02:00
}
2020-02-21 23:26:13 +01:00
newnode - > connect ( c . signal . get_name ( ) , c . callable , c . binds , Object : : CONNECT_PERSIST ) ;
2018-02-21 13:38:21 +01:00
}
}
2014-02-10 02:10:30 +01:00
2018-02-21 13:38:21 +01:00
String newname = n - > get_name ( ) ;
2015-09-07 15:13:29 +02:00
2018-02-21 13:38:21 +01:00
List < Node * > to_erase ;
for ( int i = 0 ; i < n - > get_child_count ( ) ; i + + ) {
2020-04-02 01:20:12 +02:00
if ( n - > get_child ( i ) - > get_owner ( ) = = nullptr & & n - > is_owned_by_parent ( ) ) {
2018-02-21 13:38:21 +01:00
to_erase . push_back ( n - > get_child ( i ) ) ;
}
}
n - > replace_by ( newnode , true ) ;
2014-02-10 02:10:30 +01:00
2018-02-21 13:38:21 +01:00
if ( n = = edited_scene ) {
edited_scene = newnode ;
editor - > set_edited_scene ( newnode ) ;
}
2016-01-18 00:03:57 +01:00
2018-02-21 13:38:21 +01:00
//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 " ) ) ;
}
2019-04-23 21:10:44 +02:00
//p_remove_old was added to support undo
2020-05-14 16:41:43 +02:00
if ( p_remove_old ) {
2019-04-23 21:10:44 +02:00
editor_data - > get_undo_redo ( ) . clear_history ( ) ;
2020-05-14 16:41:43 +02:00
}
2018-02-21 13:38:21 +01:00
newnode - > set_name ( newname ) ;
editor - > push_item ( newnode ) ;
2019-04-23 21:10:44 +02:00
if ( p_remove_old ) {
memdelete ( n ) ;
2018-02-21 13:38:21 +01:00
2019-04-23 21:10:44 +02:00
while ( to_erase . front ( ) ) {
memdelete ( to_erase . front ( ) - > get ( ) ) ;
to_erase . pop_front ( ) ;
}
2014-02-10 02:10:30 +01:00
}
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : set_edited_scene ( Node * p_scene ) {
edited_scene = p_scene ;
2014-02-10 02:10:30 +01:00
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : set_selected ( Node * p_node , bool p_emit_selected ) {
scene_tree - > set_selected ( p_node , p_emit_selected ) ;
2014-02-10 02:10:30 +01:00
}
2015-11-27 21:42:48 +01:00
void SceneTreeDock : : _new_scene_from ( String p_file ) {
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2015-11-27 21:42:48 +01:00
2017-03-05 16:44:50 +01:00
if ( selection . size ( ) ! = 1 ) {
2016-05-04 03:25:37 +02:00
accept - > set_text ( TTR ( " This operation requires a single selected node. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
return ;
}
2018-09-07 15:54:26 +02:00
if ( EditorNode : : get_singleton ( ) - > is_scene_open ( p_file ) ) {
accept - > set_text ( TTR ( " Can't overwrite scene that is still open! " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2018-09-07 15:54:26 +02:00
return ;
}
2015-11-27 21:42:48 +01:00
Node * base = selection . front ( ) - > get ( ) ;
2021-02-28 17:19:01 +01:00
Map < const Node * , Node * > duplimap ;
Node * copy = base - > duplicate_from_editor ( duplimap ) ;
2015-11-27 21:42:48 +01:00
if ( copy ) {
2021-02-28 17:19:01 +01:00
for ( int i = 0 ; i < copy - > get_child_count ( ) ; i + + ) {
_set_node_owner_recursive ( copy - > get_child ( i ) , copy ) ;
}
2017-03-05 16:44:50 +01:00
Ref < PackedScene > sdata = memnew ( PackedScene ) ;
2015-11-27 21:42:48 +01:00
Error err = sdata - > pack ( copy ) ;
memdelete ( copy ) ;
2017-03-05 16:44:50 +01:00
if ( err ! = OK ) {
2016-05-04 03:25:37 +02:00
accept - > set_text ( TTR ( " Couldn't save new scene. Likely dependencies (instances) couldn't be satisfied. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
return ;
}
2017-03-05 16:44:50 +01:00
int flg = 0 ;
2020-05-14 16:41:43 +02:00
if ( EditorSettings : : get_singleton ( ) - > get ( " filesystem/on_save/compress_binary_resources " ) ) {
2017-03-05 16:44:50 +01:00
flg | = ResourceSaver : : FLAG_COMPRESS ;
2020-05-14 16:41:43 +02:00
}
2015-11-27 21:42:48 +01:00
2017-03-05 16:44:50 +01:00
err = ResourceSaver : : save ( p_file , sdata , flg ) ;
if ( err ! = OK ) {
2016-05-04 03:25:37 +02:00
accept - > set_text ( TTR ( " Error saving scene. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
return ;
}
2016-10-11 16:54:46 +02:00
_replace_with_branch_scene ( p_file , base ) ;
2015-11-27 21:42:48 +01:00
} else {
2016-05-04 03:25:37 +02:00
accept - > set_text ( TTR ( " Error duplicating scene to save it. " ) ) ;
2020-03-06 18:00:16 +01:00
accept - > popup_centered ( ) ;
2015-11-27 21:42:48 +01:00
return ;
}
}
2021-02-28 17:19:01 +01:00
void SceneTreeDock : : _set_node_owner_recursive ( Node * p_node , Node * p_owner ) {
if ( ! p_node - > get_owner ( ) ) {
p_node - > set_owner ( p_owner ) ;
}
for ( int i = 0 ; i < p_node - > get_child_count ( ) ; i + + ) {
_set_node_owner_recursive ( p_node - > get_child ( i ) , p_owner ) ;
}
}
2017-03-05 16:44:50 +01:00
static bool _is_node_visible ( Node * p_node ) {
2020-05-14 16:41:43 +02:00
if ( ! p_node - > get_owner ( ) ) {
2016-05-11 16:46:08 +02:00
return false ;
2020-05-14 16:41:43 +02:00
}
if ( p_node - > get_owner ( ) ! = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) & & ! EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > is_editable_instance ( p_node - > get_owner ( ) ) ) {
2016-05-11 16:46:08 +02:00
return false ;
2020-05-14 16:41:43 +02:00
}
2016-05-11 16:46:08 +02:00
return true ;
}
2017-03-05 16:44:50 +01:00
static bool _has_visible_children ( Node * p_node ) {
2016-11-02 16:23:03 +01:00
bool collapsed = p_node - > is_displayed_folded ( ) ;
2020-05-14 16:41:43 +02:00
if ( collapsed ) {
2016-05-11 16:46:08 +02:00
return false ;
2020-05-14 16:41:43 +02:00
}
2016-05-11 16:46:08 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < p_node - > get_child_count ( ) ; i + + ) {
Node * child = p_node - > get_child ( i ) ;
2020-05-14 16:41:43 +02:00
if ( ! _is_node_visible ( child ) ) {
2016-05-11 16:46:08 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2016-05-11 16:46:08 +02:00
return true ;
}
return false ;
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _normalize_drop ( Node * & to_node , int & to_pos , int p_type ) {
to_pos = - 1 ;
2016-05-11 16:46:08 +02:00
2017-03-05 16:44:50 +01:00
if ( p_type = = - 1 ) {
2016-05-11 16:46:08 +02:00
//drop at above selected node
2017-03-05 16:44:50 +01:00
if ( to_node = = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) ) {
2020-04-02 01:20:12 +02:00
to_node = nullptr ;
2019-08-15 04:57:49 +02:00
ERR_FAIL_MSG ( " Cannot perform drop above the root node! " ) ;
2016-05-12 01:57:52 +02:00
}
2016-05-11 16:46:08 +02:00
2017-03-05 16:44:50 +01:00
to_pos = to_node - > get_index ( ) ;
to_node = to_node - > get_parent ( ) ;
2016-06-18 20:30:44 +02:00
2017-03-05 16:44:50 +01:00
} 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
2017-03-24 21:45:31 +01:00
to_pos = 0 ; //just insert at beginning of root node
2017-03-05 16:44:50 +01:00
return ;
}
2016-06-18 20:30:44 +02:00
2020-04-02 01:20:12 +02:00
Node * lower_sibling = nullptr ;
2016-06-18 20:30:44 +02:00
2017-03-05 16:44:50 +01:00
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 ;
2016-06-18 20:30:44 +02:00
}
}
2017-03-05 16:44:50 +01:00
if ( lower_sibling ) {
to_pos = lower_sibling - > get_index ( ) ;
}
to_node = to_node - > get_parent ( ) ;
}
2016-05-11 16:46:08 +02:00
}
2016-05-12 01:57:52 +02:00
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _files_dropped ( Vector < String > p_files , NodePath p_to , int p_type ) {
2016-05-12 01:57:52 +02:00
Node * node = get_node ( p_to ) ;
ERR_FAIL_COND ( ! node ) ;
2021-07-16 16:27:59 +02:00
if ( scene_tree - > get_scene_tree ( ) - > get_drop_mode_flags ( ) & Tree : : DROP_MODE_INBETWEEN ) {
// Dropped PackedScene, instance it.
int to_pos = - 1 ;
_normalize_drop ( node , to_pos , p_type ) ;
_perform_instantiate_scenes ( p_files , node , to_pos ) ;
} else {
String res_path = p_files [ 0 ] ;
StringName res_type = EditorFileSystem : : get_singleton ( ) - > get_file_type ( res_path ) ;
List < String > valid_properties ;
List < PropertyInfo > pinfo ;
node - > get_property_list ( & pinfo ) ;
2021-07-24 15:46:25 +02:00
for ( const PropertyInfo & p : pinfo ) {
2021-07-16 16:27:59 +02:00
if ( ! ( p . usage & PROPERTY_USAGE_EDITOR ) | | ! ( p . usage & PROPERTY_USAGE_STORAGE ) | | p . hint ! = PROPERTY_HINT_RESOURCE_TYPE ) {
continue ;
}
Vector < String > valid_types = p . hint_string . split ( " , " ) ;
2021-07-24 15:46:25 +02:00
for ( const String & prop_type : valid_types ) {
2021-07-16 16:27:59 +02:00
if ( res_type = = prop_type | | ClassDB : : is_parent_class ( res_type , prop_type ) | | EditorNode : : get_editor_data ( ) . script_class_is_parent ( res_type , prop_type ) ) {
valid_properties . push_back ( p . name ) ;
break ;
}
}
}
if ( valid_properties . size ( ) > 1 ) {
property_drop_node = node ;
resource_drop_path = res_path ;
bool capitalize = bool ( EDITOR_GET ( " interface/inspector/capitalize_properties " ) ) ;
menu_properties - > clear ( ) ;
2021-07-24 15:46:25 +02:00
for ( const String & p : valid_properties ) {
2021-07-16 16:27:59 +02:00
menu_properties - > add_item ( capitalize ? p . capitalize ( ) : p ) ;
menu_properties - > set_item_metadata ( menu_properties - > get_item_count ( ) - 1 , p ) ;
}
menu_properties - > set_size ( Size2 ( 1 , 1 ) ) ;
menu_properties - > set_position ( get_screen_position ( ) + get_local_mouse_position ( ) ) ;
menu_properties - > popup ( ) ;
} else if ( ! valid_properties . is_empty ( ) ) {
_perform_property_drop ( node , valid_properties [ 0 ] , ResourceLoader : : load ( res_path ) ) ;
}
}
2016-05-12 01:57:52 +02:00
}
2016-10-27 16:32:41 +02:00
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 ) {
2018-03-07 20:08:13 +01:00
editor_data - > get_undo_redo ( ) . create_action ( TTR ( " Attach Script " ) ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( n , " set_script " , scr ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( n , " set_script " , n - > get_script ( ) ) ;
editor_data - > get_undo_redo ( ) . add_do_method ( this , " _update_script_button " ) ;
editor_data - > get_undo_redo ( ) . add_undo_method ( this , " _update_script_button " ) ;
editor_data - > get_undo_redo ( ) . commit_action ( ) ;
2016-10-27 16:32:41 +02:00
}
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _nodes_dragged ( Array p_nodes , NodePath p_to , int p_type ) {
2019-07-04 15:41:21 +02:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2016-05-12 01:57:52 +02:00
2020-12-15 13:04:21 +01:00
if ( selection . is_empty ( ) ) {
2019-07-04 15:41:21 +02:00
return ; //nothing to reparent
2020-05-14 16:41:43 +02:00
}
2016-05-12 01:57:52 +02:00
2019-07-04 15:41:21 +02:00
Node * to_node = get_node ( p_to ) ;
2020-05-14 16:41:43 +02:00
if ( ! to_node ) {
2016-05-12 01:57:52 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2016-05-12 01:57:52 +02:00
2019-07-04 15:41:21 +02:00
Vector < Node * > nodes ;
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
nodes . push_back ( E ) ;
2019-07-04 15:41:21 +02:00
}
2017-03-05 16:44:50 +01:00
int to_pos = - 1 ;
2016-05-11 16:46:08 +02:00
2017-03-05 16:44:50 +01:00
_normalize_drop ( to_node , to_pos , p_type ) ;
2020-04-28 15:19:37 +02:00
_do_reparent ( to_node , to_pos , nodes , ! Input : : get_singleton ( ) - > is_key_pressed ( KEY_SHIFT ) ) ;
2016-05-11 16:46:08 +02:00
}
2017-06-05 05:12:19 +02:00
void SceneTreeDock : : _add_children_to_popup ( Object * p_obj , int p_depth ) {
2020-05-14 16:41:43 +02:00
if ( p_depth > 8 ) {
2017-06-05 05:12:19 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2017-06-05 05:12:19 +02:00
List < PropertyInfo > pinfo ;
p_obj - > get_property_list ( & pinfo ) ;
2021-07-24 15:46:25 +02:00
for ( const PropertyInfo & E : pinfo ) {
2021-07-16 05:45:57 +02:00
if ( ! ( E . usage & PROPERTY_USAGE_EDITOR ) ) {
2017-06-05 05:12:19 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2021-07-16 05:45:57 +02:00
if ( E . hint ! = PROPERTY_HINT_RESOURCE_TYPE ) {
2017-06-05 05:12:19 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2017-06-05 05:12:19 +02:00
2021-07-16 05:45:57 +02:00
Variant value = p_obj - > get ( E . name ) ;
2020-05-14 16:41:43 +02:00
if ( value . get_type ( ) ! = Variant : : OBJECT ) {
2017-06-05 05:12:19 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2017-06-05 05:12:19 +02:00
Object * obj = value ;
2020-05-14 16:41:43 +02:00
if ( ! obj ) {
2017-06-05 05:12:19 +02:00
continue ;
2020-05-14 16:41:43 +02:00
}
2017-06-05 05:12:19 +02:00
2019-06-11 20:43:37 +02:00
Ref < Texture2D > icon = EditorNode : : get_singleton ( ) - > get_object_icon ( obj ) ;
2017-06-05 05:12:19 +02:00
if ( menu - > get_item_count ( ) = = 0 ) {
2017-12-19 16:07:50 +01:00
menu - > add_submenu_item ( TTR ( " Sub-Resources " ) , " Sub-Resources " ) ;
2017-06-05 05:12:19 +02:00
}
2017-12-17 15:55:24 +01:00
int index = menu_subresources - > get_item_count ( ) ;
2021-07-16 05:45:57 +02:00
menu_subresources - > add_icon_item ( icon , E . name . capitalize ( ) , EDIT_SUBRESOURCE_BASE + subresources . size ( ) ) ;
2017-12-17 15:55:24 +01:00
menu_subresources - > set_item_h_offset ( index , p_depth * 10 * EDSCALE ) ;
2017-08-07 12:17:31 +02:00
subresources . push_back ( obj - > get_instance_id ( ) ) ;
2017-06-05 05:12:19 +02:00
_add_children_to_popup ( obj , p_depth + 1 ) ;
}
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _tree_rmb ( const Vector2 & p_menu_pos ) {
2016-05-16 17:23:40 +02:00
if ( ! EditorNode : : get_singleton ( ) - > get_edited_scene ( ) ) {
menu - > clear ( ) ;
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Add " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/add_child_node " ) , TOOL_NEW ) ;
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Instance " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/instance_scene " ) , TOOL_INSTANTIATE ) ;
2019-04-09 00:18:03 +02:00
}
2016-05-16 17:23:40 +02:00
2017-03-05 16:44:50 +01:00
menu - > set_size ( Size2 ( 1 , 1 ) ) ;
2020-07-01 19:44:19 +02:00
menu - > set_position ( get_screen_position ( ) + p_menu_pos ) ;
2016-05-16 17:23:40 +02:00
menu - > popup ( ) ;
return ;
}
2017-03-05 16:44:50 +01:00
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2019-11-04 16:45:16 +01:00
List < Node * > full_selection = editor_selection - > get_full_selected_node_list ( ) ; // Above method only returns nodes with common parent.
2016-05-16 04:41:48 +02:00
2020-05-14 16:41:43 +02:00
if ( selection . size ( ) = = 0 ) {
2016-05-16 04:41:48 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2016-05-16 17:23:40 +02:00
2016-05-16 04:41:48 +02:00
menu - > clear ( ) ;
2018-10-03 11:25:18 +02:00
Ref < Script > existing_script ;
2020-02-17 15:10:45 +01:00
bool existing_script_removable = true ;
2017-03-05 16:44:50 +01:00
if ( selection . size ( ) = = 1 ) {
2018-01-02 08:10:49 +01:00
Node * selected = selection [ 0 ] ;
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
subresources . clear ( ) ;
menu_subresources - > clear ( ) ;
menu_subresources - > set_size ( Size2 ( 1 , 1 ) ) ;
_add_children_to_popup ( selection . front ( ) - > get ( ) , 0 ) ;
2020-05-14 16:41:43 +02:00
if ( menu - > get_item_count ( ) > 0 ) {
2019-04-09 00:18:03 +02:00
menu - > add_separator ( ) ;
2020-05-14 16:41:43 +02:00
}
2017-06-05 05:12:19 +02:00
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Add " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/add_child_node " ) , TOOL_NEW ) ;
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Instance " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/instance_scene " ) , TOOL_INSTANTIATE ) ;
2019-04-09 00:18:03 +02:00
}
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Collapse " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/expand_collapse_all " ) , TOOL_EXPAND_COLLAPSE ) ;
2018-07-07 16:51:18 +02:00
menu - > add_separator ( ) ;
2018-10-03 11:25:18 +02:00
existing_script = selected - > get_script ( ) ;
2019-07-19 21:21:30 +02:00
if ( EditorNode : : get_singleton ( ) - > get_object_custom_type_base ( selected ) = = existing_script ) {
2020-02-17 15:10:45 +01:00
existing_script_removable = false ;
2019-07-19 21:21:30 +02:00
}
2018-10-03 11:25:18 +02:00
}
2018-01-02 08:10:49 +01:00
2021-05-06 22:01:36 +02:00
if ( profile_allow_editing ) {
2020-01-07 17:43:21 +01:00
menu - > add_shortcut ( ED_GET_SHORTCUT ( " scene_tree/cut_node " ) , TOOL_CUT ) ;
menu - > add_shortcut ( ED_GET_SHORTCUT ( " scene_tree/copy_node " ) , TOOL_COPY ) ;
if ( selection . size ( ) = = 1 & & ! node_clipboard . is_empty ( ) ) {
menu - > add_shortcut ( ED_GET_SHORTCUT ( " scene_tree/paste_node " ) , TOOL_PASTE ) ;
}
menu - > add_separator ( ) ;
2021-05-06 22:01:36 +02:00
}
2020-01-07 17:43:21 +01:00
2021-05-06 22:01:36 +02:00
if ( profile_allow_script_editing ) {
2019-11-04 16:45:16 +01:00
bool add_separator = false ;
2018-10-03 11:25:18 +02:00
2019-11-04 16:45:16 +01:00
if ( full_selection . size ( ) = = 1 ) {
add_separator = true ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " ScriptCreate " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/attach_script " ) , TOOL_ATTACH_SCRIPT ) ;
2019-10-21 06:57:10 +02:00
if ( existing_script . is_valid ( ) ) {
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " ScriptExtend " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/extend_script " ) , TOOL_EXTEND_SCRIPT ) ;
2019-04-14 14:04:04 +02:00
}
2019-04-09 00:18:03 +02:00
}
2020-02-17 15:10:45 +01:00
if ( existing_script . is_valid ( ) & & existing_script_removable ) {
2019-11-04 16:45:16 +01:00
add_separator = true ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " ScriptRemove " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/detach_script " ) , TOOL_DETACH_SCRIPT ) ;
2019-11-04 16:45:16 +01:00
} else if ( full_selection . size ( ) > 1 ) {
bool script_exists = false ;
2021-07-16 05:45:57 +02:00
for ( Node * E : full_selection ) {
if ( ! E - > get_script ( ) . is_null ( ) ) {
2019-11-04 16:45:16 +01:00
script_exists = true ;
break ;
}
}
if ( script_exists ) {
add_separator = true ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " ScriptRemove " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/detach_script " ) , TOOL_DETACH_SCRIPT ) ;
2019-11-04 16:45:16 +01:00
}
}
2021-05-06 23:37:12 +02:00
if ( add_separator & & profile_allow_editing ) {
2019-11-04 16:45:16 +01:00
menu - > add_separator ( ) ;
2019-04-09 00:18:03 +02:00
}
2016-05-16 04:41:48 +02:00
}
2018-10-03 11:25:18 +02:00
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
2019-11-04 16:45:16 +01:00
if ( full_selection . size ( ) = = 1 ) {
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Rename " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/rename " ) , TOOL_RENAME ) ;
2019-04-09 00:18:03 +02:00
}
2021-02-22 20:18:14 +01:00
bool can_replace = true ;
2021-07-16 05:45:57 +02:00
for ( Node * E : selection ) {
if ( E ! = edited_scene & & ( E - > get_owner ( ) ! = edited_scene | | E - > get_filename ( ) ! = " " ) ) {
2021-02-22 20:18:14 +01:00
can_replace = false ;
break ;
}
}
if ( can_replace ) {
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Reload " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/change_node_type " ) , TOOL_REPLACE ) ;
2021-02-22 20:18:14 +01:00
}
2019-04-09 00:18:03 +02:00
if ( scene_tree - > get_selected ( ) ! = edited_scene ) {
menu - > add_separator ( ) ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " MoveUp " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/move_up " ) , TOOL_MOVE_UP ) ;
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " MoveDown " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/move_down " ) , TOOL_MOVE_DOWN ) ;
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Duplicate " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/duplicate " ) , TOOL_DUPLICATE ) ;
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Reparent " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/reparent " ) , TOOL_REPARENT ) ;
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " ReparentToNewNode " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/reparent_to_new_node " ) , TOOL_REPARENT_TO_NEW_NODE ) ;
2019-11-04 16:45:16 +01:00
if ( selection . size ( ) = = 1 ) {
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " NewRoot " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/make_root " ) , TOOL_MAKE_ROOT ) ;
2019-11-04 16:45:16 +01:00
}
2019-04-09 00:18:03 +02:00
}
2018-01-02 08:10:49 +01:00
}
2017-03-05 16:44:50 +01:00
if ( selection . size ( ) = = 1 ) {
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
menu - > add_separator ( ) ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " CreateNewSceneFrom " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/save_branch_as_scene " ) , TOOL_NEW_SCENE_FROM ) ;
2019-11-04 16:45:16 +01:00
}
if ( full_selection . size ( ) = = 1 ) {
2019-04-09 00:18:03 +02:00
menu - > add_separator ( ) ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " CopyNodePath " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/copy_node_path " ) , TOOL_COPY_NODE_PATH ) ;
2019-04-09 00:18:03 +02:00
}
2017-07-04 12:50:20 +02:00
bool is_external = ( selection [ 0 ] - > get_filename ( ) ! = " " ) ;
2017-06-30 18:17:33 +02:00
if ( is_external ) {
2020-04-02 01:20:12 +02:00
bool is_inherited = selection [ 0 ] - > get_scene_inherited_state ( ) ! = nullptr ;
bool is_top_level = selection [ 0 ] - > get_owner ( ) = = nullptr ;
2017-07-28 10:32:49 +02:00
if ( is_inherited & & is_top_level ) {
2017-07-04 12:50:20 +02:00
menu - > add_separator ( ) ;
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
menu - > add_item ( TTR ( " Clear Inheritance " ) , TOOL_SCENE_CLEAR_INHERITANCE ) ;
}
2021-07-17 23:22:52 +02:00
menu - > add_icon_item ( get_theme_icon ( SNAME ( " Load " ) , SNAME ( " EditorIcons " ) ) , TTR ( " Open in Editor " ) , TOOL_SCENE_OPEN_INHERITED ) ;
2017-07-04 12:50:20 +02:00
} else if ( ! is_top_level ) {
menu - > add_separator ( ) ;
2017-06-30 18:17:33 +02:00
bool editable = EditorNode : : get_singleton ( ) - > get_edited_scene ( ) - > is_editable_instance ( selection [ 0 ] ) ;
bool placeholder = selection [ 0 ] - > get_scene_instance_load_placeholder ( ) ;
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
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 ( " Make Local " ) , TOOL_SCENE_MAKE_LOCAL ) ;
}
2021-07-17 23:22:52 +02:00
menu - > add_icon_item ( get_theme_icon ( SNAME ( " Load " ) , SNAME ( " EditorIcons " ) ) , TTR ( " Open in Editor " ) , TOOL_SCENE_OPEN ) ;
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
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 ) ;
}
2017-06-30 18:17:33 +02:00
}
}
2016-05-16 04:41:48 +02:00
}
2018-05-17 23:02:16 +02:00
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing & & selection . size ( ) > 1 ) {
2018-05-17 23:02:16 +02:00
//this is not a commonly used action, it makes no sense for it to be where it was nor always present.
menu - > add_separator ( ) ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Rename " ) , SNAME ( " EditorIcons " ) ) , ED_GET_SHORTCUT ( " scene_tree/batch_rename " ) , TOOL_BATCH_RENAME ) ;
2018-05-17 23:02:16 +02:00
}
2018-10-03 11:25:18 +02:00
menu - > add_separator ( ) ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_item ( get_theme_icon ( SNAME ( " Help " ) , SNAME ( " EditorIcons " ) ) , TTR ( " Open Documentation " ) , TOOL_OPEN_DOCUMENTATION ) ;
2018-10-03 11:25:18 +02:00
2019-04-09 00:18:03 +02:00
if ( profile_allow_editing ) {
menu - > add_separator ( ) ;
2021-07-17 23:22:52 +02:00
menu - > add_icon_shortcut ( get_theme_icon ( SNAME ( " Remove " ) , SNAME ( " EditorIcons " ) ) , ED_SHORTCUT ( " scene_tree/delete " , TTR ( " Delete Node(s) " ) , KEY_DELETE ) , TOOL_ERASE ) ;
2019-04-09 00:18:03 +02:00
}
2017-03-05 16:44:50 +01:00
menu - > set_size ( Size2 ( 1 , 1 ) ) ;
2017-03-29 17:29:38 +02:00
menu - > set_position ( p_menu_pos ) ;
2016-05-16 04:41:48 +02:00
menu - > popup ( ) ;
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : _filter_changed ( const String & p_filter ) {
2016-05-16 17:23:40 +02:00
scene_tree - > set_filter ( p_filter ) ;
}
String SceneTreeDock : : get_filter ( ) {
return filter - > get_text ( ) ;
}
2017-03-05 16:44:50 +01:00
void SceneTreeDock : : set_filter ( const String & p_filter ) {
2016-05-16 17:23:40 +02:00
filter - > set_text ( p_filter ) ;
scene_tree - > set_filter ( p_filter ) ;
}
2016-07-28 21:37:52 +02:00
void SceneTreeDock : : _focus_node ( ) {
Node * node = scene_tree - > get_selected ( ) ;
ERR_FAIL_COND ( ! node ) ;
2017-01-03 03:03:46 +01:00
if ( node - > is_class ( " CanvasItem " ) ) {
2017-08-24 22:58:51 +02:00
CanvasItemEditorPlugin * editor = Object : : cast_to < CanvasItemEditorPlugin > ( editor_data - > get_editor ( " 2D " ) ) ;
2016-07-28 21:37:52 +02:00
editor - > get_canvas_item_editor ( ) - > focus_selection ( ) ;
} else {
2020-03-26 22:49:16 +01:00
Node3DEditorPlugin * editor = Object : : cast_to < Node3DEditorPlugin > ( editor_data - > get_editor ( " 3D " ) ) ;
2016-07-28 21:37:52 +02:00
editor - > get_spatial_editor ( ) - > get_editor_viewport ( 0 ) - > focus_selection ( ) ;
}
}
2019-10-21 06:57:10 +02:00
void SceneTreeDock : : attach_script_to_selected ( bool p_extend ) {
2020-05-31 19:31:45 +02:00
if ( ScriptServer : : get_language_count ( ) = = 0 ) {
EditorNode : : get_singleton ( ) - > show_warning ( TTR ( " Cannot attach a script: there are no languages registered. \n This is probably because this editor was built with all language modules disabled. " ) ) ;
return ;
}
2019-10-21 06:57:10 +02:00
if ( ! profile_allow_script_editing ) {
return ;
}
List < Node * > selection = editor_selection - > get_selected_node_list ( ) ;
2020-12-15 13:04:21 +01:00
if ( selection . is_empty ( ) ) {
2019-10-21 06:57:10 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2019-10-21 06:57:10 +02:00
Node * selected = scene_tree - > get_selected ( ) ;
2020-05-14 16:41:43 +02:00
if ( ! selected ) {
2019-10-21 06:57:10 +02:00
selected = selection . front ( ) - > get ( ) ;
2020-05-14 16:41:43 +02:00
}
2019-10-21 06:57:10 +02:00
Ref < Script > existing = selected - > get_script ( ) ;
String path = selected - > get_filename ( ) ;
if ( path = = " " ) {
String root_path = editor_data - > get_edited_scene_root ( ) - > get_filename ( ) ;
if ( root_path = = " " ) {
path = String ( " res:// " ) . plus_file ( selected - > get_name ( ) ) ;
} else {
path = root_path . get_base_dir ( ) . plus_file ( selected - > get_name ( ) ) ;
}
}
String inherits = selected - > get_class ( ) ;
if ( p_extend & & existing . is_valid ( ) ) {
for ( int i = 0 ; i < ScriptServer : : get_language_count ( ) ; i + + ) {
ScriptLanguage * l = ScriptServer : : get_language ( i ) ;
if ( l - > get_type ( ) = = existing - > get_class ( ) ) {
String name = l - > get_global_class_name ( existing - > get_path ( ) ) ;
if ( ScriptServer : : is_global_class ( name ) & & EDITOR_GET ( " interface/editors/derive_script_globals_by_name " ) . operator bool ( ) ) {
inherits = name ;
} else if ( l - > can_inherit_from_file ( ) ) {
inherits = " \" " + existing - > get_path ( ) + " \" " ;
}
break ;
}
}
}
2020-02-21 18:28:45 +01:00
script_create_dialog - > connect ( " script_created " , callable_mp ( this , & SceneTreeDock : : _script_created ) ) ;
2020-10-26 23:26:44 +01:00
script_create_dialog - > connect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _script_creation_closed ) ) ;
script_create_dialog - > connect ( " cancelled " , callable_mp ( this , & SceneTreeDock : : _script_creation_closed ) ) ;
2019-10-21 06:57:10 +02:00
script_create_dialog - > set_inheritance_base_type ( " Node " ) ;
script_create_dialog - > config ( inherits , path ) ;
script_create_dialog - > popup_centered ( ) ;
}
void SceneTreeDock : : open_script_dialog ( Node * p_for_node , bool p_extend ) {
2017-03-05 16:44:50 +01:00
scene_tree - > set_selected ( p_for_node , false ) ;
2019-10-21 06:57:10 +02:00
if ( p_extend ) {
_tool_selected ( TOOL_EXTEND_SCRIPT ) ;
} else {
_tool_selected ( TOOL_ATTACH_SCRIPT ) ;
}
2016-09-13 00:31:07 +02:00
}
2020-08-25 01:32:58 +02:00
void SceneTreeDock : : open_add_child_dialog ( ) {
create_dialog - > set_base_type ( " CanvasItem " ) ;
_tool_selected ( TOOL_NEW , true ) ;
reset_create_dialog = true ;
}
void SceneTreeDock : : open_instance_child_dialog ( ) {
2021-06-18 00:03:09 +02:00
_tool_selected ( TOOL_INSTANTIATE , true ) ;
2020-08-25 01:32:58 +02:00
}
2017-11-16 02:21:29 +01:00
void SceneTreeDock : : add_remote_tree_editor ( Control * p_remote ) {
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND ( remote_tree ! = nullptr ) ;
2017-11-16 02:21:29 +01:00
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 ( ) ;
}
2017-11-22 14:50:54 +01:00
void SceneTreeDock : : show_tab_buttons ( ) {
button_hb - > show ( ) ;
}
void SceneTreeDock : : hide_tab_buttons ( ) {
button_hb - > hide ( ) ;
}
2017-11-16 02:21:29 +01:00
void SceneTreeDock : : _remote_tree_selected ( ) {
scene_tree - > hide ( ) ;
2019-05-30 02:20:59 +02:00
create_root_dialog - > hide ( ) ;
2020-05-14 16:41:43 +02:00
if ( remote_tree ) {
2017-11-16 02:21:29 +01:00
remote_tree - > show ( ) ;
2020-05-14 16:41:43 +02:00
}
2017-11-16 02:21:29 +01:00
edit_remote - > set_pressed ( true ) ;
edit_local - > set_pressed ( false ) ;
2017-11-23 08:23:24 +01:00
2021-07-17 23:22:52 +02:00
emit_signal ( SNAME ( " remote_tree_selected " ) ) ;
2017-11-16 02:21:29 +01:00
}
void SceneTreeDock : : _local_tree_selected ( ) {
2020-06-10 00:06:15 +02:00
if ( ! bool ( EDITOR_GET ( " interface/editors/show_scene_tree_root_selection " ) ) | | get_tree ( ) - > get_edited_scene_root ( ) ! = nullptr ) {
scene_tree - > show ( ) ;
}
2020-05-14 16:41:43 +02:00
if ( remote_tree ) {
2017-11-16 02:21:29 +01:00
remote_tree - > hide ( ) ;
2020-05-14 16:41:43 +02:00
}
2017-11-16 02:21:29 +01:00
edit_remote - > set_pressed ( false ) ;
edit_local - > set_pressed ( true ) ;
}
2018-07-25 05:48:24 +02:00
void SceneTreeDock : : _update_create_root_dialog ( ) {
BaseButton * toggle = Object : : cast_to < BaseButton > ( create_root_dialog - > get_node ( String ( " NodeShortcutsTopRow/NodeShortcutsToggle " ) ) ) ;
Node * node_shortcuts = create_root_dialog - > get_node ( String ( " NodeShortcuts " ) ) ;
2020-05-14 16:41:43 +02:00
if ( ! toggle | | ! node_shortcuts ) {
2018-07-25 05:48:24 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-07-25 05:48:24 +02:00
Control * beginner_nodes = Object : : cast_to < Control > ( node_shortcuts - > get_node ( String ( " BeginnerNodeShortcuts " ) ) ) ;
Control * favorite_nodes = Object : : cast_to < Control > ( node_shortcuts - > get_node ( String ( " FavoriteNodeShortcuts " ) ) ) ;
2020-05-14 16:41:43 +02:00
if ( ! beginner_nodes | | ! favorite_nodes ) {
2018-07-25 05:48:24 +02:00
return ;
2020-05-14 16:41:43 +02:00
}
2018-07-25 05:48:24 +02:00
EditorSettings : : get_singleton ( ) - > set_setting ( " _use_favorites_root_selection " , toggle - > is_pressed ( ) ) ;
EditorSettings : : get_singleton ( ) - > save ( ) ;
if ( toggle - > is_pressed ( ) ) {
for ( int i = 0 ; i < favorite_nodes - > get_child_count ( ) ; i + + ) {
favorite_nodes - > get_child ( i ) - > queue_delete ( ) ;
}
FileAccess * f = FileAccess : : open ( EditorSettings : : get_singleton ( ) - > get_project_settings_dir ( ) . plus_file ( " favorites.Node " ) , FileAccess : : READ ) ;
if ( f ) {
while ( ! f - > eof_reached ( ) ) {
String l = f - > get_line ( ) . strip_edges ( ) ;
if ( l ! = String ( ) ) {
Button * button = memnew ( Button ) ;
favorite_nodes - > add_child ( button ) ;
2020-07-24 15:14:56 +02:00
button - > set_text ( l ) ;
2018-07-25 05:48:24 +02:00
String name = l . get_slicec ( ' ' , 0 ) ;
2020-05-14 16:41:43 +02:00
if ( ScriptServer : : is_global_class ( name ) ) {
2019-03-09 04:47:27 +01:00
name = ScriptServer : : get_global_class_native_base ( name ) ;
2020-05-14 16:41:43 +02:00
}
2018-09-02 23:40:51 +02:00
button - > set_icon ( EditorNode : : get_singleton ( ) - > get_class_icon ( name ) ) ;
2020-02-21 18:28:45 +01:00
button - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _favorite_root_selected ) , make_binds ( l ) ) ;
2018-07-25 05:48:24 +02:00
}
}
memdelete ( f ) ;
}
if ( ! favorite_nodes - > is_visible_in_tree ( ) ) {
favorite_nodes - > show ( ) ;
beginner_nodes - > hide ( ) ;
}
} else {
if ( ! beginner_nodes - > is_visible_in_tree ( ) ) {
beginner_nodes - > show ( ) ;
favorite_nodes - > hide ( ) ;
}
}
}
void SceneTreeDock : : _favorite_root_selected ( const String & p_class ) {
selected_favorite_root = p_class ;
2020-03-03 10:46:03 +01:00
_tool_selected ( TOOL_CREATE_FAVORITE ) ;
2018-07-25 05:48:24 +02:00
}
2019-04-09 00:18:03 +02:00
void SceneTreeDock : : _feature_profile_changed ( ) {
Ref < EditorFeatureProfile > profile = EditorFeatureProfileManager : : get_singleton ( ) - > get_current_profile ( ) ;
if ( profile . is_valid ( ) ) {
profile_allow_editing = ! profile - > is_feature_disabled ( EditorFeatureProfile : : FEATURE_SCENE_TREE ) ;
profile_allow_script_editing = ! profile - > is_feature_disabled ( EditorFeatureProfile : : FEATURE_SCRIPT ) ;
2019-11-10 16:58:56 +01:00
bool profile_allow_3d = ! profile - > is_feature_disabled ( EditorFeatureProfile : : FEATURE_3D ) ;
2019-04-09 00:18:03 +02:00
2019-11-10 16:58:56 +01:00
button_3d - > set_visible ( profile_allow_3d ) ;
2019-04-09 00:18:03 +02:00
button_add - > set_visible ( profile_allow_editing ) ;
button_instance - > set_visible ( profile_allow_editing ) ;
scene_tree - > set_can_rename ( profile_allow_editing ) ;
} else {
2019-11-10 16:58:56 +01:00
button_3d - > set_visible ( true ) ;
2019-04-09 00:18:03 +02:00
button_add - > set_visible ( true ) ;
button_instance - > set_visible ( true ) ;
scene_tree - > set_can_rename ( true ) ;
profile_allow_editing = true ;
profile_allow_script_editing = true ;
}
_update_script_button ( ) ;
}
2020-01-07 17:43:21 +01:00
void SceneTreeDock : : _clear_clipboard ( ) {
2021-07-16 05:45:57 +02:00
for ( Node * E : node_clipboard ) {
memdelete ( E ) ;
2020-01-07 17:43:21 +01:00
}
node_clipboard . clear ( ) ;
2021-02-12 17:36:37 +01:00
clipboard_resource_remap . clear ( ) ;
}
void SceneTreeDock : : _create_remap_for_node ( Node * p_node , Map < RES , RES > & r_remap ) {
List < PropertyInfo > props ;
p_node - > get_property_list ( & props ) ;
2021-06-18 00:03:09 +02:00
bool is_instantiated = EditorPropertyRevert : : may_node_be_in_instance ( p_node ) ;
2021-02-12 17:36:37 +01:00
2021-07-24 15:46:25 +02:00
for ( const PropertyInfo & E : props ) {
2021-07-16 05:45:57 +02:00
if ( ! ( E . usage & PROPERTY_USAGE_STORAGE ) ) {
2021-02-12 17:36:37 +01:00
continue ;
}
2021-07-16 05:45:57 +02:00
Variant v = p_node - > get ( E . name ) ;
2021-02-12 17:36:37 +01:00
if ( v . is_ref ( ) ) {
RES res = v ;
if ( res . is_valid ( ) ) {
2021-06-18 00:03:09 +02:00
if ( is_instantiated ) {
2021-06-07 12:52:05 +02:00
Variant orig ;
2021-07-16 05:45:57 +02:00
if ( EditorPropertyRevert : : get_instantiated_node_original_property ( p_node , E . name , orig ) ) {
2021-06-07 12:52:05 +02:00
if ( ! EditorPropertyRevert : : is_node_property_different ( p_node , v , orig ) ) {
continue ;
}
}
}
2021-02-13 02:57:29 +01:00
if ( ( res - > get_path ( ) = = " " | | res - > get_path ( ) . find ( " :: " ) > - 1 ) & & ! r_remap . has ( res ) ) {
2021-02-12 17:36:37 +01:00
_create_remap_for_resource ( res , r_remap ) ;
}
}
}
}
for ( int i = 0 ; i < p_node - > get_child_count ( ) ; i + + ) {
_create_remap_for_node ( p_node - > get_child ( i ) , r_remap ) ;
}
}
void SceneTreeDock : : _create_remap_for_resource ( RES p_resource , Map < RES , RES > & r_remap ) {
r_remap [ p_resource ] = p_resource - > duplicate ( ) ;
List < PropertyInfo > props ;
p_resource - > get_property_list ( & props ) ;
2021-07-24 15:46:25 +02:00
for ( const PropertyInfo & E : props ) {
2021-07-16 05:45:57 +02:00
if ( ! ( E . usage & PROPERTY_USAGE_STORAGE ) ) {
2021-02-12 17:36:37 +01:00
continue ;
}
2021-07-16 05:45:57 +02:00
Variant v = p_resource - > get ( E . name ) ;
2021-02-12 17:36:37 +01:00
if ( v . is_ref ( ) ) {
RES res = v ;
if ( res . is_valid ( ) ) {
2021-02-13 02:57:29 +01:00
if ( ( res - > get_path ( ) = = " " | | res - > get_path ( ) . find ( " :: " ) > - 1 ) & & ! r_remap . has ( res ) ) {
2021-02-12 17:36:37 +01:00
_create_remap_for_resource ( res , r_remap ) ;
}
}
}
}
2020-01-07 17:43:21 +01:00
}
2014-02-10 02:10:30 +01:00
void SceneTreeDock : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " _set_owners " ) , & SceneTreeDock : : _set_owners ) ;
ClassDB : : bind_method ( D_METHOD ( " _unhandled_key_input " ) , & SceneTreeDock : : _unhandled_key_input ) ;
ClassDB : : bind_method ( D_METHOD ( " _input " ) , & SceneTreeDock : : _input ) ;
2018-03-07 20:08:13 +01:00
ClassDB : : bind_method ( D_METHOD ( " _update_script_button " ) , & SceneTreeDock : : _update_script_button ) ;
2017-03-05 16:44:50 +01:00
2021-06-18 00:03:09 +02:00
ClassDB : : bind_method ( D_METHOD ( " instantiate " ) , & SceneTreeDock : : instantiate ) ;
2019-08-20 18:06:21 +02:00
ClassDB : : bind_method ( D_METHOD ( " get_tree_editor " ) , & SceneTreeDock : : get_tree_editor ) ;
2019-04-23 21:10:44 +02:00
ClassDB : : bind_method ( D_METHOD ( " replace_node " ) , & SceneTreeDock : : replace_node ) ;
2017-11-23 08:23:24 +01:00
ADD_SIGNAL ( MethodInfo ( " remote_tree_selected " ) ) ;
2020-08-25 01:32:58 +02:00
ADD_SIGNAL ( MethodInfo ( " add_node_used " ) ) ;
ADD_SIGNAL ( MethodInfo ( " node_created " , PropertyInfo ( Variant : : OBJECT , " node " , PROPERTY_HINT_RESOURCE_TYPE , " Node " ) ) ) ;
2014-02-10 02:10:30 +01:00
}
2021-04-27 17:43:49 +02:00
SceneTreeDock * SceneTreeDock : : singleton = nullptr ;
void SceneTreeDock : : _update_configuration_warning ( ) {
if ( singleton ) {
MessageQueue : : get_singleton ( ) - > push_callable ( callable_mp ( singleton - > scene_tree , & SceneTreeEditor : : update_warning ) ) ;
}
}
2017-03-05 16:44:50 +01:00
SceneTreeDock : : SceneTreeDock ( EditorNode * p_editor , Node * p_scene_root , EditorSelection * p_editor_selection , EditorData & p_editor_data ) {
2021-04-27 17:43:49 +02:00
singleton = this ;
2017-11-26 02:59:31 +01:00
set_name ( " Scene " ) ;
2017-03-05 16:44:50 +01:00
editor = p_editor ;
2020-04-02 01:20:12 +02:00
edited_scene = nullptr ;
2017-03-05 16:44:50 +01:00
editor_data = & p_editor_data ;
editor_selection = p_editor_selection ;
scene_root = p_scene_root ;
2014-02-10 02:10:30 +01:00
VBoxContainer * vbc = this ;
2017-03-05 16:44:50 +01:00
HBoxContainer * filter_hbc = memnew ( HBoxContainer ) ;
2020-03-12 13:37:40 +01:00
filter_hbc - > add_theme_constant_override ( " separate " , 0 ) ;
2014-02-10 02:10:30 +01:00
2020-04-25 15:04:49 +02:00
ED_SHORTCUT ( " scene_tree/rename " , TTR ( " Rename " ) , KEY_F2 ) ;
ED_SHORTCUT ( " scene_tree/batch_rename " , TTR ( " Batch Rename " ) , KEY_MASK_SHIFT | KEY_F2 ) ;
2017-03-05 16:44:50 +01:00
ED_SHORTCUT ( " scene_tree/add_child_node " , TTR ( " Add Child Node " ) , KEY_MASK_CMD | KEY_A ) ;
2021-06-18 00:03:09 +02:00
ED_SHORTCUT ( " scene_tree/instance_scene " , TTR ( " Instantiate Child Scene " ) , KEY_MASK_CMD | KEY_MASK_SHIFT | KEY_A ) ;
2018-07-07 16:51:18 +02:00
ED_SHORTCUT ( " scene_tree/expand_collapse_all " , TTR ( " Expand/Collapse All " ) ) ;
2020-01-07 17:43:21 +01:00
ED_SHORTCUT ( " scene_tree/cut_node " , TTR ( " Cut " ) , KEY_MASK_CMD | KEY_X ) ;
ED_SHORTCUT ( " scene_tree/copy_node " , TTR ( " Copy " ) , KEY_MASK_CMD | KEY_C ) ;
ED_SHORTCUT ( " scene_tree/paste_node " , TTR ( " Paste " ) , KEY_MASK_CMD | KEY_V ) ;
2016-06-19 21:33:42 +02:00
ED_SHORTCUT ( " scene_tree/change_node_type " , TTR ( " Change Type " ) ) ;
2016-11-09 17:29:15 +01:00
ED_SHORTCUT ( " scene_tree/attach_script " , TTR ( " Attach Script " ) ) ;
2018-10-25 20:33:16 +02:00
ED_SHORTCUT ( " scene_tree/extend_script " , TTR ( " Extend Script " ) ) ;
2020-05-09 18:59:19 +02:00
ED_SHORTCUT ( " scene_tree/detach_script " , TTR ( " Detach Script " ) ) ;
2016-06-19 21:33:42 +02:00
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 ) ;
2017-03-05 16:44:50 +01:00
ED_SHORTCUT ( " scene_tree/duplicate " , TTR ( " Duplicate " ) , KEY_MASK_CMD | KEY_D ) ;
2016-06-19 21:33:42 +02:00
ED_SHORTCUT ( " scene_tree/reparent " , TTR ( " Reparent " ) ) ;
2018-09-12 20:47:12 +02:00
ED_SHORTCUT ( " scene_tree/reparent_to_new_node " , TTR ( " Reparent to New Node " ) ) ;
2018-07-16 04:52:57 +02:00
ED_SHORTCUT ( " scene_tree/make_root " , TTR ( " Make Scene Root " ) ) ;
2016-06-19 21:33:42 +02:00
ED_SHORTCUT ( " scene_tree/save_branch_as_scene " , TTR ( " Save Branch as Scene " ) ) ;
2020-01-07 17:43:21 +01:00
ED_SHORTCUT ( " scene_tree/copy_node_path " , TTR ( " Copy Node Path " ) , KEY_MASK_CMD | KEY_MASK_SHIFT | KEY_C ) ;
2017-03-05 16:44:50 +01:00
ED_SHORTCUT ( " scene_tree/delete_no_confirm " , TTR ( " Delete (No Confirm) " ) , KEY_MASK_SHIFT | KEY_DELETE ) ;
2016-06-12 17:47:29 +02:00
ED_SHORTCUT ( " scene_tree/delete " , TTR ( " Delete " ) , KEY_DELETE ) ;
2016-06-19 21:33:42 +02:00
2020-06-19 20:49:04 +02:00
button_add = memnew ( Button ) ;
button_add - > set_flat ( true ) ;
2020-02-21 18:28:45 +01:00
button_add - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_NEW , false ) ) ;
2018-07-07 16:51:18 +02:00
button_add - > set_tooltip ( TTR ( " Add/Create a New Node. " ) ) ;
2019-03-06 05:19:34 +01:00
button_add - > set_shortcut ( ED_GET_SHORTCUT ( " scene_tree/add_child_node " ) ) ;
filter_hbc - > add_child ( button_add ) ;
2014-02-10 02:10:30 +01:00
2020-06-19 20:49:04 +02:00
button_instance = memnew ( Button ) ;
button_instance - > set_flat ( true ) ;
2021-06-18 00:03:09 +02:00
button_instance - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_INSTANTIATE , false ) ) ;
button_instance - > set_tooltip ( TTR ( " Instantiate a scene file as a Node. Creates an inherited scene if no root node exists. " ) ) ;
2019-03-06 05:19:34 +01:00
button_instance - > set_shortcut ( ED_GET_SHORTCUT ( " scene_tree/instance_scene " ) ) ;
filter_hbc - > add_child ( button_instance ) ;
2014-02-10 02:10:30 +01:00
2016-05-16 17:23:40 +02:00
vbc - > add_child ( filter_hbc ) ;
2017-03-05 16:44:50 +01:00
filter = memnew ( LineEdit ) ;
2016-05-16 17:23:40 +02:00
filter - > set_h_size_flags ( SIZE_EXPAND_FILL ) ;
2017-07-18 21:35:37 +02:00
filter - > set_placeholder ( TTR ( " Filter nodes " ) ) ;
2016-05-16 17:23:40 +02:00
filter_hbc - > add_child ( filter ) ;
2021-02-12 15:05:10 +01:00
filter - > add_theme_constant_override ( " minimum_character_width " , 0 ) ;
2020-02-21 18:28:45 +01:00
filter - > connect ( " text_changed " , callable_mp ( this , & SceneTreeDock : : _filter_changed ) ) ;
2016-05-16 17:23:40 +02:00
2020-06-19 20:49:04 +02:00
button_create_script = memnew ( Button ) ;
button_create_script - > set_flat ( true ) ;
2020-02-21 18:28:45 +01:00
button_create_script - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_ATTACH_SCRIPT , false ) ) ;
2020-05-09 18:59:19 +02:00
button_create_script - > set_tooltip ( TTR ( " Attach a new or existing script to the selected node. " ) ) ;
2019-03-06 05:19:34 +01:00
button_create_script - > set_shortcut ( ED_GET_SHORTCUT ( " scene_tree/attach_script " ) ) ;
filter_hbc - > add_child ( button_create_script ) ;
button_create_script - > hide ( ) ;
2020-06-19 20:49:04 +02:00
button_detach_script = memnew ( Button ) ;
button_detach_script - > set_flat ( true ) ;
2020-05-09 18:59:19 +02:00
button_detach_script - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( TOOL_DETACH_SCRIPT , false ) ) ;
button_detach_script - > set_tooltip ( TTR ( " Detach the script from the selected node. " ) ) ;
button_detach_script - > set_shortcut ( ED_GET_SHORTCUT ( " scene_tree/detach_script " ) ) ;
filter_hbc - > add_child ( button_detach_script ) ;
button_detach_script - > hide ( ) ;
2016-10-31 15:45:20 +01:00
2017-11-16 02:21:29 +01:00
button_hb = memnew ( HBoxContainer ) ;
vbc - > add_child ( button_hb ) ;
2020-06-19 20:49:04 +02:00
edit_remote = memnew ( Button ) ;
edit_remote - > set_flat ( true ) ;
2017-11-16 02:21:29 +01:00
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 ) ;
2021-04-12 17:47:47 +02:00
edit_remote - > set_tooltip ( TTR ( " If selected, the Remote scene tree dock will cause the project to stutter every time it updates. \n Switch back to the Local scene tree dock to improve performance. " ) ) ;
2020-02-21 18:28:45 +01:00
edit_remote - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _remote_tree_selected ) ) ;
2017-11-16 02:21:29 +01:00
2020-06-19 20:49:04 +02:00
edit_local = memnew ( Button ) ;
edit_local - > set_flat ( true ) ;
2017-11-16 02:21:29 +01:00
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 ) ;
2020-04-21 20:03:42 +02:00
edit_local - > set_pressed ( true ) ;
2020-02-21 18:28:45 +01:00
edit_local - > connect ( " pressed " , callable_mp ( this , & SceneTreeDock : : _local_tree_selected ) ) ;
2017-11-16 02:21:29 +01:00
2020-04-02 01:20:12 +02:00
remote_tree = nullptr ;
2017-11-16 02:21:29 +01:00
button_hb - > hide ( ) ;
2018-07-16 04:11:29 +02:00
create_root_dialog = memnew ( VBoxContainer ) ;
vbc - > add_child ( create_root_dialog ) ;
create_root_dialog - > hide ( ) ;
2017-03-05 16:44:50 +01:00
scene_tree = memnew ( SceneTreeEditor ( false , true , true ) ) ;
2017-11-16 02:21:29 +01:00
2014-02-10 02:10:30 +01:00
vbc - > add_child ( scene_tree ) ;
2017-03-05 16:44:50 +01:00
scene_tree - > set_v_size_flags ( SIZE_EXPAND | SIZE_FILL ) ;
2020-02-21 18:28:45 +01:00
scene_tree - > connect ( " rmb_pressed " , callable_mp ( this , & SceneTreeDock : : _tree_rmb ) ) ;
2017-03-05 16:44:50 +01:00
2020-02-21 18:28:45 +01:00
scene_tree - > connect ( " node_selected " , callable_mp ( this , & SceneTreeDock : : _node_selected ) , varray ( ) , CONNECT_DEFERRED ) ;
scene_tree - > connect ( " node_renamed " , callable_mp ( this , & SceneTreeDock : : _node_renamed ) , varray ( ) , CONNECT_DEFERRED ) ;
scene_tree - > connect ( " node_prerename " , callable_mp ( this , & SceneTreeDock : : _node_prerenamed ) ) ;
scene_tree - > connect ( " open " , callable_mp ( this , & SceneTreeDock : : _load_request ) ) ;
scene_tree - > connect ( " open_script " , callable_mp ( this , & SceneTreeDock : : _script_open_request ) ) ;
scene_tree - > connect ( " nodes_rearranged " , callable_mp ( this , & SceneTreeDock : : _nodes_dragged ) ) ;
scene_tree - > connect ( " files_dropped " , callable_mp ( this , & SceneTreeDock : : _files_dropped ) ) ;
scene_tree - > connect ( " script_dropped " , callable_mp ( this , & SceneTreeDock : : _script_dropped ) ) ;
scene_tree - > connect ( " nodes_dragged " , callable_mp ( this , & SceneTreeDock : : _nodes_drag_begin ) ) ;
2016-05-11 16:46:08 +02:00
2020-02-21 18:28:45 +01:00
scene_tree - > get_scene_tree ( ) - > connect ( " item_double_clicked " , callable_mp ( this , & SceneTreeDock : : _focus_node ) ) ;
2021-06-19 04:25:24 +02:00
scene_tree - > get_scene_tree ( ) - > connect ( " item_collapsed " , callable_mp ( this , & SceneTreeDock : : _node_collapsed ) ) ;
editor_selection - > connect ( " selection_changed " , callable_mp ( this , & SceneTreeDock : : _selection_changed ) ) ;
2016-07-28 21:37:52 +02:00
2014-02-10 02:10:30 +01:00
scene_tree - > set_undo_redo ( & editor_data - > get_undo_redo ( ) ) ;
scene_tree - > set_editor_selection ( editor_selection ) ;
2017-03-05 16:44:50 +01:00
create_dialog = memnew ( CreateDialog ) ;
2014-02-10 02:10:30 +01:00
create_dialog - > set_base_type ( " Node " ) ;
add_child ( create_dialog ) ;
2020-02-21 18:28:45 +01:00
create_dialog - > connect ( " create " , callable_mp ( this , & SceneTreeDock : : _create ) ) ;
create_dialog - > connect ( " favorites_updated " , callable_mp ( this , & SceneTreeDock : : _update_create_root_dialog ) ) ;
2014-02-10 02:10:30 +01:00
2018-01-21 07:12:25 +01:00
rename_dialog = memnew ( RenameDialog ( scene_tree , & editor_data - > get_undo_redo ( ) ) ) ;
add_child ( rename_dialog ) ;
2017-03-05 16:44:50 +01:00
script_create_dialog = memnew ( ScriptCreateDialog ) ;
2019-02-18 16:45:26 +01:00
script_create_dialog - > set_inheritance_base_type ( " Node " ) ;
2014-02-10 02:10:30 +01:00
add_child ( script_create_dialog ) ;
2015-11-27 21:42:48 +01:00
2017-03-05 16:44:50 +01:00
reparent_dialog = memnew ( ReparentDialog ) ;
2014-02-10 02:10:30 +01:00
add_child ( reparent_dialog ) ;
2020-02-21 18:28:45 +01:00
reparent_dialog - > connect ( " reparent " , callable_mp ( this , & SceneTreeDock : : _node_reparent ) ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
accept = memnew ( AcceptDialog ) ;
2014-02-10 02:10:30 +01:00
add_child ( accept ) ;
2018-10-17 07:03:22 +02:00
quick_open = memnew ( EditorQuickOpen ) ;
add_child ( quick_open ) ;
2020-02-21 18:28:45 +01:00
quick_open - > connect ( " quick_open " , callable_mp ( this , & SceneTreeDock : : _quick_open ) ) ;
2020-09-17 03:40:00 +02:00
2014-04-10 05:18:27 +02:00
set_process_unhandled_key_input ( true ) ;
2014-02-10 02:10:30 +01:00
2017-03-05 16:44:50 +01:00
delete_dialog = memnew ( ConfirmationDialog ) ;
2014-02-10 02:10:30 +01:00
add_child ( delete_dialog ) ;
2020-01-07 17:43:21 +01:00
delete_dialog - > connect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _delete_confirm ) , varray ( false ) ) ;
2015-11-27 21:42:48 +01:00
2018-09-13 00:49:12 +02:00
editable_instance_remove_dialog = memnew ( ConfirmationDialog ) ;
add_child ( editable_instance_remove_dialog ) ;
2020-02-21 18:28:45 +01:00
editable_instance_remove_dialog - > connect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _toggle_editable_children_from_selection ) ) ;
2018-09-13 00:49:12 +02:00
2019-09-04 21:02:26 +02:00
placeholder_editable_instance_remove_dialog = memnew ( ConfirmationDialog ) ;
add_child ( placeholder_editable_instance_remove_dialog ) ;
2020-02-21 18:28:45 +01:00
placeholder_editable_instance_remove_dialog - > connect ( " confirmed " , callable_mp ( this , & SceneTreeDock : : _toggle_placeholder_from_selection ) ) ;
2019-09-04 21:02:26 +02:00
2017-03-05 16:44:50 +01:00
new_scene_from_dialog = memnew ( EditorFileDialog ) ;
2020-03-06 18:00:16 +01:00
new_scene_from_dialog - > set_file_mode ( EditorFileDialog : : FILE_MODE_SAVE_FILE ) ;
2015-11-27 21:42:48 +01:00
add_child ( new_scene_from_dialog ) ;
2020-02-21 18:28:45 +01:00
new_scene_from_dialog - > connect ( " file_selected " , callable_mp ( this , & SceneTreeDock : : _new_scene_from ) ) ;
2016-05-11 16:46:08 +02:00
2017-03-05 16:44:50 +01:00
menu = memnew ( PopupMenu ) ;
2016-05-16 04:41:48 +02:00
add_child ( menu ) ;
2020-02-25 21:41:54 +01:00
menu - > connect ( " id_pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( false ) ) ;
2020-03-12 13:37:40 +01:00
2017-12-17 15:55:24 +01:00
menu_subresources = memnew ( PopupMenu ) ;
menu_subresources - > set_name ( " Sub-Resources " ) ;
2020-02-25 21:41:54 +01:00
menu_subresources - > connect ( " id_pressed " , callable_mp ( this , & SceneTreeDock : : _tool_selected ) , make_binds ( false ) ) ;
2017-12-17 15:55:24 +01:00
menu - > add_child ( menu_subresources ) ;
2017-03-05 16:44:50 +01:00
first_enter = true ;
restore_script_editor_on_drag = false ;
2014-02-10 02:10:30 +01:00
2021-07-16 16:27:59 +02:00
menu_properties = memnew ( PopupMenu ) ;
add_child ( menu_properties ) ;
menu_properties - > connect ( " id_pressed " , callable_mp ( this , & SceneTreeDock : : _property_selected ) ) ;
2017-06-30 18:17:33 +02:00
clear_inherit_confirm = memnew ( ConfirmationDialog ) ;
clear_inherit_confirm - > set_text ( TTR ( " Clear Inheritance? (No Undo!) " ) ) ;
2020-12-14 19:37:30 +01:00
clear_inherit_confirm - > get_ok_button ( ) - > set_text ( TTR ( " Clear " ) ) ;
2017-06-30 18:17:33 +02:00
add_child ( clear_inherit_confirm ) ;
2016-08-03 16:28:20 +02:00
set_process_input ( true ) ;
2018-07-16 04:11:29 +02:00
set_process ( true ) ;
2019-04-09 00:18:03 +02:00
profile_allow_editing = true ;
profile_allow_script_editing = true ;
2018-07-16 04:11:29 +02:00
EDITOR_DEF ( " interface/editors/show_scene_tree_root_selection " , true ) ;
2019-09-03 12:42:34 +02:00
EDITOR_DEF ( " interface/editors/derive_script_globals_by_name " , true ) ;
2018-07-25 05:48:24 +02:00
EDITOR_DEF ( " _use_favorites_root_selection " , false ) ;
2021-04-27 17:43:49 +02:00
Resource : : _update_configuration_warning = _update_configuration_warning ;
2014-02-10 02:10:30 +01:00
}
2020-01-07 17:43:21 +01:00
SceneTreeDock : : ~ SceneTreeDock ( ) {
2021-04-27 17:43:49 +02:00
singleton = nullptr ;
2020-01-07 17:43:21 +01:00
if ( ! node_clipboard . is_empty ( ) ) {
_clear_clipboard ( ) ;
}
}